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

   1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
   2
   3 #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
   4 #include "ril.pb.h"
   5 #include <google/protobuf/stubs/once.h>
   6 #include <google/protobuf/io/coded_stream.h>
   7 #include <google/protobuf/wire_format_lite_inl.h>
   8 #include <google/protobuf/descriptor.h>
   9 #include <google/protobuf/reflection_ops.h>
  10 #include <google/protobuf/wire_format.h>
  11 // @@protoc_insertion_point(includes)
  12
  13 namespace ril_proto {
  14
  15 namespace {
  16
  17 const ::google::protobuf::Descriptor* RilAppStatus_descriptor_ = NULL;
  18 const ::google::protobuf::internal::GeneratedMessageReflection*
  19   RilAppStatus_reflection_ = NULL;
  20 const ::google::protobuf::Descriptor* RilCardStatus_descriptor_ = NULL;
  21 const ::google::protobuf::internal::GeneratedMessageReflection*
  22   RilCardStatus_reflection_ = NULL;
  23 const ::google::protobuf::Descriptor* RspStrings_descriptor_ = NULL;
  24 const ::google::protobuf::internal::GeneratedMessageReflection*
  25   RspStrings_reflection_ = NULL;
  26 const ::google::protobuf::Descriptor* RspIntegers_descriptor_ = NULL;
  27 const ::google::protobuf::internal::GeneratedMessageReflection*
  28   RspIntegers_reflection_ = NULL;
  29 const ::google::protobuf::Descriptor* ReqGetSimStatus_descriptor_ = NULL;
  30 const ::google::protobuf::internal::GeneratedMessageReflection*
  31   ReqGetSimStatus_reflection_ = NULL;
  32 const ::google::protobuf::Descriptor* RspGetSimStatus_descriptor_ = NULL;
  33 const ::google::protobuf::internal::GeneratedMessageReflection*
  34   RspGetSimStatus_reflection_ = NULL;
  35 const ::google::protobuf::Descriptor* ReqEnterSimPin_descriptor_ = NULL;
  36 const ::google::protobuf::internal::GeneratedMessageReflection*
  37   ReqEnterSimPin_reflection_ = NULL;
  38 const ::google::protobuf::Descriptor* RspEnterSimPin_descriptor_ = NULL;
  39 const ::google::protobuf::internal::GeneratedMessageReflection*
  40   RspEnterSimPin_reflection_ = NULL;
  41 const ::google::protobuf::Descriptor* ReqHangUp_descriptor_ = NULL;
  42 const ::google::protobuf::internal::GeneratedMessageReflection*
  43   ReqHangUp_reflection_ = NULL;
  44 const ::google::protobuf::Descriptor* ReqScreenState_descriptor_ = NULL;
  45 const ::google::protobuf::internal::GeneratedMessageReflection*
  46   ReqScreenState_reflection_ = NULL;
  47 const ::google::protobuf::Descriptor* RspOperator_descriptor_ = NULL;
  48 const ::google::protobuf::internal::GeneratedMessageReflection*
  49   RspOperator_reflection_ = NULL;
  50 const ::google::protobuf::EnumDescriptor* RilCommand_descriptor_ = NULL;
  51 const ::google::protobuf::EnumDescriptor* RadioState_descriptor_ = NULL;
  52 const ::google::protobuf::EnumDescriptor* RilCardState_descriptor_ = NULL;
  53 const ::google::protobuf::EnumDescriptor* RilPersoSubstate_descriptor_ = NULL;
  54 const ::google::protobuf::EnumDescriptor* RilAppState_descriptor_ = NULL;
  55 const ::google::protobuf::EnumDescriptor* RilPinState_descriptor_ = NULL;
  56 const ::google::protobuf::EnumDescriptor* RilAppType_descriptor_ = NULL;
  57
  58 }  // namespace
  59
  60
  61 void protobuf_AssignDesc_ril_2eproto() {
  62   protobuf_AddDesc_ril_2eproto();
  63   const ::google::protobuf::FileDescriptor* file =
  64     ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
  65       "ril.proto");
  66   GOOGLE_CHECK(file != NULL);
  67   RilAppStatus_descriptor_ = file->message_type(0);
  68   static const int RilAppStatus_offsets_[8] = {
  69     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, app_type_),
  70     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, app_state_),
  71     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, perso_substate_),
  72     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, aid_),
  73     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, app_label_),
  74     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, pin1_replaced_),
  75     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, pin1_),
  76     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, pin2_),
  77   };
  78   RilAppStatus_reflection_ =
  79     new ::google::protobuf::internal::GeneratedMessageReflection(
  80       RilAppStatus_descriptor_,
  81       RilAppStatus::default_instance_,
  82       RilAppStatus_offsets_,
  83       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, _has_bits_[0]),
  84       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, _unknown_fields_),
  85       -1,
  86       ::google::protobuf::DescriptorPool::generated_pool(),
  87       ::google::protobuf::MessageFactory::generated_factory(),
  88       sizeof(RilAppStatus));
  89   RilCardStatus_descriptor_ = file->message_type(1);
  90   static const int RilCardStatus_offsets_[6] = {
  91     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCardStatus, card_state_),
  92     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCardStatus, universal_pin_state_),
  93     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCardStatus, gsm_umts_subscription_app_index_),
  94     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCardStatus, cdma_subscription_app_index_),
  95     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCardStatus, num_applications_),
  96     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCardStatus, applications_),
  97   };
  98   RilCardStatus_reflection_ =
  99     new ::google::protobuf::internal::GeneratedMessageReflection(
 100       RilCardStatus_descriptor_,
 101       RilCardStatus::default_instance_,
 102       RilCardStatus_offsets_,
 103       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCardStatus, _has_bits_[0]),
 104       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCardStatus, _unknown_fields_),
 105       -1,
 106       ::google::protobuf::DescriptorPool::generated_pool(),
 107       ::google::protobuf::MessageFactory::generated_factory(),
 108       sizeof(RilCardStatus));
 109   RspStrings_descriptor_ = file->message_type(2);
 110   static const int RspStrings_offsets_[1] = {
 111     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspStrings, strings_),
 112   };
 113   RspStrings_reflection_ =
 114     new ::google::protobuf::internal::GeneratedMessageReflection(
 115       RspStrings_descriptor_,
 116       RspStrings::default_instance_,
 117       RspStrings_offsets_,
 118       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspStrings, _has_bits_[0]),
 119       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspStrings, _unknown_fields_),
 120       -1,
 121       ::google::protobuf::DescriptorPool::generated_pool(),
 122       ::google::protobuf::MessageFactory::generated_factory(),
 123       sizeof(RspStrings));
 124   RspIntegers_descriptor_ = file->message_type(3);
 125   static const int RspIntegers_offsets_[1] = {
 126     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspIntegers, integers_),
 127   };
 128   RspIntegers_reflection_ =
 129     new ::google::protobuf::internal::GeneratedMessageReflection(
 130       RspIntegers_descriptor_,
 131       RspIntegers::default_instance_,
 132       RspIntegers_offsets_,
 133       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspIntegers, _has_bits_[0]),
 134       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspIntegers, _unknown_fields_),
 135       -1,
 136       ::google::protobuf::DescriptorPool::generated_pool(),
 137       ::google::protobuf::MessageFactory::generated_factory(),
 138       sizeof(RspIntegers));
 139   ReqGetSimStatus_descriptor_ = file->message_type(4);
 140   static const int ReqGetSimStatus_offsets_[1] = {
 141   };
 142   ReqGetSimStatus_reflection_ =
 143     new ::google::protobuf::internal::GeneratedMessageReflection(
 144       ReqGetSimStatus_descriptor_,
 145       ReqGetSimStatus::default_instance_,
 146       ReqGetSimStatus_offsets_,
 147       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqGetSimStatus, _has_bits_[0]),
 148       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqGetSimStatus, _unknown_fields_),
 149       -1,
 150       ::google::protobuf::DescriptorPool::generated_pool(),
 151       ::google::protobuf::MessageFactory::generated_factory(),
 152       sizeof(ReqGetSimStatus));
 153   RspGetSimStatus_descriptor_ = file->message_type(5);
 154   static const int RspGetSimStatus_offsets_[1] = {
 155     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspGetSimStatus, card_status_),
 156   };
 157   RspGetSimStatus_reflection_ =
 158     new ::google::protobuf::internal::GeneratedMessageReflection(
 159       RspGetSimStatus_descriptor_,
 160       RspGetSimStatus::default_instance_,
 161       RspGetSimStatus_offsets_,
 162       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspGetSimStatus, _has_bits_[0]),
 163       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspGetSimStatus, _unknown_fields_),
 164       -1,
 165       ::google::protobuf::DescriptorPool::generated_pool(),
 166       ::google::protobuf::MessageFactory::generated_factory(),
 167       sizeof(RspGetSimStatus));
 168   ReqEnterSimPin_descriptor_ = file->message_type(6);
 169   static const int ReqEnterSimPin_offsets_[1] = {
 170     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqEnterSimPin, pin_),
 171   };
 172   ReqEnterSimPin_reflection_ =
 173     new ::google::protobuf::internal::GeneratedMessageReflection(
 174       ReqEnterSimPin_descriptor_,
 175       ReqEnterSimPin::default_instance_,
 176       ReqEnterSimPin_offsets_,
 177       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqEnterSimPin, _has_bits_[0]),
 178       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqEnterSimPin, _unknown_fields_),
 179       -1,
 180       ::google::protobuf::DescriptorPool::generated_pool(),
 181       ::google::protobuf::MessageFactory::generated_factory(),
 182       sizeof(ReqEnterSimPin));
 183   RspEnterSimPin_descriptor_ = file->message_type(7);
 184   static const int RspEnterSimPin_offsets_[1] = {
 185     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspEnterSimPin, retries_remaining_),
 186   };
 187   RspEnterSimPin_reflection_ =
 188     new ::google::protobuf::internal::GeneratedMessageReflection(
 189       RspEnterSimPin_descriptor_,
 190       RspEnterSimPin::default_instance_,
 191       RspEnterSimPin_offsets_,
 192       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspEnterSimPin, _has_bits_[0]),
 193       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspEnterSimPin, _unknown_fields_),
 194       -1,
 195       ::google::protobuf::DescriptorPool::generated_pool(),
 196       ::google::protobuf::MessageFactory::generated_factory(),
 197       sizeof(RspEnterSimPin));
 198   ReqHangUp_descriptor_ = file->message_type(8);
 199   static const int ReqHangUp_offsets_[1] = {
 200     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqHangUp, connection_index_),
 201   };
 202   ReqHangUp_reflection_ =
 203     new ::google::protobuf::internal::GeneratedMessageReflection(
 204       ReqHangUp_descriptor_,
 205       ReqHangUp::default_instance_,
 206       ReqHangUp_offsets_,
 207       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqHangUp, _has_bits_[0]),
 208       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqHangUp, _unknown_fields_),
 209       -1,
 210       ::google::protobuf::DescriptorPool::generated_pool(),
 211       ::google::protobuf::MessageFactory::generated_factory(),
 212       sizeof(ReqHangUp));
 213   ReqScreenState_descriptor_ = file->message_type(9);
 214   static const int ReqScreenState_offsets_[1] = {
 215     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqScreenState, state_),
 216   };
 217   ReqScreenState_reflection_ =
 218     new ::google::protobuf::internal::GeneratedMessageReflection(
 219       ReqScreenState_descriptor_,
 220       ReqScreenState::default_instance_,
 221       ReqScreenState_offsets_,
 222       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqScreenState, _has_bits_[0]),
 223       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqScreenState, _unknown_fields_),
 224       -1,
 225       ::google::protobuf::DescriptorPool::generated_pool(),
 226       ::google::protobuf::MessageFactory::generated_factory(),
 227       sizeof(ReqScreenState));
 228   RspOperator_descriptor_ = file->message_type(10);
 229   static const int RspOperator_offsets_[3] = {
 230     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspOperator, long_alpha_ons_),
 231     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspOperator, short_alpha_ons_),
 232     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspOperator, mcc_mnc_),
 233   };
 234   RspOperator_reflection_ =
 235     new ::google::protobuf::internal::GeneratedMessageReflection(
 236       RspOperator_descriptor_,
 237       RspOperator::default_instance_,
 238       RspOperator_offsets_,
 239       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspOperator, _has_bits_[0]),
 240       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspOperator, _unknown_fields_),
 241       -1,
 242       ::google::protobuf::DescriptorPool::generated_pool(),
 243       ::google::protobuf::MessageFactory::generated_factory(),
 244       sizeof(RspOperator));
 245   RilCommand_descriptor_ = file->enum_type(0);
 246   RadioState_descriptor_ = file->enum_type(1);
 247   RilCardState_descriptor_ = file->enum_type(2);
 248   RilPersoSubstate_descriptor_ = file->enum_type(3);
 249   RilAppState_descriptor_ = file->enum_type(4);
 250   RilPinState_descriptor_ = file->enum_type(5);
 251   RilAppType_descriptor_ = file->enum_type(6);
 252 }
 253
 254 namespace {
 255
 256 GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
 257 inline void protobuf_AssignDescriptorsOnce() {
 258   ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
 259                  &protobuf_AssignDesc_ril_2eproto);
 260 }
 261
 262 void protobuf_RegisterTypes(const ::std::string&) {
 263   protobuf_AssignDescriptorsOnce();
 264   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 265     RilAppStatus_descriptor_, &RilAppStatus::default_instance());
 266   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 267     RilCardStatus_descriptor_, &RilCardStatus::default_instance());
 268   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 269     RspStrings_descriptor_, &RspStrings::default_instance());
 270   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 271     RspIntegers_descriptor_, &RspIntegers::default_instance());
 272   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 273     ReqGetSimStatus_descriptor_, &ReqGetSimStatus::default_instance());
 274   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 275     RspGetSimStatus_descriptor_, &RspGetSimStatus::default_instance());
 276   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 277     ReqEnterSimPin_descriptor_, &ReqEnterSimPin::default_instance());
 278   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 279     RspEnterSimPin_descriptor_, &RspEnterSimPin::default_instance());
 280   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 281     ReqHangUp_descriptor_, &ReqHangUp::default_instance());
 282   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 283     ReqScreenState_descriptor_, &ReqScreenState::default_instance());
 284   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 285     RspOperator_descriptor_, &RspOperator::default_instance());
 286 }
 287
 288 }  // namespace
 289
 290 void protobuf_ShutdownFile_ril_2eproto() {
 291   delete RilAppStatus::default_instance_;
 292   delete RilAppStatus_reflection_;
 293   delete RilCardStatus::default_instance_;
 294   delete RilCardStatus_reflection_;
 295   delete RspStrings::default_instance_;
 296   delete RspStrings_reflection_;
 297   delete RspIntegers::default_instance_;
 298   delete RspIntegers_reflection_;
 299   delete ReqGetSimStatus::default_instance_;
 300   delete ReqGetSimStatus_reflection_;
 301   delete RspGetSimStatus::default_instance_;
 302   delete RspGetSimStatus_reflection_;
 303   delete ReqEnterSimPin::default_instance_;
 304   delete ReqEnterSimPin_reflection_;
 305   delete RspEnterSimPin::default_instance_;
 306   delete RspEnterSimPin_reflection_;
 307   delete ReqHangUp::default_instance_;
 308   delete ReqHangUp_reflection_;
 309   delete ReqScreenState::default_instance_;
 310   delete ReqScreenState_reflection_;
 311   delete RspOperator::default_instance_;
 312   delete RspOperator_reflection_;
 313 }
 314
 315 void protobuf_AddDesc_ril_2eproto() {
 316   static bool already_here = false;
 317   if (already_here) return;
 318   already_here = true;
 319   GOOGLE_PROTOBUF_VERIFY_VERSION;
 320
 321   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
 322     "\n\tril.proto\022\tril_proto\"\232\002\n\014RilAppStatus\022"
 323     "\'\n\010app_type\030\001 \001(\0162\025.ril_proto.RilAppType"
 324     "\022)\n\tapp_state\030\002 \001(\0162\026.ril_proto.RilAppSt"
 325     "ate\0223\n\016perso_substate\030\003 \001(\0162\033.ril_proto."
 326     "RilPersoSubstate\022\013\n\003aid\030\004 \001(\t\022\021\n\tapp_lab"
 327     "el\030\005 \001(\t\022\025\n\rpin1_replaced\030\006 \001(\005\022$\n\004pin1\030"
 328     "\007 \001(\0162\026.ril_proto.RilPinState\022$\n\004pin2\030\010 "
 329     "\001(\0162\026.ril_proto.RilPinState\"\210\002\n\rRilCardS"
 330     "tatus\022+\n\ncard_state\030\001 \001(\0162\027.ril_proto.Ri"
 331     "lCardState\0223\n\023universal_pin_state\030\002 \001(\0162"
 332     "\026.ril_proto.RilPinState\022\'\n\037gsm_umts_subs"
 333     "cription_app_index\030\003 \001(\005\022#\n\033cdma_subscri"
 334     "ption_app_index\030\004 \001(\005\022\030\n\020num_application"
 335     "s\030\005 \001(\005\022-\n\014applications\030\006 \003(\0132\027.ril_prot"
 336     "o.RilAppStatus\"\035\n\nRspStrings\022\017\n\007strings\030"
 337     "\001 \003(\t\"\037\n\013RspIntegers\022\020\n\010integers\030\001 \003(\005\"\021"
 338     "\n\017ReqGetSimStatus\"@\n\017RspGetSimStatus\022-\n\013"
 339     "card_status\030\001 \002(\0132\030.ril_proto.RilCardSta"
 340     "tus\"\035\n\016ReqEnterSimPin\022\013\n\003pin\030\001 \002(\t\"+\n\016Rs"
 341     "pEnterSimPin\022\031\n\021retries_remaining\030\001 \002(\005\""
 342     "%\n\tReqHangUp\022\030\n\020connection_index\030\001 \002(\005\"\037"
 343     "\n\016ReqScreenState\022\r\n\005state\030\001 \002(\010\"O\n\013RspOp"
 344     "erator\022\026\n\016long_alpha_ons\030\001 \001(\t\022\027\n\017short_"
 345     "alpha_ons\030\002 \001(\t\022\017\n\007mcc_mnc\030\003 \001(\t*a\n\nRilC"
 346     "ommand\022\026\n\022CMD_GET_SIM_STATUS\020\001\022\025\n\021CMD_EN"
 347     "TER_SIM_PIN\020\002\022\016\n\nCMD_HANGUP\020\014\022\024\n\020CMD_SCR"
 348     "EEN_STATE\020=*\271\002\n\nRadioState\022\023\n\017RADIO_STAT"
 349     "E_OFF\020\000\022\033\n\027RADIO_STATE_UNAVAILABLE\020\001\022\035\n\031"
 350     "RADIO_STATE_SIM_NOT_READY\020\002\022$\n RADIO_STA"
 351     "TE_SIM_LOCKED_OR_ABSENT\020\003\022\031\n\025RADIO_STATE"
 352     "_SIM_READY\020\004\022\036\n\032RADIO_STATE_RUIM_NOT_REA"
 353     "DY\020\005\022\032\n\026RADIO_STATE_RUIM_READY\020\006\022%\n!RADI"
 354     "O_STATE_RUIM_LOCKED_OR_ABSENT\020\007\022\034\n\030RADIO"
 355     "_STATE_NV_NOT_READY\020\010\022\030\n\024RADIO_STATE_NV_"
 356     "READY\020\t*P\n\014RilCardState\022\024\n\020CARDSTATE_ABS"
 357     "ENT\020\000\022\025\n\021CARDSTATE_PRESENT\020\001\022\023\n\017CARDSTAT"
 358     "E_ERROR\020\002*\361\006\n\020RilPersoSubstate\022\031\n\025PERSOS"
 359     "UBSTATE_UNKNOWN\020\000\022\035\n\031PERSOSUBSTATE_IN_PR"
 360     "OGRESS\020\001\022\027\n\023PERSOSUBSTATE_READY\020\002\022\035\n\031PER"
 361     "SOSUBSTATE_SIM_NETWORK\020\003\022$\n PERSOSUBSTAT"
 362     "E_SIM_NETWORK_SUBSET\020\004\022\037\n\033PERSOSUBSTATE_"
 363     "SIM_CORPORATE\020\005\022&\n\"PERSOSUBSTATE_SIM_SER"
 364     "VICE_PROVIDER\020\006\022\031\n\025PERSOSUBSTATE_SIM_SIM"
 365     "\020\007\022!\n\035PERSOSUBSTATE_SIM_NETWORK_PUK\020\010\022(\n"
 366     "$PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK\020\t\022"
 367     "#\n\037PERSOSUBSTATE_SIM_CORPORATE_PUK\020\n\022*\n&"
 368     "PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK\020\013"
 369     "\022\035\n\031PERSOSUBSTATE_SIM_SIM_PUK\020\014\022\037\n\033PERSO"
 370     "SUBSTATE_RUIM_NETWORK1\020\r\022\037\n\033PERSOSUBSTAT"
 371     "E_RUIM_NETWORK2\020\016\022\033\n\027PERSOSUBSTATE_RUIM_"
 372     "HRPD\020\017\022 \n\034PERSOSUBSTATE_RUIM_CORPORATE\020\020"
 373     "\022\'\n#PERSOSUBSTATE_RUIM_SERVICE_PROVIDER\020"
 374     "\021\022\033\n\027PERSOSUBSTATE_RUIM_RUIM\020\022\022#\n\037PERSOS"
 375     "UBSTATE_RUIM_NETWORK1_PUK\020\023\022#\n\037PERSOSUBS"
 376     "TATE_RUIM_NETWORK2_PUK\020\024\022\037\n\033PERSOSUBSTAT"
 377     "E_RUIM_HRPD_PUK\020\025\022$\n PERSOSUBSTATE_RUIM_"
 378     "CORPORATE_PUK\020\026\022+\n\'PERSOSUBSTATE_RUIM_SE"
 379     "RVICE_PROVIDER_PUK\020\027\022\037\n\033PERSOSUBSTATE_RU"
 380     "IM_RUIM_PUK\020\030*\223\001\n\013RilAppState\022\024\n\020APPSTAT"
 381     "E_UNKNOWN\020\000\022\025\n\021APPSTATE_DETECTED\020\001\022\020\n\014AP"
 382     "PSTATE_PIN\020\002\022\020\n\014APPSTATE_PUK\020\003\022\037\n\033APPSTA"
 383     "TE_SUBSCRIPTION_PERSO\020\004\022\022\n\016APPSTATE_READ"
 384     "Y\020\005*\275\001\n\013RilPinState\022\024\n\020PINSTATE_UNKNOWN\020"
 385     "\000\022!\n\035PINSTATE_ENABLED_NOT_VERIFIED\020\001\022\035\n\031"
 386     "PINSTATE_ENABLED_VERIFIED\020\002\022\025\n\021PINSTATE_"
 387     "DISABLED\020\003\022\034\n\030PINSTATE_ENABLED_BLOCKED\020\004"
 388     "\022!\n\035PINSTATE_ENABLED_PERM_BLOCKED\020\005*h\n\nR"
 389     "ilAppType\022\023\n\017APPTYPE_UNKNOWN\020\000\022\017\n\013APPTYP"
 390     "E_SIM\020\001\022\020\n\014APPTYPE_USIM\020\002\022\020\n\014APPTYPE_RUI"
 391     "M\020\003\022\020\n\014APPTYPE_CSIM\020\004B3\n(com.android.int"
 392     "ernal.telephony.ril_protoB\007RilCmds", 2834);
 393   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
 394     "ril.proto", &protobuf_RegisterTypes);
 395   RilAppStatus::default_instance_ = new RilAppStatus();
 396   RilCardStatus::default_instance_ = new RilCardStatus();
 397   RspStrings::default_instance_ = new RspStrings();
 398   RspIntegers::default_instance_ = new RspIntegers();
 399   ReqGetSimStatus::default_instance_ = new ReqGetSimStatus();
 400   RspGetSimStatus::default_instance_ = new RspGetSimStatus();
 401   ReqEnterSimPin::default_instance_ = new ReqEnterSimPin();
 402   RspEnterSimPin::default_instance_ = new RspEnterSimPin();
 403   ReqHangUp::default_instance_ = new ReqHangUp();
 404   ReqScreenState::default_instance_ = new ReqScreenState();
 405   RspOperator::default_instance_ = new RspOperator();
 406   RilAppStatus::default_instance_->InitAsDefaultInstance();
 407   RilCardStatus::default_instance_->InitAsDefaultInstance();
 408   RspStrings::default_instance_->InitAsDefaultInstance();
 409   RspIntegers::default_instance_->InitAsDefaultInstance();
 410   ReqGetSimStatus::default_instance_->InitAsDefaultInstance();
 411   RspGetSimStatus::default_instance_->InitAsDefaultInstance();
 412   ReqEnterSimPin::default_instance_->InitAsDefaultInstance();
 413   RspEnterSimPin::default_instance_->InitAsDefaultInstance();
 414   ReqHangUp::default_instance_->InitAsDefaultInstance();
 415   ReqScreenState::default_instance_->InitAsDefaultInstance();
 416   RspOperator::default_instance_->InitAsDefaultInstance();
 417   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_ril_2eproto);
 418 }
 419
 420 // Force AddDescriptors() to be called at static initialization time.
 421 struct StaticDescriptorInitializer_ril_2eproto {
 422   StaticDescriptorInitializer_ril_2eproto() {
 423     protobuf_AddDesc_ril_2eproto();
 424   }
 425 } static_descriptor_initializer_ril_2eproto_;
 426
 427 const ::google::protobuf::EnumDescriptor* RilCommand_descriptor() {
 428   protobuf_AssignDescriptorsOnce();
 429   return RilCommand_descriptor_;
 430 }
 431 bool RilCommand_IsValid(int value) {
 432   switch(value) {
 433     case 1:
 434     case 2:
 435     case 12:
 436     case 61:
 437       return true;
 438     default:
 439       return false;
 440   }
 441 }
 442
 443 const ::google::protobuf::EnumDescriptor* RadioState_descriptor() {
 444   protobuf_AssignDescriptorsOnce();
 445   return RadioState_descriptor_;
 446 }
 447 bool RadioState_IsValid(int value) {
 448   switch(value) {
 449     case 0:
 450     case 1:
 451     case 2:
 452     case 3:
 453     case 4:
 454     case 5:
 455     case 6:
 456     case 7:
 457     case 8:
 458     case 9:
 459       return true;
 460     default:
 461       return false;
 462   }
 463 }
 464
 465 const ::google::protobuf::EnumDescriptor* RilCardState_descriptor() {
 466   protobuf_AssignDescriptorsOnce();
 467   return RilCardState_descriptor_;
 468 }
 469 bool RilCardState_IsValid(int value) {
 470   switch(value) {
 471     case 0:
 472     case 1:
 473     case 2:
 474       return true;
 475     default:
 476       return false;
 477   }
 478 }
 479
 480 const ::google::protobuf::EnumDescriptor* RilPersoSubstate_descriptor() {
 481   protobuf_AssignDescriptorsOnce();
 482   return RilPersoSubstate_descriptor_;
 483 }
 484 bool RilPersoSubstate_IsValid(int value) {
 485   switch(value) {
 486     case 0:
 487     case 1:
 488     case 2:
 489     case 3:
 490     case 4:
 491     case 5:
 492     case 6:
 493     case 7:
 494     case 8:
 495     case 9:
 496     case 10:
 497     case 11:
 498     case 12:
 499     case 13:
 500     case 14:
 501     case 15:
 502     case 16:
 503     case 17:
 504     case 18:
 505     case 19:
 506     case 20:
 507     case 21:
 508     case 22:
 509     case 23:
 510     case 24:
 511       return true;
 512     default:
 513       return false;
 514   }
 515 }
 516
 517 const ::google::protobuf::EnumDescriptor* RilAppState_descriptor() {
 518   protobuf_AssignDescriptorsOnce();
 519   return RilAppState_descriptor_;
 520 }
 521 bool RilAppState_IsValid(int value) {
 522   switch(value) {
 523     case 0:
 524     case 1:
 525     case 2:
 526     case 3:
 527     case 4:
 528     case 5:
 529       return true;
 530     default:
 531       return false;
 532   }
 533 }
 534
 535 const ::google::protobuf::EnumDescriptor* RilPinState_descriptor() {
 536   protobuf_AssignDescriptorsOnce();
 537   return RilPinState_descriptor_;
 538 }
 539 bool RilPinState_IsValid(int value) {
 540   switch(value) {
 541     case 0:
 542     case 1:
 543     case 2:
 544     case 3:
 545     case 4:
 546     case 5:
 547       return true;
 548     default:
 549       return false;
 550   }
 551 }
 552
 553 const ::google::protobuf::EnumDescriptor* RilAppType_descriptor() {
 554   protobuf_AssignDescriptorsOnce();
 555   return RilAppType_descriptor_;
 556 }
 557 bool RilAppType_IsValid(int value) {
 558   switch(value) {
 559     case 0:
 560     case 1:
 561     case 2:
 562     case 3:
 563     case 4:
 564       return true;
 565     default:
 566       return false;
 567   }
 568 }
 569
 570
 571 // ===================================================================
 572
 573 const ::std::string RilAppStatus::_default_aid_;
 574 const ::std::string RilAppStatus::_default_app_label_;
 575 #ifndef _MSC_VER
 576 const int RilAppStatus::kAppTypeFieldNumber;
 577 const int RilAppStatus::kAppStateFieldNumber;
 578 const int RilAppStatus::kPersoSubstateFieldNumber;
 579 const int RilAppStatus::kAidFieldNumber;
 580 const int RilAppStatus::kAppLabelFieldNumber;
 581 const int RilAppStatus::kPin1ReplacedFieldNumber;
 582 const int RilAppStatus::kPin1FieldNumber;
 583 const int RilAppStatus::kPin2FieldNumber;
 584 #endif  // !_MSC_VER
 585
 586 RilAppStatus::RilAppStatus()
 587   : ::google::protobuf::Message() {
 588   SharedCtor();
 589 }
 590
 591 void RilAppStatus::InitAsDefaultInstance() {
 592 }
 593
 594 RilAppStatus::RilAppStatus(const RilAppStatus& from)
 595   : ::google::protobuf::Message() {
 596   SharedCtor();
 597   MergeFrom(from);
 598 }
 599
 600 void RilAppStatus::SharedCtor() {
 601   _cached_size_ = 0;
 602   app_type_ = 0;
 603   app_state_ = 0;
 604   perso_substate_ = 0;
 605   aid_ = const_cast< ::std::string*>(&_default_aid_);
 606   app_label_ = const_cast< ::std::string*>(&_default_app_label_);
 607   pin1_replaced_ = 0;
 608   pin1_ = 0;
 609   pin2_ = 0;
 610   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 611 }
 612
 613 RilAppStatus::~RilAppStatus() {
 614   SharedDtor();
 615 }
 616
 617 void RilAppStatus::SharedDtor() {
 618   if (aid_ != &_default_aid_) {
 619     delete aid_;
 620   }
 621   if (app_label_ != &_default_app_label_) {
 622     delete app_label_;
 623   }
 624   if (this != default_instance_) {
 625   }
 626 }
 627
 628 void RilAppStatus::SetCachedSize(int size) const {
 629   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
 630   _cached_size_ = size;
 631   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 632 }
 633 const ::google::protobuf::Descriptor* RilAppStatus::descriptor() {
 634   protobuf_AssignDescriptorsOnce();
 635   return RilAppStatus_descriptor_;
 636 }
 637
 638 const RilAppStatus& RilAppStatus::default_instance() {
 639   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
 640 }
 641
 642 RilAppStatus* RilAppStatus::default_instance_ = NULL;
 643
 644 RilAppStatus* RilAppStatus::New() const {
 645   return new RilAppStatus;
 646 }
 647
 648 void RilAppStatus::Clear() {
 649   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
 650     app_type_ = 0;
 651     app_state_ = 0;
 652     perso_substate_ = 0;
 653     if (_has_bit(3)) {
 654       if (aid_ != &_default_aid_) {
 655         aid_->clear();
 656       }
 657     }
 658     if (_has_bit(4)) {
 659       if (app_label_ != &_default_app_label_) {
 660         app_label_->clear();
 661       }
 662     }
 663     pin1_replaced_ = 0;
 664     pin1_ = 0;
 665     pin2_ = 0;
 666   }
 667   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 668   mutable_unknown_fields()->Clear();
 669 }
 670
 671 bool RilAppStatus::MergePartialFromCodedStream(
 672     ::google::protobuf::io::CodedInputStream* input) {
 673 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
 674   ::google::protobuf::uint32 tag;
 675   while ((tag = input->ReadTag()) != 0) {
 676     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
 677       // optional .ril_proto.RilAppType app_type = 1;
 678       case 1: {
 679         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 680             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
 681           int value;
 682           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
 683                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
 684                  input, &value)));
 685           if (ril_proto::RilAppType_IsValid(value)) {
 686             set_app_type(static_cast< ril_proto::RilAppType >(value));
 687           } else {
 688             mutable_unknown_fields()->AddVarint(1, value);
 689           }
 690         } else {
 691           goto handle_uninterpreted;
 692         }
 693         if (input->ExpectTag(16)) goto parse_app_state;
 694         break;
 695       }
 696
 697       // optional .ril_proto.RilAppState app_state = 2;
 698       case 2: {
 699         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 700             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
 701          parse_app_state:
 702           int value;
 703           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
 704                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
 705                  input, &value)));
 706           if (ril_proto::RilAppState_IsValid(value)) {
 707             set_app_state(static_cast< ril_proto::RilAppState >(value));
 708           } else {
 709             mutable_unknown_fields()->AddVarint(2, value);
 710           }
 711         } else {
 712           goto handle_uninterpreted;
 713         }
 714         if (input->ExpectTag(24)) goto parse_perso_substate;
 715         break;
 716       }
 717
 718       // optional .ril_proto.RilPersoSubstate perso_substate = 3;
 719       case 3: {
 720         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 721             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
 722          parse_perso_substate:
 723           int value;
 724           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
 725                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
 726                  input, &value)));
 727           if (ril_proto::RilPersoSubstate_IsValid(value)) {
 728             set_perso_substate(static_cast< ril_proto::RilPersoSubstate >(value));
 729           } else {
 730             mutable_unknown_fields()->AddVarint(3, value);
 731           }
 732         } else {
 733           goto handle_uninterpreted;
 734         }
 735         if (input->ExpectTag(34)) goto parse_aid;
 736         break;
 737       }
 738
 739       // optional string aid = 4;
 740       case 4: {
 741         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 742             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 743          parse_aid:
 744           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
 745                 input, this->mutable_aid()));
 746           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 747             this->aid().data(), this->aid().length(),
 748             ::google::protobuf::internal::WireFormat::PARSE);
 749         } else {
 750           goto handle_uninterpreted;
 751         }
 752         if (input->ExpectTag(42)) goto parse_app_label;
 753         break;
 754       }
 755
 756       // optional string app_label = 5;
 757       case 5: {
 758         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 759             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 760          parse_app_label:
 761           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
 762                 input, this->mutable_app_label()));
 763           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 764             this->app_label().data(), this->app_label().length(),
 765             ::google::protobuf::internal::WireFormat::PARSE);
 766         } else {
 767           goto handle_uninterpreted;
 768         }
 769         if (input->ExpectTag(48)) goto parse_pin1_replaced;
 770         break;
 771       }
 772
 773       // optional int32 pin1_replaced = 6;
 774       case 6: {
 775         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 776             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
 777          parse_pin1_replaced:
 778           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
 779                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
 780                  input, &pin1_replaced_)));
 781           _set_bit(5);
 782         } else {
 783           goto handle_uninterpreted;
 784         }
 785         if (input->ExpectTag(56)) goto parse_pin1;
 786         break;
 787       }
 788
 789       // optional .ril_proto.RilPinState pin1 = 7;
 790       case 7: {
 791         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 792             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
 793          parse_pin1:
 794           int value;
 795           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
 796                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
 797                  input, &value)));
 798           if (ril_proto::RilPinState_IsValid(value)) {
 799             set_pin1(static_cast< ril_proto::RilPinState >(value));
 800           } else {
 801             mutable_unknown_fields()->AddVarint(7, value);
 802           }
 803         } else {
 804           goto handle_uninterpreted;
 805         }
 806         if (input->ExpectTag(64)) goto parse_pin2;
 807         break;
 808       }
 809
 810       // optional .ril_proto.RilPinState pin2 = 8;
 811       case 8: {
 812         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 813             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
 814          parse_pin2:
 815           int value;
 816           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
 817                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
 818                  input, &value)));
 819           if (ril_proto::RilPinState_IsValid(value)) {
 820             set_pin2(static_cast< ril_proto::RilPinState >(value));
 821           } else {
 822             mutable_unknown_fields()->AddVarint(8, value);
 823           }
 824         } else {
 825           goto handle_uninterpreted;
 826         }
 827         if (input->ExpectAtEnd()) return true;
 828         break;
 829       }
 830
 831       default: {
 832       handle_uninterpreted:
 833         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 834             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
 835           return true;
 836         }
 837         DO_(::google::protobuf::internal::WireFormat::SkipField(
 838               input, tag, mutable_unknown_fields()));
 839         break;
 840       }
 841     }
 842   }
 843   return true;
 844 #undef DO_
 845 }
 846
 847 void RilAppStatus::SerializeWithCachedSizes(
 848     ::google::protobuf::io::CodedOutputStream* output) const {
 849   // optional .ril_proto.RilAppType app_type = 1;
 850   if (_has_bit(0)) {
 851     ::google::protobuf::internal::WireFormatLite::WriteEnum(
 852       1, this->app_type(), output);
 853   }
 854
 855   // optional .ril_proto.RilAppState app_state = 2;
 856   if (_has_bit(1)) {
 857     ::google::protobuf::internal::WireFormatLite::WriteEnum(
 858       2, this->app_state(), output);
 859   }
 860
 861   // optional .ril_proto.RilPersoSubstate perso_substate = 3;
 862   if (_has_bit(2)) {
 863     ::google::protobuf::internal::WireFormatLite::WriteEnum(
 864       3, this->perso_substate(), output);
 865   }
 866
 867   // optional string aid = 4;
 868   if (_has_bit(3)) {
 869     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 870       this->aid().data(), this->aid().length(),
 871       ::google::protobuf::internal::WireFormat::SERIALIZE);
 872     ::google::protobuf::internal::WireFormatLite::WriteString(
 873       4, this->aid(), output);
 874   }
 875
 876   // optional string app_label = 5;
 877   if (_has_bit(4)) {
 878     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 879       this->app_label().data(), this->app_label().length(),
 880       ::google::protobuf::internal::WireFormat::SERIALIZE);
 881     ::google::protobuf::internal::WireFormatLite::WriteString(
 882       5, this->app_label(), output);
 883   }
 884
 885   // optional int32 pin1_replaced = 6;
 886   if (_has_bit(5)) {
 887     ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->pin1_replaced(), output);
 888   }
 889
 890   // optional .ril_proto.RilPinState pin1 = 7;
 891   if (_has_bit(6)) {
 892     ::google::protobuf::internal::WireFormatLite::WriteEnum(
 893       7, this->pin1(), output);
 894   }
 895
 896   // optional .ril_proto.RilPinState pin2 = 8;
 897   if (_has_bit(7)) {
 898     ::google::protobuf::internal::WireFormatLite::WriteEnum(
 899       8, this->pin2(), output);
 900   }
 901
 902   if (!unknown_fields().empty()) {
 903     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
 904         unknown_fields(), output);
 905   }
 906 }
 907
 908 ::google::protobuf::uint8* RilAppStatus::SerializeWithCachedSizesToArray(
 909     ::google::protobuf::uint8* target) const {
 910   // optional .ril_proto.RilAppType app_type = 1;
 911   if (_has_bit(0)) {
 912     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
 913       1, this->app_type(), target);
 914   }
 915
 916   // optional .ril_proto.RilAppState app_state = 2;
 917   if (_has_bit(1)) {
 918     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
 919       2, this->app_state(), target);
 920   }
 921
 922   // optional .ril_proto.RilPersoSubstate perso_substate = 3;
 923   if (_has_bit(2)) {
 924     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
 925       3, this->perso_substate(), target);
 926   }
 927
 928   // optional string aid = 4;
 929   if (_has_bit(3)) {
 930     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 931       this->aid().data(), this->aid().length(),
 932       ::google::protobuf::internal::WireFormat::SERIALIZE);
 933     target =
 934       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
 935         4, this->aid(), target);
 936   }
 937
 938   // optional string app_label = 5;
 939   if (_has_bit(4)) {
 940     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 941       this->app_label().data(), this->app_label().length(),
 942       ::google::protobuf::internal::WireFormat::SERIALIZE);
 943     target =
 944       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
 945         5, this->app_label(), target);
 946   }
 947
 948   // optional int32 pin1_replaced = 6;
 949   if (_has_bit(5)) {
 950     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->pin1_replaced(), target);
 951   }
 952
 953   // optional .ril_proto.RilPinState pin1 = 7;
 954   if (_has_bit(6)) {
 955     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
 956       7, this->pin1(), target);
 957   }
 958
 959   // optional .ril_proto.RilPinState pin2 = 8;
 960   if (_has_bit(7)) {
 961     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
 962       8, this->pin2(), target);
 963   }
 964
 965   if (!unknown_fields().empty()) {
 966     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
 967         unknown_fields(), target);
 968   }
 969   return target;
 970 }
 971
 972 int RilAppStatus::ByteSize() const {
 973   int total_size = 0;
 974
 975   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
 976     // optional .ril_proto.RilAppType app_type = 1;
 977     if (has_app_type()) {
 978       total_size += 1 +
 979         ::google::protobuf::internal::WireFormatLite::EnumSize(this->app_type());
 980     }
 981
 982     // optional .ril_proto.RilAppState app_state = 2;
 983     if (has_app_state()) {
 984       total_size += 1 +
 985         ::google::protobuf::internal::WireFormatLite::EnumSize(this->app_state());
 986     }
 987
 988     // optional .ril_proto.RilPersoSubstate perso_substate = 3;
 989     if (has_perso_substate()) {
 990       total_size += 1 +
 991         ::google::protobuf::internal::WireFormatLite::EnumSize(this->perso_substate());
 992     }
 993
 994     // optional string aid = 4;
 995     if (has_aid()) {
 996       total_size += 1 +
 997         ::google::protobuf::internal::WireFormatLite::StringSize(
 998           this->aid());
 999     }
1000
1001     // optional string app_label = 5;
1002     if (has_app_label()) {
1003       total_size += 1 +
1004         ::google::protobuf::internal::WireFormatLite::StringSize(
1005           this->app_label());
1006     }
1007
1008     // optional int32 pin1_replaced = 6;
1009     if (has_pin1_replaced()) {
1010       total_size += 1 +
1011         ::google::protobuf::internal::WireFormatLite::Int32Size(
1012           this->pin1_replaced());
1013     }
1014
1015     // optional .ril_proto.RilPinState pin1 = 7;
1016     if (has_pin1()) {
1017       total_size += 1 +
1018         ::google::protobuf::internal::WireFormatLite::EnumSize(this->pin1());
1019     }
1020
1021     // optional .ril_proto.RilPinState pin2 = 8;
1022     if (has_pin2()) {
1023       total_size += 1 +
1024         ::google::protobuf::internal::WireFormatLite::EnumSize(this->pin2());
1025     }
1026
1027   }
1028   if (!unknown_fields().empty()) {
1029     total_size +=
1030       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1031         unknown_fields());
1032   }
1033   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1034   _cached_size_ = total_size;
1035   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1036   return total_size;
1037 }
1038
1039 void RilAppStatus::MergeFrom(const ::google::protobuf::Message& from) {
1040   GOOGLE_CHECK_NE(&from, this);
1041   const RilAppStatus* source =
1042     ::google::protobuf::internal::dynamic_cast_if_available<const RilAppStatus*>(
1043       &from);
1044   if (source == NULL) {
1045     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1046   } else {
1047     MergeFrom(*source);
1048   }
1049 }
1050
1051 void RilAppStatus::MergeFrom(const RilAppStatus& from) {
1052   GOOGLE_CHECK_NE(&from, this);
1053   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1054     if (from._has_bit(0)) {
1055       set_app_type(from.app_type());
1056     }
1057     if (from._has_bit(1)) {
1058       set_app_state(from.app_state());
1059     }
1060     if (from._has_bit(2)) {
1061       set_perso_substate(from.perso_substate());
1062     }
1063     if (from._has_bit(3)) {
1064       set_aid(from.aid());
1065     }
1066     if (from._has_bit(4)) {
1067       set_app_label(from.app_label());
1068     }
1069     if (from._has_bit(5)) {
1070       set_pin1_replaced(from.pin1_replaced());
1071     }
1072     if (from._has_bit(6)) {
1073       set_pin1(from.pin1());
1074     }
1075     if (from._has_bit(7)) {
1076       set_pin2(from.pin2());
1077     }
1078   }
1079   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
1080 }
1081
1082 void RilAppStatus::CopyFrom(const ::google::protobuf::Message& from) {
1083   if (&from == this) return;
1084   Clear();
1085   MergeFrom(from);
1086 }
1087
1088 void RilAppStatus::CopyFrom(const RilAppStatus& from) {
1089   if (&from == this) return;
1090   Clear();
1091   MergeFrom(from);
1092 }
1093
1094 bool RilAppStatus::IsInitialized() const {
1095
1096   return true;
1097 }
1098
1099 void RilAppStatus::Swap(RilAppStatus* other) {
1100   if (other != this) {
1101     std::swap(app_type_, other->app_type_);
1102     std::swap(app_state_, other->app_state_);
1103     std::swap(perso_substate_, other->perso_substate_);
1104     std::swap(aid_, other->aid_);
1105     std::swap(app_label_, other->app_label_);
1106     std::swap(pin1_replaced_, other->pin1_replaced_);
1107     std::swap(pin1_, other->pin1_);
1108     std::swap(pin2_, other->pin2_);
1109     std::swap(_has_bits_[0], other->_has_bits_[0]);
1110     _unknown_fields_.Swap(&other->_unknown_fields_);
1111     std::swap(_cached_size_, other->_cached_size_);
1112   }
1113 }
1114
1115 ::google::protobuf::Metadata RilAppStatus::GetMetadata() const {
1116   protobuf_AssignDescriptorsOnce();
1117   ::google::protobuf::Metadata metadata;
1118   metadata.descriptor = RilAppStatus_descriptor_;
1119   metadata.reflection = RilAppStatus_reflection_;
1120   return metadata;
1121 }
1122
1123
1124 // ===================================================================
1125
1126 #ifndef _MSC_VER
1127 const int RilCardStatus::kCardStateFieldNumber;
1128 const int RilCardStatus::kUniversalPinStateFieldNumber;
1129 const int RilCardStatus::kGsmUmtsSubscriptionAppIndexFieldNumber;
1130 const int RilCardStatus::kCdmaSubscriptionAppIndexFieldNumber;
1131 const int RilCardStatus::kNumApplicationsFieldNumber;
1132 const int RilCardStatus::kApplicationsFieldNumber;
1133 #endif  // !_MSC_VER
1134
1135 RilCardStatus::RilCardStatus()
1136   : ::google::protobuf::Message() {
1137   SharedCtor();
1138 }
1139
1140 void RilCardStatus::InitAsDefaultInstance() {
1141 }
1142
1143 RilCardStatus::RilCardStatus(const RilCardStatus& from)
1144   : ::google::protobuf::Message() {
1145   SharedCtor();
1146   MergeFrom(from);
1147 }
1148
1149 void RilCardStatus::SharedCtor() {
1150   _cached_size_ = 0;
1151   card_state_ = 0;
1152   universal_pin_state_ = 0;
1153   gsm_umts_subscription_app_index_ = 0;
1154   cdma_subscription_app_index_ = 0;
1155   num_applications_ = 0;
1156   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1157 }
1158
1159 RilCardStatus::~RilCardStatus() {
1160   SharedDtor();
1161 }
1162
1163 void RilCardStatus::SharedDtor() {
1164   if (this != default_instance_) {
1165   }
1166 }
1167
1168 void RilCardStatus::SetCachedSize(int size) const {
1169   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1170   _cached_size_ = size;
1171   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1172 }
1173 const ::google::protobuf::Descriptor* RilCardStatus::descriptor() {
1174   protobuf_AssignDescriptorsOnce();
1175   return RilCardStatus_descriptor_;
1176 }
1177
1178 const RilCardStatus& RilCardStatus::default_instance() {
1179   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
1180 }
1181
1182 RilCardStatus* RilCardStatus::default_instance_ = NULL;
1183
1184 RilCardStatus* RilCardStatus::New() const {
1185   return new RilCardStatus;
1186 }
1187
1188 void RilCardStatus::Clear() {
1189   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1190     card_state_ = 0;
1191     universal_pin_state_ = 0;
1192     gsm_umts_subscription_app_index_ = 0;
1193     cdma_subscription_app_index_ = 0;
1194     num_applications_ = 0;
1195   }
1196   applications_.Clear();
1197   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1198   mutable_unknown_fields()->Clear();
1199 }
1200
1201 bool RilCardStatus::MergePartialFromCodedStream(
1202     ::google::protobuf::io::CodedInputStream* input) {
1203 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
1204   ::google::protobuf::uint32 tag;
1205   while ((tag = input->ReadTag()) != 0) {
1206     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1207       // optional .ril_proto.RilCardState card_state = 1;
1208       case 1: {
1209         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1210             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1211           int value;
1212           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1213                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
1214                  input, &value)));
1215           if (ril_proto::RilCardState_IsValid(value)) {
1216             set_card_state(static_cast< ril_proto::RilCardState >(value));
1217           } else {
1218             mutable_unknown_fields()->AddVarint(1, value);
1219           }
1220         } else {
1221           goto handle_uninterpreted;
1222         }
1223         if (input->ExpectTag(16)) goto parse_universal_pin_state;
1224         break;
1225       }
1226
1227       // optional .ril_proto.RilPinState universal_pin_state = 2;
1228       case 2: {
1229         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1230             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1231          parse_universal_pin_state:
1232           int value;
1233           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1234                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
1235                  input, &value)));
1236           if (ril_proto::RilPinState_IsValid(value)) {
1237             set_universal_pin_state(static_cast< ril_proto::RilPinState >(value));
1238           } else {
1239             mutable_unknown_fields()->AddVarint(2, value);
1240           }
1241         } else {
1242           goto handle_uninterpreted;
1243         }
1244         if (input->ExpectTag(24)) goto parse_gsm_umts_subscription_app_index;
1245         break;
1246       }
1247
1248       // optional int32 gsm_umts_subscription_app_index = 3;
1249       case 3: {
1250         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1251             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1252          parse_gsm_umts_subscription_app_index:
1253           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1254                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
1255                  input, &gsm_umts_subscription_app_index_)));
1256           _set_bit(2);
1257         } else {
1258           goto handle_uninterpreted;
1259         }
1260         if (input->ExpectTag(32)) goto parse_cdma_subscription_app_index;
1261         break;
1262       }
1263
1264       // optional int32 cdma_subscription_app_index = 4;
1265       case 4: {
1266         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1267             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1268          parse_cdma_subscription_app_index:
1269           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1270                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
1271                  input, &cdma_subscription_app_index_)));
1272           _set_bit(3);
1273         } else {
1274           goto handle_uninterpreted;
1275         }
1276         if (input->ExpectTag(40)) goto parse_num_applications;
1277         break;
1278       }
1279
1280       // optional int32 num_applications = 5;
1281       case 5: {
1282         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1283             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1284          parse_num_applications:
1285           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1286                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
1287                  input, &num_applications_)));
1288           _set_bit(4);
1289         } else {
1290           goto handle_uninterpreted;
1291         }
1292         if (input->ExpectTag(50)) goto parse_applications;
1293         break;
1294       }
1295
1296       // repeated .ril_proto.RilAppStatus applications = 6;
1297       case 6: {
1298         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1299             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1300          parse_applications:
1301           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1302                 input, add_applications()));
1303         } else {
1304           goto handle_uninterpreted;
1305         }
1306         if (input->ExpectTag(50)) goto parse_applications;
1307         if (input->ExpectAtEnd()) return true;
1308         break;
1309       }
1310
1311       default: {
1312       handle_uninterpreted:
1313         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1314             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
1315           return true;
1316         }
1317         DO_(::google::protobuf::internal::WireFormat::SkipField(
1318               input, tag, mutable_unknown_fields()));
1319         break;
1320       }
1321     }
1322   }
1323   return true;
1324 #undef DO_
1325 }
1326
1327 void RilCardStatus::SerializeWithCachedSizes(
1328     ::google::protobuf::io::CodedOutputStream* output) const {
1329   // optional .ril_proto.RilCardState card_state = 1;
1330   if (_has_bit(0)) {
1331     ::google::protobuf::internal::WireFormatLite::WriteEnum(
1332       1, this->card_state(), output);
1333   }
1334
1335   // optional .ril_proto.RilPinState universal_pin_state = 2;
1336   if (_has_bit(1)) {
1337     ::google::protobuf::internal::WireFormatLite::WriteEnum(
1338       2, this->universal_pin_state(), output);
1339   }
1340
1341   // optional int32 gsm_umts_subscription_app_index = 3;
1342   if (_has_bit(2)) {
1343     ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->gsm_umts_subscription_app_index(), output);
1344   }
1345
1346   // optional int32 cdma_subscription_app_index = 4;
1347   if (_has_bit(3)) {
1348     ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->cdma_subscription_app_index(), output);
1349   }
1350
1351   // optional int32 num_applications = 5;
1352   if (_has_bit(4)) {
1353     ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->num_applications(), output);
1354   }
1355
1356   // repeated .ril_proto.RilAppStatus applications = 6;
1357   for (int i = 0; i < this->applications_size(); i++) {
1358     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1359       6, this->applications(i), output);
1360   }
1361
1362   if (!unknown_fields().empty()) {
1363     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1364         unknown_fields(), output);
1365   }
1366 }
1367
1368 ::google::protobuf::uint8* RilCardStatus::SerializeWithCachedSizesToArray(
1369     ::google::protobuf::uint8* target) const {
1370   // optional .ril_proto.RilCardState card_state = 1;
1371   if (_has_bit(0)) {
1372     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
1373       1, this->card_state(), target);
1374   }
1375
1376   // optional .ril_proto.RilPinState universal_pin_state = 2;
1377   if (_has_bit(1)) {
1378     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
1379       2, this->universal_pin_state(), target);
1380   }
1381
1382   // optional int32 gsm_umts_subscription_app_index = 3;
1383   if (_has_bit(2)) {
1384     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->gsm_umts_subscription_app_index(), target);
1385   }
1386
1387   // optional int32 cdma_subscription_app_index = 4;
1388   if (_has_bit(3)) {
1389     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->cdma_subscription_app_index(), target);
1390   }
1391
1392   // optional int32 num_applications = 5;
1393   if (_has_bit(4)) {
1394     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->num_applications(), target);
1395   }
1396
1397   // repeated .ril_proto.RilAppStatus applications = 6;
1398   for (int i = 0; i < this->applications_size(); i++) {
1399     target = ::google::protobuf::internal::WireFormatLite::
1400       WriteMessageNoVirtualToArray(
1401         6, this->applications(i), target);
1402   }
1403
1404   if (!unknown_fields().empty()) {
1405     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
1406         unknown_fields(), target);
1407   }
1408   return target;
1409 }
1410
1411 int RilCardStatus::ByteSize() const {
1412   int total_size = 0;
1413
1414   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1415     // optional .ril_proto.RilCardState card_state = 1;
1416     if (has_card_state()) {
1417       total_size += 1 +
1418         ::google::protobuf::internal::WireFormatLite::EnumSize(this->card_state());
1419     }
1420
1421     // optional .ril_proto.RilPinState universal_pin_state = 2;
1422     if (has_universal_pin_state()) {
1423       total_size += 1 +
1424         ::google::protobuf::internal::WireFormatLite::EnumSize(this->universal_pin_state());
1425     }
1426
1427     // optional int32 gsm_umts_subscription_app_index = 3;
1428     if (has_gsm_umts_subscription_app_index()) {
1429       total_size += 1 +
1430         ::google::protobuf::internal::WireFormatLite::Int32Size(
1431           this->gsm_umts_subscription_app_index());
1432     }
1433
1434     // optional int32 cdma_subscription_app_index = 4;
1435     if (has_cdma_subscription_app_index()) {
1436       total_size += 1 +
1437         ::google::protobuf::internal::WireFormatLite::Int32Size(
1438           this->cdma_subscription_app_index());
1439     }
1440
1441     // optional int32 num_applications = 5;
1442     if (has_num_applications()) {
1443       total_size += 1 +
1444         ::google::protobuf::internal::WireFormatLite::Int32Size(
1445           this->num_applications());
1446     }
1447
1448   }
1449   // repeated .ril_proto.RilAppStatus applications = 6;
1450   total_size += 1 * this->applications_size();
1451   for (int i = 0; i < this->applications_size(); i++) {
1452     total_size +=
1453       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1454         this->applications(i));
1455   }
1456
1457   if (!unknown_fields().empty()) {
1458     total_size +=
1459       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1460         unknown_fields());
1461   }
1462   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1463   _cached_size_ = total_size;
1464   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1465   return total_size;
1466 }
1467
1468 void RilCardStatus::MergeFrom(const ::google::protobuf::Message& from) {
1469   GOOGLE_CHECK_NE(&from, this);
1470   const RilCardStatus* source =
1471     ::google::protobuf::internal::dynamic_cast_if_available<const RilCardStatus*>(
1472       &from);
1473   if (source == NULL) {
1474     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1475   } else {
1476     MergeFrom(*source);
1477   }
1478 }
1479
1480 void RilCardStatus::MergeFrom(const RilCardStatus& from) {
1481   GOOGLE_CHECK_NE(&from, this);
1482   applications_.MergeFrom(from.applications_);
1483   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1484     if (from._has_bit(0)) {
1485       set_card_state(from.card_state());
1486     }
1487     if (from._has_bit(1)) {
1488       set_universal_pin_state(from.universal_pin_state());
1489     }
1490     if (from._has_bit(2)) {
1491       set_gsm_umts_subscription_app_index(from.gsm_umts_subscription_app_index());
1492     }
1493     if (from._has_bit(3)) {
1494       set_cdma_subscription_app_index(from.cdma_subscription_app_index());
1495     }
1496     if (from._has_bit(4)) {
1497       set_num_applications(from.num_applications());
1498     }
1499   }
1500   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
1501 }
1502
1503 void RilCardStatus::CopyFrom(const ::google::protobuf::Message& from) {
1504   if (&from == this) return;
1505   Clear();
1506   MergeFrom(from);
1507 }
1508
1509 void RilCardStatus::CopyFrom(const RilCardStatus& from) {
1510   if (&from == this) return;
1511   Clear();
1512   MergeFrom(from);
1513 }
1514
1515 bool RilCardStatus::IsInitialized() const {
1516
1517   return true;
1518 }
1519
1520 void RilCardStatus::Swap(RilCardStatus* other) {
1521   if (other != this) {
1522     std::swap(card_state_, other->card_state_);
1523     std::swap(universal_pin_state_, other->universal_pin_state_);
1524     std::swap(gsm_umts_subscription_app_index_, other->gsm_umts_subscription_app_index_);
1525     std::swap(cdma_subscription_app_index_, other->cdma_subscription_app_index_);
1526     std::swap(num_applications_, other->num_applications_);
1527     applications_.Swap(&other->applications_);
1528     std::swap(_has_bits_[0], other->_has_bits_[0]);
1529     _unknown_fields_.Swap(&other->_unknown_fields_);
1530     std::swap(_cached_size_, other->_cached_size_);
1531   }
1532 }
1533
1534 ::google::protobuf::Metadata RilCardStatus::GetMetadata() const {
1535   protobuf_AssignDescriptorsOnce();
1536   ::google::protobuf::Metadata metadata;
1537   metadata.descriptor = RilCardStatus_descriptor_;
1538   metadata.reflection = RilCardStatus_reflection_;
1539   return metadata;
1540 }
1541
1542
1543 // ===================================================================
1544
1545 #ifndef _MSC_VER
1546 const int RspStrings::kStringsFieldNumber;
1547 #endif  // !_MSC_VER
1548
1549 RspStrings::RspStrings()
1550   : ::google::protobuf::Message() {
1551   SharedCtor();
1552 }
1553
1554 void RspStrings::InitAsDefaultInstance() {
1555 }
1556
1557 RspStrings::RspStrings(const RspStrings& from)
1558   : ::google::protobuf::Message() {
1559   SharedCtor();
1560   MergeFrom(from);
1561 }
1562
1563 void RspStrings::SharedCtor() {
1564   _cached_size_ = 0;
1565   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1566 }
1567
1568 RspStrings::~RspStrings() {
1569   SharedDtor();
1570 }
1571
1572 void RspStrings::SharedDtor() {
1573   if (this != default_instance_) {
1574   }
1575 }
1576
1577 void RspStrings::SetCachedSize(int size) const {
1578   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1579   _cached_size_ = size;
1580   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1581 }
1582 const ::google::protobuf::Descriptor* RspStrings::descriptor() {
1583   protobuf_AssignDescriptorsOnce();
1584   return RspStrings_descriptor_;
1585 }
1586
1587 const RspStrings& RspStrings::default_instance() {
1588   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
1589 }
1590
1591 RspStrings* RspStrings::default_instance_ = NULL;
1592
1593 RspStrings* RspStrings::New() const {
1594   return new RspStrings;
1595 }
1596
1597 void RspStrings::Clear() {
1598   strings_.Clear();
1599   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1600   mutable_unknown_fields()->Clear();
1601 }
1602
1603 bool RspStrings::MergePartialFromCodedStream(
1604     ::google::protobuf::io::CodedInputStream* input) {
1605 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
1606   ::google::protobuf::uint32 tag;
1607   while ((tag = input->ReadTag()) != 0) {
1608     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1609       // repeated string strings = 1;
1610       case 1: {
1611         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1612             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1613          parse_strings:
1614           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1615                 input, this->add_strings()));
1616           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1617             this->strings(0).data(), this->strings(0).length(),
1618             ::google::protobuf::internal::WireFormat::PARSE);
1619         } else {
1620           goto handle_uninterpreted;
1621         }
1622         if (input->ExpectTag(10)) goto parse_strings;
1623         if (input->ExpectAtEnd()) return true;
1624         break;
1625       }
1626
1627       default: {
1628       handle_uninterpreted:
1629         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1630             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
1631           return true;
1632         }
1633         DO_(::google::protobuf::internal::WireFormat::SkipField(
1634               input, tag, mutable_unknown_fields()));
1635         break;
1636       }
1637     }
1638   }
1639   return true;
1640 #undef DO_
1641 }
1642
1643 void RspStrings::SerializeWithCachedSizes(
1644     ::google::protobuf::io::CodedOutputStream* output) const {
1645   // repeated string strings = 1;
1646   for (int i = 0; i < this->strings_size(); i++) {
1647   ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1648     this->strings(i).data(), this->strings(i).length(),
1649     ::google::protobuf::internal::WireFormat::SERIALIZE);
1650     ::google::protobuf::internal::WireFormatLite::WriteString(
1651       1, this->strings(i), output);
1652   }
1653
1654   if (!unknown_fields().empty()) {
1655     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1656         unknown_fields(), output);
1657   }
1658 }
1659
1660 ::google::protobuf::uint8* RspStrings::SerializeWithCachedSizesToArray(
1661     ::google::protobuf::uint8* target) const {
1662   // repeated string strings = 1;
1663   for (int i = 0; i < this->strings_size(); i++) {
1664     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1665       this->strings(i).data(), this->strings(i).length(),
1666       ::google::protobuf::internal::WireFormat::SERIALIZE);
1667     target = ::google::protobuf::internal::WireFormatLite::
1668       WriteStringToArray(1, this->strings(i), target);
1669   }
1670
1671   if (!unknown_fields().empty()) {
1672     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
1673         unknown_fields(), target);
1674   }
1675   return target;
1676 }
1677
1678 int RspStrings::ByteSize() const {
1679   int total_size = 0;
1680
1681   // repeated string strings = 1;
1682   total_size += 1 * this->strings_size();
1683   for (int i = 0; i < this->strings_size(); i++) {
1684     total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
1685       this->strings(i));
1686   }
1687
1688   if (!unknown_fields().empty()) {
1689     total_size +=
1690       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1691         unknown_fields());
1692   }
1693   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1694   _cached_size_ = total_size;
1695   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1696   return total_size;
1697 }
1698
1699 void RspStrings::MergeFrom(const ::google::protobuf::Message& from) {
1700   GOOGLE_CHECK_NE(&from, this);
1701   const RspStrings* source =
1702     ::google::protobuf::internal::dynamic_cast_if_available<const RspStrings*>(
1703       &from);
1704   if (source == NULL) {
1705     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1706   } else {
1707     MergeFrom(*source);
1708   }
1709 }
1710
1711 void RspStrings::MergeFrom(const RspStrings& from) {
1712   GOOGLE_CHECK_NE(&from, this);
1713   strings_.MergeFrom(from.strings_);
1714   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
1715 }
1716
1717 void RspStrings::CopyFrom(const ::google::protobuf::Message& from) {
1718   if (&from == this) return;
1719   Clear();
1720   MergeFrom(from);
1721 }
1722
1723 void RspStrings::CopyFrom(const RspStrings& from) {
1724   if (&from == this) return;
1725   Clear();
1726   MergeFrom(from);
1727 }
1728
1729 bool RspStrings::IsInitialized() const {
1730
1731   return true;
1732 }
1733
1734 void RspStrings::Swap(RspStrings* other) {
1735   if (other != this) {
1736     strings_.Swap(&other->strings_);
1737     std::swap(_has_bits_[0], other->_has_bits_[0]);
1738     _unknown_fields_.Swap(&other->_unknown_fields_);
1739     std::swap(_cached_size_, other->_cached_size_);
1740   }
1741 }
1742
1743 ::google::protobuf::Metadata RspStrings::GetMetadata() const {
1744   protobuf_AssignDescriptorsOnce();
1745   ::google::protobuf::Metadata metadata;
1746   metadata.descriptor = RspStrings_descriptor_;
1747   metadata.reflection = RspStrings_reflection_;
1748   return metadata;
1749 }
1750
1751
1752 // ===================================================================
1753
1754 #ifndef _MSC_VER
1755 const int RspIntegers::kIntegersFieldNumber;
1756 #endif  // !_MSC_VER
1757
1758 RspIntegers::RspIntegers()
1759   : ::google::protobuf::Message() {
1760   SharedCtor();
1761 }
1762
1763 void RspIntegers::InitAsDefaultInstance() {
1764 }
1765
1766 RspIntegers::RspIntegers(const RspIntegers& from)
1767   : ::google::protobuf::Message() {
1768   SharedCtor();
1769   MergeFrom(from);
1770 }
1771
1772 void RspIntegers::SharedCtor() {
1773   _cached_size_ = 0;
1774   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1775 }
1776
1777 RspIntegers::~RspIntegers() {
1778   SharedDtor();
1779 }
1780
1781 void RspIntegers::SharedDtor() {
1782   if (this != default_instance_) {
1783   }
1784 }
1785
1786 void RspIntegers::SetCachedSize(int size) const {
1787   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1788   _cached_size_ = size;
1789   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1790 }
1791 const ::google::protobuf::Descriptor* RspIntegers::descriptor() {
1792   protobuf_AssignDescriptorsOnce();
1793   return RspIntegers_descriptor_;
1794 }
1795
1796 const RspIntegers& RspIntegers::default_instance() {
1797   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
1798 }
1799
1800 RspIntegers* RspIntegers::default_instance_ = NULL;
1801
1802 RspIntegers* RspIntegers::New() const {
1803   return new RspIntegers;
1804 }
1805
1806 void RspIntegers::Clear() {
1807   integers_.Clear();
1808   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1809   mutable_unknown_fields()->Clear();
1810 }
1811
1812 bool RspIntegers::MergePartialFromCodedStream(
1813     ::google::protobuf::io::CodedInputStream* input) {
1814 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
1815   ::google::protobuf::uint32 tag;
1816   while ((tag = input->ReadTag()) != 0) {
1817     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1818       // repeated int32 integers = 1;
1819       case 1: {
1820         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1821             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1822          parse_integers:
1823           DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
1824                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
1825                  1, 8, input, this->mutable_integers())));
1826         } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
1827                    == ::google::protobuf::internal::WireFormatLite::
1828                       WIRETYPE_LENGTH_DELIMITED) {
1829           DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
1830                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
1831                  input, this->mutable_integers())));
1832         } else {
1833           goto handle_uninterpreted;
1834         }
1835         if (input->ExpectTag(8)) goto parse_integers;
1836         if (input->ExpectAtEnd()) return true;
1837         break;
1838       }
1839
1840       default: {
1841       handle_uninterpreted:
1842         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1843             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
1844           return true;
1845         }
1846         DO_(::google::protobuf::internal::WireFormat::SkipField(
1847               input, tag, mutable_unknown_fields()));
1848         break;
1849       }
1850     }
1851   }
1852   return true;
1853 #undef DO_
1854 }
1855
1856 void RspIntegers::SerializeWithCachedSizes(
1857     ::google::protobuf::io::CodedOutputStream* output) const {
1858   // repeated int32 integers = 1;
1859   for (int i = 0; i < this->integers_size(); i++) {
1860     ::google::protobuf::internal::WireFormatLite::WriteInt32(
1861       1, this->integers(i), output);
1862   }
1863
1864   if (!unknown_fields().empty()) {
1865     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1866         unknown_fields(), output);
1867   }
1868 }
1869
1870 ::google::protobuf::uint8* RspIntegers::SerializeWithCachedSizesToArray(
1871     ::google::protobuf::uint8* target) const {
1872   // repeated int32 integers = 1;
1873   for (int i = 0; i < this->integers_size(); i++) {
1874     target = ::google::protobuf::internal::WireFormatLite::
1875       WriteInt32ToArray(1, this->integers(i), target);
1876   }
1877
1878   if (!unknown_fields().empty()) {
1879     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
1880         unknown_fields(), target);
1881   }
1882   return target;
1883 }
1884
1885 int RspIntegers::ByteSize() const {
1886   int total_size = 0;
1887
1888   // repeated int32 integers = 1;
1889   {
1890     int data_size = 0;
1891     for (int i = 0; i < this->integers_size(); i++) {
1892       data_size += ::google::protobuf::internal::WireFormatLite::
1893         Int32Size(this->integers(i));
1894     }
1895     total_size += 1 * this->integers_size() + data_size;
1896   }
1897
1898   if (!unknown_fields().empty()) {
1899     total_size +=
1900       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1901         unknown_fields());
1902   }
1903   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1904   _cached_size_ = total_size;
1905   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1906   return total_size;
1907 }
1908
1909 void RspIntegers::MergeFrom(const ::google::protobuf::Message& from) {
1910   GOOGLE_CHECK_NE(&from, this);
1911   const RspIntegers* source =
1912     ::google::protobuf::internal::dynamic_cast_if_available<const RspIntegers*>(
1913       &from);
1914   if (source == NULL) {
1915     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1916   } else {
1917     MergeFrom(*source);
1918   }
1919 }
1920
1921 void RspIntegers::MergeFrom(const RspIntegers& from) {
1922   GOOGLE_CHECK_NE(&from, this);
1923   integers_.MergeFrom(from.integers_);
1924   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
1925 }
1926
1927 void RspIntegers::CopyFrom(const ::google::protobuf::Message& from) {
1928   if (&from == this) return;
1929   Clear();
1930   MergeFrom(from);
1931 }
1932
1933 void RspIntegers::CopyFrom(const RspIntegers& from) {
1934   if (&from == this) return;
1935   Clear();
1936   MergeFrom(from);
1937 }
1938
1939 bool RspIntegers::IsInitialized() const {
1940
1941   return true;
1942 }
1943
1944 void RspIntegers::Swap(RspIntegers* other) {
1945   if (other != this) {
1946     integers_.Swap(&other->integers_);
1947     std::swap(_has_bits_[0], other->_has_bits_[0]);
1948     _unknown_fields_.Swap(&other->_unknown_fields_);
1949     std::swap(_cached_size_, other->_cached_size_);
1950   }
1951 }
1952
1953 ::google::protobuf::Metadata RspIntegers::GetMetadata() const {
1954   protobuf_AssignDescriptorsOnce();
1955   ::google::protobuf::Metadata metadata;
1956   metadata.descriptor = RspIntegers_descriptor_;
1957   metadata.reflection = RspIntegers_reflection_;
1958   return metadata;
1959 }
1960
1961
1962 // ===================================================================
1963
1964 #ifndef _MSC_VER
1965 #endif  // !_MSC_VER
1966
1967 ReqGetSimStatus::ReqGetSimStatus()
1968   : ::google::protobuf::Message() {
1969   SharedCtor();
1970 }
1971
1972 void ReqGetSimStatus::InitAsDefaultInstance() {
1973 }
1974
1975 ReqGetSimStatus::ReqGetSimStatus(const ReqGetSimStatus& from)
1976   : ::google::protobuf::Message() {
1977   SharedCtor();
1978   MergeFrom(from);
1979 }
1980
1981 void ReqGetSimStatus::SharedCtor() {
1982   _cached_size_ = 0;
1983   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1984 }
1985
1986 ReqGetSimStatus::~ReqGetSimStatus() {
1987   SharedDtor();
1988 }
1989
1990 void ReqGetSimStatus::SharedDtor() {
1991   if (this != default_instance_) {
1992   }
1993 }
1994
1995 void ReqGetSimStatus::SetCachedSize(int size) const {
1996   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1997   _cached_size_ = size;
1998   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1999 }
2000 const ::google::protobuf::Descriptor* ReqGetSimStatus::descriptor() {
2001   protobuf_AssignDescriptorsOnce();
2002   return ReqGetSimStatus_descriptor_;
2003 }
2004
2005 const ReqGetSimStatus& ReqGetSimStatus::default_instance() {
2006   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
2007 }
2008
2009 ReqGetSimStatus* ReqGetSimStatus::default_instance_ = NULL;
2010
2011 ReqGetSimStatus* ReqGetSimStatus::New() const {
2012   return new ReqGetSimStatus;
2013 }
2014
2015 void ReqGetSimStatus::Clear() {
2016   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2017   mutable_unknown_fields()->Clear();
2018 }
2019
2020 bool ReqGetSimStatus::MergePartialFromCodedStream(
2021     ::google::protobuf::io::CodedInputStream* input) {
2022 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
2023   ::google::protobuf::uint32 tag;
2024   while ((tag = input->ReadTag()) != 0) {
2025     if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2026         ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
2027       return true;
2028     }
2029     DO_(::google::protobuf::internal::WireFormat::SkipField(
2030           input, tag, mutable_unknown_fields()));
2031   }
2032   return true;
2033 #undef DO_
2034 }
2035
2036 void ReqGetSimStatus::SerializeWithCachedSizes(
2037     ::google::protobuf::io::CodedOutputStream* output) const {
2038   if (!unknown_fields().empty()) {
2039     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
2040         unknown_fields(), output);
2041   }
2042 }
2043
2044 ::google::protobuf::uint8* ReqGetSimStatus::SerializeWithCachedSizesToArray(
2045     ::google::protobuf::uint8* target) const {
2046   if (!unknown_fields().empty()) {
2047     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
2048         unknown_fields(), target);
2049   }
2050   return target;
2051 }
2052
2053 int ReqGetSimStatus::ByteSize() const {
2054   int total_size = 0;
2055
2056   if (!unknown_fields().empty()) {
2057     total_size +=
2058       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
2059         unknown_fields());
2060   }
2061   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2062   _cached_size_ = total_size;
2063   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2064   return total_size;
2065 }
2066
2067 void ReqGetSimStatus::MergeFrom(const ::google::protobuf::Message& from) {
2068   GOOGLE_CHECK_NE(&from, this);
2069   const ReqGetSimStatus* source =
2070     ::google::protobuf::internal::dynamic_cast_if_available<const ReqGetSimStatus*>(
2071       &from);
2072   if (source == NULL) {
2073     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2074   } else {
2075     MergeFrom(*source);
2076   }
2077 }
2078
2079 void ReqGetSimStatus::MergeFrom(const ReqGetSimStatus& from) {
2080   GOOGLE_CHECK_NE(&from, this);
2081   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
2082 }
2083
2084 void ReqGetSimStatus::CopyFrom(const ::google::protobuf::Message& from) {
2085   if (&from == this) return;
2086   Clear();
2087   MergeFrom(from);
2088 }
2089
2090 void ReqGetSimStatus::CopyFrom(const ReqGetSimStatus& from) {
2091   if (&from == this) return;
2092   Clear();
2093   MergeFrom(from);
2094 }
2095
2096 bool ReqGetSimStatus::IsInitialized() const {
2097
2098   return true;
2099 }
2100
2101 void ReqGetSimStatus::Swap(ReqGetSimStatus* other) {
2102   if (other != this) {
2103     _unknown_fields_.Swap(&other->_unknown_fields_);
2104     std::swap(_cached_size_, other->_cached_size_);
2105   }
2106 }
2107
2108 ::google::protobuf::Metadata ReqGetSimStatus::GetMetadata() const {
2109   protobuf_AssignDescriptorsOnce();
2110   ::google::protobuf::Metadata metadata;
2111   metadata.descriptor = ReqGetSimStatus_descriptor_;
2112   metadata.reflection = ReqGetSimStatus_reflection_;
2113   return metadata;
2114 }
2115
2116
2117 // ===================================================================
2118
2119 #ifndef _MSC_VER
2120 const int RspGetSimStatus::kCardStatusFieldNumber;
2121 #endif  // !_MSC_VER
2122
2123 RspGetSimStatus::RspGetSimStatus()
2124   : ::google::protobuf::Message() {
2125   SharedCtor();
2126 }
2127
2128 void RspGetSimStatus::InitAsDefaultInstance() {
2129   card_status_ = const_cast< ::ril_proto::RilCardStatus*>(&::ril_proto::RilCardStatus::default_instance());
2130 }
2131
2132 RspGetSimStatus::RspGetSimStatus(const RspGetSimStatus& from)
2133   : ::google::protobuf::Message() {
2134   SharedCtor();
2135   MergeFrom(from);
2136 }
2137
2138 void RspGetSimStatus::SharedCtor() {
2139   _cached_size_ = 0;
2140   card_status_ = NULL;
2141   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2142 }
2143
2144 RspGetSimStatus::~RspGetSimStatus() {
2145   SharedDtor();
2146 }
2147
2148 void RspGetSimStatus::SharedDtor() {
2149   if (this != default_instance_) {
2150     delete card_status_;
2151   }
2152 }
2153
2154 void RspGetSimStatus::SetCachedSize(int size) const {
2155   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2156   _cached_size_ = size;
2157   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2158 }
2159 const ::google::protobuf::Descriptor* RspGetSimStatus::descriptor() {
2160   protobuf_AssignDescriptorsOnce();
2161   return RspGetSimStatus_descriptor_;
2162 }
2163
2164 const RspGetSimStatus& RspGetSimStatus::default_instance() {
2165   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
2166 }
2167
2168 RspGetSimStatus* RspGetSimStatus::default_instance_ = NULL;
2169
2170 RspGetSimStatus* RspGetSimStatus::New() const {
2171   return new RspGetSimStatus;
2172 }
2173
2174 void RspGetSimStatus::Clear() {
2175   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2176     if (_has_bit(0)) {
2177       if (card_status_ != NULL) card_status_->::ril_proto::RilCardStatus::Clear();
2178     }
2179   }
2180   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2181   mutable_unknown_fields()->Clear();
2182 }
2183
2184 bool RspGetSimStatus::MergePartialFromCodedStream(
2185     ::google::protobuf::io::CodedInputStream* input) {
2186 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
2187   ::google::protobuf::uint32 tag;
2188   while ((tag = input->ReadTag()) != 0) {
2189     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
2190       // required .ril_proto.RilCardStatus card_status = 1;
2191       case 1: {
2192         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2193             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2194           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
2195                input, mutable_card_status()));
2196         } else {
2197           goto handle_uninterpreted;
2198         }
2199         if (input->ExpectAtEnd()) return true;
2200         break;
2201       }
2202
2203       default: {
2204       handle_uninterpreted:
2205         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2206             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
2207           return true;
2208         }
2209         DO_(::google::protobuf::internal::WireFormat::SkipField(
2210               input, tag, mutable_unknown_fields()));
2211         break;
2212       }
2213     }
2214   }
2215   return true;
2216 #undef DO_
2217 }
2218
2219 void RspGetSimStatus::SerializeWithCachedSizes(
2220     ::google::protobuf::io::CodedOutputStream* output) const {
2221   // required .ril_proto.RilCardStatus card_status = 1;
2222   if (_has_bit(0)) {
2223     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2224       1, this->card_status(), output);
2225   }
2226
2227   if (!unknown_fields().empty()) {
2228     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
2229         unknown_fields(), output);
2230   }
2231 }
2232
2233 ::google::protobuf::uint8* RspGetSimStatus::SerializeWithCachedSizesToArray(
2234     ::google::protobuf::uint8* target) const {
2235   // required .ril_proto.RilCardStatus card_status = 1;
2236   if (_has_bit(0)) {
2237     target = ::google::protobuf::internal::WireFormatLite::
2238       WriteMessageNoVirtualToArray(
2239         1, this->card_status(), target);
2240   }
2241
2242   if (!unknown_fields().empty()) {
2243     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
2244         unknown_fields(), target);
2245   }
2246   return target;
2247 }
2248
2249 int RspGetSimStatus::ByteSize() const {
2250   int total_size = 0;
2251
2252   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2253     // required .ril_proto.RilCardStatus card_status = 1;
2254     if (has_card_status()) {
2255       total_size += 1 +
2256         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
2257           this->card_status());
2258     }
2259
2260   }
2261   if (!unknown_fields().empty()) {
2262     total_size +=
2263       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
2264         unknown_fields());
2265   }
2266   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2267   _cached_size_ = total_size;
2268   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2269   return total_size;
2270 }
2271
2272 void RspGetSimStatus::MergeFrom(const ::google::protobuf::Message& from) {
2273   GOOGLE_CHECK_NE(&from, this);
2274   const RspGetSimStatus* source =
2275     ::google::protobuf::internal::dynamic_cast_if_available<const RspGetSimStatus*>(
2276       &from);
2277   if (source == NULL) {
2278     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2279   } else {
2280     MergeFrom(*source);
2281   }
2282 }
2283
2284 void RspGetSimStatus::MergeFrom(const RspGetSimStatus& from) {
2285   GOOGLE_CHECK_NE(&from, this);
2286   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2287     if (from._has_bit(0)) {
2288       mutable_card_status()->::ril_proto::RilCardStatus::MergeFrom(from.card_status());
2289     }
2290   }
2291   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
2292 }
2293
2294 void RspGetSimStatus::CopyFrom(const ::google::protobuf::Message& from) {
2295   if (&from == this) return;
2296   Clear();
2297   MergeFrom(from);
2298 }
2299
2300 void RspGetSimStatus::CopyFrom(const RspGetSimStatus& from) {
2301   if (&from == this) return;
2302   Clear();
2303   MergeFrom(from);
2304 }
2305
2306 bool RspGetSimStatus::IsInitialized() const {
2307   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
2308
2309   return true;
2310 }
2311
2312 void RspGetSimStatus::Swap(RspGetSimStatus* other) {
2313   if (other != this) {
2314     std::swap(card_status_, other->card_status_);
2315     std::swap(_has_bits_[0], other->_has_bits_[0]);
2316     _unknown_fields_.Swap(&other->_unknown_fields_);
2317     std::swap(_cached_size_, other->_cached_size_);
2318   }
2319 }
2320
2321 ::google::protobuf::Metadata RspGetSimStatus::GetMetadata() const {
2322   protobuf_AssignDescriptorsOnce();
2323   ::google::protobuf::Metadata metadata;
2324   metadata.descriptor = RspGetSimStatus_descriptor_;
2325   metadata.reflection = RspGetSimStatus_reflection_;
2326   return metadata;
2327 }
2328
2329
2330 // ===================================================================
2331
2332 const ::std::string ReqEnterSimPin::_default_pin_;
2333 #ifndef _MSC_VER
2334 const int ReqEnterSimPin::kPinFieldNumber;
2335 #endif  // !_MSC_VER
2336
2337 ReqEnterSimPin::ReqEnterSimPin()
2338   : ::google::protobuf::Message() {
2339   SharedCtor();
2340 }
2341
2342 void ReqEnterSimPin::InitAsDefaultInstance() {
2343 }
2344
2345 ReqEnterSimPin::ReqEnterSimPin(const ReqEnterSimPin& from)
2346   : ::google::protobuf::Message() {
2347   SharedCtor();
2348   MergeFrom(from);
2349 }
2350
2351 void ReqEnterSimPin::SharedCtor() {
2352   _cached_size_ = 0;
2353   pin_ = const_cast< ::std::string*>(&_default_pin_);
2354   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2355 }
2356
2357 ReqEnterSimPin::~ReqEnterSimPin() {
2358   SharedDtor();
2359 }
2360
2361 void ReqEnterSimPin::SharedDtor() {
2362   if (pin_ != &_default_pin_) {
2363     delete pin_;
2364   }
2365   if (this != default_instance_) {
2366   }
2367 }
2368
2369 void ReqEnterSimPin::SetCachedSize(int size) const {
2370   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2371   _cached_size_ = size;
2372   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2373 }
2374 const ::google::protobuf::Descriptor* ReqEnterSimPin::descriptor() {
2375   protobuf_AssignDescriptorsOnce();
2376   return ReqEnterSimPin_descriptor_;
2377 }
2378
2379 const ReqEnterSimPin& ReqEnterSimPin::default_instance() {
2380   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
2381 }
2382
2383 ReqEnterSimPin* ReqEnterSimPin::default_instance_ = NULL;
2384
2385 ReqEnterSimPin* ReqEnterSimPin::New() const {
2386   return new ReqEnterSimPin;
2387 }
2388
2389 void ReqEnterSimPin::Clear() {
2390   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2391     if (_has_bit(0)) {
2392       if (pin_ != &_default_pin_) {
2393         pin_->clear();
2394       }
2395     }
2396   }
2397   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2398   mutable_unknown_fields()->Clear();
2399 }
2400
2401 bool ReqEnterSimPin::MergePartialFromCodedStream(
2402     ::google::protobuf::io::CodedInputStream* input) {
2403 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
2404   ::google::protobuf::uint32 tag;
2405   while ((tag = input->ReadTag()) != 0) {
2406     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
2407       // required string pin = 1;
2408       case 1: {
2409         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2410             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2411           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
2412                 input, this->mutable_pin()));
2413           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2414             this->pin().data(), this->pin().length(),
2415             ::google::protobuf::internal::WireFormat::PARSE);
2416         } else {
2417           goto handle_uninterpreted;
2418         }
2419         if (input->ExpectAtEnd()) return true;
2420         break;
2421       }
2422
2423       default: {
2424       handle_uninterpreted:
2425         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2426             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
2427           return true;
2428         }
2429         DO_(::google::protobuf::internal::WireFormat::SkipField(
2430               input, tag, mutable_unknown_fields()));
2431         break;
2432       }
2433     }
2434   }
2435   return true;
2436 #undef DO_
2437 }
2438
2439 void ReqEnterSimPin::SerializeWithCachedSizes(
2440     ::google::protobuf::io::CodedOutputStream* output) const {
2441   // required string pin = 1;
2442   if (_has_bit(0)) {
2443     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2444       this->pin().data(), this->pin().length(),
2445       ::google::protobuf::internal::WireFormat::SERIALIZE);
2446     ::google::protobuf::internal::WireFormatLite::WriteString(
2447       1, this->pin(), output);
2448   }
2449
2450   if (!unknown_fields().empty()) {
2451     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
2452         unknown_fields(), output);
2453   }
2454 }
2455
2456 ::google::protobuf::uint8* ReqEnterSimPin::SerializeWithCachedSizesToArray(
2457     ::google::protobuf::uint8* target) const {
2458   // required string pin = 1;
2459   if (_has_bit(0)) {
2460     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2461       this->pin().data(), this->pin().length(),
2462       ::google::protobuf::internal::WireFormat::SERIALIZE);
2463     target =
2464       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2465         1, this->pin(), target);
2466   }
2467
2468   if (!unknown_fields().empty()) {
2469     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
2470         unknown_fields(), target);
2471   }
2472   return target;
2473 }
2474
2475 int ReqEnterSimPin::ByteSize() const {
2476   int total_size = 0;
2477
2478   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2479     // required string pin = 1;
2480     if (has_pin()) {
2481       total_size += 1 +
2482         ::google::protobuf::internal::WireFormatLite::StringSize(
2483           this->pin());
2484     }
2485
2486   }
2487   if (!unknown_fields().empty()) {
2488     total_size +=
2489       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
2490         unknown_fields());
2491   }
2492   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2493   _cached_size_ = total_size;
2494   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2495   return total_size;
2496 }
2497
2498 void ReqEnterSimPin::MergeFrom(const ::google::protobuf::Message& from) {
2499   GOOGLE_CHECK_NE(&from, this);
2500   const ReqEnterSimPin* source =
2501     ::google::protobuf::internal::dynamic_cast_if_available<const ReqEnterSimPin*>(
2502       &from);
2503   if (source == NULL) {
2504     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2505   } else {
2506     MergeFrom(*source);
2507   }
2508 }
2509
2510 void ReqEnterSimPin::MergeFrom(const ReqEnterSimPin& from) {
2511   GOOGLE_CHECK_NE(&from, this);
2512   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2513     if (from._has_bit(0)) {
2514       set_pin(from.pin());
2515     }
2516   }
2517   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
2518 }
2519
2520 void ReqEnterSimPin::CopyFrom(const ::google::protobuf::Message& from) {
2521   if (&from == this) return;
2522   Clear();
2523   MergeFrom(from);
2524 }
2525
2526 void ReqEnterSimPin::CopyFrom(const ReqEnterSimPin& from) {
2527   if (&from == this) return;
2528   Clear();
2529   MergeFrom(from);
2530 }
2531
2532 bool ReqEnterSimPin::IsInitialized() const {
2533   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
2534
2535   return true;
2536 }
2537
2538 void ReqEnterSimPin::Swap(ReqEnterSimPin* other) {
2539   if (other != this) {
2540     std::swap(pin_, other->pin_);
2541     std::swap(_has_bits_[0], other->_has_bits_[0]);
2542     _unknown_fields_.Swap(&other->_unknown_fields_);
2543     std::swap(_cached_size_, other->_cached_size_);
2544   }
2545 }
2546
2547 ::google::protobuf::Metadata ReqEnterSimPin::GetMetadata() const {
2548   protobuf_AssignDescriptorsOnce();
2549   ::google::protobuf::Metadata metadata;
2550   metadata.descriptor = ReqEnterSimPin_descriptor_;
2551   metadata.reflection = ReqEnterSimPin_reflection_;
2552   return metadata;
2553 }
2554
2555
2556 // ===================================================================
2557
2558 #ifndef _MSC_VER
2559 const int RspEnterSimPin::kRetriesRemainingFieldNumber;
2560 #endif  // !_MSC_VER
2561
2562 RspEnterSimPin::RspEnterSimPin()
2563   : ::google::protobuf::Message() {
2564   SharedCtor();
2565 }
2566
2567 void RspEnterSimPin::InitAsDefaultInstance() {
2568 }
2569
2570 RspEnterSimPin::RspEnterSimPin(const RspEnterSimPin& from)
2571   : ::google::protobuf::Message() {
2572   SharedCtor();
2573   MergeFrom(from);
2574 }
2575
2576 void RspEnterSimPin::SharedCtor() {
2577   _cached_size_ = 0;
2578   retries_remaining_ = 0;
2579   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2580 }
2581
2582 RspEnterSimPin::~RspEnterSimPin() {
2583   SharedDtor();
2584 }
2585
2586 void RspEnterSimPin::SharedDtor() {
2587   if (this != default_instance_) {
2588   }
2589 }
2590
2591 void RspEnterSimPin::SetCachedSize(int size) const {
2592   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2593   _cached_size_ = size;
2594   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2595 }
2596 const ::google::protobuf::Descriptor* RspEnterSimPin::descriptor() {
2597   protobuf_AssignDescriptorsOnce();
2598   return RspEnterSimPin_descriptor_;
2599 }
2600
2601 const RspEnterSimPin& RspEnterSimPin::default_instance() {
2602   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
2603 }
2604
2605 RspEnterSimPin* RspEnterSimPin::default_instance_ = NULL;
2606
2607 RspEnterSimPin* RspEnterSimPin::New() const {
2608   return new RspEnterSimPin;
2609 }
2610
2611 void RspEnterSimPin::Clear() {
2612   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2613     retries_remaining_ = 0;
2614   }
2615   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2616   mutable_unknown_fields()->Clear();
2617 }
2618
2619 bool RspEnterSimPin::MergePartialFromCodedStream(
2620     ::google::protobuf::io::CodedInputStream* input) {
2621 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
2622   ::google::protobuf::uint32 tag;
2623   while ((tag = input->ReadTag()) != 0) {
2624     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
2625       // required int32 retries_remaining = 1;
2626       case 1: {
2627         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2628             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2629           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2630                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
2631                  input, &retries_remaining_)));
2632           _set_bit(0);
2633         } else {
2634           goto handle_uninterpreted;
2635         }
2636         if (input->ExpectAtEnd()) return true;
2637         break;
2638       }
2639
2640       default: {
2641       handle_uninterpreted:
2642         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2643             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
2644           return true;
2645         }
2646         DO_(::google::protobuf::internal::WireFormat::SkipField(
2647               input, tag, mutable_unknown_fields()));
2648         break;
2649       }
2650     }
2651   }
2652   return true;
2653 #undef DO_
2654 }
2655
2656 void RspEnterSimPin::SerializeWithCachedSizes(
2657     ::google::protobuf::io::CodedOutputStream* output) const {
2658   // required int32 retries_remaining = 1;
2659   if (_has_bit(0)) {
2660     ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->retries_remaining(), output);
2661   }
2662
2663   if (!unknown_fields().empty()) {
2664     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
2665         unknown_fields(), output);
2666   }
2667 }
2668
2669 ::google::protobuf::uint8* RspEnterSimPin::SerializeWithCachedSizesToArray(
2670     ::google::protobuf::uint8* target) const {
2671   // required int32 retries_remaining = 1;
2672   if (_has_bit(0)) {
2673     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->retries_remaining(), target);
2674   }
2675
2676   if (!unknown_fields().empty()) {
2677     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
2678         unknown_fields(), target);
2679   }
2680   return target;
2681 }
2682
2683 int RspEnterSimPin::ByteSize() const {
2684   int total_size = 0;
2685
2686   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2687     // required int32 retries_remaining = 1;
2688     if (has_retries_remaining()) {
2689       total_size += 1 +
2690         ::google::protobuf::internal::WireFormatLite::Int32Size(
2691           this->retries_remaining());
2692     }
2693
2694   }
2695   if (!unknown_fields().empty()) {
2696     total_size +=
2697       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
2698         unknown_fields());
2699   }
2700   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2701   _cached_size_ = total_size;
2702   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2703   return total_size;
2704 }
2705
2706 void RspEnterSimPin::MergeFrom(const ::google::protobuf::Message& from) {
2707   GOOGLE_CHECK_NE(&from, this);
2708   const RspEnterSimPin* source =
2709     ::google::protobuf::internal::dynamic_cast_if_available<const RspEnterSimPin*>(
2710       &from);
2711   if (source == NULL) {
2712     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2713   } else {
2714     MergeFrom(*source);
2715   }
2716 }
2717
2718 void RspEnterSimPin::MergeFrom(const RspEnterSimPin& from) {
2719   GOOGLE_CHECK_NE(&from, this);
2720   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2721     if (from._has_bit(0)) {
2722       set_retries_remaining(from.retries_remaining());
2723     }
2724   }
2725   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
2726 }
2727
2728 void RspEnterSimPin::CopyFrom(const ::google::protobuf::Message& from) {
2729   if (&from == this) return;
2730   Clear();
2731   MergeFrom(from);
2732 }
2733
2734 void RspEnterSimPin::CopyFrom(const RspEnterSimPin& from) {
2735   if (&from == this) return;
2736   Clear();
2737   MergeFrom(from);
2738 }
2739
2740 bool RspEnterSimPin::IsInitialized() const {
2741   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
2742
2743   return true;
2744 }
2745
2746 void RspEnterSimPin::Swap(RspEnterSimPin* other) {
2747   if (other != this) {
2748     std::swap(retries_remaining_, other->retries_remaining_);
2749     std::swap(_has_bits_[0], other->_has_bits_[0]);
2750     _unknown_fields_.Swap(&other->_unknown_fields_);
2751     std::swap(_cached_size_, other->_cached_size_);
2752   }
2753 }
2754
2755 ::google::protobuf::Metadata RspEnterSimPin::GetMetadata() const {
2756   protobuf_AssignDescriptorsOnce();
2757   ::google::protobuf::Metadata metadata;
2758   metadata.descriptor = RspEnterSimPin_descriptor_;
2759   metadata.reflection = RspEnterSimPin_reflection_;
2760   return metadata;
2761 }
2762
2763
2764 // ===================================================================
2765
2766 #ifndef _MSC_VER
2767 const int ReqHangUp::kConnectionIndexFieldNumber;
2768 #endif  // !_MSC_VER
2769
2770 ReqHangUp::ReqHangUp()
2771   : ::google::protobuf::Message() {
2772   SharedCtor();
2773 }
2774
2775 void ReqHangUp::InitAsDefaultInstance() {
2776 }
2777
2778 ReqHangUp::ReqHangUp(const ReqHangUp& from)
2779   : ::google::protobuf::Message() {
2780   SharedCtor();
2781   MergeFrom(from);
2782 }
2783
2784 void ReqHangUp::SharedCtor() {
2785   _cached_size_ = 0;
2786   connection_index_ = 0;
2787   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2788 }
2789
2790 ReqHangUp::~ReqHangUp() {
2791   SharedDtor();
2792 }
2793
2794 void ReqHangUp::SharedDtor() {
2795   if (this != default_instance_) {
2796   }
2797 }
2798
2799 void ReqHangUp::SetCachedSize(int size) const {
2800   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2801   _cached_size_ = size;
2802   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2803 }
2804 const ::google::protobuf::Descriptor* ReqHangUp::descriptor() {
2805   protobuf_AssignDescriptorsOnce();
2806   return ReqHangUp_descriptor_;
2807 }
2808
2809 const ReqHangUp& ReqHangUp::default_instance() {
2810   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
2811 }
2812
2813 ReqHangUp* ReqHangUp::default_instance_ = NULL;
2814
2815 ReqHangUp* ReqHangUp::New() const {
2816   return new ReqHangUp;
2817 }
2818
2819 void ReqHangUp::Clear() {
2820   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2821     connection_index_ = 0;
2822   }
2823   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2824   mutable_unknown_fields()->Clear();
2825 }
2826
2827 bool ReqHangUp::MergePartialFromCodedStream(
2828     ::google::protobuf::io::CodedInputStream* input) {
2829 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
2830   ::google::protobuf::uint32 tag;
2831   while ((tag = input->ReadTag()) != 0) {
2832     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
2833       // required int32 connection_index = 1;
2834       case 1: {
2835         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2836             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2837           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2838                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
2839                  input, &connection_index_)));
2840           _set_bit(0);
2841         } else {
2842           goto handle_uninterpreted;
2843         }
2844         if (input->ExpectAtEnd()) return true;
2845         break;
2846       }
2847
2848       default: {
2849       handle_uninterpreted:
2850         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2851             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
2852           return true;
2853         }
2854         DO_(::google::protobuf::internal::WireFormat::SkipField(
2855               input, tag, mutable_unknown_fields()));
2856         break;
2857       }
2858     }
2859   }
2860   return true;
2861 #undef DO_
2862 }
2863
2864 void ReqHangUp::SerializeWithCachedSizes(
2865     ::google::protobuf::io::CodedOutputStream* output) const {
2866   // required int32 connection_index = 1;
2867   if (_has_bit(0)) {
2868     ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->connection_index(), output);
2869   }
2870
2871   if (!unknown_fields().empty()) {
2872     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
2873         unknown_fields(), output);
2874   }
2875 }
2876
2877 ::google::protobuf::uint8* ReqHangUp::SerializeWithCachedSizesToArray(
2878     ::google::protobuf::uint8* target) const {
2879   // required int32 connection_index = 1;
2880   if (_has_bit(0)) {
2881     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->connection_index(), target);
2882   }
2883
2884   if (!unknown_fields().empty()) {
2885     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
2886         unknown_fields(), target);
2887   }
2888   return target;
2889 }
2890
2891 int ReqHangUp::ByteSize() const {
2892   int total_size = 0;
2893
2894   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2895     // required int32 connection_index = 1;
2896     if (has_connection_index()) {
2897       total_size += 1 +
2898         ::google::protobuf::internal::WireFormatLite::Int32Size(
2899           this->connection_index());
2900     }
2901
2902   }
2903   if (!unknown_fields().empty()) {
2904     total_size +=
2905       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
2906         unknown_fields());
2907   }
2908   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2909   _cached_size_ = total_size;
2910   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2911   return total_size;
2912 }
2913
2914 void ReqHangUp::MergeFrom(const ::google::protobuf::Message& from) {
2915   GOOGLE_CHECK_NE(&from, this);
2916   const ReqHangUp* source =
2917     ::google::protobuf::internal::dynamic_cast_if_available<const ReqHangUp*>(
2918       &from);
2919   if (source == NULL) {
2920     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2921   } else {
2922     MergeFrom(*source);
2923   }
2924 }
2925
2926 void ReqHangUp::MergeFrom(const ReqHangUp& from) {
2927   GOOGLE_CHECK_NE(&from, this);
2928   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2929     if (from._has_bit(0)) {
2930       set_connection_index(from.connection_index());
2931     }
2932   }
2933   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
2934 }
2935
2936 void ReqHangUp::CopyFrom(const ::google::protobuf::Message& from) {
2937   if (&from == this) return;
2938   Clear();
2939   MergeFrom(from);
2940 }
2941
2942 void ReqHangUp::CopyFrom(const ReqHangUp& from) {
2943   if (&from == this) return;
2944   Clear();
2945   MergeFrom(from);
2946 }
2947
2948 bool ReqHangUp::IsInitialized() const {
2949   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
2950
2951   return true;
2952 }
2953
2954 void ReqHangUp::Swap(ReqHangUp* other) {
2955   if (other != this) {
2956     std::swap(connection_index_, other->connection_index_);
2957     std::swap(_has_bits_[0], other->_has_bits_[0]);
2958     _unknown_fields_.Swap(&other->_unknown_fields_);
2959     std::swap(_cached_size_, other->_cached_size_);
2960   }
2961 }
2962
2963 ::google::protobuf::Metadata ReqHangUp::GetMetadata() const {
2964   protobuf_AssignDescriptorsOnce();
2965   ::google::protobuf::Metadata metadata;
2966   metadata.descriptor = ReqHangUp_descriptor_;
2967   metadata.reflection = ReqHangUp_reflection_;
2968   return metadata;
2969 }
2970
2971
2972 // ===================================================================
2973
2974 #ifndef _MSC_VER
2975 const int ReqScreenState::kStateFieldNumber;
2976 #endif  // !_MSC_VER
2977
2978 ReqScreenState::ReqScreenState()
2979   : ::google::protobuf::Message() {
2980   SharedCtor();
2981 }
2982
2983 void ReqScreenState::InitAsDefaultInstance() {
2984 }
2985
2986 ReqScreenState::ReqScreenState(const ReqScreenState& from)
2987   : ::google::protobuf::Message() {
2988   SharedCtor();
2989   MergeFrom(from);
2990 }
2991
2992 void ReqScreenState::SharedCtor() {
2993   _cached_size_ = 0;
2994   state_ = false;
2995   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2996 }
2997
2998 ReqScreenState::~ReqScreenState() {
2999   SharedDtor();
3000 }
3001
3002 void ReqScreenState::SharedDtor() {
3003   if (this != default_instance_) {
3004   }
3005 }
3006
3007 void ReqScreenState::SetCachedSize(int size) const {
3008   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
3009   _cached_size_ = size;
3010   GOOGLE_SAFE_CONCURRENT_WRITES_END();
3011 }
3012 const ::google::protobuf::Descriptor* ReqScreenState::descriptor() {
3013   protobuf_AssignDescriptorsOnce();
3014   return ReqScreenState_descriptor_;
3015 }
3016
3017 const ReqScreenState& ReqScreenState::default_instance() {
3018   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
3019 }
3020
3021 ReqScreenState* ReqScreenState::default_instance_ = NULL;
3022
3023 ReqScreenState* ReqScreenState::New() const {
3024   return new ReqScreenState;
3025 }
3026
3027 void ReqScreenState::Clear() {
3028   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3029     state_ = false;
3030   }
3031   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3032   mutable_unknown_fields()->Clear();
3033 }
3034
3035 bool ReqScreenState::MergePartialFromCodedStream(
3036     ::google::protobuf::io::CodedInputStream* input) {
3037 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
3038   ::google::protobuf::uint32 tag;
3039   while ((tag = input->ReadTag()) != 0) {
3040     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
3041       // required bool state = 1;
3042       case 1: {
3043         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3044             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
3045           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
3046                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
3047                  input, &state_)));
3048           _set_bit(0);
3049         } else {
3050           goto handle_uninterpreted;
3051         }
3052         if (input->ExpectAtEnd()) return true;
3053         break;
3054       }
3055
3056       default: {
3057       handle_uninterpreted:
3058         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3059             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
3060           return true;
3061         }
3062         DO_(::google::protobuf::internal::WireFormat::SkipField(
3063               input, tag, mutable_unknown_fields()));
3064         break;
3065       }
3066     }
3067   }
3068   return true;
3069 #undef DO_
3070 }
3071
3072 void ReqScreenState::SerializeWithCachedSizes(
3073     ::google::protobuf::io::CodedOutputStream* output) const {
3074   // required bool state = 1;
3075   if (_has_bit(0)) {
3076     ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->state(), output);
3077   }
3078
3079   if (!unknown_fields().empty()) {
3080     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
3081         unknown_fields(), output);
3082   }
3083 }
3084
3085 ::google::protobuf::uint8* ReqScreenState::SerializeWithCachedSizesToArray(
3086     ::google::protobuf::uint8* target) const {
3087   // required bool state = 1;
3088   if (_has_bit(0)) {
3089     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->state(), target);
3090   }
3091
3092   if (!unknown_fields().empty()) {
3093     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
3094         unknown_fields(), target);
3095   }
3096   return target;
3097 }
3098
3099 int ReqScreenState::ByteSize() const {
3100   int total_size = 0;
3101
3102   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3103     // required bool state = 1;
3104     if (has_state()) {
3105       total_size += 1 + 1;
3106     }
3107
3108   }
3109   if (!unknown_fields().empty()) {
3110     total_size +=
3111       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
3112         unknown_fields());
3113   }
3114   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
3115   _cached_size_ = total_size;
3116   GOOGLE_SAFE_CONCURRENT_WRITES_END();
3117   return total_size;
3118 }
3119
3120 void ReqScreenState::MergeFrom(const ::google::protobuf::Message& from) {
3121   GOOGLE_CHECK_NE(&from, this);
3122   const ReqScreenState* source =
3123     ::google::protobuf::internal::dynamic_cast_if_available<const ReqScreenState*>(
3124       &from);
3125   if (source == NULL) {
3126     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
3127   } else {
3128     MergeFrom(*source);
3129   }
3130 }
3131
3132 void ReqScreenState::MergeFrom(const ReqScreenState& from) {
3133   GOOGLE_CHECK_NE(&from, this);
3134   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3135     if (from._has_bit(0)) {
3136       set_state(from.state());
3137     }
3138   }
3139   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
3140 }
3141
3142 void ReqScreenState::CopyFrom(const ::google::protobuf::Message& from) {
3143   if (&from == this) return;
3144   Clear();
3145   MergeFrom(from);
3146 }
3147
3148 void ReqScreenState::CopyFrom(const ReqScreenState& from) {
3149   if (&from == this) return;
3150   Clear();
3151   MergeFrom(from);
3152 }
3153
3154 bool ReqScreenState::IsInitialized() const {
3155   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
3156
3157   return true;
3158 }
3159
3160 void ReqScreenState::Swap(ReqScreenState* other) {
3161   if (other != this) {
3162     std::swap(state_, other->state_);
3163     std::swap(_has_bits_[0], other->_has_bits_[0]);
3164     _unknown_fields_.Swap(&other->_unknown_fields_);
3165     std::swap(_cached_size_, other->_cached_size_);
3166   }
3167 }
3168
3169 ::google::protobuf::Metadata ReqScreenState::GetMetadata() const {
3170   protobuf_AssignDescriptorsOnce();
3171   ::google::protobuf::Metadata metadata;
3172   metadata.descriptor = ReqScreenState_descriptor_;
3173   metadata.reflection = ReqScreenState_reflection_;
3174   return metadata;
3175 }
3176
3177
3178 // ===================================================================
3179
3180 const ::std::string RspOperator::_default_long_alpha_ons_;
3181 const ::std::string RspOperator::_default_short_alpha_ons_;
3182 const ::std::string RspOperator::_default_mcc_mnc_;
3183 #ifndef _MSC_VER
3184 const int RspOperator::kLongAlphaOnsFieldNumber;
3185 const int RspOperator::kShortAlphaOnsFieldNumber;
3186 const int RspOperator::kMccMncFieldNumber;
3187 #endif  // !_MSC_VER
3188
3189 RspOperator::RspOperator()
3190   : ::google::protobuf::Message() {
3191   SharedCtor();
3192 }
3193
3194 void RspOperator::InitAsDefaultInstance() {
3195 }
3196
3197 RspOperator::RspOperator(const RspOperator& from)
3198   : ::google::protobuf::Message() {
3199   SharedCtor();
3200   MergeFrom(from);
3201 }
3202
3203 void RspOperator::SharedCtor() {
3204   _cached_size_ = 0;
3205   long_alpha_ons_ = const_cast< ::std::string*>(&_default_long_alpha_ons_);
3206   short_alpha_ons_ = const_cast< ::std::string*>(&_default_short_alpha_ons_);
3207   mcc_mnc_ = const_cast< ::std::string*>(&_default_mcc_mnc_);
3208   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3209 }
3210
3211 RspOperator::~RspOperator() {
3212   SharedDtor();
3213 }
3214
3215 void RspOperator::SharedDtor() {
3216   if (long_alpha_ons_ != &_default_long_alpha_ons_) {
3217     delete long_alpha_ons_;
3218   }
3219   if (short_alpha_ons_ != &_default_short_alpha_ons_) {
3220     delete short_alpha_ons_;
3221   }
3222   if (mcc_mnc_ != &_default_mcc_mnc_) {
3223     delete mcc_mnc_;
3224   }
3225   if (this != default_instance_) {
3226   }
3227 }
3228
3229 void RspOperator::SetCachedSize(int size) const {
3230   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
3231   _cached_size_ = size;
3232   GOOGLE_SAFE_CONCURRENT_WRITES_END();
3233 }
3234 const ::google::protobuf::Descriptor* RspOperator::descriptor() {
3235   protobuf_AssignDescriptorsOnce();
3236   return RspOperator_descriptor_;
3237 }
3238
3239 const RspOperator& RspOperator::default_instance() {
3240   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
3241 }
3242
3243 RspOperator* RspOperator::default_instance_ = NULL;
3244
3245 RspOperator* RspOperator::New() const {
3246   return new RspOperator;
3247 }
3248
3249 void RspOperator::Clear() {
3250   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3251     if (_has_bit(0)) {
3252       if (long_alpha_ons_ != &_default_long_alpha_ons_) {
3253         long_alpha_ons_->clear();
3254       }
3255     }
3256     if (_has_bit(1)) {
3257       if (short_alpha_ons_ != &_default_short_alpha_ons_) {
3258         short_alpha_ons_->clear();
3259       }
3260     }
3261     if (_has_bit(2)) {
3262       if (mcc_mnc_ != &_default_mcc_mnc_) {
3263         mcc_mnc_->clear();
3264       }
3265     }
3266   }
3267   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3268   mutable_unknown_fields()->Clear();
3269 }
3270
3271 bool RspOperator::MergePartialFromCodedStream(
3272     ::google::protobuf::io::CodedInputStream* input) {
3273 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
3274   ::google::protobuf::uint32 tag;
3275   while ((tag = input->ReadTag()) != 0) {
3276     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
3277       // optional string long_alpha_ons = 1;
3278       case 1: {
3279         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3280             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
3281           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
3282                 input, this->mutable_long_alpha_ons()));
3283           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3284             this->long_alpha_ons().data(), this->long_alpha_ons().length(),
3285             ::google::protobuf::internal::WireFormat::PARSE);
3286         } else {
3287           goto handle_uninterpreted;
3288         }
3289         if (input->ExpectTag(18)) goto parse_short_alpha_ons;
3290         break;
3291       }
3292
3293       // optional string short_alpha_ons = 2;
3294       case 2: {
3295         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3296             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
3297          parse_short_alpha_ons:
3298           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
3299                 input, this->mutable_short_alpha_ons()));
3300           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3301             this->short_alpha_ons().data(), this->short_alpha_ons().length(),
3302             ::google::protobuf::internal::WireFormat::PARSE);
3303         } else {
3304           goto handle_uninterpreted;
3305         }
3306         if (input->ExpectTag(26)) goto parse_mcc_mnc;
3307         break;
3308       }
3309
3310       // optional string mcc_mnc = 3;
3311       case 3: {
3312         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3313             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
3314          parse_mcc_mnc:
3315           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
3316                 input, this->mutable_mcc_mnc()));
3317           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3318             this->mcc_mnc().data(), this->mcc_mnc().length(),
3319             ::google::protobuf::internal::WireFormat::PARSE);
3320         } else {
3321           goto handle_uninterpreted;
3322         }
3323         if (input->ExpectAtEnd()) return true;
3324         break;
3325       }
3326
3327       default: {
3328       handle_uninterpreted:
3329         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3330             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
3331           return true;
3332         }
3333         DO_(::google::protobuf::internal::WireFormat::SkipField(
3334               input, tag, mutable_unknown_fields()));
3335         break;
3336       }
3337     }
3338   }
3339   return true;
3340 #undef DO_
3341 }
3342
3343 void RspOperator::SerializeWithCachedSizes(
3344     ::google::protobuf::io::CodedOutputStream* output) const {
3345   // optional string long_alpha_ons = 1;
3346   if (_has_bit(0)) {
3347     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3348       this->long_alpha_ons().data(), this->long_alpha_ons().length(),
3349       ::google::protobuf::internal::WireFormat::SERIALIZE);
3350     ::google::protobuf::internal::WireFormatLite::WriteString(
3351       1, this->long_alpha_ons(), output);
3352   }
3353
3354   // optional string short_alpha_ons = 2;
3355   if (_has_bit(1)) {
3356     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3357       this->short_alpha_ons().data(), this->short_alpha_ons().length(),
3358       ::google::protobuf::internal::WireFormat::SERIALIZE);
3359     ::google::protobuf::internal::WireFormatLite::WriteString(
3360       2, this->short_alpha_ons(), output);
3361   }
3362
3363   // optional string mcc_mnc = 3;
3364   if (_has_bit(2)) {
3365     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3366       this->mcc_mnc().data(), this->mcc_mnc().length(),
3367       ::google::protobuf::internal::WireFormat::SERIALIZE);
3368     ::google::protobuf::internal::WireFormatLite::WriteString(
3369       3, this->mcc_mnc(), output);
3370   }
3371
3372   if (!unknown_fields().empty()) {
3373     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
3374         unknown_fields(), output);
3375   }
3376 }
3377
3378 ::google::protobuf::uint8* RspOperator::SerializeWithCachedSizesToArray(
3379     ::google::protobuf::uint8* target) const {
3380   // optional string long_alpha_ons = 1;
3381   if (_has_bit(0)) {
3382     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3383       this->long_alpha_ons().data(), this->long_alpha_ons().length(),
3384       ::google::protobuf::internal::WireFormat::SERIALIZE);
3385     target =
3386       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3387         1, this->long_alpha_ons(), target);
3388   }
3389
3390   // optional string short_alpha_ons = 2;
3391   if (_has_bit(1)) {
3392     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3393       this->short_alpha_ons().data(), this->short_alpha_ons().length(),
3394       ::google::protobuf::internal::WireFormat::SERIALIZE);
3395     target =
3396       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3397         2, this->short_alpha_ons(), target);
3398   }
3399
3400   // optional string mcc_mnc = 3;
3401   if (_has_bit(2)) {
3402     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3403       this->mcc_mnc().data(), this->mcc_mnc().length(),
3404       ::google::protobuf::internal::WireFormat::SERIALIZE);
3405     target =
3406       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3407         3, this->mcc_mnc(), target);
3408   }
3409
3410   if (!unknown_fields().empty()) {
3411     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
3412         unknown_fields(), target);
3413   }
3414   return target;
3415 }
3416
3417 int RspOperator::ByteSize() const {
3418   int total_size = 0;
3419
3420   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3421     // optional string long_alpha_ons = 1;
3422     if (has_long_alpha_ons()) {
3423       total_size += 1 +
3424         ::google::protobuf::internal::WireFormatLite::StringSize(
3425           this->long_alpha_ons());
3426     }
3427
3428     // optional string short_alpha_ons = 2;
3429     if (has_short_alpha_ons()) {
3430       total_size += 1 +
3431         ::google::protobuf::internal::WireFormatLite::StringSize(
3432           this->short_alpha_ons());
3433     }
3434
3435     // optional string mcc_mnc = 3;
3436     if (has_mcc_mnc()) {
3437       total_size += 1 +
3438         ::google::protobuf::internal::WireFormatLite::StringSize(
3439           this->mcc_mnc());
3440     }
3441
3442   }
3443   if (!unknown_fields().empty()) {
3444     total_size +=
3445       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
3446         unknown_fields());
3447   }
3448   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
3449   _cached_size_ = total_size;
3450   GOOGLE_SAFE_CONCURRENT_WRITES_END();
3451   return total_size;
3452 }
3453
3454 void RspOperator::MergeFrom(const ::google::protobuf::Message& from) {
3455   GOOGLE_CHECK_NE(&from, this);
3456   const RspOperator* source =
3457     ::google::protobuf::internal::dynamic_cast_if_available<const RspOperator*>(
3458       &from);
3459   if (source == NULL) {
3460     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
3461   } else {
3462     MergeFrom(*source);
3463   }
3464 }
3465
3466 void RspOperator::MergeFrom(const RspOperator& from) {
3467   GOOGLE_CHECK_NE(&from, this);
3468   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3469     if (from._has_bit(0)) {
3470       set_long_alpha_ons(from.long_alpha_ons());
3471     }
3472     if (from._has_bit(1)) {
3473       set_short_alpha_ons(from.short_alpha_ons());
3474     }
3475     if (from._has_bit(2)) {
3476       set_mcc_mnc(from.mcc_mnc());
3477     }
3478   }
3479   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
3480 }
3481
3482 void RspOperator::CopyFrom(const ::google::protobuf::Message& from) {
3483   if (&from == this) return;
3484   Clear();
3485   MergeFrom(from);
3486 }
3487
3488 void RspOperator::CopyFrom(const RspOperator& from) {
3489   if (&from == this) return;
3490   Clear();
3491   MergeFrom(from);
3492 }
3493
3494 bool RspOperator::IsInitialized() const {
3495
3496   return true;
3497 }
3498
3499 void RspOperator::Swap(RspOperator* other) {
3500   if (other != this) {
3501     std::swap(long_alpha_ons_, other->long_alpha_ons_);
3502     std::swap(short_alpha_ons_, other->short_alpha_ons_);
3503     std::swap(mcc_mnc_, other->mcc_mnc_);
3504     std::swap(_has_bits_[0], other->_has_bits_[0]);
3505     _unknown_fields_.Swap(&other->_unknown_fields_);
3506     std::swap(_cached_size_, other->_cached_size_);
3507   }
3508 }
3509
3510 ::google::protobuf::Metadata RspOperator::GetMetadata() const {
3511   protobuf_AssignDescriptorsOnce();
3512   ::google::protobuf::Metadata metadata;
3513   metadata.descriptor = RspOperator_descriptor_;
3514   metadata.reflection = RspOperator_reflection_;
3515   return metadata;
3516 }
3517
3518
3519 // @@protoc_insertion_point(namespace_scope)
3520
3521 }  // namespace ril_proto
3522
3523 // @@protoc_insertion_point(global_scope)