hardware/ril/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* RilUusInfo_descriptor_ = NULL;
  24 const ::google::protobuf::internal::GeneratedMessageReflection*
  25   RilUusInfo_reflection_ = NULL;
  26 const ::google::protobuf::Descriptor* RilCall_descriptor_ = NULL;
  27 const ::google::protobuf::internal::GeneratedMessageReflection*
  28   RilCall_reflection_ = NULL;
  29 const ::google::protobuf::Descriptor* RILGWSignalStrength_descriptor_ = NULL;
  30 const ::google::protobuf::internal::GeneratedMessageReflection*
  31   RILGWSignalStrength_reflection_ = NULL;
  32 const ::google::protobuf::Descriptor* RILCDMASignalStrength_descriptor_ = NULL;
  33 const ::google::protobuf::internal::GeneratedMessageReflection*
  34   RILCDMASignalStrength_reflection_ = NULL;
  35 const ::google::protobuf::Descriptor* RILEVDOSignalStrength_descriptor_ = NULL;
  36 const ::google::protobuf::internal::GeneratedMessageReflection*
  37   RILEVDOSignalStrength_reflection_ = NULL;
  38 const ::google::protobuf::Descriptor* RspStrings_descriptor_ = NULL;
  39 const ::google::protobuf::internal::GeneratedMessageReflection*
  40   RspStrings_reflection_ = NULL;
  41 const ::google::protobuf::Descriptor* RspIntegers_descriptor_ = NULL;
  42 const ::google::protobuf::internal::GeneratedMessageReflection*
  43   RspIntegers_reflection_ = NULL;
  44 const ::google::protobuf::Descriptor* RspGetSimStatus_descriptor_ = NULL;
  45 const ::google::protobuf::internal::GeneratedMessageReflection*
  46   RspGetSimStatus_reflection_ = NULL;
  47 const ::google::protobuf::Descriptor* ReqEnterSimPin_descriptor_ = NULL;
  48 const ::google::protobuf::internal::GeneratedMessageReflection*
  49   ReqEnterSimPin_reflection_ = NULL;
  50 const ::google::protobuf::Descriptor* RspEnterSimPin_descriptor_ = NULL;
  51 const ::google::protobuf::internal::GeneratedMessageReflection*
  52   RspEnterSimPin_reflection_ = NULL;
  53 const ::google::protobuf::Descriptor* RspGetCurrentCalls_descriptor_ = NULL;
  54 const ::google::protobuf::internal::GeneratedMessageReflection*
  55   RspGetCurrentCalls_reflection_ = NULL;
  56 const ::google::protobuf::Descriptor* ReqDial_descriptor_ = NULL;
  57 const ::google::protobuf::internal::GeneratedMessageReflection*
  58   ReqDial_reflection_ = NULL;
  59 const ::google::protobuf::Descriptor* ReqHangUp_descriptor_ = NULL;
  60 const ::google::protobuf::internal::GeneratedMessageReflection*
  61   ReqHangUp_reflection_ = NULL;
  62 const ::google::protobuf::Descriptor* RspLastCallFailCause_descriptor_ = NULL;
  63 const ::google::protobuf::internal::GeneratedMessageReflection*
  64   RspLastCallFailCause_reflection_ = NULL;
  65 const ::google::protobuf::Descriptor* RspSignalStrength_descriptor_ = NULL;
  66 const ::google::protobuf::internal::GeneratedMessageReflection*
  67   RspSignalStrength_reflection_ = NULL;
  68 const ::google::protobuf::Descriptor* RspOperator_descriptor_ = NULL;
  69 const ::google::protobuf::internal::GeneratedMessageReflection*
  70   RspOperator_reflection_ = NULL;
  71 const ::google::protobuf::Descriptor* ReqSeparateConnection_descriptor_ = NULL;
  72 const ::google::protobuf::internal::GeneratedMessageReflection*
  73   ReqSeparateConnection_reflection_ = NULL;
  74 const ::google::protobuf::Descriptor* ReqSetMute_descriptor_ = NULL;
  75 const ::google::protobuf::internal::GeneratedMessageReflection*
  76   ReqSetMute_reflection_ = NULL;
  77 const ::google::protobuf::Descriptor* ReqScreenState_descriptor_ = NULL;
  78 const ::google::protobuf::internal::GeneratedMessageReflection*
  79   ReqScreenState_reflection_ = NULL;
  80 const ::google::protobuf::EnumDescriptor* RadioState_descriptor_ = NULL;
  81 const ::google::protobuf::EnumDescriptor* RilCardState_descriptor_ = NULL;
  82 const ::google::protobuf::EnumDescriptor* RilPersoSubstate_descriptor_ = NULL;
  83 const ::google::protobuf::EnumDescriptor* RilAppState_descriptor_ = NULL;
  84 const ::google::protobuf::EnumDescriptor* RilPinState_descriptor_ = NULL;
  85 const ::google::protobuf::EnumDescriptor* RilAppType_descriptor_ = NULL;
  86 const ::google::protobuf::EnumDescriptor* RilUusType_descriptor_ = NULL;
  87 const ::google::protobuf::EnumDescriptor* RilUusDcs_descriptor_ = NULL;
  88 const ::google::protobuf::EnumDescriptor* RilCallState_descriptor_ = NULL;
  89
  90 }  // namespace
  91
  92
  93 void protobuf_AssignDesc_ril_2eproto() {
  94   protobuf_AddDesc_ril_2eproto();
  95   const ::google::protobuf::FileDescriptor* file =
  96     ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
  97       "ril.proto");
  98   GOOGLE_CHECK(file != NULL);
  99   RilAppStatus_descriptor_ = file->message_type(0);
 100   static const int RilAppStatus_offsets_[8] = {
 101     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, app_type_),
 102     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, app_state_),
 103     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, perso_substate_),
 104     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, aid_),
 105     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, app_label_),
 106     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, pin1_replaced_),
 107     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, pin1_),
 108     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, pin2_),
 109   };
 110   RilAppStatus_reflection_ =
 111     new ::google::protobuf::internal::GeneratedMessageReflection(
 112       RilAppStatus_descriptor_,
 113       RilAppStatus::default_instance_,
 114       RilAppStatus_offsets_,
 115       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, _has_bits_[0]),
 116       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilAppStatus, _unknown_fields_),
 117       -1,
 118       ::google::protobuf::DescriptorPool::generated_pool(),
 119       ::google::protobuf::MessageFactory::generated_factory(),
 120       sizeof(RilAppStatus));
 121   RilCardStatus_descriptor_ = file->message_type(1);
 122   static const int RilCardStatus_offsets_[6] = {
 123     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCardStatus, card_state_),
 124     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCardStatus, universal_pin_state_),
 125     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCardStatus, gsm_umts_subscription_app_index_),
 126     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCardStatus, cdma_subscription_app_index_),
 127     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCardStatus, num_applications_),
 128     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCardStatus, applications_),
 129   };
 130   RilCardStatus_reflection_ =
 131     new ::google::protobuf::internal::GeneratedMessageReflection(
 132       RilCardStatus_descriptor_,
 133       RilCardStatus::default_instance_,
 134       RilCardStatus_offsets_,
 135       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCardStatus, _has_bits_[0]),
 136       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCardStatus, _unknown_fields_),
 137       -1,
 138       ::google::protobuf::DescriptorPool::generated_pool(),
 139       ::google::protobuf::MessageFactory::generated_factory(),
 140       sizeof(RilCardStatus));
 141   RilUusInfo_descriptor_ = file->message_type(2);
 142   static const int RilUusInfo_offsets_[4] = {
 143     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilUusInfo, uus_type_),
 144     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilUusInfo, uus_dcs_),
 145     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilUusInfo, uus_length_),
 146     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilUusInfo, uus_data_),
 147   };
 148   RilUusInfo_reflection_ =
 149     new ::google::protobuf::internal::GeneratedMessageReflection(
 150       RilUusInfo_descriptor_,
 151       RilUusInfo::default_instance_,
 152       RilUusInfo_offsets_,
 153       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilUusInfo, _has_bits_[0]),
 154       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilUusInfo, _unknown_fields_),
 155       -1,
 156       ::google::protobuf::DescriptorPool::generated_pool(),
 157       ::google::protobuf::MessageFactory::generated_factory(),
 158       sizeof(RilUusInfo));
 159   RilCall_descriptor_ = file->message_type(3);
 160   static const int RilCall_offsets_[13] = {
 161     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCall, state_),
 162     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCall, index_),
 163     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCall, toa_),
 164     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCall, is_mpty_),
 165     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCall, is_mt_),
 166     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCall, als_),
 167     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCall, is_voice_),
 168     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCall, is_voice_privacy_),
 169     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCall, number_),
 170     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCall, number_presentation_),
 171     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCall, name_),
 172     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCall, name_presentation_),
 173     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCall, uus_info_),
 174   };
 175   RilCall_reflection_ =
 176     new ::google::protobuf::internal::GeneratedMessageReflection(
 177       RilCall_descriptor_,
 178       RilCall::default_instance_,
 179       RilCall_offsets_,
 180       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCall, _has_bits_[0]),
 181       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RilCall, _unknown_fields_),
 182       -1,
 183       ::google::protobuf::DescriptorPool::generated_pool(),
 184       ::google::protobuf::MessageFactory::generated_factory(),
 185       sizeof(RilCall));
 186   RILGWSignalStrength_descriptor_ = file->message_type(4);
 187   static const int RILGWSignalStrength_offsets_[2] = {
 188     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RILGWSignalStrength, signal_strength_),
 189     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RILGWSignalStrength, bit_error_rate_),
 190   };
 191   RILGWSignalStrength_reflection_ =
 192     new ::google::protobuf::internal::GeneratedMessageReflection(
 193       RILGWSignalStrength_descriptor_,
 194       RILGWSignalStrength::default_instance_,
 195       RILGWSignalStrength_offsets_,
 196       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RILGWSignalStrength, _has_bits_[0]),
 197       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RILGWSignalStrength, _unknown_fields_),
 198       -1,
 199       ::google::protobuf::DescriptorPool::generated_pool(),
 200       ::google::protobuf::MessageFactory::generated_factory(),
 201       sizeof(RILGWSignalStrength));
 202   RILCDMASignalStrength_descriptor_ = file->message_type(5);
 203   static const int RILCDMASignalStrength_offsets_[2] = {
 204     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RILCDMASignalStrength, dbm_),
 205     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RILCDMASignalStrength, ecio_),
 206   };
 207   RILCDMASignalStrength_reflection_ =
 208     new ::google::protobuf::internal::GeneratedMessageReflection(
 209       RILCDMASignalStrength_descriptor_,
 210       RILCDMASignalStrength::default_instance_,
 211       RILCDMASignalStrength_offsets_,
 212       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RILCDMASignalStrength, _has_bits_[0]),
 213       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RILCDMASignalStrength, _unknown_fields_),
 214       -1,
 215       ::google::protobuf::DescriptorPool::generated_pool(),
 216       ::google::protobuf::MessageFactory::generated_factory(),
 217       sizeof(RILCDMASignalStrength));
 218   RILEVDOSignalStrength_descriptor_ = file->message_type(6);
 219   static const int RILEVDOSignalStrength_offsets_[3] = {
 220     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RILEVDOSignalStrength, dbm_),
 221     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RILEVDOSignalStrength, ecio_),
 222     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RILEVDOSignalStrength, signal_noise_ratio_),
 223   };
 224   RILEVDOSignalStrength_reflection_ =
 225     new ::google::protobuf::internal::GeneratedMessageReflection(
 226       RILEVDOSignalStrength_descriptor_,
 227       RILEVDOSignalStrength::default_instance_,
 228       RILEVDOSignalStrength_offsets_,
 229       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RILEVDOSignalStrength, _has_bits_[0]),
 230       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RILEVDOSignalStrength, _unknown_fields_),
 231       -1,
 232       ::google::protobuf::DescriptorPool::generated_pool(),
 233       ::google::protobuf::MessageFactory::generated_factory(),
 234       sizeof(RILEVDOSignalStrength));
 235   RspStrings_descriptor_ = file->message_type(7);
 236   static const int RspStrings_offsets_[1] = {
 237     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspStrings, strings_),
 238   };
 239   RspStrings_reflection_ =
 240     new ::google::protobuf::internal::GeneratedMessageReflection(
 241       RspStrings_descriptor_,
 242       RspStrings::default_instance_,
 243       RspStrings_offsets_,
 244       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspStrings, _has_bits_[0]),
 245       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspStrings, _unknown_fields_),
 246       -1,
 247       ::google::protobuf::DescriptorPool::generated_pool(),
 248       ::google::protobuf::MessageFactory::generated_factory(),
 249       sizeof(RspStrings));
 250   RspIntegers_descriptor_ = file->message_type(8);
 251   static const int RspIntegers_offsets_[1] = {
 252     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspIntegers, integers_),
 253   };
 254   RspIntegers_reflection_ =
 255     new ::google::protobuf::internal::GeneratedMessageReflection(
 256       RspIntegers_descriptor_,
 257       RspIntegers::default_instance_,
 258       RspIntegers_offsets_,
 259       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspIntegers, _has_bits_[0]),
 260       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspIntegers, _unknown_fields_),
 261       -1,
 262       ::google::protobuf::DescriptorPool::generated_pool(),
 263       ::google::protobuf::MessageFactory::generated_factory(),
 264       sizeof(RspIntegers));
 265   RspGetSimStatus_descriptor_ = file->message_type(9);
 266   static const int RspGetSimStatus_offsets_[1] = {
 267     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspGetSimStatus, card_status_),
 268   };
 269   RspGetSimStatus_reflection_ =
 270     new ::google::protobuf::internal::GeneratedMessageReflection(
 271       RspGetSimStatus_descriptor_,
 272       RspGetSimStatus::default_instance_,
 273       RspGetSimStatus_offsets_,
 274       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspGetSimStatus, _has_bits_[0]),
 275       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspGetSimStatus, _unknown_fields_),
 276       -1,
 277       ::google::protobuf::DescriptorPool::generated_pool(),
 278       ::google::protobuf::MessageFactory::generated_factory(),
 279       sizeof(RspGetSimStatus));
 280   ReqEnterSimPin_descriptor_ = file->message_type(10);
 281   static const int ReqEnterSimPin_offsets_[1] = {
 282     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqEnterSimPin, pin_),
 283   };
 284   ReqEnterSimPin_reflection_ =
 285     new ::google::protobuf::internal::GeneratedMessageReflection(
 286       ReqEnterSimPin_descriptor_,
 287       ReqEnterSimPin::default_instance_,
 288       ReqEnterSimPin_offsets_,
 289       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqEnterSimPin, _has_bits_[0]),
 290       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqEnterSimPin, _unknown_fields_),
 291       -1,
 292       ::google::protobuf::DescriptorPool::generated_pool(),
 293       ::google::protobuf::MessageFactory::generated_factory(),
 294       sizeof(ReqEnterSimPin));
 295   RspEnterSimPin_descriptor_ = file->message_type(11);
 296   static const int RspEnterSimPin_offsets_[1] = {
 297     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspEnterSimPin, retries_remaining_),
 298   };
 299   RspEnterSimPin_reflection_ =
 300     new ::google::protobuf::internal::GeneratedMessageReflection(
 301       RspEnterSimPin_descriptor_,
 302       RspEnterSimPin::default_instance_,
 303       RspEnterSimPin_offsets_,
 304       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspEnterSimPin, _has_bits_[0]),
 305       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspEnterSimPin, _unknown_fields_),
 306       -1,
 307       ::google::protobuf::DescriptorPool::generated_pool(),
 308       ::google::protobuf::MessageFactory::generated_factory(),
 309       sizeof(RspEnterSimPin));
 310   RspGetCurrentCalls_descriptor_ = file->message_type(12);
 311   static const int RspGetCurrentCalls_offsets_[1] = {
 312     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspGetCurrentCalls, calls_),
 313   };
 314   RspGetCurrentCalls_reflection_ =
 315     new ::google::protobuf::internal::GeneratedMessageReflection(
 316       RspGetCurrentCalls_descriptor_,
 317       RspGetCurrentCalls::default_instance_,
 318       RspGetCurrentCalls_offsets_,
 319       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspGetCurrentCalls, _has_bits_[0]),
 320       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspGetCurrentCalls, _unknown_fields_),
 321       -1,
 322       ::google::protobuf::DescriptorPool::generated_pool(),
 323       ::google::protobuf::MessageFactory::generated_factory(),
 324       sizeof(RspGetCurrentCalls));
 325   ReqDial_descriptor_ = file->message_type(13);
 326   static const int ReqDial_offsets_[3] = {
 327     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqDial, address_),
 328     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqDial, clir_),
 329     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqDial, uus_info_),
 330   };
 331   ReqDial_reflection_ =
 332     new ::google::protobuf::internal::GeneratedMessageReflection(
 333       ReqDial_descriptor_,
 334       ReqDial::default_instance_,
 335       ReqDial_offsets_,
 336       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqDial, _has_bits_[0]),
 337       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqDial, _unknown_fields_),
 338       -1,
 339       ::google::protobuf::DescriptorPool::generated_pool(),
 340       ::google::protobuf::MessageFactory::generated_factory(),
 341       sizeof(ReqDial));
 342   ReqHangUp_descriptor_ = file->message_type(14);
 343   static const int ReqHangUp_offsets_[1] = {
 344     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqHangUp, connection_index_),
 345   };
 346   ReqHangUp_reflection_ =
 347     new ::google::protobuf::internal::GeneratedMessageReflection(
 348       ReqHangUp_descriptor_,
 349       ReqHangUp::default_instance_,
 350       ReqHangUp_offsets_,
 351       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqHangUp, _has_bits_[0]),
 352       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqHangUp, _unknown_fields_),
 353       -1,
 354       ::google::protobuf::DescriptorPool::generated_pool(),
 355       ::google::protobuf::MessageFactory::generated_factory(),
 356       sizeof(ReqHangUp));
 357   RspLastCallFailCause_descriptor_ = file->message_type(15);
 358   static const int RspLastCallFailCause_offsets_[1] = {
 359     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspLastCallFailCause, last_call_fail_cause_),
 360   };
 361   RspLastCallFailCause_reflection_ =
 362     new ::google::protobuf::internal::GeneratedMessageReflection(
 363       RspLastCallFailCause_descriptor_,
 364       RspLastCallFailCause::default_instance_,
 365       RspLastCallFailCause_offsets_,
 366       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspLastCallFailCause, _has_bits_[0]),
 367       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspLastCallFailCause, _unknown_fields_),
 368       -1,
 369       ::google::protobuf::DescriptorPool::generated_pool(),
 370       ::google::protobuf::MessageFactory::generated_factory(),
 371       sizeof(RspLastCallFailCause));
 372   RspSignalStrength_descriptor_ = file->message_type(16);
 373   static const int RspSignalStrength_offsets_[3] = {
 374     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspSignalStrength, gw_signalstrength_),
 375     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspSignalStrength, cdma_signalstrength_),
 376     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspSignalStrength, evdo_signalstrength_),
 377   };
 378   RspSignalStrength_reflection_ =
 379     new ::google::protobuf::internal::GeneratedMessageReflection(
 380       RspSignalStrength_descriptor_,
 381       RspSignalStrength::default_instance_,
 382       RspSignalStrength_offsets_,
 383       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspSignalStrength, _has_bits_[0]),
 384       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspSignalStrength, _unknown_fields_),
 385       -1,
 386       ::google::protobuf::DescriptorPool::generated_pool(),
 387       ::google::protobuf::MessageFactory::generated_factory(),
 388       sizeof(RspSignalStrength));
 389   RspOperator_descriptor_ = file->message_type(17);
 390   static const int RspOperator_offsets_[3] = {
 391     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspOperator, long_alpha_ons_),
 392     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspOperator, short_alpha_ons_),
 393     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspOperator, mcc_mnc_),
 394   };
 395   RspOperator_reflection_ =
 396     new ::google::protobuf::internal::GeneratedMessageReflection(
 397       RspOperator_descriptor_,
 398       RspOperator::default_instance_,
 399       RspOperator_offsets_,
 400       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspOperator, _has_bits_[0]),
 401       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RspOperator, _unknown_fields_),
 402       -1,
 403       ::google::protobuf::DescriptorPool::generated_pool(),
 404       ::google::protobuf::MessageFactory::generated_factory(),
 405       sizeof(RspOperator));
 406   ReqSeparateConnection_descriptor_ = file->message_type(18);
 407   static const int ReqSeparateConnection_offsets_[1] = {
 408     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqSeparateConnection, index_),
 409   };
 410   ReqSeparateConnection_reflection_ =
 411     new ::google::protobuf::internal::GeneratedMessageReflection(
 412       ReqSeparateConnection_descriptor_,
 413       ReqSeparateConnection::default_instance_,
 414       ReqSeparateConnection_offsets_,
 415       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqSeparateConnection, _has_bits_[0]),
 416       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqSeparateConnection, _unknown_fields_),
 417       -1,
 418       ::google::protobuf::DescriptorPool::generated_pool(),
 419       ::google::protobuf::MessageFactory::generated_factory(),
 420       sizeof(ReqSeparateConnection));
 421   ReqSetMute_descriptor_ = file->message_type(19);
 422   static const int ReqSetMute_offsets_[1] = {
 423     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqSetMute, state_),
 424   };
 425   ReqSetMute_reflection_ =
 426     new ::google::protobuf::internal::GeneratedMessageReflection(
 427       ReqSetMute_descriptor_,
 428       ReqSetMute::default_instance_,
 429       ReqSetMute_offsets_,
 430       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqSetMute, _has_bits_[0]),
 431       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqSetMute, _unknown_fields_),
 432       -1,
 433       ::google::protobuf::DescriptorPool::generated_pool(),
 434       ::google::protobuf::MessageFactory::generated_factory(),
 435       sizeof(ReqSetMute));
 436   ReqScreenState_descriptor_ = file->message_type(20);
 437   static const int ReqScreenState_offsets_[1] = {
 438     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqScreenState, state_),
 439   };
 440   ReqScreenState_reflection_ =
 441     new ::google::protobuf::internal::GeneratedMessageReflection(
 442       ReqScreenState_descriptor_,
 443       ReqScreenState::default_instance_,
 444       ReqScreenState_offsets_,
 445       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqScreenState, _has_bits_[0]),
 446       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReqScreenState, _unknown_fields_),
 447       -1,
 448       ::google::protobuf::DescriptorPool::generated_pool(),
 449       ::google::protobuf::MessageFactory::generated_factory(),
 450       sizeof(ReqScreenState));
 451   RadioState_descriptor_ = file->enum_type(0);
 452   RilCardState_descriptor_ = file->enum_type(1);
 453   RilPersoSubstate_descriptor_ = file->enum_type(2);
 454   RilAppState_descriptor_ = file->enum_type(3);
 455   RilPinState_descriptor_ = file->enum_type(4);
 456   RilAppType_descriptor_ = file->enum_type(5);
 457   RilUusType_descriptor_ = file->enum_type(6);
 458   RilUusDcs_descriptor_ = file->enum_type(7);
 459   RilCallState_descriptor_ = file->enum_type(8);
 460 }
 461
 462 namespace {
 463
 464 GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
 465 inline void protobuf_AssignDescriptorsOnce() {
 466   ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
 467                  &protobuf_AssignDesc_ril_2eproto);
 468 }
 469
 470 void protobuf_RegisterTypes(const ::std::string&) {
 471   protobuf_AssignDescriptorsOnce();
 472   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 473     RilAppStatus_descriptor_, &RilAppStatus::default_instance());
 474   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 475     RilCardStatus_descriptor_, &RilCardStatus::default_instance());
 476   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 477     RilUusInfo_descriptor_, &RilUusInfo::default_instance());
 478   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 479     RilCall_descriptor_, &RilCall::default_instance());
 480   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 481     RILGWSignalStrength_descriptor_, &RILGWSignalStrength::default_instance());
 482   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 483     RILCDMASignalStrength_descriptor_, &RILCDMASignalStrength::default_instance());
 484   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 485     RILEVDOSignalStrength_descriptor_, &RILEVDOSignalStrength::default_instance());
 486   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 487     RspStrings_descriptor_, &RspStrings::default_instance());
 488   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 489     RspIntegers_descriptor_, &RspIntegers::default_instance());
 490   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 491     RspGetSimStatus_descriptor_, &RspGetSimStatus::default_instance());
 492   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 493     ReqEnterSimPin_descriptor_, &ReqEnterSimPin::default_instance());
 494   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 495     RspEnterSimPin_descriptor_, &RspEnterSimPin::default_instance());
 496   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 497     RspGetCurrentCalls_descriptor_, &RspGetCurrentCalls::default_instance());
 498   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 499     ReqDial_descriptor_, &ReqDial::default_instance());
 500   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 501     ReqHangUp_descriptor_, &ReqHangUp::default_instance());
 502   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 503     RspLastCallFailCause_descriptor_, &RspLastCallFailCause::default_instance());
 504   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 505     RspSignalStrength_descriptor_, &RspSignalStrength::default_instance());
 506   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 507     RspOperator_descriptor_, &RspOperator::default_instance());
 508   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 509     ReqSeparateConnection_descriptor_, &ReqSeparateConnection::default_instance());
 510   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 511     ReqSetMute_descriptor_, &ReqSetMute::default_instance());
 512   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 513     ReqScreenState_descriptor_, &ReqScreenState::default_instance());
 514 }
 515
 516 }  // namespace
 517
 518 void protobuf_ShutdownFile_ril_2eproto() {
 519   delete RilAppStatus::default_instance_;
 520   delete RilAppStatus_reflection_;
 521   delete RilCardStatus::default_instance_;
 522   delete RilCardStatus_reflection_;
 523   delete RilUusInfo::default_instance_;
 524   delete RilUusInfo_reflection_;
 525   delete RilCall::default_instance_;
 526   delete RilCall_reflection_;
 527   delete RILGWSignalStrength::default_instance_;
 528   delete RILGWSignalStrength_reflection_;
 529   delete RILCDMASignalStrength::default_instance_;
 530   delete RILCDMASignalStrength_reflection_;
 531   delete RILEVDOSignalStrength::default_instance_;
 532   delete RILEVDOSignalStrength_reflection_;
 533   delete RspStrings::default_instance_;
 534   delete RspStrings_reflection_;
 535   delete RspIntegers::default_instance_;
 536   delete RspIntegers_reflection_;
 537   delete RspGetSimStatus::default_instance_;
 538   delete RspGetSimStatus_reflection_;
 539   delete ReqEnterSimPin::default_instance_;
 540   delete ReqEnterSimPin_reflection_;
 541   delete RspEnterSimPin::default_instance_;
 542   delete RspEnterSimPin_reflection_;
 543   delete RspGetCurrentCalls::default_instance_;
 544   delete RspGetCurrentCalls_reflection_;
 545   delete ReqDial::default_instance_;
 546   delete ReqDial_reflection_;
 547   delete ReqHangUp::default_instance_;
 548   delete ReqHangUp_reflection_;
 549   delete RspLastCallFailCause::default_instance_;
 550   delete RspLastCallFailCause_reflection_;
 551   delete RspSignalStrength::default_instance_;
 552   delete RspSignalStrength_reflection_;
 553   delete RspOperator::default_instance_;
 554   delete RspOperator_reflection_;
 555   delete ReqSeparateConnection::default_instance_;
 556   delete ReqSeparateConnection_reflection_;
 557   delete ReqSetMute::default_instance_;
 558   delete ReqSetMute_reflection_;
 559   delete ReqScreenState::default_instance_;
 560   delete ReqScreenState_reflection_;
 561 }
 562
 563 void protobuf_AddDesc_ril_2eproto() {
 564   static bool already_here = false;
 565   if (already_here) return;
 566   already_here = true;
 567   GOOGLE_PROTOBUF_VERIFY_VERSION;
 568
 569   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
 570     "\n\tril.proto\022\tril_proto\"\232\002\n\014RilAppStatus\022"
 571     "\'\n\010app_type\030\001 \001(\0162\025.ril_proto.RilAppType"
 572     "\022)\n\tapp_state\030\002 \001(\0162\026.ril_proto.RilAppSt"
 573     "ate\0223\n\016perso_substate\030\003 \001(\0162\033.ril_proto."
 574     "RilPersoSubstate\022\013\n\003aid\030\004 \001(\t\022\021\n\tapp_lab"
 575     "el\030\005 \001(\t\022\025\n\rpin1_replaced\030\006 \001(\005\022$\n\004pin1\030"
 576     "\007 \001(\0162\026.ril_proto.RilPinState\022$\n\004pin2\030\010 "
 577     "\001(\0162\026.ril_proto.RilPinState\"\210\002\n\rRilCardS"
 578     "tatus\022+\n\ncard_state\030\001 \001(\0162\027.ril_proto.Ri"
 579     "lCardState\0223\n\023universal_pin_state\030\002 \001(\0162"
 580     "\026.ril_proto.RilPinState\022\'\n\037gsm_umts_subs"
 581     "cription_app_index\030\003 \001(\005\022#\n\033cdma_subscri"
 582     "ption_app_index\030\004 \001(\005\022\030\n\020num_application"
 583     "s\030\005 \001(\005\022-\n\014applications\030\006 \003(\0132\027.ril_prot"
 584     "o.RilAppStatus\"\202\001\n\nRilUusInfo\022\'\n\010uus_typ"
 585     "e\030\001 \001(\0162\025.ril_proto.RilUusType\022%\n\007uus_dc"
 586     "s\030\002 \001(\0162\024.ril_proto.RilUusDcs\022\022\n\nuus_len"
 587     "gth\030\003 \001(\005\022\020\n\010uus_data\030\004 \001(\t\"\245\002\n\007RilCall\022"
 588     "&\n\005state\030\001 \001(\0162\027.ril_proto.RilCallState\022"
 589     "\r\n\005index\030\002 \001(\005\022\013\n\003toa\030\003 \001(\005\022\017\n\007is_mpty\030\004"
 590     " \001(\010\022\r\n\005is_mt\030\005 \001(\010\022\013\n\003als\030\006 \001(\005\022\020\n\010is_v"
 591     "oice\030\007 \001(\010\022\030\n\020is_voice_privacy\030\010 \001(\010\022\016\n\006"
 592     "number\030\t \001(\t\022\033\n\023number_presentation\030\n \001("
 593     "\005\022\014\n\004name\030\013 \001(\t\022\031\n\021name_presentation\030\014 \001"
 594     "(\005\022\'\n\010uus_info\030\r \001(\0132\025.ril_proto.RilUusI"
 595     "nfo\"F\n\023RILGWSignalStrength\022\027\n\017signal_str"
 596     "ength\030\001 \001(\005\022\026\n\016bit_error_rate\030\002 \001(\005\"2\n\025R"
 597     "ILCDMASignalStrength\022\013\n\003dbm\030\001 \001(\005\022\014\n\004eci"
 598     "o\030\002 \001(\005\"N\n\025RILEVDOSignalStrength\022\013\n\003dbm\030"
 599     "\001 \001(\005\022\014\n\004ecio\030\002 \001(\005\022\032\n\022signal_noise_rati"
 600     "o\030\003 \001(\005\"\035\n\nRspStrings\022\017\n\007strings\030\001 \003(\t\"\037"
 601     "\n\013RspIntegers\022\020\n\010integers\030\001 \003(\005\"@\n\017RspGe"
 602     "tSimStatus\022-\n\013card_status\030\001 \002(\0132\030.ril_pr"
 603     "oto.RilCardStatus\"\035\n\016ReqEnterSimPin\022\013\n\003p"
 604     "in\030\001 \002(\t\"+\n\016RspEnterSimPin\022\031\n\021retries_re"
 605     "maining\030\001 \002(\005\"7\n\022RspGetCurrentCalls\022!\n\005c"
 606     "alls\030\001 \003(\0132\022.ril_proto.RilCall\"Q\n\007ReqDia"
 607     "l\022\017\n\007address\030\001 \001(\t\022\014\n\004clir\030\002 \001(\005\022\'\n\010uus_"
 608     "info\030\003 \001(\0132\025.ril_proto.RilUusInfo\"%\n\tReq"
 609     "HangUp\022\030\n\020connection_index\030\001 \002(\005\"4\n\024RspL"
 610     "astCallFailCause\022\034\n\024last_call_fail_cause"
 611     "\030\001 \002(\005\"\314\001\n\021RspSignalStrength\0229\n\021gw_signa"
 612     "lstrength\030\001 \001(\0132\036.ril_proto.RILGWSignalS"
 613     "trength\022=\n\023cdma_signalstrength\030\002 \001(\0132 .r"
 614     "il_proto.RILCDMASignalStrength\022=\n\023evdo_s"
 615     "ignalstrength\030\003 \001(\0132 .ril_proto.RILEVDOS"
 616     "ignalStrength\"O\n\013RspOperator\022\026\n\016long_alp"
 617     "ha_ons\030\001 \001(\t\022\027\n\017short_alpha_ons\030\002 \001(\t\022\017\n"
 618     "\007mcc_mnc\030\003 \001(\t\"&\n\025ReqSeparateConnection\022"
 619     "\r\n\005index\030\001 \002(\005\"\033\n\nReqSetMute\022\r\n\005state\030\001 "
 620     "\002(\010\"\037\n\016ReqScreenState\022\r\n\005state\030\001 \002(\010*\257\002\n"
 621     "\nRadioState\022\022\n\016RADIOSTATE_OFF\020\000\022\032\n\026RADIO"
 622     "STATE_UNAVAILABLE\020\001\022\034\n\030RADIOSTATE_SIM_NO"
 623     "T_READY\020\002\022#\n\037RADIOSTATE_SIM_LOCKED_OR_AB"
 624     "SENT\020\003\022\030\n\024RADIOSTATE_SIM_READY\020\004\022\035\n\031RADI"
 625     "OSTATE_RUIM_NOT_READY\020\005\022\031\n\025RADIOSTATE_RU"
 626     "IM_READY\020\006\022$\n RADIOSTATE_RUIM_LOCKED_OR_"
 627     "ABSENT\020\007\022\033\n\027RADIOSTATE_NV_NOT_READY\020\010\022\027\n"
 628     "\023RADIOSTATE_NV_READY\020\t*P\n\014RilCardState\022\024"
 629     "\n\020CARDSTATE_ABSENT\020\000\022\025\n\021CARDSTATE_PRESEN"
 630     "T\020\001\022\023\n\017CARDSTATE_ERROR\020\002*\361\006\n\020RilPersoSub"
 631     "state\022\031\n\025PERSOSUBSTATE_UNKNOWN\020\000\022\035\n\031PERS"
 632     "OSUBSTATE_IN_PROGRESS\020\001\022\027\n\023PERSOSUBSTATE"
 633     "_READY\020\002\022\035\n\031PERSOSUBSTATE_SIM_NETWORK\020\003\022"
 634     "$\n PERSOSUBSTATE_SIM_NETWORK_SUBSET\020\004\022\037\n"
 635     "\033PERSOSUBSTATE_SIM_CORPORATE\020\005\022&\n\"PERSOS"
 636     "UBSTATE_SIM_SERVICE_PROVIDER\020\006\022\031\n\025PERSOS"
 637     "UBSTATE_SIM_SIM\020\007\022!\n\035PERSOSUBSTATE_SIM_N"
 638     "ETWORK_PUK\020\010\022(\n$PERSOSUBSTATE_SIM_NETWOR"
 639     "K_SUBSET_PUK\020\t\022#\n\037PERSOSUBSTATE_SIM_CORP"
 640     "ORATE_PUK\020\n\022*\n&PERSOSUBSTATE_SIM_SERVICE"
 641     "_PROVIDER_PUK\020\013\022\035\n\031PERSOSUBSTATE_SIM_SIM"
 642     "_PUK\020\014\022\037\n\033PERSOSUBSTATE_RUIM_NETWORK1\020\r\022"
 643     "\037\n\033PERSOSUBSTATE_RUIM_NETWORK2\020\016\022\033\n\027PERS"
 644     "OSUBSTATE_RUIM_HRPD\020\017\022 \n\034PERSOSUBSTATE_R"
 645     "UIM_CORPORATE\020\020\022\'\n#PERSOSUBSTATE_RUIM_SE"
 646     "RVICE_PROVIDER\020\021\022\033\n\027PERSOSUBSTATE_RUIM_R"
 647     "UIM\020\022\022#\n\037PERSOSUBSTATE_RUIM_NETWORK1_PUK"
 648     "\020\023\022#\n\037PERSOSUBSTATE_RUIM_NETWORK2_PUK\020\024\022"
 649     "\037\n\033PERSOSUBSTATE_RUIM_HRPD_PUK\020\025\022$\n PERS"
 650     "OSUBSTATE_RUIM_CORPORATE_PUK\020\026\022+\n\'PERSOS"
 651     "UBSTATE_RUIM_SERVICE_PROVIDER_PUK\020\027\022\037\n\033P"
 652     "ERSOSUBSTATE_RUIM_RUIM_PUK\020\030*\223\001\n\013RilAppS"
 653     "tate\022\024\n\020APPSTATE_UNKNOWN\020\000\022\025\n\021APPSTATE_D"
 654     "ETECTED\020\001\022\020\n\014APPSTATE_PIN\020\002\022\020\n\014APPSTATE_"
 655     "PUK\020\003\022\037\n\033APPSTATE_SUBSCRIPTION_PERSO\020\004\022\022"
 656     "\n\016APPSTATE_READY\020\005*\275\001\n\013RilPinState\022\024\n\020PI"
 657     "NSTATE_UNKNOWN\020\000\022!\n\035PINSTATE_ENABLED_NOT"
 658     "_VERIFIED\020\001\022\035\n\031PINSTATE_ENABLED_VERIFIED"
 659     "\020\002\022\025\n\021PINSTATE_DISABLED\020\003\022\034\n\030PINSTATE_EN"
 660     "ABLED_BLOCKED\020\004\022!\n\035PINSTATE_ENABLED_PERM"
 661     "_BLOCKED\020\005*h\n\nRilAppType\022\023\n\017APPTYPE_UNKN"
 662     "OWN\020\000\022\017\n\013APPTYPE_SIM\020\001\022\020\n\014APPTYPE_USIM\020\002"
 663     "\022\020\n\014APPTYPE_RUIM\020\003\022\020\n\014APPTYPE_CSIM\020\004*\316\001\n"
 664     "\nRilUusType\022\030\n\024RILUUSTYPE1_IMPLICIT\020\000\022\030\n"
 665     "\024RILUUSTYPE1_REQUIRED\020\001\022\034\n\030RILUUSTYPE1_N"
 666     "OT_REQUIRED\020\002\022\030\n\024RILUUSTYPE2_REQUIRED\020\003\022"
 667     "\034\n\030RILUUSTYPE2_NOT_REQUIRED\020\004\022\030\n\024RILUUST"
 668     "YPE3_REQUIRED\020\005\022\034\n\030RILUUSTYPE3_NOT_REQUI"
 669     "RED\020\006*p\n\tRilUusDcs\022\021\n\rRILUUSDCS_USP\020\000\022\024\n"
 670     "\020RILUUSDCS_OSIHLP\020\001\022\022\n\016RILUUSDCS_X244\020\002\022"
 671     "\022\n\016RILUUSDCS_RMCF\020\003\022\022\n\016RILUUSDCS_IA5c\020\004*"
 672     "\231\001\n\014RilCallState\022\024\n\020CALLSTATE_ACTIVE\020\000\022\025"
 673     "\n\021CALLSTATE_HOLDING\020\001\022\025\n\021CALLSTATE_DIALI"
 674     "NG\020\002\022\026\n\022CALLSTATE_ALERTING\020\003\022\026\n\022CALLSTAT"
 675     "E_INCOMING\020\004\022\025\n\021CALLSTATE_WAITING\020\005B3\n(c"
 676     "om.android.internal.telephony.ril_protoB"
 677     "\007RilCmds", 4288);
 678   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
 679     "ril.proto", &protobuf_RegisterTypes);
 680   RilAppStatus::default_instance_ = new RilAppStatus();
 681   RilCardStatus::default_instance_ = new RilCardStatus();
 682   RilUusInfo::default_instance_ = new RilUusInfo();
 683   RilCall::default_instance_ = new RilCall();
 684   RILGWSignalStrength::default_instance_ = new RILGWSignalStrength();
 685   RILCDMASignalStrength::default_instance_ = new RILCDMASignalStrength();
 686   RILEVDOSignalStrength::default_instance_ = new RILEVDOSignalStrength();
 687   RspStrings::default_instance_ = new RspStrings();
 688   RspIntegers::default_instance_ = new RspIntegers();
 689   RspGetSimStatus::default_instance_ = new RspGetSimStatus();
 690   ReqEnterSimPin::default_instance_ = new ReqEnterSimPin();
 691   RspEnterSimPin::default_instance_ = new RspEnterSimPin();
 692   RspGetCurrentCalls::default_instance_ = new RspGetCurrentCalls();
 693   ReqDial::default_instance_ = new ReqDial();
 694   ReqHangUp::default_instance_ = new ReqHangUp();
 695   RspLastCallFailCause::default_instance_ = new RspLastCallFailCause();
 696   RspSignalStrength::default_instance_ = new RspSignalStrength();
 697   RspOperator::default_instance_ = new RspOperator();
 698   ReqSeparateConnection::default_instance_ = new ReqSeparateConnection();
 699   ReqSetMute::default_instance_ = new ReqSetMute();
 700   ReqScreenState::default_instance_ = new ReqScreenState();
 701   RilAppStatus::default_instance_->InitAsDefaultInstance();
 702   RilCardStatus::default_instance_->InitAsDefaultInstance();
 703   RilUusInfo::default_instance_->InitAsDefaultInstance();
 704   RilCall::default_instance_->InitAsDefaultInstance();
 705   RILGWSignalStrength::default_instance_->InitAsDefaultInstance();
 706   RILCDMASignalStrength::default_instance_->InitAsDefaultInstance();
 707   RILEVDOSignalStrength::default_instance_->InitAsDefaultInstance();
 708   RspStrings::default_instance_->InitAsDefaultInstance();
 709   RspIntegers::default_instance_->InitAsDefaultInstance();
 710   RspGetSimStatus::default_instance_->InitAsDefaultInstance();
 711   ReqEnterSimPin::default_instance_->InitAsDefaultInstance();
 712   RspEnterSimPin::default_instance_->InitAsDefaultInstance();
 713   RspGetCurrentCalls::default_instance_->InitAsDefaultInstance();
 714   ReqDial::default_instance_->InitAsDefaultInstance();
 715   ReqHangUp::default_instance_->InitAsDefaultInstance();
 716   RspLastCallFailCause::default_instance_->InitAsDefaultInstance();
 717   RspSignalStrength::default_instance_->InitAsDefaultInstance();
 718   RspOperator::default_instance_->InitAsDefaultInstance();
 719   ReqSeparateConnection::default_instance_->InitAsDefaultInstance();
 720   ReqSetMute::default_instance_->InitAsDefaultInstance();
 721   ReqScreenState::default_instance_->InitAsDefaultInstance();
 722   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_ril_2eproto);
 723 }
 724
 725 // Force AddDescriptors() to be called at static initialization time.
 726 struct StaticDescriptorInitializer_ril_2eproto {
 727   StaticDescriptorInitializer_ril_2eproto() {
 728     protobuf_AddDesc_ril_2eproto();
 729   }
 730 } static_descriptor_initializer_ril_2eproto_;
 731
 732 const ::google::protobuf::EnumDescriptor* RadioState_descriptor() {
 733   protobuf_AssignDescriptorsOnce();
 734   return RadioState_descriptor_;
 735 }
 736 bool RadioState_IsValid(int value) {
 737   switch(value) {
 738     case 0:
 739     case 1:
 740     case 2:
 741     case 3:
 742     case 4:
 743     case 5:
 744     case 6:
 745     case 7:
 746     case 8:
 747     case 9:
 748       return true;
 749     default:
 750       return false;
 751   }
 752 }
 753
 754 const ::google::protobuf::EnumDescriptor* RilCardState_descriptor() {
 755   protobuf_AssignDescriptorsOnce();
 756   return RilCardState_descriptor_;
 757 }
 758 bool RilCardState_IsValid(int value) {
 759   switch(value) {
 760     case 0:
 761     case 1:
 762     case 2:
 763       return true;
 764     default:
 765       return false;
 766   }
 767 }
 768
 769 const ::google::protobuf::EnumDescriptor* RilPersoSubstate_descriptor() {
 770   protobuf_AssignDescriptorsOnce();
 771   return RilPersoSubstate_descriptor_;
 772 }
 773 bool RilPersoSubstate_IsValid(int value) {
 774   switch(value) {
 775     case 0:
 776     case 1:
 777     case 2:
 778     case 3:
 779     case 4:
 780     case 5:
 781     case 6:
 782     case 7:
 783     case 8:
 784     case 9:
 785     case 10:
 786     case 11:
 787     case 12:
 788     case 13:
 789     case 14:
 790     case 15:
 791     case 16:
 792     case 17:
 793     case 18:
 794     case 19:
 795     case 20:
 796     case 21:
 797     case 22:
 798     case 23:
 799     case 24:
 800       return true;
 801     default:
 802       return false;
 803   }
 804 }
 805
 806 const ::google::protobuf::EnumDescriptor* RilAppState_descriptor() {
 807   protobuf_AssignDescriptorsOnce();
 808   return RilAppState_descriptor_;
 809 }
 810 bool RilAppState_IsValid(int value) {
 811   switch(value) {
 812     case 0:
 813     case 1:
 814     case 2:
 815     case 3:
 816     case 4:
 817     case 5:
 818       return true;
 819     default:
 820       return false;
 821   }
 822 }
 823
 824 const ::google::protobuf::EnumDescriptor* RilPinState_descriptor() {
 825   protobuf_AssignDescriptorsOnce();
 826   return RilPinState_descriptor_;
 827 }
 828 bool RilPinState_IsValid(int value) {
 829   switch(value) {
 830     case 0:
 831     case 1:
 832     case 2:
 833     case 3:
 834     case 4:
 835     case 5:
 836       return true;
 837     default:
 838       return false;
 839   }
 840 }
 841
 842 const ::google::protobuf::EnumDescriptor* RilAppType_descriptor() {
 843   protobuf_AssignDescriptorsOnce();
 844   return RilAppType_descriptor_;
 845 }
 846 bool RilAppType_IsValid(int value) {
 847   switch(value) {
 848     case 0:
 849     case 1:
 850     case 2:
 851     case 3:
 852     case 4:
 853       return true;
 854     default:
 855       return false;
 856   }
 857 }
 858
 859 const ::google::protobuf::EnumDescriptor* RilUusType_descriptor() {
 860   protobuf_AssignDescriptorsOnce();
 861   return RilUusType_descriptor_;
 862 }
 863 bool RilUusType_IsValid(int value) {
 864   switch(value) {
 865     case 0:
 866     case 1:
 867     case 2:
 868     case 3:
 869     case 4:
 870     case 5:
 871     case 6:
 872       return true;
 873     default:
 874       return false;
 875   }
 876 }
 877
 878 const ::google::protobuf::EnumDescriptor* RilUusDcs_descriptor() {
 879   protobuf_AssignDescriptorsOnce();
 880   return RilUusDcs_descriptor_;
 881 }
 882 bool RilUusDcs_IsValid(int value) {
 883   switch(value) {
 884     case 0:
 885     case 1:
 886     case 2:
 887     case 3:
 888     case 4:
 889       return true;
 890     default:
 891       return false;
 892   }
 893 }
 894
 895 const ::google::protobuf::EnumDescriptor* RilCallState_descriptor() {
 896   protobuf_AssignDescriptorsOnce();
 897   return RilCallState_descriptor_;
 898 }
 899 bool RilCallState_IsValid(int value) {
 900   switch(value) {
 901     case 0:
 902     case 1:
 903     case 2:
 904     case 3:
 905     case 4:
 906     case 5:
 907       return true;
 908     default:
 909       return false;
 910   }
 911 }
 912
 913
 914 // ===================================================================
 915
 916 const ::std::string RilAppStatus::_default_aid_;
 917 const ::std::string RilAppStatus::_default_app_label_;
 918 #ifndef _MSC_VER
 919 const int RilAppStatus::kAppTypeFieldNumber;
 920 const int RilAppStatus::kAppStateFieldNumber;
 921 const int RilAppStatus::kPersoSubstateFieldNumber;
 922 const int RilAppStatus::kAidFieldNumber;
 923 const int RilAppStatus::kAppLabelFieldNumber;
 924 const int RilAppStatus::kPin1ReplacedFieldNumber;
 925 const int RilAppStatus::kPin1FieldNumber;
 926 const int RilAppStatus::kPin2FieldNumber;
 927 #endif  // !_MSC_VER
 928
 929 RilAppStatus::RilAppStatus()
 930   : ::google::protobuf::Message() {
 931   SharedCtor();
 932 }
 933
 934 void RilAppStatus::InitAsDefaultInstance() {
 935 }
 936
 937 RilAppStatus::RilAppStatus(const RilAppStatus& from)
 938   : ::google::protobuf::Message() {
 939   SharedCtor();
 940   MergeFrom(from);
 941 }
 942
 943 void RilAppStatus::SharedCtor() {
 944   _cached_size_ = 0;
 945   app_type_ = 0;
 946   app_state_ = 0;
 947   perso_substate_ = 0;
 948   aid_ = const_cast< ::std::string*>(&_default_aid_);
 949   app_label_ = const_cast< ::std::string*>(&_default_app_label_);
 950   pin1_replaced_ = 0;
 951   pin1_ = 0;
 952   pin2_ = 0;
 953   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 954 }
 955
 956 RilAppStatus::~RilAppStatus() {
 957   SharedDtor();
 958 }
 959
 960 void RilAppStatus::SharedDtor() {
 961   if (aid_ != &_default_aid_) {
 962     delete aid_;
 963   }
 964   if (app_label_ != &_default_app_label_) {
 965     delete app_label_;
 966   }
 967   if (this != default_instance_) {
 968   }
 969 }
 970
 971 void RilAppStatus::SetCachedSize(int size) const {
 972   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
 973   _cached_size_ = size;
 974   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 975 }
 976 const ::google::protobuf::Descriptor* RilAppStatus::descriptor() {
 977   protobuf_AssignDescriptorsOnce();
 978   return RilAppStatus_descriptor_;
 979 }
 980
 981 const RilAppStatus& RilAppStatus::default_instance() {
 982   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
 983 }
 984
 985 RilAppStatus* RilAppStatus::default_instance_ = NULL;
 986
 987 RilAppStatus* RilAppStatus::New() const {
 988   return new RilAppStatus;
 989 }
 990
 991 void RilAppStatus::Clear() {
 992   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
 993     app_type_ = 0;
 994     app_state_ = 0;
 995     perso_substate_ = 0;
 996     if (_has_bit(3)) {
 997       if (aid_ != &_default_aid_) {
 998         aid_->clear();
 999       }
1000     }
1001     if (_has_bit(4)) {
1002       if (app_label_ != &_default_app_label_) {
1003         app_label_->clear();
1004       }
1005     }
1006     pin1_replaced_ = 0;
1007     pin1_ = 0;
1008     pin2_ = 0;
1009   }
1010   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1011   mutable_unknown_fields()->Clear();
1012 }
1013
1014 bool RilAppStatus::MergePartialFromCodedStream(
1015     ::google::protobuf::io::CodedInputStream* input) {
1016 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
1017   ::google::protobuf::uint32 tag;
1018   while ((tag = input->ReadTag()) != 0) {
1019     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1020       // optional .ril_proto.RilAppType app_type = 1;
1021       case 1: {
1022         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1023             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1024           int value;
1025           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1026                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
1027                  input, &value)));
1028           if (ril_proto::RilAppType_IsValid(value)) {
1029             set_app_type(static_cast< ril_proto::RilAppType >(value));
1030           } else {
1031             mutable_unknown_fields()->AddVarint(1, value);
1032           }
1033         } else {
1034           goto handle_uninterpreted;
1035         }
1036         if (input->ExpectTag(16)) goto parse_app_state;
1037         break;
1038       }
1039
1040       // optional .ril_proto.RilAppState app_state = 2;
1041       case 2: {
1042         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1043             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1044          parse_app_state:
1045           int value;
1046           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1047                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
1048                  input, &value)));
1049           if (ril_proto::RilAppState_IsValid(value)) {
1050             set_app_state(static_cast< ril_proto::RilAppState >(value));
1051           } else {
1052             mutable_unknown_fields()->AddVarint(2, value);
1053           }
1054         } else {
1055           goto handle_uninterpreted;
1056         }
1057         if (input->ExpectTag(24)) goto parse_perso_substate;
1058         break;
1059       }
1060
1061       // optional .ril_proto.RilPersoSubstate perso_substate = 3;
1062       case 3: {
1063         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1064             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1065          parse_perso_substate:
1066           int value;
1067           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1068                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
1069                  input, &value)));
1070           if (ril_proto::RilPersoSubstate_IsValid(value)) {
1071             set_perso_substate(static_cast< ril_proto::RilPersoSubstate >(value));
1072           } else {
1073             mutable_unknown_fields()->AddVarint(3, value);
1074           }
1075         } else {
1076           goto handle_uninterpreted;
1077         }
1078         if (input->ExpectTag(34)) goto parse_aid;
1079         break;
1080       }
1081
1082       // optional string aid = 4;
1083       case 4: {
1084         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1085             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1086          parse_aid:
1087           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1088                 input, this->mutable_aid()));
1089           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1090             this->aid().data(), this->aid().length(),
1091             ::google::protobuf::internal::WireFormat::PARSE);
1092         } else {
1093           goto handle_uninterpreted;
1094         }
1095         if (input->ExpectTag(42)) goto parse_app_label;
1096         break;
1097       }
1098
1099       // optional string app_label = 5;
1100       case 5: {
1101         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1102             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1103          parse_app_label:
1104           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1105                 input, this->mutable_app_label()));
1106           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1107             this->app_label().data(), this->app_label().length(),
1108             ::google::protobuf::internal::WireFormat::PARSE);
1109         } else {
1110           goto handle_uninterpreted;
1111         }
1112         if (input->ExpectTag(48)) goto parse_pin1_replaced;
1113         break;
1114       }
1115
1116       // optional int32 pin1_replaced = 6;
1117       case 6: {
1118         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1119             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1120          parse_pin1_replaced:
1121           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1122                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
1123                  input, &pin1_replaced_)));
1124           _set_bit(5);
1125         } else {
1126           goto handle_uninterpreted;
1127         }
1128         if (input->ExpectTag(56)) goto parse_pin1;
1129         break;
1130       }
1131
1132       // optional .ril_proto.RilPinState pin1 = 7;
1133       case 7: {
1134         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1135             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1136          parse_pin1:
1137           int value;
1138           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1139                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
1140                  input, &value)));
1141           if (ril_proto::RilPinState_IsValid(value)) {
1142             set_pin1(static_cast< ril_proto::RilPinState >(value));
1143           } else {
1144             mutable_unknown_fields()->AddVarint(7, value);
1145           }
1146         } else {
1147           goto handle_uninterpreted;
1148         }
1149         if (input->ExpectTag(64)) goto parse_pin2;
1150         break;
1151       }
1152
1153       // optional .ril_proto.RilPinState pin2 = 8;
1154       case 8: {
1155         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1156             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1157          parse_pin2:
1158           int value;
1159           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1160                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
1161                  input, &value)));
1162           if (ril_proto::RilPinState_IsValid(value)) {
1163             set_pin2(static_cast< ril_proto::RilPinState >(value));
1164           } else {
1165             mutable_unknown_fields()->AddVarint(8, value);
1166           }
1167         } else {
1168           goto handle_uninterpreted;
1169         }
1170         if (input->ExpectAtEnd()) return true;
1171         break;
1172       }
1173
1174       default: {
1175       handle_uninterpreted:
1176         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1177             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
1178           return true;
1179         }
1180         DO_(::google::protobuf::internal::WireFormat::SkipField(
1181               input, tag, mutable_unknown_fields()));
1182         break;
1183       }
1184     }
1185   }
1186   return true;
1187 #undef DO_
1188 }
1189
1190 void RilAppStatus::SerializeWithCachedSizes(
1191     ::google::protobuf::io::CodedOutputStream* output) const {
1192   // optional .ril_proto.RilAppType app_type = 1;
1193   if (_has_bit(0)) {
1194     ::google::protobuf::internal::WireFormatLite::WriteEnum(
1195       1, this->app_type(), output);
1196   }
1197
1198   // optional .ril_proto.RilAppState app_state = 2;
1199   if (_has_bit(1)) {
1200     ::google::protobuf::internal::WireFormatLite::WriteEnum(
1201       2, this->app_state(), output);
1202   }
1203
1204   // optional .ril_proto.RilPersoSubstate perso_substate = 3;
1205   if (_has_bit(2)) {
1206     ::google::protobuf::internal::WireFormatLite::WriteEnum(
1207       3, this->perso_substate(), output);
1208   }
1209
1210   // optional string aid = 4;
1211   if (_has_bit(3)) {
1212     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1213       this->aid().data(), this->aid().length(),
1214       ::google::protobuf::internal::WireFormat::SERIALIZE);
1215     ::google::protobuf::internal::WireFormatLite::WriteString(
1216       4, this->aid(), output);
1217   }
1218
1219   // optional string app_label = 5;
1220   if (_has_bit(4)) {
1221     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1222       this->app_label().data(), this->app_label().length(),
1223       ::google::protobuf::internal::WireFormat::SERIALIZE);
1224     ::google::protobuf::internal::WireFormatLite::WriteString(
1225       5, this->app_label(), output);
1226   }
1227
1228   // optional int32 pin1_replaced = 6;
1229   if (_has_bit(5)) {
1230     ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->pin1_replaced(), output);
1231   }
1232
1233   // optional .ril_proto.RilPinState pin1 = 7;
1234   if (_has_bit(6)) {
1235     ::google::protobuf::internal::WireFormatLite::WriteEnum(
1236       7, this->pin1(), output);
1237   }
1238
1239   // optional .ril_proto.RilPinState pin2 = 8;
1240   if (_has_bit(7)) {
1241     ::google::protobuf::internal::WireFormatLite::WriteEnum(
1242       8, this->pin2(), output);
1243   }
1244
1245   if (!unknown_fields().empty()) {
1246     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1247         unknown_fields(), output);
1248   }
1249 }
1250
1251 ::google::protobuf::uint8* RilAppStatus::SerializeWithCachedSizesToArray(
1252     ::google::protobuf::uint8* target) const {
1253   // optional .ril_proto.RilAppType app_type = 1;
1254   if (_has_bit(0)) {
1255     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
1256       1, this->app_type(), target);
1257   }
1258
1259   // optional .ril_proto.RilAppState app_state = 2;
1260   if (_has_bit(1)) {
1261     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
1262       2, this->app_state(), target);
1263   }
1264
1265   // optional .ril_proto.RilPersoSubstate perso_substate = 3;
1266   if (_has_bit(2)) {
1267     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
1268       3, this->perso_substate(), target);
1269   }
1270
1271   // optional string aid = 4;
1272   if (_has_bit(3)) {
1273     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1274       this->aid().data(), this->aid().length(),
1275       ::google::protobuf::internal::WireFormat::SERIALIZE);
1276     target =
1277       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1278         4, this->aid(), target);
1279   }
1280
1281   // optional string app_label = 5;
1282   if (_has_bit(4)) {
1283     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1284       this->app_label().data(), this->app_label().length(),
1285       ::google::protobuf::internal::WireFormat::SERIALIZE);
1286     target =
1287       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1288         5, this->app_label(), target);
1289   }
1290
1291   // optional int32 pin1_replaced = 6;
1292   if (_has_bit(5)) {
1293     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->pin1_replaced(), target);
1294   }
1295
1296   // optional .ril_proto.RilPinState pin1 = 7;
1297   if (_has_bit(6)) {
1298     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
1299       7, this->pin1(), target);
1300   }
1301
1302   // optional .ril_proto.RilPinState pin2 = 8;
1303   if (_has_bit(7)) {
1304     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
1305       8, this->pin2(), target);
1306   }
1307
1308   if (!unknown_fields().empty()) {
1309     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
1310         unknown_fields(), target);
1311   }
1312   return target;
1313 }
1314
1315 int RilAppStatus::ByteSize() const {
1316   int total_size = 0;
1317
1318   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1319     // optional .ril_proto.RilAppType app_type = 1;
1320     if (has_app_type()) {
1321       total_size += 1 +
1322         ::google::protobuf::internal::WireFormatLite::EnumSize(this->app_type());
1323     }
1324
1325     // optional .ril_proto.RilAppState app_state = 2;
1326     if (has_app_state()) {
1327       total_size += 1 +
1328         ::google::protobuf::internal::WireFormatLite::EnumSize(this->app_state());
1329     }
1330
1331     // optional .ril_proto.RilPersoSubstate perso_substate = 3;
1332     if (has_perso_substate()) {
1333       total_size += 1 +
1334         ::google::protobuf::internal::WireFormatLite::EnumSize(this->perso_substate());
1335     }
1336
1337     // optional string aid = 4;
1338     if (has_aid()) {
1339       total_size += 1 +
1340         ::google::protobuf::internal::WireFormatLite::StringSize(
1341           this->aid());
1342     }
1343
1344     // optional string app_label = 5;
1345     if (has_app_label()) {
1346       total_size += 1 +
1347         ::google::protobuf::internal::WireFormatLite::StringSize(
1348           this->app_label());
1349     }
1350
1351     // optional int32 pin1_replaced = 6;
1352     if (has_pin1_replaced()) {
1353       total_size += 1 +
1354         ::google::protobuf::internal::WireFormatLite::Int32Size(
1355           this->pin1_replaced());
1356     }
1357
1358     // optional .ril_proto.RilPinState pin1 = 7;
1359     if (has_pin1()) {
1360       total_size += 1 +
1361         ::google::protobuf::internal::WireFormatLite::EnumSize(this->pin1());
1362     }
1363
1364     // optional .ril_proto.RilPinState pin2 = 8;
1365     if (has_pin2()) {
1366       total_size += 1 +
1367         ::google::protobuf::internal::WireFormatLite::EnumSize(this->pin2());
1368     }
1369
1370   }
1371   if (!unknown_fields().empty()) {
1372     total_size +=
1373       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1374         unknown_fields());
1375   }
1376   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1377   _cached_size_ = total_size;
1378   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1379   return total_size;
1380 }
1381
1382 void RilAppStatus::MergeFrom(const ::google::protobuf::Message& from) {
1383   GOOGLE_CHECK_NE(&from, this);
1384   const RilAppStatus* source =
1385     ::google::protobuf::internal::dynamic_cast_if_available<const RilAppStatus*>(
1386       &from);
1387   if (source == NULL) {
1388     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1389   } else {
1390     MergeFrom(*source);
1391   }
1392 }
1393
1394 void RilAppStatus::MergeFrom(const RilAppStatus& from) {
1395   GOOGLE_CHECK_NE(&from, this);
1396   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1397     if (from._has_bit(0)) {
1398       set_app_type(from.app_type());
1399     }
1400     if (from._has_bit(1)) {
1401       set_app_state(from.app_state());
1402     }
1403     if (from._has_bit(2)) {
1404       set_perso_substate(from.perso_substate());
1405     }
1406     if (from._has_bit(3)) {
1407       set_aid(from.aid());
1408     }
1409     if (from._has_bit(4)) {
1410       set_app_label(from.app_label());
1411     }
1412     if (from._has_bit(5)) {
1413       set_pin1_replaced(from.pin1_replaced());
1414     }
1415     if (from._has_bit(6)) {
1416       set_pin1(from.pin1());
1417     }
1418     if (from._has_bit(7)) {
1419       set_pin2(from.pin2());
1420     }
1421   }
1422   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
1423 }
1424
1425 void RilAppStatus::CopyFrom(const ::google::protobuf::Message& from) {
1426   if (&from == this) return;
1427   Clear();
1428   MergeFrom(from);
1429 }
1430
1431 void RilAppStatus::CopyFrom(const RilAppStatus& from) {
1432   if (&from == this) return;
1433   Clear();
1434   MergeFrom(from);
1435 }
1436
1437 bool RilAppStatus::IsInitialized() const {
1438
1439   return true;
1440 }
1441
1442 void RilAppStatus::Swap(RilAppStatus* other) {
1443   if (other != this) {
1444     std::swap(app_type_, other->app_type_);
1445     std::swap(app_state_, other->app_state_);
1446     std::swap(perso_substate_, other->perso_substate_);
1447     std::swap(aid_, other->aid_);
1448     std::swap(app_label_, other->app_label_);
1449     std::swap(pin1_replaced_, other->pin1_replaced_);
1450     std::swap(pin1_, other->pin1_);
1451     std::swap(pin2_, other->pin2_);
1452     std::swap(_has_bits_[0], other->_has_bits_[0]);
1453     _unknown_fields_.Swap(&other->_unknown_fields_);
1454     std::swap(_cached_size_, other->_cached_size_);
1455   }
1456 }
1457
1458 ::google::protobuf::Metadata RilAppStatus::GetMetadata() const {
1459   protobuf_AssignDescriptorsOnce();
1460   ::google::protobuf::Metadata metadata;
1461   metadata.descriptor = RilAppStatus_descriptor_;
1462   metadata.reflection = RilAppStatus_reflection_;
1463   return metadata;
1464 }
1465
1466
1467 // ===================================================================
1468
1469 #ifndef _MSC_VER
1470 const int RilCardStatus::kCardStateFieldNumber;
1471 const int RilCardStatus::kUniversalPinStateFieldNumber;
1472 const int RilCardStatus::kGsmUmtsSubscriptionAppIndexFieldNumber;
1473 const int RilCardStatus::kCdmaSubscriptionAppIndexFieldNumber;
1474 const int RilCardStatus::kNumApplicationsFieldNumber;
1475 const int RilCardStatus::kApplicationsFieldNumber;
1476 #endif  // !_MSC_VER
1477
1478 RilCardStatus::RilCardStatus()
1479   : ::google::protobuf::Message() {
1480   SharedCtor();
1481 }
1482
1483 void RilCardStatus::InitAsDefaultInstance() {
1484 }
1485
1486 RilCardStatus::RilCardStatus(const RilCardStatus& from)
1487   : ::google::protobuf::Message() {
1488   SharedCtor();
1489   MergeFrom(from);
1490 }
1491
1492 void RilCardStatus::SharedCtor() {
1493   _cached_size_ = 0;
1494   card_state_ = 0;
1495   universal_pin_state_ = 0;
1496   gsm_umts_subscription_app_index_ = 0;
1497   cdma_subscription_app_index_ = 0;
1498   num_applications_ = 0;
1499   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1500 }
1501
1502 RilCardStatus::~RilCardStatus() {
1503   SharedDtor();
1504 }
1505
1506 void RilCardStatus::SharedDtor() {
1507   if (this != default_instance_) {
1508   }
1509 }
1510
1511 void RilCardStatus::SetCachedSize(int size) const {
1512   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1513   _cached_size_ = size;
1514   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1515 }
1516 const ::google::protobuf::Descriptor* RilCardStatus::descriptor() {
1517   protobuf_AssignDescriptorsOnce();
1518   return RilCardStatus_descriptor_;
1519 }
1520
1521 const RilCardStatus& RilCardStatus::default_instance() {
1522   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
1523 }
1524
1525 RilCardStatus* RilCardStatus::default_instance_ = NULL;
1526
1527 RilCardStatus* RilCardStatus::New() const {
1528   return new RilCardStatus;
1529 }
1530
1531 void RilCardStatus::Clear() {
1532   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1533     card_state_ = 0;
1534     universal_pin_state_ = 0;
1535     gsm_umts_subscription_app_index_ = 0;
1536     cdma_subscription_app_index_ = 0;
1537     num_applications_ = 0;
1538   }
1539   applications_.Clear();
1540   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1541   mutable_unknown_fields()->Clear();
1542 }
1543
1544 bool RilCardStatus::MergePartialFromCodedStream(
1545     ::google::protobuf::io::CodedInputStream* input) {
1546 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
1547   ::google::protobuf::uint32 tag;
1548   while ((tag = input->ReadTag()) != 0) {
1549     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1550       // optional .ril_proto.RilCardState card_state = 1;
1551       case 1: {
1552         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1553             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1554           int value;
1555           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1556                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
1557                  input, &value)));
1558           if (ril_proto::RilCardState_IsValid(value)) {
1559             set_card_state(static_cast< ril_proto::RilCardState >(value));
1560           } else {
1561             mutable_unknown_fields()->AddVarint(1, value);
1562           }
1563         } else {
1564           goto handle_uninterpreted;
1565         }
1566         if (input->ExpectTag(16)) goto parse_universal_pin_state;
1567         break;
1568       }
1569
1570       // optional .ril_proto.RilPinState universal_pin_state = 2;
1571       case 2: {
1572         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1573             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1574          parse_universal_pin_state:
1575           int value;
1576           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1577                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
1578                  input, &value)));
1579           if (ril_proto::RilPinState_IsValid(value)) {
1580             set_universal_pin_state(static_cast< ril_proto::RilPinState >(value));
1581           } else {
1582             mutable_unknown_fields()->AddVarint(2, value);
1583           }
1584         } else {
1585           goto handle_uninterpreted;
1586         }
1587         if (input->ExpectTag(24)) goto parse_gsm_umts_subscription_app_index;
1588         break;
1589       }
1590
1591       // optional int32 gsm_umts_subscription_app_index = 3;
1592       case 3: {
1593         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1594             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1595          parse_gsm_umts_subscription_app_index:
1596           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1597                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
1598                  input, &gsm_umts_subscription_app_index_)));
1599           _set_bit(2);
1600         } else {
1601           goto handle_uninterpreted;
1602         }
1603         if (input->ExpectTag(32)) goto parse_cdma_subscription_app_index;
1604         break;
1605       }
1606
1607       // optional int32 cdma_subscription_app_index = 4;
1608       case 4: {
1609         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1610             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1611          parse_cdma_subscription_app_index:
1612           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1613                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
1614                  input, &cdma_subscription_app_index_)));
1615           _set_bit(3);
1616         } else {
1617           goto handle_uninterpreted;
1618         }
1619         if (input->ExpectTag(40)) goto parse_num_applications;
1620         break;
1621       }
1622
1623       // optional int32 num_applications = 5;
1624       case 5: {
1625         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1626             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1627          parse_num_applications:
1628           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1629                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
1630                  input, &num_applications_)));
1631           _set_bit(4);
1632         } else {
1633           goto handle_uninterpreted;
1634         }
1635         if (input->ExpectTag(50)) goto parse_applications;
1636         break;
1637       }
1638
1639       // repeated .ril_proto.RilAppStatus applications = 6;
1640       case 6: {
1641         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1642             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1643          parse_applications:
1644           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1645                 input, add_applications()));
1646         } else {
1647           goto handle_uninterpreted;
1648         }
1649         if (input->ExpectTag(50)) goto parse_applications;
1650         if (input->ExpectAtEnd()) return true;
1651         break;
1652       }
1653
1654       default: {
1655       handle_uninterpreted:
1656         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1657             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
1658           return true;
1659         }
1660         DO_(::google::protobuf::internal::WireFormat::SkipField(
1661               input, tag, mutable_unknown_fields()));
1662         break;
1663       }
1664     }
1665   }
1666   return true;
1667 #undef DO_
1668 }
1669
1670 void RilCardStatus::SerializeWithCachedSizes(
1671     ::google::protobuf::io::CodedOutputStream* output) const {
1672   // optional .ril_proto.RilCardState card_state = 1;
1673   if (_has_bit(0)) {
1674     ::google::protobuf::internal::WireFormatLite::WriteEnum(
1675       1, this->card_state(), output);
1676   }
1677
1678   // optional .ril_proto.RilPinState universal_pin_state = 2;
1679   if (_has_bit(1)) {
1680     ::google::protobuf::internal::WireFormatLite::WriteEnum(
1681       2, this->universal_pin_state(), output);
1682   }
1683
1684   // optional int32 gsm_umts_subscription_app_index = 3;
1685   if (_has_bit(2)) {
1686     ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->gsm_umts_subscription_app_index(), output);
1687   }
1688
1689   // optional int32 cdma_subscription_app_index = 4;
1690   if (_has_bit(3)) {
1691     ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->cdma_subscription_app_index(), output);
1692   }
1693
1694   // optional int32 num_applications = 5;
1695   if (_has_bit(4)) {
1696     ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->num_applications(), output);
1697   }
1698
1699   // repeated .ril_proto.RilAppStatus applications = 6;
1700   for (int i = 0; i < this->applications_size(); i++) {
1701     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1702       6, this->applications(i), output);
1703   }
1704
1705   if (!unknown_fields().empty()) {
1706     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1707         unknown_fields(), output);
1708   }
1709 }
1710
1711 ::google::protobuf::uint8* RilCardStatus::SerializeWithCachedSizesToArray(
1712     ::google::protobuf::uint8* target) const {
1713   // optional .ril_proto.RilCardState card_state = 1;
1714   if (_has_bit(0)) {
1715     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
1716       1, this->card_state(), target);
1717   }
1718
1719   // optional .ril_proto.RilPinState universal_pin_state = 2;
1720   if (_has_bit(1)) {
1721     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
1722       2, this->universal_pin_state(), target);
1723   }
1724
1725   // optional int32 gsm_umts_subscription_app_index = 3;
1726   if (_has_bit(2)) {
1727     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->gsm_umts_subscription_app_index(), target);
1728   }
1729
1730   // optional int32 cdma_subscription_app_index = 4;
1731   if (_has_bit(3)) {
1732     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->cdma_subscription_app_index(), target);
1733   }
1734
1735   // optional int32 num_applications = 5;
1736   if (_has_bit(4)) {
1737     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->num_applications(), target);
1738   }
1739
1740   // repeated .ril_proto.RilAppStatus applications = 6;
1741   for (int i = 0; i < this->applications_size(); i++) {
1742     target = ::google::protobuf::internal::WireFormatLite::
1743       WriteMessageNoVirtualToArray(
1744         6, this->applications(i), target);
1745   }
1746
1747   if (!unknown_fields().empty()) {
1748     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
1749         unknown_fields(), target);
1750   }
1751   return target;
1752 }
1753
1754 int RilCardStatus::ByteSize() const {
1755   int total_size = 0;
1756
1757   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1758     // optional .ril_proto.RilCardState card_state = 1;
1759     if (has_card_state()) {
1760       total_size += 1 +
1761         ::google::protobuf::internal::WireFormatLite::EnumSize(this->card_state());
1762     }
1763
1764     // optional .ril_proto.RilPinState universal_pin_state = 2;
1765     if (has_universal_pin_state()) {
1766       total_size += 1 +
1767         ::google::protobuf::internal::WireFormatLite::EnumSize(this->universal_pin_state());
1768     }
1769
1770     // optional int32 gsm_umts_subscription_app_index = 3;
1771     if (has_gsm_umts_subscription_app_index()) {
1772       total_size += 1 +
1773         ::google::protobuf::internal::WireFormatLite::Int32Size(
1774           this->gsm_umts_subscription_app_index());
1775     }
1776
1777     // optional int32 cdma_subscription_app_index = 4;
1778     if (has_cdma_subscription_app_index()) {
1779       total_size += 1 +
1780         ::google::protobuf::internal::WireFormatLite::Int32Size(
1781           this->cdma_subscription_app_index());
1782     }
1783
1784     // optional int32 num_applications = 5;
1785     if (has_num_applications()) {
1786       total_size += 1 +
1787         ::google::protobuf::internal::WireFormatLite::Int32Size(
1788           this->num_applications());
1789     }
1790
1791   }
1792   // repeated .ril_proto.RilAppStatus applications = 6;
1793   total_size += 1 * this->applications_size();
1794   for (int i = 0; i < this->applications_size(); i++) {
1795     total_size +=
1796       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1797         this->applications(i));
1798   }
1799
1800   if (!unknown_fields().empty()) {
1801     total_size +=
1802       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1803         unknown_fields());
1804   }
1805   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1806   _cached_size_ = total_size;
1807   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1808   return total_size;
1809 }
1810
1811 void RilCardStatus::MergeFrom(const ::google::protobuf::Message& from) {
1812   GOOGLE_CHECK_NE(&from, this);
1813   const RilCardStatus* source =
1814     ::google::protobuf::internal::dynamic_cast_if_available<const RilCardStatus*>(
1815       &from);
1816   if (source == NULL) {
1817     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1818   } else {
1819     MergeFrom(*source);
1820   }
1821 }
1822
1823 void RilCardStatus::MergeFrom(const RilCardStatus& from) {
1824   GOOGLE_CHECK_NE(&from, this);
1825   applications_.MergeFrom(from.applications_);
1826   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1827     if (from._has_bit(0)) {
1828       set_card_state(from.card_state());
1829     }
1830     if (from._has_bit(1)) {
1831       set_universal_pin_state(from.universal_pin_state());
1832     }
1833     if (from._has_bit(2)) {
1834       set_gsm_umts_subscription_app_index(from.gsm_umts_subscription_app_index());
1835     }
1836     if (from._has_bit(3)) {
1837       set_cdma_subscription_app_index(from.cdma_subscription_app_index());
1838     }
1839     if (from._has_bit(4)) {
1840       set_num_applications(from.num_applications());
1841     }
1842   }
1843   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
1844 }
1845
1846 void RilCardStatus::CopyFrom(const ::google::protobuf::Message& from) {
1847   if (&from == this) return;
1848   Clear();
1849   MergeFrom(from);
1850 }
1851
1852 void RilCardStatus::CopyFrom(const RilCardStatus& from) {
1853   if (&from == this) return;
1854   Clear();
1855   MergeFrom(from);
1856 }
1857
1858 bool RilCardStatus::IsInitialized() const {
1859
1860   return true;
1861 }
1862
1863 void RilCardStatus::Swap(RilCardStatus* other) {
1864   if (other != this) {
1865     std::swap(card_state_, other->card_state_);
1866     std::swap(universal_pin_state_, other->universal_pin_state_);
1867     std::swap(gsm_umts_subscription_app_index_, other->gsm_umts_subscription_app_index_);
1868     std::swap(cdma_subscription_app_index_, other->cdma_subscription_app_index_);
1869     std::swap(num_applications_, other->num_applications_);
1870     applications_.Swap(&other->applications_);
1871     std::swap(_has_bits_[0], other->_has_bits_[0]);
1872     _unknown_fields_.Swap(&other->_unknown_fields_);
1873     std::swap(_cached_size_, other->_cached_size_);
1874   }
1875 }
1876
1877 ::google::protobuf::Metadata RilCardStatus::GetMetadata() const {
1878   protobuf_AssignDescriptorsOnce();
1879   ::google::protobuf::Metadata metadata;
1880   metadata.descriptor = RilCardStatus_descriptor_;
1881   metadata.reflection = RilCardStatus_reflection_;
1882   return metadata;
1883 }
1884
1885
1886 // ===================================================================
1887
1888 const ::std::string RilUusInfo::_default_uus_data_;
1889 #ifndef _MSC_VER
1890 const int RilUusInfo::kUusTypeFieldNumber;
1891 const int RilUusInfo::kUusDcsFieldNumber;
1892 const int RilUusInfo::kUusLengthFieldNumber;
1893 const int RilUusInfo::kUusDataFieldNumber;
1894 #endif  // !_MSC_VER
1895
1896 RilUusInfo::RilUusInfo()
1897   : ::google::protobuf::Message() {
1898   SharedCtor();
1899 }
1900
1901 void RilUusInfo::InitAsDefaultInstance() {
1902 }
1903
1904 RilUusInfo::RilUusInfo(const RilUusInfo& from)
1905   : ::google::protobuf::Message() {
1906   SharedCtor();
1907   MergeFrom(from);
1908 }
1909
1910 void RilUusInfo::SharedCtor() {
1911   _cached_size_ = 0;
1912   uus_type_ = 0;
1913   uus_dcs_ = 0;
1914   uus_length_ = 0;
1915   uus_data_ = const_cast< ::std::string*>(&_default_uus_data_);
1916   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1917 }
1918
1919 RilUusInfo::~RilUusInfo() {
1920   SharedDtor();
1921 }
1922
1923 void RilUusInfo::SharedDtor() {
1924   if (uus_data_ != &_default_uus_data_) {
1925     delete uus_data_;
1926   }
1927   if (this != default_instance_) {
1928   }
1929 }
1930
1931 void RilUusInfo::SetCachedSize(int size) const {
1932   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1933   _cached_size_ = size;
1934   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1935 }
1936 const ::google::protobuf::Descriptor* RilUusInfo::descriptor() {
1937   protobuf_AssignDescriptorsOnce();
1938   return RilUusInfo_descriptor_;
1939 }
1940
1941 const RilUusInfo& RilUusInfo::default_instance() {
1942   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
1943 }
1944
1945 RilUusInfo* RilUusInfo::default_instance_ = NULL;
1946
1947 RilUusInfo* RilUusInfo::New() const {
1948   return new RilUusInfo;
1949 }
1950
1951 void RilUusInfo::Clear() {
1952   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1953     uus_type_ = 0;
1954     uus_dcs_ = 0;
1955     uus_length_ = 0;
1956     if (_has_bit(3)) {
1957       if (uus_data_ != &_default_uus_data_) {
1958         uus_data_->clear();
1959       }
1960     }
1961   }
1962   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1963   mutable_unknown_fields()->Clear();
1964 }
1965
1966 bool RilUusInfo::MergePartialFromCodedStream(
1967     ::google::protobuf::io::CodedInputStream* input) {
1968 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
1969   ::google::protobuf::uint32 tag;
1970   while ((tag = input->ReadTag()) != 0) {
1971     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1972       // optional .ril_proto.RilUusType uus_type = 1;
1973       case 1: {
1974         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1975             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1976           int value;
1977           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1978                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
1979                  input, &value)));
1980           if (ril_proto::RilUusType_IsValid(value)) {
1981             set_uus_type(static_cast< ril_proto::RilUusType >(value));
1982           } else {
1983             mutable_unknown_fields()->AddVarint(1, value);
1984           }
1985         } else {
1986           goto handle_uninterpreted;
1987         }
1988         if (input->ExpectTag(16)) goto parse_uus_dcs;
1989         break;
1990       }
1991
1992       // optional .ril_proto.RilUusDcs uus_dcs = 2;
1993       case 2: {
1994         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1995             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1996          parse_uus_dcs:
1997           int value;
1998           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1999                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
2000                  input, &value)));
2001           if (ril_proto::RilUusDcs_IsValid(value)) {
2002             set_uus_dcs(static_cast< ril_proto::RilUusDcs >(value));
2003           } else {
2004             mutable_unknown_fields()->AddVarint(2, value);
2005           }
2006         } else {
2007           goto handle_uninterpreted;
2008         }
2009         if (input->ExpectTag(24)) goto parse_uus_length;
2010         break;
2011       }
2012
2013       // optional int32 uus_length = 3;
2014       case 3: {
2015         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2016             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2017          parse_uus_length:
2018           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2019                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
2020                  input, &uus_length_)));
2021           _set_bit(2);
2022         } else {
2023           goto handle_uninterpreted;
2024         }
2025         if (input->ExpectTag(34)) goto parse_uus_data;
2026         break;
2027       }
2028
2029       // optional string uus_data = 4;
2030       case 4: {
2031         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2032             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2033          parse_uus_data:
2034           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
2035                 input, this->mutable_uus_data()));
2036           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2037             this->uus_data().data(), this->uus_data().length(),
2038             ::google::protobuf::internal::WireFormat::PARSE);
2039         } else {
2040           goto handle_uninterpreted;
2041         }
2042         if (input->ExpectAtEnd()) return true;
2043         break;
2044       }
2045
2046       default: {
2047       handle_uninterpreted:
2048         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2049             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
2050           return true;
2051         }
2052         DO_(::google::protobuf::internal::WireFormat::SkipField(
2053               input, tag, mutable_unknown_fields()));
2054         break;
2055       }
2056     }
2057   }
2058   return true;
2059 #undef DO_
2060 }
2061
2062 void RilUusInfo::SerializeWithCachedSizes(
2063     ::google::protobuf::io::CodedOutputStream* output) const {
2064   // optional .ril_proto.RilUusType uus_type = 1;
2065   if (_has_bit(0)) {
2066     ::google::protobuf::internal::WireFormatLite::WriteEnum(
2067       1, this->uus_type(), output);
2068   }
2069
2070   // optional .ril_proto.RilUusDcs uus_dcs = 2;
2071   if (_has_bit(1)) {
2072     ::google::protobuf::internal::WireFormatLite::WriteEnum(
2073       2, this->uus_dcs(), output);
2074   }
2075
2076   // optional int32 uus_length = 3;
2077   if (_has_bit(2)) {
2078     ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->uus_length(), output);
2079   }
2080
2081   // optional string uus_data = 4;
2082   if (_has_bit(3)) {
2083     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2084       this->uus_data().data(), this->uus_data().length(),
2085       ::google::protobuf::internal::WireFormat::SERIALIZE);
2086     ::google::protobuf::internal::WireFormatLite::WriteString(
2087       4, this->uus_data(), output);
2088   }
2089
2090   if (!unknown_fields().empty()) {
2091     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
2092         unknown_fields(), output);
2093   }
2094 }
2095
2096 ::google::protobuf::uint8* RilUusInfo::SerializeWithCachedSizesToArray(
2097     ::google::protobuf::uint8* target) const {
2098   // optional .ril_proto.RilUusType uus_type = 1;
2099   if (_has_bit(0)) {
2100     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
2101       1, this->uus_type(), target);
2102   }
2103
2104   // optional .ril_proto.RilUusDcs uus_dcs = 2;
2105   if (_has_bit(1)) {
2106     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
2107       2, this->uus_dcs(), target);
2108   }
2109
2110   // optional int32 uus_length = 3;
2111   if (_has_bit(2)) {
2112     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->uus_length(), target);
2113   }
2114
2115   // optional string uus_data = 4;
2116   if (_has_bit(3)) {
2117     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2118       this->uus_data().data(), this->uus_data().length(),
2119       ::google::protobuf::internal::WireFormat::SERIALIZE);
2120     target =
2121       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2122         4, this->uus_data(), target);
2123   }
2124
2125   if (!unknown_fields().empty()) {
2126     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
2127         unknown_fields(), target);
2128   }
2129   return target;
2130 }
2131
2132 int RilUusInfo::ByteSize() const {
2133   int total_size = 0;
2134
2135   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2136     // optional .ril_proto.RilUusType uus_type = 1;
2137     if (has_uus_type()) {
2138       total_size += 1 +
2139         ::google::protobuf::internal::WireFormatLite::EnumSize(this->uus_type());
2140     }
2141
2142     // optional .ril_proto.RilUusDcs uus_dcs = 2;
2143     if (has_uus_dcs()) {
2144       total_size += 1 +
2145         ::google::protobuf::internal::WireFormatLite::EnumSize(this->uus_dcs());
2146     }
2147
2148     // optional int32 uus_length = 3;
2149     if (has_uus_length()) {
2150       total_size += 1 +
2151         ::google::protobuf::internal::WireFormatLite::Int32Size(
2152           this->uus_length());
2153     }
2154
2155     // optional string uus_data = 4;
2156     if (has_uus_data()) {
2157       total_size += 1 +
2158         ::google::protobuf::internal::WireFormatLite::StringSize(
2159           this->uus_data());
2160     }
2161
2162   }
2163   if (!unknown_fields().empty()) {
2164     total_size +=
2165       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
2166         unknown_fields());
2167   }
2168   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2169   _cached_size_ = total_size;
2170   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2171   return total_size;
2172 }
2173
2174 void RilUusInfo::MergeFrom(const ::google::protobuf::Message& from) {
2175   GOOGLE_CHECK_NE(&from, this);
2176   const RilUusInfo* source =
2177     ::google::protobuf::internal::dynamic_cast_if_available<const RilUusInfo*>(
2178       &from);
2179   if (source == NULL) {
2180     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2181   } else {
2182     MergeFrom(*source);
2183   }
2184 }
2185
2186 void RilUusInfo::MergeFrom(const RilUusInfo& from) {
2187   GOOGLE_CHECK_NE(&from, this);
2188   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2189     if (from._has_bit(0)) {
2190       set_uus_type(from.uus_type());
2191     }
2192     if (from._has_bit(1)) {
2193       set_uus_dcs(from.uus_dcs());
2194     }
2195     if (from._has_bit(2)) {
2196       set_uus_length(from.uus_length());
2197     }
2198     if (from._has_bit(3)) {
2199       set_uus_data(from.uus_data());
2200     }
2201   }
2202   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
2203 }
2204
2205 void RilUusInfo::CopyFrom(const ::google::protobuf::Message& from) {
2206   if (&from == this) return;
2207   Clear();
2208   MergeFrom(from);
2209 }
2210
2211 void RilUusInfo::CopyFrom(const RilUusInfo& from) {
2212   if (&from == this) return;
2213   Clear();
2214   MergeFrom(from);
2215 }
2216
2217 bool RilUusInfo::IsInitialized() const {
2218
2219   return true;
2220 }
2221
2222 void RilUusInfo::Swap(RilUusInfo* other) {
2223   if (other != this) {
2224     std::swap(uus_type_, other->uus_type_);
2225     std::swap(uus_dcs_, other->uus_dcs_);
2226     std::swap(uus_length_, other->uus_length_);
2227     std::swap(uus_data_, other->uus_data_);
2228     std::swap(_has_bits_[0], other->_has_bits_[0]);
2229     _unknown_fields_.Swap(&other->_unknown_fields_);
2230     std::swap(_cached_size_, other->_cached_size_);
2231   }
2232 }
2233
2234 ::google::protobuf::Metadata RilUusInfo::GetMetadata() const {
2235   protobuf_AssignDescriptorsOnce();
2236   ::google::protobuf::Metadata metadata;
2237   metadata.descriptor = RilUusInfo_descriptor_;
2238   metadata.reflection = RilUusInfo_reflection_;
2239   return metadata;
2240 }
2241
2242
2243 // ===================================================================
2244
2245 const ::std::string RilCall::_default_number_;
2246 const ::std::string RilCall::_default_name_;
2247 #ifndef _MSC_VER
2248 const int RilCall::kStateFieldNumber;
2249 const int RilCall::kIndexFieldNumber;
2250 const int RilCall::kToaFieldNumber;
2251 const int RilCall::kIsMptyFieldNumber;
2252 const int RilCall::kIsMtFieldNumber;
2253 const int RilCall::kAlsFieldNumber;
2254 const int RilCall::kIsVoiceFieldNumber;
2255 const int RilCall::kIsVoicePrivacyFieldNumber;
2256 const int RilCall::kNumberFieldNumber;
2257 const int RilCall::kNumberPresentationFieldNumber;
2258 const int RilCall::kNameFieldNumber;
2259 const int RilCall::kNamePresentationFieldNumber;
2260 const int RilCall::kUusInfoFieldNumber;
2261 #endif  // !_MSC_VER
2262
2263 RilCall::RilCall()
2264   : ::google::protobuf::Message() {
2265   SharedCtor();
2266 }
2267
2268 void RilCall::InitAsDefaultInstance() {
2269   uus_info_ = const_cast< ::ril_proto::RilUusInfo*>(&::ril_proto::RilUusInfo::default_instance());
2270 }
2271
2272 RilCall::RilCall(const RilCall& from)
2273   : ::google::protobuf::Message() {
2274   SharedCtor();
2275   MergeFrom(from);
2276 }
2277
2278 void RilCall::SharedCtor() {
2279   _cached_size_ = 0;
2280   state_ = 0;
2281   index_ = 0;
2282   toa_ = 0;
2283   is_mpty_ = false;
2284   is_mt_ = false;
2285   als_ = 0;
2286   is_voice_ = false;
2287   is_voice_privacy_ = false;
2288   number_ = const_cast< ::std::string*>(&_default_number_);
2289   number_presentation_ = 0;
2290   name_ = const_cast< ::std::string*>(&_default_name_);
2291   name_presentation_ = 0;
2292   uus_info_ = NULL;
2293   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2294 }
2295
2296 RilCall::~RilCall() {
2297   SharedDtor();
2298 }
2299
2300 void RilCall::SharedDtor() {
2301   if (number_ != &_default_number_) {
2302     delete number_;
2303   }
2304   if (name_ != &_default_name_) {
2305     delete name_;
2306   }
2307   if (this != default_instance_) {
2308     delete uus_info_;
2309   }
2310 }
2311
2312 void RilCall::SetCachedSize(int size) const {
2313   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2314   _cached_size_ = size;
2315   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2316 }
2317 const ::google::protobuf::Descriptor* RilCall::descriptor() {
2318   protobuf_AssignDescriptorsOnce();
2319   return RilCall_descriptor_;
2320 }
2321
2322 const RilCall& RilCall::default_instance() {
2323   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
2324 }
2325
2326 RilCall* RilCall::default_instance_ = NULL;
2327
2328 RilCall* RilCall::New() const {
2329   return new RilCall;
2330 }
2331
2332 void RilCall::Clear() {
2333   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2334     state_ = 0;
2335     index_ = 0;
2336     toa_ = 0;
2337     is_mpty_ = false;
2338     is_mt_ = false;
2339     als_ = 0;
2340     is_voice_ = false;
2341     is_voice_privacy_ = false;
2342   }
2343   if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
2344     if (_has_bit(8)) {
2345       if (number_ != &_default_number_) {
2346         number_->clear();
2347       }
2348     }
2349     number_presentation_ = 0;
2350     if (_has_bit(10)) {
2351       if (name_ != &_default_name_) {
2352         name_->clear();
2353       }
2354     }
2355     name_presentation_ = 0;
2356     if (_has_bit(12)) {
2357       if (uus_info_ != NULL) uus_info_->::ril_proto::RilUusInfo::Clear();
2358     }
2359   }
2360   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2361   mutable_unknown_fields()->Clear();
2362 }
2363
2364 bool RilCall::MergePartialFromCodedStream(
2365     ::google::protobuf::io::CodedInputStream* input) {
2366 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
2367   ::google::protobuf::uint32 tag;
2368   while ((tag = input->ReadTag()) != 0) {
2369     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
2370       // optional .ril_proto.RilCallState state = 1;
2371       case 1: {
2372         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2373             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2374           int value;
2375           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2376                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
2377                  input, &value)));
2378           if (ril_proto::RilCallState_IsValid(value)) {
2379             set_state(static_cast< ril_proto::RilCallState >(value));
2380           } else {
2381             mutable_unknown_fields()->AddVarint(1, value);
2382           }
2383         } else {
2384           goto handle_uninterpreted;
2385         }
2386         if (input->ExpectTag(16)) goto parse_index;
2387         break;
2388       }
2389
2390       // optional int32 index = 2;
2391       case 2: {
2392         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2393             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2394          parse_index:
2395           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2396                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
2397                  input, &index_)));
2398           _set_bit(1);
2399         } else {
2400           goto handle_uninterpreted;
2401         }
2402         if (input->ExpectTag(24)) goto parse_toa;
2403         break;
2404       }
2405
2406       // optional int32 toa = 3;
2407       case 3: {
2408         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2409             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2410          parse_toa:
2411           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2412                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
2413                  input, &toa_)));
2414           _set_bit(2);
2415         } else {
2416           goto handle_uninterpreted;
2417         }
2418         if (input->ExpectTag(32)) goto parse_is_mpty;
2419         break;
2420       }
2421
2422       // optional bool is_mpty = 4;
2423       case 4: {
2424         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2425             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2426          parse_is_mpty:
2427           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2428                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
2429                  input, &is_mpty_)));
2430           _set_bit(3);
2431         } else {
2432           goto handle_uninterpreted;
2433         }
2434         if (input->ExpectTag(40)) goto parse_is_mt;
2435         break;
2436       }
2437
2438       // optional bool is_mt = 5;
2439       case 5: {
2440         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2441             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2442          parse_is_mt:
2443           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2444                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
2445                  input, &is_mt_)));
2446           _set_bit(4);
2447         } else {
2448           goto handle_uninterpreted;
2449         }
2450         if (input->ExpectTag(48)) goto parse_als;
2451         break;
2452       }
2453
2454       // optional int32 als = 6;
2455       case 6: {
2456         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2457             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2458          parse_als:
2459           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2460                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
2461                  input, &als_)));
2462           _set_bit(5);
2463         } else {
2464           goto handle_uninterpreted;
2465         }
2466         if (input->ExpectTag(56)) goto parse_is_voice;
2467         break;
2468       }
2469
2470       // optional bool is_voice = 7;
2471       case 7: {
2472         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2473             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2474          parse_is_voice:
2475           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2476                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
2477                  input, &is_voice_)));
2478           _set_bit(6);
2479         } else {
2480           goto handle_uninterpreted;
2481         }
2482         if (input->ExpectTag(64)) goto parse_is_voice_privacy;
2483         break;
2484       }
2485
2486       // optional bool is_voice_privacy = 8;
2487       case 8: {
2488         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2489             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2490          parse_is_voice_privacy:
2491           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2492                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
2493                  input, &is_voice_privacy_)));
2494           _set_bit(7);
2495         } else {
2496           goto handle_uninterpreted;
2497         }
2498         if (input->ExpectTag(74)) goto parse_number;
2499         break;
2500       }
2501
2502       // optional string number = 9;
2503       case 9: {
2504         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2505             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2506          parse_number:
2507           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
2508                 input, this->mutable_number()));
2509           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2510             this->number().data(), this->number().length(),
2511             ::google::protobuf::internal::WireFormat::PARSE);
2512         } else {
2513           goto handle_uninterpreted;
2514         }
2515         if (input->ExpectTag(80)) goto parse_number_presentation;
2516         break;
2517       }
2518
2519       // optional int32 number_presentation = 10;
2520       case 10: {
2521         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2522             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2523          parse_number_presentation:
2524           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2525                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
2526                  input, &number_presentation_)));
2527           _set_bit(9);
2528         } else {
2529           goto handle_uninterpreted;
2530         }
2531         if (input->ExpectTag(90)) goto parse_name;
2532         break;
2533       }
2534
2535       // optional string name = 11;
2536       case 11: {
2537         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2538             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2539          parse_name:
2540           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
2541                 input, this->mutable_name()));
2542           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2543             this->name().data(), this->name().length(),
2544             ::google::protobuf::internal::WireFormat::PARSE);
2545         } else {
2546           goto handle_uninterpreted;
2547         }
2548         if (input->ExpectTag(96)) goto parse_name_presentation;
2549         break;
2550       }
2551
2552       // optional int32 name_presentation = 12;
2553       case 12: {
2554         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2555             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2556          parse_name_presentation:
2557           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2558                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
2559                  input, &name_presentation_)));
2560           _set_bit(11);
2561         } else {
2562           goto handle_uninterpreted;
2563         }
2564         if (input->ExpectTag(106)) goto parse_uus_info;
2565         break;
2566       }
2567
2568       // optional .ril_proto.RilUusInfo uus_info = 13;
2569       case 13: {
2570         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2571             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2572          parse_uus_info:
2573           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
2574                input, mutable_uus_info()));
2575         } else {
2576           goto handle_uninterpreted;
2577         }
2578         if (input->ExpectAtEnd()) return true;
2579         break;
2580       }
2581
2582       default: {
2583       handle_uninterpreted:
2584         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2585             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
2586           return true;
2587         }
2588         DO_(::google::protobuf::internal::WireFormat::SkipField(
2589               input, tag, mutable_unknown_fields()));
2590         break;
2591       }
2592     }
2593   }
2594   return true;
2595 #undef DO_
2596 }
2597
2598 void RilCall::SerializeWithCachedSizes(
2599     ::google::protobuf::io::CodedOutputStream* output) const {
2600   // optional .ril_proto.RilCallState state = 1;
2601   if (_has_bit(0)) {
2602     ::google::protobuf::internal::WireFormatLite::WriteEnum(
2603       1, this->state(), output);
2604   }
2605
2606   // optional int32 index = 2;
2607   if (_has_bit(1)) {
2608     ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->index(), output);
2609   }
2610
2611   // optional int32 toa = 3;
2612   if (_has_bit(2)) {
2613     ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->toa(), output);
2614   }
2615
2616   // optional bool is_mpty = 4;
2617   if (_has_bit(3)) {
2618     ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->is_mpty(), output);
2619   }
2620
2621   // optional bool is_mt = 5;
2622   if (_has_bit(4)) {
2623     ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->is_mt(), output);
2624   }
2625
2626   // optional int32 als = 6;
2627   if (_has_bit(5)) {
2628     ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->als(), output);
2629   }
2630
2631   // optional bool is_voice = 7;
2632   if (_has_bit(6)) {
2633     ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->is_voice(), output);
2634   }
2635
2636   // optional bool is_voice_privacy = 8;
2637   if (_has_bit(7)) {
2638     ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->is_voice_privacy(), output);
2639   }
2640
2641   // optional string number = 9;
2642   if (_has_bit(8)) {
2643     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2644       this->number().data(), this->number().length(),
2645       ::google::protobuf::internal::WireFormat::SERIALIZE);
2646     ::google::protobuf::internal::WireFormatLite::WriteString(
2647       9, this->number(), output);
2648   }
2649
2650   // optional int32 number_presentation = 10;
2651   if (_has_bit(9)) {
2652     ::google::protobuf::internal::WireFormatLite::WriteInt32(10, this->number_presentation(), output);
2653   }
2654
2655   // optional string name = 11;
2656   if (_has_bit(10)) {
2657     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2658       this->name().data(), this->name().length(),
2659       ::google::protobuf::internal::WireFormat::SERIALIZE);
2660     ::google::protobuf::internal::WireFormatLite::WriteString(
2661       11, this->name(), output);
2662   }
2663
2664   // optional int32 name_presentation = 12;
2665   if (_has_bit(11)) {
2666     ::google::protobuf::internal::WireFormatLite::WriteInt32(12, this->name_presentation(), output);
2667   }
2668
2669   // optional .ril_proto.RilUusInfo uus_info = 13;
2670   if (_has_bit(12)) {
2671     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2672       13, this->uus_info(), output);
2673   }
2674
2675   if (!unknown_fields().empty()) {
2676     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
2677         unknown_fields(), output);
2678   }
2679 }
2680
2681 ::google::protobuf::uint8* RilCall::SerializeWithCachedSizesToArray(
2682     ::google::protobuf::uint8* target) const {
2683   // optional .ril_proto.RilCallState state = 1;
2684   if (_has_bit(0)) {
2685     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
2686       1, this->state(), target);
2687   }
2688
2689   // optional int32 index = 2;
2690   if (_has_bit(1)) {
2691     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->index(), target);
2692   }
2693
2694   // optional int32 toa = 3;
2695   if (_has_bit(2)) {
2696     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->toa(), target);
2697   }
2698
2699   // optional bool is_mpty = 4;
2700   if (_has_bit(3)) {
2701     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->is_mpty(), target);
2702   }
2703
2704   // optional bool is_mt = 5;
2705   if (_has_bit(4)) {
2706     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->is_mt(), target);
2707   }
2708
2709   // optional int32 als = 6;
2710   if (_has_bit(5)) {
2711     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->als(), target);
2712   }
2713
2714   // optional bool is_voice = 7;
2715   if (_has_bit(6)) {
2716     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->is_voice(), target);
2717   }
2718
2719   // optional bool is_voice_privacy = 8;
2720   if (_has_bit(7)) {
2721     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(8, this->is_voice_privacy(), target);
2722   }
2723
2724   // optional string number = 9;
2725   if (_has_bit(8)) {
2726     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2727       this->number().data(), this->number().length(),
2728       ::google::protobuf::internal::WireFormat::SERIALIZE);
2729     target =
2730       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2731         9, this->number(), target);
2732   }
2733
2734   // optional int32 number_presentation = 10;
2735   if (_has_bit(9)) {
2736     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(10, this->number_presentation(), target);
2737   }
2738
2739   // optional string name = 11;
2740   if (_has_bit(10)) {
2741     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2742       this->name().data(), this->name().length(),
2743       ::google::protobuf::internal::WireFormat::SERIALIZE);
2744     target =
2745       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2746         11, this->name(), target);
2747   }
2748
2749   // optional int32 name_presentation = 12;
2750   if (_has_bit(11)) {
2751     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(12, this->name_presentation(), target);
2752   }
2753
2754   // optional .ril_proto.RilUusInfo uus_info = 13;
2755   if (_has_bit(12)) {
2756     target = ::google::protobuf::internal::WireFormatLite::
2757       WriteMessageNoVirtualToArray(
2758         13, this->uus_info(), target);
2759   }
2760
2761   if (!unknown_fields().empty()) {
2762     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
2763         unknown_fields(), target);
2764   }
2765   return target;
2766 }
2767
2768 int RilCall::ByteSize() const {
2769   int total_size = 0;
2770
2771   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2772     // optional .ril_proto.RilCallState state = 1;
2773     if (has_state()) {
2774       total_size += 1 +
2775         ::google::protobuf::internal::WireFormatLite::EnumSize(this->state());
2776     }
2777
2778     // optional int32 index = 2;
2779     if (has_index()) {
2780       total_size += 1 +
2781         ::google::protobuf::internal::WireFormatLite::Int32Size(
2782           this->index());
2783     }
2784
2785     // optional int32 toa = 3;
2786     if (has_toa()) {
2787       total_size += 1 +
2788         ::google::protobuf::internal::WireFormatLite::Int32Size(
2789           this->toa());
2790     }
2791
2792     // optional bool is_mpty = 4;
2793     if (has_is_mpty()) {
2794       total_size += 1 + 1;
2795     }
2796
2797     // optional bool is_mt = 5;
2798     if (has_is_mt()) {
2799       total_size += 1 + 1;
2800     }
2801
2802     // optional int32 als = 6;
2803     if (has_als()) {
2804       total_size += 1 +
2805         ::google::protobuf::internal::WireFormatLite::Int32Size(
2806           this->als());
2807     }
2808
2809     // optional bool is_voice = 7;
2810     if (has_is_voice()) {
2811       total_size += 1 + 1;
2812     }
2813
2814     // optional bool is_voice_privacy = 8;
2815     if (has_is_voice_privacy()) {
2816       total_size += 1 + 1;
2817     }
2818
2819   }
2820   if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
2821     // optional string number = 9;
2822     if (has_number()) {
2823       total_size += 1 +
2824         ::google::protobuf::internal::WireFormatLite::StringSize(
2825           this->number());
2826     }
2827
2828     // optional int32 number_presentation = 10;
2829     if (has_number_presentation()) {
2830       total_size += 1 +
2831         ::google::protobuf::internal::WireFormatLite::Int32Size(
2832           this->number_presentation());
2833     }
2834
2835     // optional string name = 11;
2836     if (has_name()) {
2837       total_size += 1 +
2838         ::google::protobuf::internal::WireFormatLite::StringSize(
2839           this->name());
2840     }
2841
2842     // optional int32 name_presentation = 12;
2843     if (has_name_presentation()) {
2844       total_size += 1 +
2845         ::google::protobuf::internal::WireFormatLite::Int32Size(
2846           this->name_presentation());
2847     }
2848
2849     // optional .ril_proto.RilUusInfo uus_info = 13;
2850     if (has_uus_info()) {
2851       total_size += 1 +
2852         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
2853           this->uus_info());
2854     }
2855
2856   }
2857   if (!unknown_fields().empty()) {
2858     total_size +=
2859       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
2860         unknown_fields());
2861   }
2862   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2863   _cached_size_ = total_size;
2864   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2865   return total_size;
2866 }
2867
2868 void RilCall::MergeFrom(const ::google::protobuf::Message& from) {
2869   GOOGLE_CHECK_NE(&from, this);
2870   const RilCall* source =
2871     ::google::protobuf::internal::dynamic_cast_if_available<const RilCall*>(
2872       &from);
2873   if (source == NULL) {
2874     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2875   } else {
2876     MergeFrom(*source);
2877   }
2878 }
2879
2880 void RilCall::MergeFrom(const RilCall& from) {
2881   GOOGLE_CHECK_NE(&from, this);
2882   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2883     if (from._has_bit(0)) {
2884       set_state(from.state());
2885     }
2886     if (from._has_bit(1)) {
2887       set_index(from.index());
2888     }
2889     if (from._has_bit(2)) {
2890       set_toa(from.toa());
2891     }
2892     if (from._has_bit(3)) {
2893       set_is_mpty(from.is_mpty());
2894     }
2895     if (from._has_bit(4)) {
2896       set_is_mt(from.is_mt());
2897     }
2898     if (from._has_bit(5)) {
2899       set_als(from.als());
2900     }
2901     if (from._has_bit(6)) {
2902       set_is_voice(from.is_voice());
2903     }
2904     if (from._has_bit(7)) {
2905       set_is_voice_privacy(from.is_voice_privacy());
2906     }
2907   }
2908   if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
2909     if (from._has_bit(8)) {
2910       set_number(from.number());
2911     }
2912     if (from._has_bit(9)) {
2913       set_number_presentation(from.number_presentation());
2914     }
2915     if (from._has_bit(10)) {
2916       set_name(from.name());
2917     }
2918     if (from._has_bit(11)) {
2919       set_name_presentation(from.name_presentation());
2920     }
2921     if (from._has_bit(12)) {
2922       mutable_uus_info()->::ril_proto::RilUusInfo::MergeFrom(from.uus_info());
2923     }
2924   }
2925   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
2926 }
2927
2928 void RilCall::CopyFrom(const ::google::protobuf::Message& from) {
2929   if (&from == this) return;
2930   Clear();
2931   MergeFrom(from);
2932 }
2933
2934 void RilCall::CopyFrom(const RilCall& from) {
2935   if (&from == this) return;
2936   Clear();
2937   MergeFrom(from);
2938 }
2939
2940 bool RilCall::IsInitialized() const {
2941
2942   return true;
2943 }
2944
2945 void RilCall::Swap(RilCall* other) {
2946   if (other != this) {
2947     std::swap(state_, other->state_);
2948     std::swap(index_, other->index_);
2949     std::swap(toa_, other->toa_);
2950     std::swap(is_mpty_, other->is_mpty_);
2951     std::swap(is_mt_, other->is_mt_);
2952     std::swap(als_, other->als_);
2953     std::swap(is_voice_, other->is_voice_);
2954     std::swap(is_voice_privacy_, other->is_voice_privacy_);
2955     std::swap(number_, other->number_);
2956     std::swap(number_presentation_, other->number_presentation_);
2957     std::swap(name_, other->name_);
2958     std::swap(name_presentation_, other->name_presentation_);
2959     std::swap(uus_info_, other->uus_info_);
2960     std::swap(_has_bits_[0], other->_has_bits_[0]);
2961     _unknown_fields_.Swap(&other->_unknown_fields_);
2962     std::swap(_cached_size_, other->_cached_size_);
2963   }
2964 }
2965
2966 ::google::protobuf::Metadata RilCall::GetMetadata() const {
2967   protobuf_AssignDescriptorsOnce();
2968   ::google::protobuf::Metadata metadata;
2969   metadata.descriptor = RilCall_descriptor_;
2970   metadata.reflection = RilCall_reflection_;
2971   return metadata;
2972 }
2973
2974
2975 // ===================================================================
2976
2977 #ifndef _MSC_VER
2978 const int RILGWSignalStrength::kSignalStrengthFieldNumber;
2979 const int RILGWSignalStrength::kBitErrorRateFieldNumber;
2980 #endif  // !_MSC_VER
2981
2982 RILGWSignalStrength::RILGWSignalStrength()
2983   : ::google::protobuf::Message() {
2984   SharedCtor();
2985 }
2986
2987 void RILGWSignalStrength::InitAsDefaultInstance() {
2988 }
2989
2990 RILGWSignalStrength::RILGWSignalStrength(const RILGWSignalStrength& from)
2991   : ::google::protobuf::Message() {
2992   SharedCtor();
2993   MergeFrom(from);
2994 }
2995
2996 void RILGWSignalStrength::SharedCtor() {
2997   _cached_size_ = 0;
2998   signal_strength_ = 0;
2999   bit_error_rate_ = 0;
3000   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3001 }
3002
3003 RILGWSignalStrength::~RILGWSignalStrength() {
3004   SharedDtor();
3005 }
3006
3007 void RILGWSignalStrength::SharedDtor() {
3008   if (this != default_instance_) {
3009   }
3010 }
3011
3012 void RILGWSignalStrength::SetCachedSize(int size) const {
3013   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
3014   _cached_size_ = size;
3015   GOOGLE_SAFE_CONCURRENT_WRITES_END();
3016 }
3017 const ::google::protobuf::Descriptor* RILGWSignalStrength::descriptor() {
3018   protobuf_AssignDescriptorsOnce();
3019   return RILGWSignalStrength_descriptor_;
3020 }
3021
3022 const RILGWSignalStrength& RILGWSignalStrength::default_instance() {
3023   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
3024 }
3025
3026 RILGWSignalStrength* RILGWSignalStrength::default_instance_ = NULL;
3027
3028 RILGWSignalStrength* RILGWSignalStrength::New() const {
3029   return new RILGWSignalStrength;
3030 }
3031
3032 void RILGWSignalStrength::Clear() {
3033   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3034     signal_strength_ = 0;
3035     bit_error_rate_ = 0;
3036   }
3037   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3038   mutable_unknown_fields()->Clear();
3039 }
3040
3041 bool RILGWSignalStrength::MergePartialFromCodedStream(
3042     ::google::protobuf::io::CodedInputStream* input) {
3043 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
3044   ::google::protobuf::uint32 tag;
3045   while ((tag = input->ReadTag()) != 0) {
3046     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
3047       // optional int32 signal_strength = 1;
3048       case 1: {
3049         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3050             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
3051           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
3052                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
3053                  input, &signal_strength_)));
3054           _set_bit(0);
3055         } else {
3056           goto handle_uninterpreted;
3057         }
3058         if (input->ExpectTag(16)) goto parse_bit_error_rate;
3059         break;
3060       }
3061
3062       // optional int32 bit_error_rate = 2;
3063       case 2: {
3064         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3065             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
3066          parse_bit_error_rate:
3067           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
3068                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
3069                  input, &bit_error_rate_)));
3070           _set_bit(1);
3071         } else {
3072           goto handle_uninterpreted;
3073         }
3074         if (input->ExpectAtEnd()) return true;
3075         break;
3076       }
3077
3078       default: {
3079       handle_uninterpreted:
3080         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3081             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
3082           return true;
3083         }
3084         DO_(::google::protobuf::internal::WireFormat::SkipField(
3085               input, tag, mutable_unknown_fields()));
3086         break;
3087       }
3088     }
3089   }
3090   return true;
3091 #undef DO_
3092 }
3093
3094 void RILGWSignalStrength::SerializeWithCachedSizes(
3095     ::google::protobuf::io::CodedOutputStream* output) const {
3096   // optional int32 signal_strength = 1;
3097   if (_has_bit(0)) {
3098     ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->signal_strength(), output);
3099   }
3100
3101   // optional int32 bit_error_rate = 2;
3102   if (_has_bit(1)) {
3103     ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->bit_error_rate(), output);
3104   }
3105
3106   if (!unknown_fields().empty()) {
3107     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
3108         unknown_fields(), output);
3109   }
3110 }
3111
3112 ::google::protobuf::uint8* RILGWSignalStrength::SerializeWithCachedSizesToArray(
3113     ::google::protobuf::uint8* target) const {
3114   // optional int32 signal_strength = 1;
3115   if (_has_bit(0)) {
3116     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->signal_strength(), target);
3117   }
3118
3119   // optional int32 bit_error_rate = 2;
3120   if (_has_bit(1)) {
3121     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->bit_error_rate(), target);
3122   }
3123
3124   if (!unknown_fields().empty()) {
3125     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
3126         unknown_fields(), target);
3127   }
3128   return target;
3129 }
3130
3131 int RILGWSignalStrength::ByteSize() const {
3132   int total_size = 0;
3133
3134   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3135     // optional int32 signal_strength = 1;
3136     if (has_signal_strength()) {
3137       total_size += 1 +
3138         ::google::protobuf::internal::WireFormatLite::Int32Size(
3139           this->signal_strength());
3140     }
3141
3142     // optional int32 bit_error_rate = 2;
3143     if (has_bit_error_rate()) {
3144       total_size += 1 +
3145         ::google::protobuf::internal::WireFormatLite::Int32Size(
3146           this->bit_error_rate());
3147     }
3148
3149   }
3150   if (!unknown_fields().empty()) {
3151     total_size +=
3152       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
3153         unknown_fields());
3154   }
3155   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
3156   _cached_size_ = total_size;
3157   GOOGLE_SAFE_CONCURRENT_WRITES_END();
3158   return total_size;
3159 }
3160
3161 void RILGWSignalStrength::MergeFrom(const ::google::protobuf::Message& from) {
3162   GOOGLE_CHECK_NE(&from, this);
3163   const RILGWSignalStrength* source =
3164     ::google::protobuf::internal::dynamic_cast_if_available<const RILGWSignalStrength*>(
3165       &from);
3166   if (source == NULL) {
3167     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
3168   } else {
3169     MergeFrom(*source);
3170   }
3171 }
3172
3173 void RILGWSignalStrength::MergeFrom(const RILGWSignalStrength& from) {
3174   GOOGLE_CHECK_NE(&from, this);
3175   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3176     if (from._has_bit(0)) {
3177       set_signal_strength(from.signal_strength());
3178     }
3179     if (from._has_bit(1)) {
3180       set_bit_error_rate(from.bit_error_rate());
3181     }
3182   }
3183   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
3184 }
3185
3186 void RILGWSignalStrength::CopyFrom(const ::google::protobuf::Message& from) {
3187   if (&from == this) return;
3188   Clear();
3189   MergeFrom(from);
3190 }
3191
3192 void RILGWSignalStrength::CopyFrom(const RILGWSignalStrength& from) {
3193   if (&from == this) return;
3194   Clear();
3195   MergeFrom(from);
3196 }
3197
3198 bool RILGWSignalStrength::IsInitialized() const {
3199
3200   return true;
3201 }
3202
3203 void RILGWSignalStrength::Swap(RILGWSignalStrength* other) {
3204   if (other != this) {
3205     std::swap(signal_strength_, other->signal_strength_);
3206     std::swap(bit_error_rate_, other->bit_error_rate_);
3207     std::swap(_has_bits_[0], other->_has_bits_[0]);
3208     _unknown_fields_.Swap(&other->_unknown_fields_);
3209     std::swap(_cached_size_, other->_cached_size_);
3210   }
3211 }
3212
3213 ::google::protobuf::Metadata RILGWSignalStrength::GetMetadata() const {
3214   protobuf_AssignDescriptorsOnce();
3215   ::google::protobuf::Metadata metadata;
3216   metadata.descriptor = RILGWSignalStrength_descriptor_;
3217   metadata.reflection = RILGWSignalStrength_reflection_;
3218   return metadata;
3219 }
3220
3221
3222 // ===================================================================
3223
3224 #ifndef _MSC_VER
3225 const int RILCDMASignalStrength::kDbmFieldNumber;
3226 const int RILCDMASignalStrength::kEcioFieldNumber;
3227 #endif  // !_MSC_VER
3228
3229 RILCDMASignalStrength::RILCDMASignalStrength()
3230   : ::google::protobuf::Message() {
3231   SharedCtor();
3232 }
3233
3234 void RILCDMASignalStrength::InitAsDefaultInstance() {
3235 }
3236
3237 RILCDMASignalStrength::RILCDMASignalStrength(const RILCDMASignalStrength& from)
3238   : ::google::protobuf::Message() {
3239   SharedCtor();
3240   MergeFrom(from);
3241 }
3242
3243 void RILCDMASignalStrength::SharedCtor() {
3244   _cached_size_ = 0;
3245   dbm_ = 0;
3246   ecio_ = 0;
3247   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3248 }
3249
3250 RILCDMASignalStrength::~RILCDMASignalStrength() {
3251   SharedDtor();
3252 }
3253
3254 void RILCDMASignalStrength::SharedDtor() {
3255   if (this != default_instance_) {
3256   }
3257 }
3258
3259 void RILCDMASignalStrength::SetCachedSize(int size) const {
3260   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
3261   _cached_size_ = size;
3262   GOOGLE_SAFE_CONCURRENT_WRITES_END();
3263 }
3264 const ::google::protobuf::Descriptor* RILCDMASignalStrength::descriptor() {
3265   protobuf_AssignDescriptorsOnce();
3266   return RILCDMASignalStrength_descriptor_;
3267 }
3268
3269 const RILCDMASignalStrength& RILCDMASignalStrength::default_instance() {
3270   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
3271 }
3272
3273 RILCDMASignalStrength* RILCDMASignalStrength::default_instance_ = NULL;
3274
3275 RILCDMASignalStrength* RILCDMASignalStrength::New() const {
3276   return new RILCDMASignalStrength;
3277 }
3278
3279 void RILCDMASignalStrength::Clear() {
3280   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3281     dbm_ = 0;
3282     ecio_ = 0;
3283   }
3284   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3285   mutable_unknown_fields()->Clear();
3286 }
3287
3288 bool RILCDMASignalStrength::MergePartialFromCodedStream(
3289     ::google::protobuf::io::CodedInputStream* input) {
3290 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
3291   ::google::protobuf::uint32 tag;
3292   while ((tag = input->ReadTag()) != 0) {
3293     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
3294       // optional int32 dbm = 1;
3295       case 1: {
3296         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3297             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
3298           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
3299                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
3300                  input, &dbm_)));
3301           _set_bit(0);
3302         } else {
3303           goto handle_uninterpreted;
3304         }
3305         if (input->ExpectTag(16)) goto parse_ecio;
3306         break;
3307       }
3308
3309       // optional int32 ecio = 2;
3310       case 2: {
3311         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3312             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
3313          parse_ecio:
3314           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
3315                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
3316                  input, &ecio_)));
3317           _set_bit(1);
3318         } else {
3319           goto handle_uninterpreted;
3320         }
3321         if (input->ExpectAtEnd()) return true;
3322         break;
3323       }
3324
3325       default: {
3326       handle_uninterpreted:
3327         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3328             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
3329           return true;
3330         }
3331         DO_(::google::protobuf::internal::WireFormat::SkipField(
3332               input, tag, mutable_unknown_fields()));
3333         break;
3334       }
3335     }
3336   }
3337   return true;
3338 #undef DO_
3339 }
3340
3341 void RILCDMASignalStrength::SerializeWithCachedSizes(
3342     ::google::protobuf::io::CodedOutputStream* output) const {
3343   // optional int32 dbm = 1;
3344   if (_has_bit(0)) {
3345     ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->dbm(), output);
3346   }
3347
3348   // optional int32 ecio = 2;
3349   if (_has_bit(1)) {
3350     ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->ecio(), output);
3351   }
3352
3353   if (!unknown_fields().empty()) {
3354     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
3355         unknown_fields(), output);
3356   }
3357 }
3358
3359 ::google::protobuf::uint8* RILCDMASignalStrength::SerializeWithCachedSizesToArray(
3360     ::google::protobuf::uint8* target) const {
3361   // optional int32 dbm = 1;
3362   if (_has_bit(0)) {
3363     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->dbm(), target);
3364   }
3365
3366   // optional int32 ecio = 2;
3367   if (_has_bit(1)) {
3368     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->ecio(), target);
3369   }
3370
3371   if (!unknown_fields().empty()) {
3372     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
3373         unknown_fields(), target);
3374   }
3375   return target;
3376 }
3377
3378 int RILCDMASignalStrength::ByteSize() const {
3379   int total_size = 0;
3380
3381   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3382     // optional int32 dbm = 1;
3383     if (has_dbm()) {
3384       total_size += 1 +
3385         ::google::protobuf::internal::WireFormatLite::Int32Size(
3386           this->dbm());
3387     }
3388
3389     // optional int32 ecio = 2;
3390     if (has_ecio()) {
3391       total_size += 1 +
3392         ::google::protobuf::internal::WireFormatLite::Int32Size(
3393           this->ecio());
3394     }
3395
3396   }
3397   if (!unknown_fields().empty()) {
3398     total_size +=
3399       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
3400         unknown_fields());
3401   }
3402   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
3403   _cached_size_ = total_size;
3404   GOOGLE_SAFE_CONCURRENT_WRITES_END();
3405   return total_size;
3406 }
3407
3408 void RILCDMASignalStrength::MergeFrom(const ::google::protobuf::Message& from) {
3409   GOOGLE_CHECK_NE(&from, this);
3410   const RILCDMASignalStrength* source =
3411     ::google::protobuf::internal::dynamic_cast_if_available<const RILCDMASignalStrength*>(
3412       &from);
3413   if (source == NULL) {
3414     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
3415   } else {
3416     MergeFrom(*source);
3417   }
3418 }
3419
3420 void RILCDMASignalStrength::MergeFrom(const RILCDMASignalStrength& from) {
3421   GOOGLE_CHECK_NE(&from, this);
3422   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3423     if (from._has_bit(0)) {
3424       set_dbm(from.dbm());
3425     }
3426     if (from._has_bit(1)) {
3427       set_ecio(from.ecio());
3428     }
3429   }
3430   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
3431 }
3432
3433 void RILCDMASignalStrength::CopyFrom(const ::google::protobuf::Message& from) {
3434   if (&from == this) return;
3435   Clear();
3436   MergeFrom(from);
3437 }
3438
3439 void RILCDMASignalStrength::CopyFrom(const RILCDMASignalStrength& from) {
3440   if (&from == this) return;
3441   Clear();
3442   MergeFrom(from);
3443 }
3444
3445 bool RILCDMASignalStrength::IsInitialized() const {
3446
3447   return true;
3448 }
3449
3450 void RILCDMASignalStrength::Swap(RILCDMASignalStrength* other) {
3451   if (other != this) {
3452     std::swap(dbm_, other->dbm_);
3453     std::swap(ecio_, other->ecio_);
3454     std::swap(_has_bits_[0], other->_has_bits_[0]);
3455     _unknown_fields_.Swap(&other->_unknown_fields_);
3456     std::swap(_cached_size_, other->_cached_size_);
3457   }
3458 }
3459
3460 ::google::protobuf::Metadata RILCDMASignalStrength::GetMetadata() const {
3461   protobuf_AssignDescriptorsOnce();
3462   ::google::protobuf::Metadata metadata;
3463   metadata.descriptor = RILCDMASignalStrength_descriptor_;
3464   metadata.reflection = RILCDMASignalStrength_reflection_;
3465   return metadata;
3466 }
3467
3468
3469 // ===================================================================
3470
3471 #ifndef _MSC_VER
3472 const int RILEVDOSignalStrength::kDbmFieldNumber;
3473 const int RILEVDOSignalStrength::kEcioFieldNumber;
3474 const int RILEVDOSignalStrength::kSignalNoiseRatioFieldNumber;
3475 #endif  // !_MSC_VER
3476
3477 RILEVDOSignalStrength::RILEVDOSignalStrength()
3478   : ::google::protobuf::Message() {
3479   SharedCtor();
3480 }
3481
3482 void RILEVDOSignalStrength::InitAsDefaultInstance() {
3483 }
3484
3485 RILEVDOSignalStrength::RILEVDOSignalStrength(const RILEVDOSignalStrength& from)
3486   : ::google::protobuf::Message() {
3487   SharedCtor();
3488   MergeFrom(from);
3489 }
3490
3491 void RILEVDOSignalStrength::SharedCtor() {
3492   _cached_size_ = 0;
3493   dbm_ = 0;
3494   ecio_ = 0;
3495   signal_noise_ratio_ = 0;
3496   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3497 }
3498
3499 RILEVDOSignalStrength::~RILEVDOSignalStrength() {
3500   SharedDtor();
3501 }
3502
3503 void RILEVDOSignalStrength::SharedDtor() {
3504   if (this != default_instance_) {
3505   }
3506 }
3507
3508 void RILEVDOSignalStrength::SetCachedSize(int size) const {
3509   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
3510   _cached_size_ = size;
3511   GOOGLE_SAFE_CONCURRENT_WRITES_END();
3512 }
3513 const ::google::protobuf::Descriptor* RILEVDOSignalStrength::descriptor() {
3514   protobuf_AssignDescriptorsOnce();
3515   return RILEVDOSignalStrength_descriptor_;
3516 }
3517
3518 const RILEVDOSignalStrength& RILEVDOSignalStrength::default_instance() {
3519   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
3520 }
3521
3522 RILEVDOSignalStrength* RILEVDOSignalStrength::default_instance_ = NULL;
3523
3524 RILEVDOSignalStrength* RILEVDOSignalStrength::New() const {
3525   return new RILEVDOSignalStrength;
3526 }
3527
3528 void RILEVDOSignalStrength::Clear() {
3529   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3530     dbm_ = 0;
3531     ecio_ = 0;
3532     signal_noise_ratio_ = 0;
3533   }
3534   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3535   mutable_unknown_fields()->Clear();
3536 }
3537
3538 bool RILEVDOSignalStrength::MergePartialFromCodedStream(
3539     ::google::protobuf::io::CodedInputStream* input) {
3540 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
3541   ::google::protobuf::uint32 tag;
3542   while ((tag = input->ReadTag()) != 0) {
3543     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
3544       // optional int32 dbm = 1;
3545       case 1: {
3546         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3547             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
3548           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
3549                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
3550                  input, &dbm_)));
3551           _set_bit(0);
3552         } else {
3553           goto handle_uninterpreted;
3554         }
3555         if (input->ExpectTag(16)) goto parse_ecio;
3556         break;
3557       }
3558
3559       // optional int32 ecio = 2;
3560       case 2: {
3561         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3562             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
3563          parse_ecio:
3564           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
3565                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
3566                  input, &ecio_)));
3567           _set_bit(1);
3568         } else {
3569           goto handle_uninterpreted;
3570         }
3571         if (input->ExpectTag(24)) goto parse_signal_noise_ratio;
3572         break;
3573       }
3574
3575       // optional int32 signal_noise_ratio = 3;
3576       case 3: {
3577         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3578             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
3579          parse_signal_noise_ratio:
3580           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
3581                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
3582                  input, &signal_noise_ratio_)));
3583           _set_bit(2);
3584         } else {
3585           goto handle_uninterpreted;
3586         }
3587         if (input->ExpectAtEnd()) return true;
3588         break;
3589       }
3590
3591       default: {
3592       handle_uninterpreted:
3593         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3594             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
3595           return true;
3596         }
3597         DO_(::google::protobuf::internal::WireFormat::SkipField(
3598               input, tag, mutable_unknown_fields()));
3599         break;
3600       }
3601     }
3602   }
3603   return true;
3604 #undef DO_
3605 }
3606
3607 void RILEVDOSignalStrength::SerializeWithCachedSizes(
3608     ::google::protobuf::io::CodedOutputStream* output) const {
3609   // optional int32 dbm = 1;
3610   if (_has_bit(0)) {
3611     ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->dbm(), output);
3612   }
3613
3614   // optional int32 ecio = 2;
3615   if (_has_bit(1)) {
3616     ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->ecio(), output);
3617   }
3618
3619   // optional int32 signal_noise_ratio = 3;
3620   if (_has_bit(2)) {
3621     ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->signal_noise_ratio(), output);
3622   }
3623
3624   if (!unknown_fields().empty()) {
3625     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
3626         unknown_fields(), output);
3627   }
3628 }
3629
3630 ::google::protobuf::uint8* RILEVDOSignalStrength::SerializeWithCachedSizesToArray(
3631     ::google::protobuf::uint8* target) const {
3632   // optional int32 dbm = 1;
3633   if (_has_bit(0)) {
3634     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->dbm(), target);
3635   }
3636
3637   // optional int32 ecio = 2;
3638   if (_has_bit(1)) {
3639     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->ecio(), target);
3640   }
3641
3642   // optional int32 signal_noise_ratio = 3;
3643   if (_has_bit(2)) {
3644     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->signal_noise_ratio(), target);
3645   }
3646
3647   if (!unknown_fields().empty()) {
3648     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
3649         unknown_fields(), target);
3650   }
3651   return target;
3652 }
3653
3654 int RILEVDOSignalStrength::ByteSize() const {
3655   int total_size = 0;
3656
3657   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3658     // optional int32 dbm = 1;
3659     if (has_dbm()) {
3660       total_size += 1 +
3661         ::google::protobuf::internal::WireFormatLite::Int32Size(
3662           this->dbm());
3663     }
3664
3665     // optional int32 ecio = 2;
3666     if (has_ecio()) {
3667       total_size += 1 +
3668         ::google::protobuf::internal::WireFormatLite::Int32Size(
3669           this->ecio());
3670     }
3671
3672     // optional int32 signal_noise_ratio = 3;
3673     if (has_signal_noise_ratio()) {
3674       total_size += 1 +
3675         ::google::protobuf::internal::WireFormatLite::Int32Size(
3676           this->signal_noise_ratio());
3677     }
3678
3679   }
3680   if (!unknown_fields().empty()) {
3681     total_size +=
3682       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
3683         unknown_fields());
3684   }
3685   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
3686   _cached_size_ = total_size;
3687   GOOGLE_SAFE_CONCURRENT_WRITES_END();
3688   return total_size;
3689 }
3690
3691 void RILEVDOSignalStrength::MergeFrom(const ::google::protobuf::Message& from) {
3692   GOOGLE_CHECK_NE(&from, this);
3693   const RILEVDOSignalStrength* source =
3694     ::google::protobuf::internal::dynamic_cast_if_available<const RILEVDOSignalStrength*>(
3695       &from);
3696   if (source == NULL) {
3697     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
3698   } else {
3699     MergeFrom(*source);
3700   }
3701 }
3702
3703 void RILEVDOSignalStrength::MergeFrom(const RILEVDOSignalStrength& from) {
3704   GOOGLE_CHECK_NE(&from, this);
3705   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3706     if (from._has_bit(0)) {
3707       set_dbm(from.dbm());
3708     }
3709     if (from._has_bit(1)) {
3710       set_ecio(from.ecio());
3711     }
3712     if (from._has_bit(2)) {
3713       set_signal_noise_ratio(from.signal_noise_ratio());
3714     }
3715   }
3716   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
3717 }
3718
3719 void RILEVDOSignalStrength::CopyFrom(const ::google::protobuf::Message& from) {
3720   if (&from == this) return;
3721   Clear();
3722   MergeFrom(from);
3723 }
3724
3725 void RILEVDOSignalStrength::CopyFrom(const RILEVDOSignalStrength& from) {
3726   if (&from == this) return;
3727   Clear();
3728   MergeFrom(from);
3729 }
3730
3731 bool RILEVDOSignalStrength::IsInitialized() const {
3732
3733   return true;
3734 }
3735
3736 void RILEVDOSignalStrength::Swap(RILEVDOSignalStrength* other) {
3737   if (other != this) {
3738     std::swap(dbm_, other->dbm_);
3739     std::swap(ecio_, other->ecio_);
3740     std::swap(signal_noise_ratio_, other->signal_noise_ratio_);
3741     std::swap(_has_bits_[0], other->_has_bits_[0]);
3742     _unknown_fields_.Swap(&other->_unknown_fields_);
3743     std::swap(_cached_size_, other->_cached_size_);
3744   }
3745 }
3746
3747 ::google::protobuf::Metadata RILEVDOSignalStrength::GetMetadata() const {
3748   protobuf_AssignDescriptorsOnce();
3749   ::google::protobuf::Metadata metadata;
3750   metadata.descriptor = RILEVDOSignalStrength_descriptor_;
3751   metadata.reflection = RILEVDOSignalStrength_reflection_;
3752   return metadata;
3753 }
3754
3755
3756 // ===================================================================
3757
3758 #ifndef _MSC_VER
3759 const int RspStrings::kStringsFieldNumber;
3760 #endif  // !_MSC_VER
3761
3762 RspStrings::RspStrings()
3763   : ::google::protobuf::Message() {
3764   SharedCtor();
3765 }
3766
3767 void RspStrings::InitAsDefaultInstance() {
3768 }
3769
3770 RspStrings::RspStrings(const RspStrings& from)
3771   : ::google::protobuf::Message() {
3772   SharedCtor();
3773   MergeFrom(from);
3774 }
3775
3776 void RspStrings::SharedCtor() {
3777   _cached_size_ = 0;
3778   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3779 }
3780
3781 RspStrings::~RspStrings() {
3782   SharedDtor();
3783 }
3784
3785 void RspStrings::SharedDtor() {
3786   if (this != default_instance_) {
3787   }
3788 }
3789
3790 void RspStrings::SetCachedSize(int size) const {
3791   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
3792   _cached_size_ = size;
3793   GOOGLE_SAFE_CONCURRENT_WRITES_END();
3794 }
3795 const ::google::protobuf::Descriptor* RspStrings::descriptor() {
3796   protobuf_AssignDescriptorsOnce();
3797   return RspStrings_descriptor_;
3798 }
3799
3800 const RspStrings& RspStrings::default_instance() {
3801   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
3802 }
3803
3804 RspStrings* RspStrings::default_instance_ = NULL;
3805
3806 RspStrings* RspStrings::New() const {
3807   return new RspStrings;
3808 }
3809
3810 void RspStrings::Clear() {
3811   strings_.Clear();
3812   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3813   mutable_unknown_fields()->Clear();
3814 }
3815
3816 bool RspStrings::MergePartialFromCodedStream(
3817     ::google::protobuf::io::CodedInputStream* input) {
3818 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
3819   ::google::protobuf::uint32 tag;
3820   while ((tag = input->ReadTag()) != 0) {
3821     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
3822       // repeated string strings = 1;
3823       case 1: {
3824         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3825             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
3826          parse_strings:
3827           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
3828                 input, this->add_strings()));
3829           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3830             this->strings(0).data(), this->strings(0).length(),
3831             ::google::protobuf::internal::WireFormat::PARSE);
3832         } else {
3833           goto handle_uninterpreted;
3834         }
3835         if (input->ExpectTag(10)) goto parse_strings;
3836         if (input->ExpectAtEnd()) return true;
3837         break;
3838       }
3839
3840       default: {
3841       handle_uninterpreted:
3842         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3843             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
3844           return true;
3845         }
3846         DO_(::google::protobuf::internal::WireFormat::SkipField(
3847               input, tag, mutable_unknown_fields()));
3848         break;
3849       }
3850     }
3851   }
3852   return true;
3853 #undef DO_
3854 }
3855
3856 void RspStrings::SerializeWithCachedSizes(
3857     ::google::protobuf::io::CodedOutputStream* output) const {
3858   // repeated string strings = 1;
3859   for (int i = 0; i < this->strings_size(); i++) {
3860   ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3861     this->strings(i).data(), this->strings(i).length(),
3862     ::google::protobuf::internal::WireFormat::SERIALIZE);
3863     ::google::protobuf::internal::WireFormatLite::WriteString(
3864       1, this->strings(i), output);
3865   }
3866
3867   if (!unknown_fields().empty()) {
3868     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
3869         unknown_fields(), output);
3870   }
3871 }
3872
3873 ::google::protobuf::uint8* RspStrings::SerializeWithCachedSizesToArray(
3874     ::google::protobuf::uint8* target) const {
3875   // repeated string strings = 1;
3876   for (int i = 0; i < this->strings_size(); i++) {
3877     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3878       this->strings(i).data(), this->strings(i).length(),
3879       ::google::protobuf::internal::WireFormat::SERIALIZE);
3880     target = ::google::protobuf::internal::WireFormatLite::
3881       WriteStringToArray(1, this->strings(i), target);
3882   }
3883
3884   if (!unknown_fields().empty()) {
3885     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
3886         unknown_fields(), target);
3887   }
3888   return target;
3889 }
3890
3891 int RspStrings::ByteSize() const {
3892   int total_size = 0;
3893
3894   // repeated string strings = 1;
3895   total_size += 1 * this->strings_size();
3896   for (int i = 0; i < this->strings_size(); i++) {
3897     total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
3898       this->strings(i));
3899   }
3900
3901   if (!unknown_fields().empty()) {
3902     total_size +=
3903       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
3904         unknown_fields());
3905   }
3906   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
3907   _cached_size_ = total_size;
3908   GOOGLE_SAFE_CONCURRENT_WRITES_END();
3909   return total_size;
3910 }
3911
3912 void RspStrings::MergeFrom(const ::google::protobuf::Message& from) {
3913   GOOGLE_CHECK_NE(&from, this);
3914   const RspStrings* source =
3915     ::google::protobuf::internal::dynamic_cast_if_available<const RspStrings*>(
3916       &from);
3917   if (source == NULL) {
3918     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
3919   } else {
3920     MergeFrom(*source);
3921   }
3922 }
3923
3924 void RspStrings::MergeFrom(const RspStrings& from) {
3925   GOOGLE_CHECK_NE(&from, this);
3926   strings_.MergeFrom(from.strings_);
3927   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
3928 }
3929
3930 void RspStrings::CopyFrom(const ::google::protobuf::Message& from) {
3931   if (&from == this) return;
3932   Clear();
3933   MergeFrom(from);
3934 }
3935
3936 void RspStrings::CopyFrom(const RspStrings& from) {
3937   if (&from == this) return;
3938   Clear();
3939   MergeFrom(from);
3940 }
3941
3942 bool RspStrings::IsInitialized() const {
3943
3944   return true;
3945 }
3946
3947 void RspStrings::Swap(RspStrings* other) {
3948   if (other != this) {
3949     strings_.Swap(&other->strings_);
3950     std::swap(_has_bits_[0], other->_has_bits_[0]);
3951     _unknown_fields_.Swap(&other->_unknown_fields_);
3952     std::swap(_cached_size_, other->_cached_size_);
3953   }
3954 }
3955
3956 ::google::protobuf::Metadata RspStrings::GetMetadata() const {
3957   protobuf_AssignDescriptorsOnce();
3958   ::google::protobuf::Metadata metadata;
3959   metadata.descriptor = RspStrings_descriptor_;
3960   metadata.reflection = RspStrings_reflection_;
3961   return metadata;
3962 }
3963
3964
3965 // ===================================================================
3966
3967 #ifndef _MSC_VER
3968 const int RspIntegers::kIntegersFieldNumber;
3969 #endif  // !_MSC_VER
3970
3971 RspIntegers::RspIntegers()
3972   : ::google::protobuf::Message() {
3973   SharedCtor();
3974 }
3975
3976 void RspIntegers::InitAsDefaultInstance() {
3977 }
3978
3979 RspIntegers::RspIntegers(const RspIntegers& from)
3980   : ::google::protobuf::Message() {
3981   SharedCtor();
3982   MergeFrom(from);
3983 }
3984
3985 void RspIntegers::SharedCtor() {
3986   _cached_size_ = 0;
3987   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3988 }
3989
3990 RspIntegers::~RspIntegers() {
3991   SharedDtor();
3992 }
3993
3994 void RspIntegers::SharedDtor() {
3995   if (this != default_instance_) {
3996   }
3997 }
3998
3999 void RspIntegers::SetCachedSize(int size) const {
4000   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
4001   _cached_size_ = size;
4002   GOOGLE_SAFE_CONCURRENT_WRITES_END();
4003 }
4004 const ::google::protobuf::Descriptor* RspIntegers::descriptor() {
4005   protobuf_AssignDescriptorsOnce();
4006   return RspIntegers_descriptor_;
4007 }
4008
4009 const RspIntegers& RspIntegers::default_instance() {
4010   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
4011 }
4012
4013 RspIntegers* RspIntegers::default_instance_ = NULL;
4014
4015 RspIntegers* RspIntegers::New() const {
4016   return new RspIntegers;
4017 }
4018
4019 void RspIntegers::Clear() {
4020   integers_.Clear();
4021   ::memset(_has_bits_, 0, sizeof(_has_bits_));
4022   mutable_unknown_fields()->Clear();
4023 }
4024
4025 bool RspIntegers::MergePartialFromCodedStream(
4026     ::google::protobuf::io::CodedInputStream* input) {
4027 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
4028   ::google::protobuf::uint32 tag;
4029   while ((tag = input->ReadTag()) != 0) {
4030     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
4031       // repeated int32 integers = 1;
4032       case 1: {
4033         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4034             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
4035          parse_integers:
4036           DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
4037                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
4038                  1, 8, input, this->mutable_integers())));
4039         } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
4040                    == ::google::protobuf::internal::WireFormatLite::
4041                       WIRETYPE_LENGTH_DELIMITED) {
4042           DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
4043                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
4044                  input, this->mutable_integers())));
4045         } else {
4046           goto handle_uninterpreted;
4047         }
4048         if (input->ExpectTag(8)) goto parse_integers;
4049         if (input->ExpectAtEnd()) return true;
4050         break;
4051       }
4052
4053       default: {
4054       handle_uninterpreted:
4055         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4056             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
4057           return true;
4058         }
4059         DO_(::google::protobuf::internal::WireFormat::SkipField(
4060               input, tag, mutable_unknown_fields()));
4061         break;
4062       }
4063     }
4064   }
4065   return true;
4066 #undef DO_
4067 }
4068
4069 void RspIntegers::SerializeWithCachedSizes(
4070     ::google::protobuf::io::CodedOutputStream* output) const {
4071   // repeated int32 integers = 1;
4072   for (int i = 0; i < this->integers_size(); i++) {
4073     ::google::protobuf::internal::WireFormatLite::WriteInt32(
4074       1, this->integers(i), output);
4075   }
4076
4077   if (!unknown_fields().empty()) {
4078     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
4079         unknown_fields(), output);
4080   }
4081 }
4082
4083 ::google::protobuf::uint8* RspIntegers::SerializeWithCachedSizesToArray(
4084     ::google::protobuf::uint8* target) const {
4085   // repeated int32 integers = 1;
4086   for (int i = 0; i < this->integers_size(); i++) {
4087     target = ::google::protobuf::internal::WireFormatLite::
4088       WriteInt32ToArray(1, this->integers(i), target);
4089   }
4090
4091   if (!unknown_fields().empty()) {
4092     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
4093         unknown_fields(), target);
4094   }
4095   return target;
4096 }
4097
4098 int RspIntegers::ByteSize() const {
4099   int total_size = 0;
4100
4101   // repeated int32 integers = 1;
4102   {
4103     int data_size = 0;
4104     for (int i = 0; i < this->integers_size(); i++) {
4105       data_size += ::google::protobuf::internal::WireFormatLite::
4106         Int32Size(this->integers(i));
4107     }
4108     total_size += 1 * this->integers_size() + data_size;
4109   }
4110
4111   if (!unknown_fields().empty()) {
4112     total_size +=
4113       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
4114         unknown_fields());
4115   }
4116   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
4117   _cached_size_ = total_size;
4118   GOOGLE_SAFE_CONCURRENT_WRITES_END();
4119   return total_size;
4120 }
4121
4122 void RspIntegers::MergeFrom(const ::google::protobuf::Message& from) {
4123   GOOGLE_CHECK_NE(&from, this);
4124   const RspIntegers* source =
4125     ::google::protobuf::internal::dynamic_cast_if_available<const RspIntegers*>(
4126       &from);
4127   if (source == NULL) {
4128     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
4129   } else {
4130     MergeFrom(*source);
4131   }
4132 }
4133
4134 void RspIntegers::MergeFrom(const RspIntegers& from) {
4135   GOOGLE_CHECK_NE(&from, this);
4136   integers_.MergeFrom(from.integers_);
4137   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
4138 }
4139
4140 void RspIntegers::CopyFrom(const ::google::protobuf::Message& from) {
4141   if (&from == this) return;
4142   Clear();
4143   MergeFrom(from);
4144 }
4145
4146 void RspIntegers::CopyFrom(const RspIntegers& from) {
4147   if (&from == this) return;
4148   Clear();
4149   MergeFrom(from);
4150 }
4151
4152 bool RspIntegers::IsInitialized() const {
4153
4154   return true;
4155 }
4156
4157 void RspIntegers::Swap(RspIntegers* other) {
4158   if (other != this) {
4159     integers_.Swap(&other->integers_);
4160     std::swap(_has_bits_[0], other->_has_bits_[0]);
4161     _unknown_fields_.Swap(&other->_unknown_fields_);
4162     std::swap(_cached_size_, other->_cached_size_);
4163   }
4164 }
4165
4166 ::google::protobuf::Metadata RspIntegers::GetMetadata() const {
4167   protobuf_AssignDescriptorsOnce();
4168   ::google::protobuf::Metadata metadata;
4169   metadata.descriptor = RspIntegers_descriptor_;
4170   metadata.reflection = RspIntegers_reflection_;
4171   return metadata;
4172 }
4173
4174
4175 // ===================================================================
4176
4177 #ifndef _MSC_VER
4178 const int RspGetSimStatus::kCardStatusFieldNumber;
4179 #endif  // !_MSC_VER
4180
4181 RspGetSimStatus::RspGetSimStatus()
4182   : ::google::protobuf::Message() {
4183   SharedCtor();
4184 }
4185
4186 void RspGetSimStatus::InitAsDefaultInstance() {
4187   card_status_ = const_cast< ::ril_proto::RilCardStatus*>(&::ril_proto::RilCardStatus::default_instance());
4188 }
4189
4190 RspGetSimStatus::RspGetSimStatus(const RspGetSimStatus& from)
4191   : ::google::protobuf::Message() {
4192   SharedCtor();
4193   MergeFrom(from);
4194 }
4195
4196 void RspGetSimStatus::SharedCtor() {
4197   _cached_size_ = 0;
4198   card_status_ = NULL;
4199   ::memset(_has_bits_, 0, sizeof(_has_bits_));
4200 }
4201
4202 RspGetSimStatus::~RspGetSimStatus() {
4203   SharedDtor();
4204 }
4205
4206 void RspGetSimStatus::SharedDtor() {
4207   if (this != default_instance_) {
4208     delete card_status_;
4209   }
4210 }
4211
4212 void RspGetSimStatus::SetCachedSize(int size) const {
4213   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
4214   _cached_size_ = size;
4215   GOOGLE_SAFE_CONCURRENT_WRITES_END();
4216 }
4217 const ::google::protobuf::Descriptor* RspGetSimStatus::descriptor() {
4218   protobuf_AssignDescriptorsOnce();
4219   return RspGetSimStatus_descriptor_;
4220 }
4221
4222 const RspGetSimStatus& RspGetSimStatus::default_instance() {
4223   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
4224 }
4225
4226 RspGetSimStatus* RspGetSimStatus::default_instance_ = NULL;
4227
4228 RspGetSimStatus* RspGetSimStatus::New() const {
4229   return new RspGetSimStatus;
4230 }
4231
4232 void RspGetSimStatus::Clear() {
4233   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4234     if (_has_bit(0)) {
4235       if (card_status_ != NULL) card_status_->::ril_proto::RilCardStatus::Clear();
4236     }
4237   }
4238   ::memset(_has_bits_, 0, sizeof(_has_bits_));
4239   mutable_unknown_fields()->Clear();
4240 }
4241
4242 bool RspGetSimStatus::MergePartialFromCodedStream(
4243     ::google::protobuf::io::CodedInputStream* input) {
4244 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
4245   ::google::protobuf::uint32 tag;
4246   while ((tag = input->ReadTag()) != 0) {
4247     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
4248       // required .ril_proto.RilCardStatus card_status = 1;
4249       case 1: {
4250         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4251             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
4252           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
4253                input, mutable_card_status()));
4254         } else {
4255           goto handle_uninterpreted;
4256         }
4257         if (input->ExpectAtEnd()) return true;
4258         break;
4259       }
4260
4261       default: {
4262       handle_uninterpreted:
4263         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4264             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
4265           return true;
4266         }
4267         DO_(::google::protobuf::internal::WireFormat::SkipField(
4268               input, tag, mutable_unknown_fields()));
4269         break;
4270       }
4271     }
4272   }
4273   return true;
4274 #undef DO_
4275 }
4276
4277 void RspGetSimStatus::SerializeWithCachedSizes(
4278     ::google::protobuf::io::CodedOutputStream* output) const {
4279   // required .ril_proto.RilCardStatus card_status = 1;
4280   if (_has_bit(0)) {
4281     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
4282       1, this->card_status(), output);
4283   }
4284
4285   if (!unknown_fields().empty()) {
4286     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
4287         unknown_fields(), output);
4288   }
4289 }
4290
4291 ::google::protobuf::uint8* RspGetSimStatus::SerializeWithCachedSizesToArray(
4292     ::google::protobuf::uint8* target) const {
4293   // required .ril_proto.RilCardStatus card_status = 1;
4294   if (_has_bit(0)) {
4295     target = ::google::protobuf::internal::WireFormatLite::
4296       WriteMessageNoVirtualToArray(
4297         1, this->card_status(), target);
4298   }
4299
4300   if (!unknown_fields().empty()) {
4301     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
4302         unknown_fields(), target);
4303   }
4304   return target;
4305 }
4306
4307 int RspGetSimStatus::ByteSize() const {
4308   int total_size = 0;
4309
4310   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4311     // required .ril_proto.RilCardStatus card_status = 1;
4312     if (has_card_status()) {
4313       total_size += 1 +
4314         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
4315           this->card_status());
4316     }
4317
4318   }
4319   if (!unknown_fields().empty()) {
4320     total_size +=
4321       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
4322         unknown_fields());
4323   }
4324   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
4325   _cached_size_ = total_size;
4326   GOOGLE_SAFE_CONCURRENT_WRITES_END();
4327   return total_size;
4328 }
4329
4330 void RspGetSimStatus::MergeFrom(const ::google::protobuf::Message& from) {
4331   GOOGLE_CHECK_NE(&from, this);
4332   const RspGetSimStatus* source =
4333     ::google::protobuf::internal::dynamic_cast_if_available<const RspGetSimStatus*>(
4334       &from);
4335   if (source == NULL) {
4336     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
4337   } else {
4338     MergeFrom(*source);
4339   }
4340 }
4341
4342 void RspGetSimStatus::MergeFrom(const RspGetSimStatus& from) {
4343   GOOGLE_CHECK_NE(&from, this);
4344   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4345     if (from._has_bit(0)) {
4346       mutable_card_status()->::ril_proto::RilCardStatus::MergeFrom(from.card_status());
4347     }
4348   }
4349   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
4350 }
4351
4352 void RspGetSimStatus::CopyFrom(const ::google::protobuf::Message& from) {
4353   if (&from == this) return;
4354   Clear();
4355   MergeFrom(from);
4356 }
4357
4358 void RspGetSimStatus::CopyFrom(const RspGetSimStatus& from) {
4359   if (&from == this) return;
4360   Clear();
4361   MergeFrom(from);
4362 }
4363
4364 bool RspGetSimStatus::IsInitialized() const {
4365   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
4366
4367   return true;
4368 }
4369
4370 void RspGetSimStatus::Swap(RspGetSimStatus* other) {
4371   if (other != this) {
4372     std::swap(card_status_, other->card_status_);
4373     std::swap(_has_bits_[0], other->_has_bits_[0]);
4374     _unknown_fields_.Swap(&other->_unknown_fields_);
4375     std::swap(_cached_size_, other->_cached_size_);
4376   }
4377 }
4378
4379 ::google::protobuf::Metadata RspGetSimStatus::GetMetadata() const {
4380   protobuf_AssignDescriptorsOnce();
4381   ::google::protobuf::Metadata metadata;
4382   metadata.descriptor = RspGetSimStatus_descriptor_;
4383   metadata.reflection = RspGetSimStatus_reflection_;
4384   return metadata;
4385 }
4386
4387
4388 // ===================================================================
4389
4390 const ::std::string ReqEnterSimPin::_default_pin_;
4391 #ifndef _MSC_VER
4392 const int ReqEnterSimPin::kPinFieldNumber;
4393 #endif  // !_MSC_VER
4394
4395 ReqEnterSimPin::ReqEnterSimPin()
4396   : ::google::protobuf::Message() {
4397   SharedCtor();
4398 }
4399
4400 void ReqEnterSimPin::InitAsDefaultInstance() {
4401 }
4402
4403 ReqEnterSimPin::ReqEnterSimPin(const ReqEnterSimPin& from)
4404   : ::google::protobuf::Message() {
4405   SharedCtor();
4406   MergeFrom(from);
4407 }
4408
4409 void ReqEnterSimPin::SharedCtor() {
4410   _cached_size_ = 0;
4411   pin_ = const_cast< ::std::string*>(&_default_pin_);
4412   ::memset(_has_bits_, 0, sizeof(_has_bits_));
4413 }
4414
4415 ReqEnterSimPin::~ReqEnterSimPin() {
4416   SharedDtor();
4417 }
4418
4419 void ReqEnterSimPin::SharedDtor() {
4420   if (pin_ != &_default_pin_) {
4421     delete pin_;
4422   }
4423   if (this != default_instance_) {
4424   }
4425 }
4426
4427 void ReqEnterSimPin::SetCachedSize(int size) const {
4428   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
4429   _cached_size_ = size;
4430   GOOGLE_SAFE_CONCURRENT_WRITES_END();
4431 }
4432 const ::google::protobuf::Descriptor* ReqEnterSimPin::descriptor() {
4433   protobuf_AssignDescriptorsOnce();
4434   return ReqEnterSimPin_descriptor_;
4435 }
4436
4437 const ReqEnterSimPin& ReqEnterSimPin::default_instance() {
4438   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
4439 }
4440
4441 ReqEnterSimPin* ReqEnterSimPin::default_instance_ = NULL;
4442
4443 ReqEnterSimPin* ReqEnterSimPin::New() const {
4444   return new ReqEnterSimPin;
4445 }
4446
4447 void ReqEnterSimPin::Clear() {
4448   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4449     if (_has_bit(0)) {
4450       if (pin_ != &_default_pin_) {
4451         pin_->clear();
4452       }
4453     }
4454   }
4455   ::memset(_has_bits_, 0, sizeof(_has_bits_));
4456   mutable_unknown_fields()->Clear();
4457 }
4458
4459 bool ReqEnterSimPin::MergePartialFromCodedStream(
4460     ::google::protobuf::io::CodedInputStream* input) {
4461 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
4462   ::google::protobuf::uint32 tag;
4463   while ((tag = input->ReadTag()) != 0) {
4464     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
4465       // required string pin = 1;
4466       case 1: {
4467         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4468             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
4469           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
4470                 input, this->mutable_pin()));
4471           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4472             this->pin().data(), this->pin().length(),
4473             ::google::protobuf::internal::WireFormat::PARSE);
4474         } else {
4475           goto handle_uninterpreted;
4476         }
4477         if (input->ExpectAtEnd()) return true;
4478         break;
4479       }
4480
4481       default: {
4482       handle_uninterpreted:
4483         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4484             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
4485           return true;
4486         }
4487         DO_(::google::protobuf::internal::WireFormat::SkipField(
4488               input, tag, mutable_unknown_fields()));
4489         break;
4490       }
4491     }
4492   }
4493   return true;
4494 #undef DO_
4495 }
4496
4497 void ReqEnterSimPin::SerializeWithCachedSizes(
4498     ::google::protobuf::io::CodedOutputStream* output) const {
4499   // required string pin = 1;
4500   if (_has_bit(0)) {
4501     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4502       this->pin().data(), this->pin().length(),
4503       ::google::protobuf::internal::WireFormat::SERIALIZE);
4504     ::google::protobuf::internal::WireFormatLite::WriteString(
4505       1, this->pin(), output);
4506   }
4507
4508   if (!unknown_fields().empty()) {
4509     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
4510         unknown_fields(), output);
4511   }
4512 }
4513
4514 ::google::protobuf::uint8* ReqEnterSimPin::SerializeWithCachedSizesToArray(
4515     ::google::protobuf::uint8* target) const {
4516   // required string pin = 1;
4517   if (_has_bit(0)) {
4518     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4519       this->pin().data(), this->pin().length(),
4520       ::google::protobuf::internal::WireFormat::SERIALIZE);
4521     target =
4522       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4523         1, this->pin(), target);
4524   }
4525
4526   if (!unknown_fields().empty()) {
4527     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
4528         unknown_fields(), target);
4529   }
4530   return target;
4531 }
4532
4533 int ReqEnterSimPin::ByteSize() const {
4534   int total_size = 0;
4535
4536   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4537     // required string pin = 1;
4538     if (has_pin()) {
4539       total_size += 1 +
4540         ::google::protobuf::internal::WireFormatLite::StringSize(
4541           this->pin());
4542     }
4543
4544   }
4545   if (!unknown_fields().empty()) {
4546     total_size +=
4547       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
4548         unknown_fields());
4549   }
4550   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
4551   _cached_size_ = total_size;
4552   GOOGLE_SAFE_CONCURRENT_WRITES_END();
4553   return total_size;
4554 }
4555
4556 void ReqEnterSimPin::MergeFrom(const ::google::protobuf::Message& from) {
4557   GOOGLE_CHECK_NE(&from, this);
4558   const ReqEnterSimPin* source =
4559     ::google::protobuf::internal::dynamic_cast_if_available<const ReqEnterSimPin*>(
4560       &from);
4561   if (source == NULL) {
4562     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
4563   } else {
4564     MergeFrom(*source);
4565   }
4566 }
4567
4568 void ReqEnterSimPin::MergeFrom(const ReqEnterSimPin& from) {
4569   GOOGLE_CHECK_NE(&from, this);
4570   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4571     if (from._has_bit(0)) {
4572       set_pin(from.pin());
4573     }
4574   }
4575   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
4576 }
4577
4578 void ReqEnterSimPin::CopyFrom(const ::google::protobuf::Message& from) {
4579   if (&from == this) return;
4580   Clear();
4581   MergeFrom(from);
4582 }
4583
4584 void ReqEnterSimPin::CopyFrom(const ReqEnterSimPin& from) {
4585   if (&from == this) return;
4586   Clear();
4587   MergeFrom(from);
4588 }
4589
4590 bool ReqEnterSimPin::IsInitialized() const {
4591   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
4592
4593   return true;
4594 }
4595
4596 void ReqEnterSimPin::Swap(ReqEnterSimPin* other) {
4597   if (other != this) {
4598     std::swap(pin_, other->pin_);
4599     std::swap(_has_bits_[0], other->_has_bits_[0]);
4600     _unknown_fields_.Swap(&other->_unknown_fields_);
4601     std::swap(_cached_size_, other->_cached_size_);
4602   }
4603 }
4604
4605 ::google::protobuf::Metadata ReqEnterSimPin::GetMetadata() const {
4606   protobuf_AssignDescriptorsOnce();
4607   ::google::protobuf::Metadata metadata;
4608   metadata.descriptor = ReqEnterSimPin_descriptor_;
4609   metadata.reflection = ReqEnterSimPin_reflection_;
4610   return metadata;
4611 }
4612
4613
4614 // ===================================================================
4615
4616 #ifndef _MSC_VER
4617 const int RspEnterSimPin::kRetriesRemainingFieldNumber;
4618 #endif  // !_MSC_VER
4619
4620 RspEnterSimPin::RspEnterSimPin()
4621   : ::google::protobuf::Message() {
4622   SharedCtor();
4623 }
4624
4625 void RspEnterSimPin::InitAsDefaultInstance() {
4626 }
4627
4628 RspEnterSimPin::RspEnterSimPin(const RspEnterSimPin& from)
4629   : ::google::protobuf::Message() {
4630   SharedCtor();
4631   MergeFrom(from);
4632 }
4633
4634 void RspEnterSimPin::SharedCtor() {
4635   _cached_size_ = 0;
4636   retries_remaining_ = 0;
4637   ::memset(_has_bits_, 0, sizeof(_has_bits_));
4638 }
4639
4640 RspEnterSimPin::~RspEnterSimPin() {
4641   SharedDtor();
4642 }
4643
4644 void RspEnterSimPin::SharedDtor() {
4645   if (this != default_instance_) {
4646   }
4647 }
4648
4649 void RspEnterSimPin::SetCachedSize(int size) const {
4650   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
4651   _cached_size_ = size;
4652   GOOGLE_SAFE_CONCURRENT_WRITES_END();
4653 }
4654 const ::google::protobuf::Descriptor* RspEnterSimPin::descriptor() {
4655   protobuf_AssignDescriptorsOnce();
4656   return RspEnterSimPin_descriptor_;
4657 }
4658
4659 const RspEnterSimPin& RspEnterSimPin::default_instance() {
4660   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
4661 }
4662
4663 RspEnterSimPin* RspEnterSimPin::default_instance_ = NULL;
4664
4665 RspEnterSimPin* RspEnterSimPin::New() const {
4666   return new RspEnterSimPin;
4667 }
4668
4669 void RspEnterSimPin::Clear() {
4670   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4671     retries_remaining_ = 0;
4672   }
4673   ::memset(_has_bits_, 0, sizeof(_has_bits_));
4674   mutable_unknown_fields()->Clear();
4675 }
4676
4677 bool RspEnterSimPin::MergePartialFromCodedStream(
4678     ::google::protobuf::io::CodedInputStream* input) {
4679 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
4680   ::google::protobuf::uint32 tag;
4681   while ((tag = input->ReadTag()) != 0) {
4682     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
4683       // required int32 retries_remaining = 1;
4684       case 1: {
4685         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4686             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
4687           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
4688                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
4689                  input, &retries_remaining_)));
4690           _set_bit(0);
4691         } else {
4692           goto handle_uninterpreted;
4693         }
4694         if (input->ExpectAtEnd()) return true;
4695         break;
4696       }
4697
4698       default: {
4699       handle_uninterpreted:
4700         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4701             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
4702           return true;
4703         }
4704         DO_(::google::protobuf::internal::WireFormat::SkipField(
4705               input, tag, mutable_unknown_fields()));
4706         break;
4707       }
4708     }
4709   }
4710   return true;
4711 #undef DO_
4712 }
4713
4714 void RspEnterSimPin::SerializeWithCachedSizes(
4715     ::google::protobuf::io::CodedOutputStream* output) const {
4716   // required int32 retries_remaining = 1;
4717   if (_has_bit(0)) {
4718     ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->retries_remaining(), output);
4719   }
4720
4721   if (!unknown_fields().empty()) {
4722     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
4723         unknown_fields(), output);
4724   }
4725 }
4726
4727 ::google::protobuf::uint8* RspEnterSimPin::SerializeWithCachedSizesToArray(
4728     ::google::protobuf::uint8* target) const {
4729   // required int32 retries_remaining = 1;
4730   if (_has_bit(0)) {
4731     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->retries_remaining(), target);
4732   }
4733
4734   if (!unknown_fields().empty()) {
4735     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
4736         unknown_fields(), target);
4737   }
4738   return target;
4739 }
4740
4741 int RspEnterSimPin::ByteSize() const {
4742   int total_size = 0;
4743
4744   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4745     // required int32 retries_remaining = 1;
4746     if (has_retries_remaining()) {
4747       total_size += 1 +
4748         ::google::protobuf::internal::WireFormatLite::Int32Size(
4749           this->retries_remaining());
4750     }
4751
4752   }
4753   if (!unknown_fields().empty()) {
4754     total_size +=
4755       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
4756         unknown_fields());
4757   }
4758   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
4759   _cached_size_ = total_size;
4760   GOOGLE_SAFE_CONCURRENT_WRITES_END();
4761   return total_size;
4762 }
4763
4764 void RspEnterSimPin::MergeFrom(const ::google::protobuf::Message& from) {
4765   GOOGLE_CHECK_NE(&from, this);
4766   const RspEnterSimPin* source =
4767     ::google::protobuf::internal::dynamic_cast_if_available<const RspEnterSimPin*>(
4768       &from);
4769   if (source == NULL) {
4770     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
4771   } else {
4772     MergeFrom(*source);
4773   }
4774 }
4775
4776 void RspEnterSimPin::MergeFrom(const RspEnterSimPin& from) {
4777   GOOGLE_CHECK_NE(&from, this);
4778   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4779     if (from._has_bit(0)) {
4780       set_retries_remaining(from.retries_remaining());
4781     }
4782   }
4783   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
4784 }
4785
4786 void RspEnterSimPin::CopyFrom(const ::google::protobuf::Message& from) {
4787   if (&from == this) return;
4788   Clear();
4789   MergeFrom(from);
4790 }
4791
4792 void RspEnterSimPin::CopyFrom(const RspEnterSimPin& from) {
4793   if (&from == this) return;
4794   Clear();
4795   MergeFrom(from);
4796 }
4797
4798 bool RspEnterSimPin::IsInitialized() const {
4799   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
4800
4801   return true;
4802 }
4803
4804 void RspEnterSimPin::Swap(RspEnterSimPin* other) {
4805   if (other != this) {
4806     std::swap(retries_remaining_, other->retries_remaining_);
4807     std::swap(_has_bits_[0], other->_has_bits_[0]);
4808     _unknown_fields_.Swap(&other->_unknown_fields_);
4809     std::swap(_cached_size_, other->_cached_size_);
4810   }
4811 }
4812
4813 ::google::protobuf::Metadata RspEnterSimPin::GetMetadata() const {
4814   protobuf_AssignDescriptorsOnce();
4815   ::google::protobuf::Metadata metadata;
4816   metadata.descriptor = RspEnterSimPin_descriptor_;
4817   metadata.reflection = RspEnterSimPin_reflection_;
4818   return metadata;
4819 }
4820
4821
4822 // ===================================================================
4823
4824 #ifndef _MSC_VER
4825 const int RspGetCurrentCalls::kCallsFieldNumber;
4826 #endif  // !_MSC_VER
4827
4828 RspGetCurrentCalls::RspGetCurrentCalls()
4829   : ::google::protobuf::Message() {
4830   SharedCtor();
4831 }
4832
4833 void RspGetCurrentCalls::InitAsDefaultInstance() {
4834 }
4835
4836 RspGetCurrentCalls::RspGetCurrentCalls(const RspGetCurrentCalls& from)
4837   : ::google::protobuf::Message() {
4838   SharedCtor();
4839   MergeFrom(from);
4840 }
4841
4842 void RspGetCurrentCalls::SharedCtor() {
4843   _cached_size_ = 0;
4844   ::memset(_has_bits_, 0, sizeof(_has_bits_));
4845 }
4846
4847 RspGetCurrentCalls::~RspGetCurrentCalls() {
4848   SharedDtor();
4849 }
4850
4851 void RspGetCurrentCalls::SharedDtor() {
4852   if (this != default_instance_) {
4853   }
4854 }
4855
4856 void RspGetCurrentCalls::SetCachedSize(int size) const {
4857   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
4858   _cached_size_ = size;
4859   GOOGLE_SAFE_CONCURRENT_WRITES_END();
4860 }
4861 const ::google::protobuf::Descriptor* RspGetCurrentCalls::descriptor() {
4862   protobuf_AssignDescriptorsOnce();
4863   return RspGetCurrentCalls_descriptor_;
4864 }
4865
4866 const RspGetCurrentCalls& RspGetCurrentCalls::default_instance() {
4867   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
4868 }
4869
4870 RspGetCurrentCalls* RspGetCurrentCalls::default_instance_ = NULL;
4871
4872 RspGetCurrentCalls* RspGetCurrentCalls::New() const {
4873   return new RspGetCurrentCalls;
4874 }
4875
4876 void RspGetCurrentCalls::Clear() {
4877   calls_.Clear();
4878   ::memset(_has_bits_, 0, sizeof(_has_bits_));
4879   mutable_unknown_fields()->Clear();
4880 }
4881
4882 bool RspGetCurrentCalls::MergePartialFromCodedStream(
4883     ::google::protobuf::io::CodedInputStream* input) {
4884 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
4885   ::google::protobuf::uint32 tag;
4886   while ((tag = input->ReadTag()) != 0) {
4887     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
4888       // repeated .ril_proto.RilCall calls = 1;
4889       case 1: {
4890         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4891             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
4892          parse_calls:
4893           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
4894                 input, add_calls()));
4895         } else {
4896           goto handle_uninterpreted;
4897         }
4898         if (input->ExpectTag(10)) goto parse_calls;
4899         if (input->ExpectAtEnd()) return true;
4900         break;
4901       }
4902
4903       default: {
4904       handle_uninterpreted:
4905         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4906             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
4907           return true;
4908         }
4909         DO_(::google::protobuf::internal::WireFormat::SkipField(
4910               input, tag, mutable_unknown_fields()));
4911         break;
4912       }
4913     }
4914   }
4915   return true;
4916 #undef DO_
4917 }
4918
4919 void RspGetCurrentCalls::SerializeWithCachedSizes(
4920     ::google::protobuf::io::CodedOutputStream* output) const {
4921   // repeated .ril_proto.RilCall calls = 1;
4922   for (int i = 0; i < this->calls_size(); i++) {
4923     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
4924       1, this->calls(i), output);
4925   }
4926
4927   if (!unknown_fields().empty()) {
4928     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
4929         unknown_fields(), output);
4930   }
4931 }
4932
4933 ::google::protobuf::uint8* RspGetCurrentCalls::SerializeWithCachedSizesToArray(
4934     ::google::protobuf::uint8* target) const {
4935   // repeated .ril_proto.RilCall calls = 1;
4936   for (int i = 0; i < this->calls_size(); i++) {
4937     target = ::google::protobuf::internal::WireFormatLite::
4938       WriteMessageNoVirtualToArray(
4939         1, this->calls(i), target);
4940   }
4941
4942   if (!unknown_fields().empty()) {
4943     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
4944         unknown_fields(), target);
4945   }
4946   return target;
4947 }
4948
4949 int RspGetCurrentCalls::ByteSize() const {
4950   int total_size = 0;
4951
4952   // repeated .ril_proto.RilCall calls = 1;
4953   total_size += 1 * this->calls_size();
4954   for (int i = 0; i < this->calls_size(); i++) {
4955     total_size +=
4956       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
4957         this->calls(i));
4958   }
4959
4960   if (!unknown_fields().empty()) {
4961     total_size +=
4962       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
4963         unknown_fields());
4964   }
4965   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
4966   _cached_size_ = total_size;
4967   GOOGLE_SAFE_CONCURRENT_WRITES_END();
4968   return total_size;
4969 }
4970
4971 void RspGetCurrentCalls::MergeFrom(const ::google::protobuf::Message& from) {
4972   GOOGLE_CHECK_NE(&from, this);
4973   const RspGetCurrentCalls* source =
4974     ::google::protobuf::internal::dynamic_cast_if_available<const RspGetCurrentCalls*>(
4975       &from);
4976   if (source == NULL) {
4977     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
4978   } else {
4979     MergeFrom(*source);
4980   }
4981 }
4982
4983 void RspGetCurrentCalls::MergeFrom(const RspGetCurrentCalls& from) {
4984   GOOGLE_CHECK_NE(&from, this);
4985   calls_.MergeFrom(from.calls_);
4986   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
4987 }
4988
4989 void RspGetCurrentCalls::CopyFrom(const ::google::protobuf::Message& from) {
4990   if (&from == this) return;
4991   Clear();
4992   MergeFrom(from);
4993 }
4994
4995 void RspGetCurrentCalls::CopyFrom(const RspGetCurrentCalls& from) {
4996   if (&from == this) return;
4997   Clear();
4998   MergeFrom(from);
4999 }
5000
5001 bool RspGetCurrentCalls::IsInitialized() const {
5002
5003   return true;
5004 }
5005
5006 void RspGetCurrentCalls::Swap(RspGetCurrentCalls* other) {
5007   if (other != this) {
5008     calls_.Swap(&other->calls_);
5009     std::swap(_has_bits_[0], other->_has_bits_[0]);
5010     _unknown_fields_.Swap(&other->_unknown_fields_);
5011     std::swap(_cached_size_, other->_cached_size_);
5012   }
5013 }
5014
5015 ::google::protobuf::Metadata RspGetCurrentCalls::GetMetadata() const {
5016   protobuf_AssignDescriptorsOnce();
5017   ::google::protobuf::Metadata metadata;
5018   metadata.descriptor = RspGetCurrentCalls_descriptor_;
5019   metadata.reflection = RspGetCurrentCalls_reflection_;
5020   return metadata;
5021 }
5022
5023
5024 // ===================================================================
5025
5026 const ::std::string ReqDial::_default_address_;
5027 #ifndef _MSC_VER
5028 const int ReqDial::kAddressFieldNumber;
5029 const int ReqDial::kClirFieldNumber;
5030 const int ReqDial::kUusInfoFieldNumber;
5031 #endif  // !_MSC_VER
5032
5033 ReqDial::ReqDial()
5034   : ::google::protobuf::Message() {
5035   SharedCtor();
5036 }
5037
5038 void ReqDial::InitAsDefaultInstance() {
5039   uus_info_ = const_cast< ::ril_proto::RilUusInfo*>(&::ril_proto::RilUusInfo::default_instance());
5040 }
5041
5042 ReqDial::ReqDial(const ReqDial& from)
5043   : ::google::protobuf::Message() {
5044   SharedCtor();
5045   MergeFrom(from);
5046 }
5047
5048 void ReqDial::SharedCtor() {
5049   _cached_size_ = 0;
5050   address_ = const_cast< ::std::string*>(&_default_address_);
5051   clir_ = 0;
5052   uus_info_ = NULL;
5053   ::memset(_has_bits_, 0, sizeof(_has_bits_));
5054 }
5055
5056 ReqDial::~ReqDial() {
5057   SharedDtor();
5058 }
5059
5060 void ReqDial::SharedDtor() {
5061   if (address_ != &_default_address_) {
5062     delete address_;
5063   }
5064   if (this != default_instance_) {
5065     delete uus_info_;
5066   }
5067 }
5068
5069 void ReqDial::SetCachedSize(int size) const {
5070   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
5071   _cached_size_ = size;
5072   GOOGLE_SAFE_CONCURRENT_WRITES_END();
5073 }
5074 const ::google::protobuf::Descriptor* ReqDial::descriptor() {
5075   protobuf_AssignDescriptorsOnce();
5076   return ReqDial_descriptor_;
5077 }
5078
5079 const ReqDial& ReqDial::default_instance() {
5080   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
5081 }
5082
5083 ReqDial* ReqDial::default_instance_ = NULL;
5084
5085 ReqDial* ReqDial::New() const {
5086   return new ReqDial;
5087 }
5088
5089 void ReqDial::Clear() {
5090   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5091     if (_has_bit(0)) {
5092       if (address_ != &_default_address_) {
5093         address_->clear();
5094       }
5095     }
5096     clir_ = 0;
5097     if (_has_bit(2)) {
5098       if (uus_info_ != NULL) uus_info_->::ril_proto::RilUusInfo::Clear();
5099     }
5100   }
5101   ::memset(_has_bits_, 0, sizeof(_has_bits_));
5102   mutable_unknown_fields()->Clear();
5103 }
5104
5105 bool ReqDial::MergePartialFromCodedStream(
5106     ::google::protobuf::io::CodedInputStream* input) {
5107 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
5108   ::google::protobuf::uint32 tag;
5109   while ((tag = input->ReadTag()) != 0) {
5110     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
5111       // optional string address = 1;
5112       case 1: {
5113         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5114             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
5115           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
5116                 input, this->mutable_address()));
5117           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
5118             this->address().data(), this->address().length(),
5119             ::google::protobuf::internal::WireFormat::PARSE);
5120         } else {
5121           goto handle_uninterpreted;
5122         }
5123         if (input->ExpectTag(16)) goto parse_clir;
5124         break;
5125       }
5126
5127       // optional int32 clir = 2;
5128       case 2: {
5129         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5130             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
5131          parse_clir:
5132           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5133                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
5134                  input, &clir_)));
5135           _set_bit(1);
5136         } else {
5137           goto handle_uninterpreted;
5138         }
5139         if (input->ExpectTag(26)) goto parse_uus_info;
5140         break;
5141       }
5142
5143       // optional .ril_proto.RilUusInfo uus_info = 3;
5144       case 3: {
5145         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5146             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
5147          parse_uus_info:
5148           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
5149                input, mutable_uus_info()));
5150         } else {
5151           goto handle_uninterpreted;
5152         }
5153         if (input->ExpectAtEnd()) return true;
5154         break;
5155       }
5156
5157       default: {
5158       handle_uninterpreted:
5159         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5160             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
5161           return true;
5162         }
5163         DO_(::google::protobuf::internal::WireFormat::SkipField(
5164               input, tag, mutable_unknown_fields()));
5165         break;
5166       }
5167     }
5168   }
5169   return true;
5170 #undef DO_
5171 }
5172
5173 void ReqDial::SerializeWithCachedSizes(
5174     ::google::protobuf::io::CodedOutputStream* output) const {
5175   // optional string address = 1;
5176   if (_has_bit(0)) {
5177     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
5178       this->address().data(), this->address().length(),
5179       ::google::protobuf::internal::WireFormat::SERIALIZE);
5180     ::google::protobuf::internal::WireFormatLite::WriteString(
5181       1, this->address(), output);
5182   }
5183
5184   // optional int32 clir = 2;
5185   if (_has_bit(1)) {
5186     ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->clir(), output);
5187   }
5188
5189   // optional .ril_proto.RilUusInfo uus_info = 3;
5190   if (_has_bit(2)) {
5191     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
5192       3, this->uus_info(), output);
5193   }
5194
5195   if (!unknown_fields().empty()) {
5196     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
5197         unknown_fields(), output);
5198   }
5199 }
5200
5201 ::google::protobuf::uint8* ReqDial::SerializeWithCachedSizesToArray(
5202     ::google::protobuf::uint8* target) const {
5203   // optional string address = 1;
5204   if (_has_bit(0)) {
5205     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
5206       this->address().data(), this->address().length(),
5207       ::google::protobuf::internal::WireFormat::SERIALIZE);
5208     target =
5209       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
5210         1, this->address(), target);
5211   }
5212
5213   // optional int32 clir = 2;
5214   if (_has_bit(1)) {
5215     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->clir(), target);
5216   }
5217
5218   // optional .ril_proto.RilUusInfo uus_info = 3;
5219   if (_has_bit(2)) {
5220     target = ::google::protobuf::internal::WireFormatLite::
5221       WriteMessageNoVirtualToArray(
5222         3, this->uus_info(), target);
5223   }
5224
5225   if (!unknown_fields().empty()) {
5226     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
5227         unknown_fields(), target);
5228   }
5229   return target;
5230 }
5231
5232 int ReqDial::ByteSize() const {
5233   int total_size = 0;
5234
5235   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5236     // optional string address = 1;
5237     if (has_address()) {
5238       total_size += 1 +
5239         ::google::protobuf::internal::WireFormatLite::StringSize(
5240           this->address());
5241     }
5242
5243     // optional int32 clir = 2;
5244     if (has_clir()) {
5245       total_size += 1 +
5246         ::google::protobuf::internal::WireFormatLite::Int32Size(
5247           this->clir());
5248     }
5249
5250     // optional .ril_proto.RilUusInfo uus_info = 3;
5251     if (has_uus_info()) {
5252       total_size += 1 +
5253         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
5254           this->uus_info());
5255     }
5256
5257   }
5258   if (!unknown_fields().empty()) {
5259     total_size +=
5260       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
5261         unknown_fields());
5262   }
5263   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
5264   _cached_size_ = total_size;
5265   GOOGLE_SAFE_CONCURRENT_WRITES_END();
5266   return total_size;
5267 }
5268
5269 void ReqDial::MergeFrom(const ::google::protobuf::Message& from) {
5270   GOOGLE_CHECK_NE(&from, this);
5271   const ReqDial* source =
5272     ::google::protobuf::internal::dynamic_cast_if_available<const ReqDial*>(
5273       &from);
5274   if (source == NULL) {
5275     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
5276   } else {
5277     MergeFrom(*source);
5278   }
5279 }
5280
5281 void ReqDial::MergeFrom(const ReqDial& from) {
5282   GOOGLE_CHECK_NE(&from, this);
5283   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5284     if (from._has_bit(0)) {
5285       set_address(from.address());
5286     }
5287     if (from._has_bit(1)) {
5288       set_clir(from.clir());
5289     }
5290     if (from._has_bit(2)) {
5291       mutable_uus_info()->::ril_proto::RilUusInfo::MergeFrom(from.uus_info());
5292     }
5293   }
5294   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
5295 }
5296
5297 void ReqDial::CopyFrom(const ::google::protobuf::Message& from) {
5298   if (&from == this) return;
5299   Clear();
5300   MergeFrom(from);
5301 }
5302
5303 void ReqDial::CopyFrom(const ReqDial& from) {
5304   if (&from == this) return;
5305   Clear();
5306   MergeFrom(from);
5307 }
5308
5309 bool ReqDial::IsInitialized() const {
5310
5311   return true;
5312 }
5313
5314 void ReqDial::Swap(ReqDial* other) {
5315   if (other != this) {
5316     std::swap(address_, other->address_);
5317     std::swap(clir_, other->clir_);
5318     std::swap(uus_info_, other->uus_info_);
5319     std::swap(_has_bits_[0], other->_has_bits_[0]);
5320     _unknown_fields_.Swap(&other->_unknown_fields_);
5321     std::swap(_cached_size_, other->_cached_size_);
5322   }
5323 }
5324
5325 ::google::protobuf::Metadata ReqDial::GetMetadata() const {
5326   protobuf_AssignDescriptorsOnce();
5327   ::google::protobuf::Metadata metadata;
5328   metadata.descriptor = ReqDial_descriptor_;
5329   metadata.reflection = ReqDial_reflection_;
5330   return metadata;
5331 }
5332
5333
5334 // ===================================================================
5335
5336 #ifndef _MSC_VER
5337 const int ReqHangUp::kConnectionIndexFieldNumber;
5338 #endif  // !_MSC_VER
5339
5340 ReqHangUp::ReqHangUp()
5341   : ::google::protobuf::Message() {
5342   SharedCtor();
5343 }
5344
5345 void ReqHangUp::InitAsDefaultInstance() {
5346 }
5347
5348 ReqHangUp::ReqHangUp(const ReqHangUp& from)
5349   : ::google::protobuf::Message() {
5350   SharedCtor();
5351   MergeFrom(from);
5352 }
5353
5354 void ReqHangUp::SharedCtor() {
5355   _cached_size_ = 0;
5356   connection_index_ = 0;
5357   ::memset(_has_bits_, 0, sizeof(_has_bits_));
5358 }
5359
5360 ReqHangUp::~ReqHangUp() {
5361   SharedDtor();
5362 }
5363
5364 void ReqHangUp::SharedDtor() {
5365   if (this != default_instance_) {
5366   }
5367 }
5368
5369 void ReqHangUp::SetCachedSize(int size) const {
5370   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
5371   _cached_size_ = size;
5372   GOOGLE_SAFE_CONCURRENT_WRITES_END();
5373 }
5374 const ::google::protobuf::Descriptor* ReqHangUp::descriptor() {
5375   protobuf_AssignDescriptorsOnce();
5376   return ReqHangUp_descriptor_;
5377 }
5378
5379 const ReqHangUp& ReqHangUp::default_instance() {
5380   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
5381 }
5382
5383 ReqHangUp* ReqHangUp::default_instance_ = NULL;
5384
5385 ReqHangUp* ReqHangUp::New() const {
5386   return new ReqHangUp;
5387 }
5388
5389 void ReqHangUp::Clear() {
5390   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5391     connection_index_ = 0;
5392   }
5393   ::memset(_has_bits_, 0, sizeof(_has_bits_));
5394   mutable_unknown_fields()->Clear();
5395 }
5396
5397 bool ReqHangUp::MergePartialFromCodedStream(
5398     ::google::protobuf::io::CodedInputStream* input) {
5399 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
5400   ::google::protobuf::uint32 tag;
5401   while ((tag = input->ReadTag()) != 0) {
5402     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
5403       // required int32 connection_index = 1;
5404       case 1: {
5405         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5406             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
5407           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5408                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
5409                  input, &connection_index_)));
5410           _set_bit(0);
5411         } else {
5412           goto handle_uninterpreted;
5413         }
5414         if (input->ExpectAtEnd()) return true;
5415         break;
5416       }
5417
5418       default: {
5419       handle_uninterpreted:
5420         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5421             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
5422           return true;
5423         }
5424         DO_(::google::protobuf::internal::WireFormat::SkipField(
5425               input, tag, mutable_unknown_fields()));
5426         break;
5427       }
5428     }
5429   }
5430   return true;
5431 #undef DO_
5432 }
5433
5434 void ReqHangUp::SerializeWithCachedSizes(
5435     ::google::protobuf::io::CodedOutputStream* output) const {
5436   // required int32 connection_index = 1;
5437   if (_has_bit(0)) {
5438     ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->connection_index(), output);
5439   }
5440
5441   if (!unknown_fields().empty()) {
5442     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
5443         unknown_fields(), output);
5444   }
5445 }
5446
5447 ::google::protobuf::uint8* ReqHangUp::SerializeWithCachedSizesToArray(
5448     ::google::protobuf::uint8* target) const {
5449   // required int32 connection_index = 1;
5450   if (_has_bit(0)) {
5451     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->connection_index(), target);
5452   }
5453
5454   if (!unknown_fields().empty()) {
5455     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
5456         unknown_fields(), target);
5457   }
5458   return target;
5459 }
5460
5461 int ReqHangUp::ByteSize() const {
5462   int total_size = 0;
5463
5464   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5465     // required int32 connection_index = 1;
5466     if (has_connection_index()) {
5467       total_size += 1 +
5468         ::google::protobuf::internal::WireFormatLite::Int32Size(
5469           this->connection_index());
5470     }
5471
5472   }
5473   if (!unknown_fields().empty()) {
5474     total_size +=
5475       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
5476         unknown_fields());
5477   }
5478   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
5479   _cached_size_ = total_size;
5480   GOOGLE_SAFE_CONCURRENT_WRITES_END();
5481   return total_size;
5482 }
5483
5484 void ReqHangUp::MergeFrom(const ::google::protobuf::Message& from) {
5485   GOOGLE_CHECK_NE(&from, this);
5486   const ReqHangUp* source =
5487     ::google::protobuf::internal::dynamic_cast_if_available<const ReqHangUp*>(
5488       &from);
5489   if (source == NULL) {
5490     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
5491   } else {
5492     MergeFrom(*source);
5493   }
5494 }
5495
5496 void ReqHangUp::MergeFrom(const ReqHangUp& from) {
5497   GOOGLE_CHECK_NE(&from, this);
5498   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5499     if (from._has_bit(0)) {
5500       set_connection_index(from.connection_index());
5501     }
5502   }
5503   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
5504 }
5505
5506 void ReqHangUp::CopyFrom(const ::google::protobuf::Message& from) {
5507   if (&from == this) return;
5508   Clear();
5509   MergeFrom(from);
5510 }
5511
5512 void ReqHangUp::CopyFrom(const ReqHangUp& from) {
5513   if (&from == this) return;
5514   Clear();
5515   MergeFrom(from);
5516 }
5517
5518 bool ReqHangUp::IsInitialized() const {
5519   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
5520
5521   return true;
5522 }
5523
5524 void ReqHangUp::Swap(ReqHangUp* other) {
5525   if (other != this) {
5526     std::swap(connection_index_, other->connection_index_);
5527     std::swap(_has_bits_[0], other->_has_bits_[0]);
5528     _unknown_fields_.Swap(&other->_unknown_fields_);
5529     std::swap(_cached_size_, other->_cached_size_);
5530   }
5531 }
5532
5533 ::google::protobuf::Metadata ReqHangUp::GetMetadata() const {
5534   protobuf_AssignDescriptorsOnce();
5535   ::google::protobuf::Metadata metadata;
5536   metadata.descriptor = ReqHangUp_descriptor_;
5537   metadata.reflection = ReqHangUp_reflection_;
5538   return metadata;
5539 }
5540
5541
5542 // ===================================================================
5543
5544 #ifndef _MSC_VER
5545 const int RspLastCallFailCause::kLastCallFailCauseFieldNumber;
5546 #endif  // !_MSC_VER
5547
5548 RspLastCallFailCause::RspLastCallFailCause()
5549   : ::google::protobuf::Message() {
5550   SharedCtor();
5551 }
5552
5553 void RspLastCallFailCause::InitAsDefaultInstance() {
5554 }
5555
5556 RspLastCallFailCause::RspLastCallFailCause(const RspLastCallFailCause& from)
5557   : ::google::protobuf::Message() {
5558   SharedCtor();
5559   MergeFrom(from);
5560 }
5561
5562 void RspLastCallFailCause::SharedCtor() {
5563   _cached_size_ = 0;
5564   last_call_fail_cause_ = 0;
5565   ::memset(_has_bits_, 0, sizeof(_has_bits_));
5566 }
5567
5568 RspLastCallFailCause::~RspLastCallFailCause() {
5569   SharedDtor();
5570 }
5571
5572 void RspLastCallFailCause::SharedDtor() {
5573   if (this != default_instance_) {
5574   }
5575 }
5576
5577 void RspLastCallFailCause::SetCachedSize(int size) const {
5578   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
5579   _cached_size_ = size;
5580   GOOGLE_SAFE_CONCURRENT_WRITES_END();
5581 }
5582 const ::google::protobuf::Descriptor* RspLastCallFailCause::descriptor() {
5583   protobuf_AssignDescriptorsOnce();
5584   return RspLastCallFailCause_descriptor_;
5585 }
5586
5587 const RspLastCallFailCause& RspLastCallFailCause::default_instance() {
5588   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
5589 }
5590
5591 RspLastCallFailCause* RspLastCallFailCause::default_instance_ = NULL;
5592
5593 RspLastCallFailCause* RspLastCallFailCause::New() const {
5594   return new RspLastCallFailCause;
5595 }
5596
5597 void RspLastCallFailCause::Clear() {
5598   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5599     last_call_fail_cause_ = 0;
5600   }
5601   ::memset(_has_bits_, 0, sizeof(_has_bits_));
5602   mutable_unknown_fields()->Clear();
5603 }
5604
5605 bool RspLastCallFailCause::MergePartialFromCodedStream(
5606     ::google::protobuf::io::CodedInputStream* input) {
5607 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
5608   ::google::protobuf::uint32 tag;
5609   while ((tag = input->ReadTag()) != 0) {
5610     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
5611       // required int32 last_call_fail_cause = 1;
5612       case 1: {
5613         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5614             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
5615           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5616                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
5617                  input, &last_call_fail_cause_)));
5618           _set_bit(0);
5619         } else {
5620           goto handle_uninterpreted;
5621         }
5622         if (input->ExpectAtEnd()) return true;
5623         break;
5624       }
5625
5626       default: {
5627       handle_uninterpreted:
5628         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5629             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
5630           return true;
5631         }
5632         DO_(::google::protobuf::internal::WireFormat::SkipField(
5633               input, tag, mutable_unknown_fields()));
5634         break;
5635       }
5636     }
5637   }
5638   return true;
5639 #undef DO_
5640 }
5641
5642 void RspLastCallFailCause::SerializeWithCachedSizes(
5643     ::google::protobuf::io::CodedOutputStream* output) const {
5644   // required int32 last_call_fail_cause = 1;
5645   if (_has_bit(0)) {
5646     ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->last_call_fail_cause(), output);
5647   }
5648
5649   if (!unknown_fields().empty()) {
5650     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
5651         unknown_fields(), output);
5652   }
5653 }
5654
5655 ::google::protobuf::uint8* RspLastCallFailCause::SerializeWithCachedSizesToArray(
5656     ::google::protobuf::uint8* target) const {
5657   // required int32 last_call_fail_cause = 1;
5658   if (_has_bit(0)) {
5659     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->last_call_fail_cause(), target);
5660   }
5661
5662   if (!unknown_fields().empty()) {
5663     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
5664         unknown_fields(), target);
5665   }
5666   return target;
5667 }
5668
5669 int RspLastCallFailCause::ByteSize() const {
5670   int total_size = 0;
5671
5672   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5673     // required int32 last_call_fail_cause = 1;
5674     if (has_last_call_fail_cause()) {
5675       total_size += 1 +
5676         ::google::protobuf::internal::WireFormatLite::Int32Size(
5677           this->last_call_fail_cause());
5678     }
5679
5680   }
5681   if (!unknown_fields().empty()) {
5682     total_size +=
5683       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
5684         unknown_fields());
5685   }
5686   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
5687   _cached_size_ = total_size;
5688   GOOGLE_SAFE_CONCURRENT_WRITES_END();
5689   return total_size;
5690 }
5691
5692 void RspLastCallFailCause::MergeFrom(const ::google::protobuf::Message& from) {
5693   GOOGLE_CHECK_NE(&from, this);
5694   const RspLastCallFailCause* source =
5695     ::google::protobuf::internal::dynamic_cast_if_available<const RspLastCallFailCause*>(
5696       &from);
5697   if (source == NULL) {
5698     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
5699   } else {
5700     MergeFrom(*source);
5701   }
5702 }
5703
5704 void RspLastCallFailCause::MergeFrom(const RspLastCallFailCause& from) {
5705   GOOGLE_CHECK_NE(&from, this);
5706   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5707     if (from._has_bit(0)) {
5708       set_last_call_fail_cause(from.last_call_fail_cause());
5709     }
5710   }
5711   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
5712 }
5713
5714 void RspLastCallFailCause::CopyFrom(const ::google::protobuf::Message& from) {
5715   if (&from == this) return;
5716   Clear();
5717   MergeFrom(from);
5718 }
5719
5720 void RspLastCallFailCause::CopyFrom(const RspLastCallFailCause& from) {
5721   if (&from == this) return;
5722   Clear();
5723   MergeFrom(from);
5724 }
5725
5726 bool RspLastCallFailCause::IsInitialized() const {
5727   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
5728
5729   return true;
5730 }
5731
5732 void RspLastCallFailCause::Swap(RspLastCallFailCause* other) {
5733   if (other != this) {
5734     std::swap(last_call_fail_cause_, other->last_call_fail_cause_);
5735     std::swap(_has_bits_[0], other->_has_bits_[0]);
5736     _unknown_fields_.Swap(&other->_unknown_fields_);
5737     std::swap(_cached_size_, other->_cached_size_);
5738   }
5739 }
5740
5741 ::google::protobuf::Metadata RspLastCallFailCause::GetMetadata() const {
5742   protobuf_AssignDescriptorsOnce();
5743   ::google::protobuf::Metadata metadata;
5744   metadata.descriptor = RspLastCallFailCause_descriptor_;
5745   metadata.reflection = RspLastCallFailCause_reflection_;
5746   return metadata;
5747 }
5748
5749
5750 // ===================================================================
5751
5752 #ifndef _MSC_VER
5753 const int RspSignalStrength::kGwSignalstrengthFieldNumber;
5754 const int RspSignalStrength::kCdmaSignalstrengthFieldNumber;
5755 const int RspSignalStrength::kEvdoSignalstrengthFieldNumber;
5756 #endif  // !_MSC_VER
5757
5758 RspSignalStrength::RspSignalStrength()
5759   : ::google::protobuf::Message() {
5760   SharedCtor();
5761 }
5762
5763 void RspSignalStrength::InitAsDefaultInstance() {
5764   gw_signalstrength_ = const_cast< ::ril_proto::RILGWSignalStrength*>(&::ril_proto::RILGWSignalStrength::default_instance());
5765   cdma_signalstrength_ = const_cast< ::ril_proto::RILCDMASignalStrength*>(&::ril_proto::RILCDMASignalStrength::default_instance());
5766   evdo_signalstrength_ = const_cast< ::ril_proto::RILEVDOSignalStrength*>(&::ril_proto::RILEVDOSignalStrength::default_instance());
5767 }
5768
5769 RspSignalStrength::RspSignalStrength(const RspSignalStrength& from)
5770   : ::google::protobuf::Message() {
5771   SharedCtor();
5772   MergeFrom(from);
5773 }
5774
5775 void RspSignalStrength::SharedCtor() {
5776   _cached_size_ = 0;
5777   gw_signalstrength_ = NULL;
5778   cdma_signalstrength_ = NULL;
5779   evdo_signalstrength_ = NULL;
5780   ::memset(_has_bits_, 0, sizeof(_has_bits_));
5781 }
5782
5783 RspSignalStrength::~RspSignalStrength() {
5784   SharedDtor();
5785 }
5786
5787 void RspSignalStrength::SharedDtor() {
5788   if (this != default_instance_) {
5789     delete gw_signalstrength_;
5790     delete cdma_signalstrength_;
5791     delete evdo_signalstrength_;
5792   }
5793 }
5794
5795 void RspSignalStrength::SetCachedSize(int size) const {
5796   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
5797   _cached_size_ = size;
5798   GOOGLE_SAFE_CONCURRENT_WRITES_END();
5799 }
5800 const ::google::protobuf::Descriptor* RspSignalStrength::descriptor() {
5801   protobuf_AssignDescriptorsOnce();
5802   return RspSignalStrength_descriptor_;
5803 }
5804
5805 const RspSignalStrength& RspSignalStrength::default_instance() {
5806   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
5807 }
5808
5809 RspSignalStrength* RspSignalStrength::default_instance_ = NULL;
5810
5811 RspSignalStrength* RspSignalStrength::New() const {
5812   return new RspSignalStrength;
5813 }
5814
5815 void RspSignalStrength::Clear() {
5816   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5817     if (_has_bit(0)) {
5818       if (gw_signalstrength_ != NULL) gw_signalstrength_->::ril_proto::RILGWSignalStrength::Clear();
5819     }
5820     if (_has_bit(1)) {
5821       if (cdma_signalstrength_ != NULL) cdma_signalstrength_->::ril_proto::RILCDMASignalStrength::Clear();
5822     }
5823     if (_has_bit(2)) {
5824       if (evdo_signalstrength_ != NULL) evdo_signalstrength_->::ril_proto::RILEVDOSignalStrength::Clear();
5825     }
5826   }
5827   ::memset(_has_bits_, 0, sizeof(_has_bits_));
5828   mutable_unknown_fields()->Clear();
5829 }
5830
5831 bool RspSignalStrength::MergePartialFromCodedStream(
5832     ::google::protobuf::io::CodedInputStream* input) {
5833 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
5834   ::google::protobuf::uint32 tag;
5835   while ((tag = input->ReadTag()) != 0) {
5836     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
5837       // optional .ril_proto.RILGWSignalStrength gw_signalstrength = 1;
5838       case 1: {
5839         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5840             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
5841           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
5842                input, mutable_gw_signalstrength()));
5843         } else {
5844           goto handle_uninterpreted;
5845         }
5846         if (input->ExpectTag(18)) goto parse_cdma_signalstrength;
5847         break;
5848       }
5849
5850       // optional .ril_proto.RILCDMASignalStrength cdma_signalstrength = 2;
5851       case 2: {
5852         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5853             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
5854          parse_cdma_signalstrength:
5855           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
5856                input, mutable_cdma_signalstrength()));
5857         } else {
5858           goto handle_uninterpreted;
5859         }
5860         if (input->ExpectTag(26)) goto parse_evdo_signalstrength;
5861         break;
5862       }
5863
5864       // optional .ril_proto.RILEVDOSignalStrength evdo_signalstrength = 3;
5865       case 3: {
5866         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5867             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
5868          parse_evdo_signalstrength:
5869           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
5870                input, mutable_evdo_signalstrength()));
5871         } else {
5872           goto handle_uninterpreted;
5873         }
5874         if (input->ExpectAtEnd()) return true;
5875         break;
5876       }
5877
5878       default: {
5879       handle_uninterpreted:
5880         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5881             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
5882           return true;
5883         }
5884         DO_(::google::protobuf::internal::WireFormat::SkipField(
5885               input, tag, mutable_unknown_fields()));
5886         break;
5887       }
5888     }
5889   }
5890   return true;
5891 #undef DO_
5892 }
5893
5894 void RspSignalStrength::SerializeWithCachedSizes(
5895     ::google::protobuf::io::CodedOutputStream* output) const {
5896   // optional .ril_proto.RILGWSignalStrength gw_signalstrength = 1;
5897   if (_has_bit(0)) {
5898     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
5899       1, this->gw_signalstrength(), output);
5900   }
5901
5902   // optional .ril_proto.RILCDMASignalStrength cdma_signalstrength = 2;
5903   if (_has_bit(1)) {
5904     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
5905       2, this->cdma_signalstrength(), output);
5906   }
5907
5908   // optional .ril_proto.RILEVDOSignalStrength evdo_signalstrength = 3;
5909   if (_has_bit(2)) {
5910     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
5911       3, this->evdo_signalstrength(), output);
5912   }
5913
5914   if (!unknown_fields().empty()) {
5915     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
5916         unknown_fields(), output);
5917   }
5918 }
5919
5920 ::google::protobuf::uint8* RspSignalStrength::SerializeWithCachedSizesToArray(
5921     ::google::protobuf::uint8* target) const {
5922   // optional .ril_proto.RILGWSignalStrength gw_signalstrength = 1;
5923   if (_has_bit(0)) {
5924     target = ::google::protobuf::internal::WireFormatLite::
5925       WriteMessageNoVirtualToArray(
5926         1, this->gw_signalstrength(), target);
5927   }
5928
5929   // optional .ril_proto.RILCDMASignalStrength cdma_signalstrength = 2;
5930   if (_has_bit(1)) {
5931     target = ::google::protobuf::internal::WireFormatLite::
5932       WriteMessageNoVirtualToArray(
5933         2, this->cdma_signalstrength(), target);
5934   }
5935
5936   // optional .ril_proto.RILEVDOSignalStrength evdo_signalstrength = 3;
5937   if (_has_bit(2)) {
5938     target = ::google::protobuf::internal::WireFormatLite::
5939       WriteMessageNoVirtualToArray(
5940         3, this->evdo_signalstrength(), target);
5941   }
5942
5943   if (!unknown_fields().empty()) {
5944     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
5945         unknown_fields(), target);
5946   }
5947   return target;
5948 }
5949
5950 int RspSignalStrength::ByteSize() const {
5951   int total_size = 0;
5952
5953   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5954     // optional .ril_proto.RILGWSignalStrength gw_signalstrength = 1;
5955     if (has_gw_signalstrength()) {
5956       total_size += 1 +
5957         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
5958           this->gw_signalstrength());
5959     }
5960
5961     // optional .ril_proto.RILCDMASignalStrength cdma_signalstrength = 2;
5962     if (has_cdma_signalstrength()) {
5963       total_size += 1 +
5964         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
5965           this->cdma_signalstrength());
5966     }
5967
5968     // optional .ril_proto.RILEVDOSignalStrength evdo_signalstrength = 3;
5969     if (has_evdo_signalstrength()) {
5970       total_size += 1 +
5971         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
5972           this->evdo_signalstrength());
5973     }
5974
5975   }
5976   if (!unknown_fields().empty()) {
5977     total_size +=
5978       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
5979         unknown_fields());
5980   }
5981   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
5982   _cached_size_ = total_size;
5983   GOOGLE_SAFE_CONCURRENT_WRITES_END();
5984   return total_size;
5985 }
5986
5987 void RspSignalStrength::MergeFrom(const ::google::protobuf::Message& from) {
5988   GOOGLE_CHECK_NE(&from, this);
5989   const RspSignalStrength* source =
5990     ::google::protobuf::internal::dynamic_cast_if_available<const RspSignalStrength*>(
5991       &from);
5992   if (source == NULL) {
5993     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
5994   } else {
5995     MergeFrom(*source);
5996   }
5997 }
5998
5999 void RspSignalStrength::MergeFrom(const RspSignalStrength& from) {
6000   GOOGLE_CHECK_NE(&from, this);
6001   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6002     if (from._has_bit(0)) {
6003       mutable_gw_signalstrength()->::ril_proto::RILGWSignalStrength::MergeFrom(from.gw_signalstrength());
6004     }
6005     if (from._has_bit(1)) {
6006       mutable_cdma_signalstrength()->::ril_proto::RILCDMASignalStrength::MergeFrom(from.cdma_signalstrength());
6007     }
6008     if (from._has_bit(2)) {
6009       mutable_evdo_signalstrength()->::ril_proto::RILEVDOSignalStrength::MergeFrom(from.evdo_signalstrength());
6010     }
6011   }
6012   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
6013 }
6014
6015 void RspSignalStrength::CopyFrom(const ::google::protobuf::Message& from) {
6016   if (&from == this) return;
6017   Clear();
6018   MergeFrom(from);
6019 }
6020
6021 void RspSignalStrength::CopyFrom(const RspSignalStrength& from) {
6022   if (&from == this) return;
6023   Clear();
6024   MergeFrom(from);
6025 }
6026
6027 bool RspSignalStrength::IsInitialized() const {
6028
6029   return true;
6030 }
6031
6032 void RspSignalStrength::Swap(RspSignalStrength* other) {
6033   if (other != this) {
6034     std::swap(gw_signalstrength_, other->gw_signalstrength_);
6035     std::swap(cdma_signalstrength_, other->cdma_signalstrength_);
6036     std::swap(evdo_signalstrength_, other->evdo_signalstrength_);
6037     std::swap(_has_bits_[0], other->_has_bits_[0]);
6038     _unknown_fields_.Swap(&other->_unknown_fields_);
6039     std::swap(_cached_size_, other->_cached_size_);
6040   }
6041 }
6042
6043 ::google::protobuf::Metadata RspSignalStrength::GetMetadata() const {
6044   protobuf_AssignDescriptorsOnce();
6045   ::google::protobuf::Metadata metadata;
6046   metadata.descriptor = RspSignalStrength_descriptor_;
6047   metadata.reflection = RspSignalStrength_reflection_;
6048   return metadata;
6049 }
6050
6051
6052 // ===================================================================
6053
6054 const ::std::string RspOperator::_default_long_alpha_ons_;
6055 const ::std::string RspOperator::_default_short_alpha_ons_;
6056 const ::std::string RspOperator::_default_mcc_mnc_;
6057 #ifndef _MSC_VER
6058 const int RspOperator::kLongAlphaOnsFieldNumber;
6059 const int RspOperator::kShortAlphaOnsFieldNumber;
6060 const int RspOperator::kMccMncFieldNumber;
6061 #endif  // !_MSC_VER
6062
6063 RspOperator::RspOperator()
6064   : ::google::protobuf::Message() {
6065   SharedCtor();
6066 }
6067
6068 void RspOperator::InitAsDefaultInstance() {
6069 }
6070
6071 RspOperator::RspOperator(const RspOperator& from)
6072   : ::google::protobuf::Message() {
6073   SharedCtor();
6074   MergeFrom(from);
6075 }
6076
6077 void RspOperator::SharedCtor() {
6078   _cached_size_ = 0;
6079   long_alpha_ons_ = const_cast< ::std::string*>(&_default_long_alpha_ons_);
6080   short_alpha_ons_ = const_cast< ::std::string*>(&_default_short_alpha_ons_);
6081   mcc_mnc_ = const_cast< ::std::string*>(&_default_mcc_mnc_);
6082   ::memset(_has_bits_, 0, sizeof(_has_bits_));
6083 }
6084
6085 RspOperator::~RspOperator() {
6086   SharedDtor();
6087 }
6088
6089 void RspOperator::SharedDtor() {
6090   if (long_alpha_ons_ != &_default_long_alpha_ons_) {
6091     delete long_alpha_ons_;
6092   }
6093   if (short_alpha_ons_ != &_default_short_alpha_ons_) {
6094     delete short_alpha_ons_;
6095   }
6096   if (mcc_mnc_ != &_default_mcc_mnc_) {
6097     delete mcc_mnc_;
6098   }
6099   if (this != default_instance_) {
6100   }
6101 }
6102
6103 void RspOperator::SetCachedSize(int size) const {
6104   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
6105   _cached_size_ = size;
6106   GOOGLE_SAFE_CONCURRENT_WRITES_END();
6107 }
6108 const ::google::protobuf::Descriptor* RspOperator::descriptor() {
6109   protobuf_AssignDescriptorsOnce();
6110   return RspOperator_descriptor_;
6111 }
6112
6113 const RspOperator& RspOperator::default_instance() {
6114   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
6115 }
6116
6117 RspOperator* RspOperator::default_instance_ = NULL;
6118
6119 RspOperator* RspOperator::New() const {
6120   return new RspOperator;
6121 }
6122
6123 void RspOperator::Clear() {
6124   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6125     if (_has_bit(0)) {
6126       if (long_alpha_ons_ != &_default_long_alpha_ons_) {
6127         long_alpha_ons_->clear();
6128       }
6129     }
6130     if (_has_bit(1)) {
6131       if (short_alpha_ons_ != &_default_short_alpha_ons_) {
6132         short_alpha_ons_->clear();
6133       }
6134     }
6135     if (_has_bit(2)) {
6136       if (mcc_mnc_ != &_default_mcc_mnc_) {
6137         mcc_mnc_->clear();
6138       }
6139     }
6140   }
6141   ::memset(_has_bits_, 0, sizeof(_has_bits_));
6142   mutable_unknown_fields()->Clear();
6143 }
6144
6145 bool RspOperator::MergePartialFromCodedStream(
6146     ::google::protobuf::io::CodedInputStream* input) {
6147 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
6148   ::google::protobuf::uint32 tag;
6149   while ((tag = input->ReadTag()) != 0) {
6150     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
6151       // optional string long_alpha_ons = 1;
6152       case 1: {
6153         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6154             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6155           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
6156                 input, this->mutable_long_alpha_ons()));
6157           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
6158             this->long_alpha_ons().data(), this->long_alpha_ons().length(),
6159             ::google::protobuf::internal::WireFormat::PARSE);
6160         } else {
6161           goto handle_uninterpreted;
6162         }
6163         if (input->ExpectTag(18)) goto parse_short_alpha_ons;
6164         break;
6165       }
6166
6167       // optional string short_alpha_ons = 2;
6168       case 2: {
6169         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6170             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6171          parse_short_alpha_ons:
6172           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
6173                 input, this->mutable_short_alpha_ons()));
6174           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
6175             this->short_alpha_ons().data(), this->short_alpha_ons().length(),
6176             ::google::protobuf::internal::WireFormat::PARSE);
6177         } else {
6178           goto handle_uninterpreted;
6179         }
6180         if (input->ExpectTag(26)) goto parse_mcc_mnc;
6181         break;
6182       }
6183
6184       // optional string mcc_mnc = 3;
6185       case 3: {
6186         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6187             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6188          parse_mcc_mnc:
6189           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
6190                 input, this->mutable_mcc_mnc()));
6191           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
6192             this->mcc_mnc().data(), this->mcc_mnc().length(),
6193             ::google::protobuf::internal::WireFormat::PARSE);
6194         } else {
6195           goto handle_uninterpreted;
6196         }
6197         if (input->ExpectAtEnd()) return true;
6198         break;
6199       }
6200
6201       default: {
6202       handle_uninterpreted:
6203         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6204             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
6205           return true;
6206         }
6207         DO_(::google::protobuf::internal::WireFormat::SkipField(
6208               input, tag, mutable_unknown_fields()));
6209         break;
6210       }
6211     }
6212   }
6213   return true;
6214 #undef DO_
6215 }
6216
6217 void RspOperator::SerializeWithCachedSizes(
6218     ::google::protobuf::io::CodedOutputStream* output) const {
6219   // optional string long_alpha_ons = 1;
6220   if (_has_bit(0)) {
6221     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
6222       this->long_alpha_ons().data(), this->long_alpha_ons().length(),
6223       ::google::protobuf::internal::WireFormat::SERIALIZE);
6224     ::google::protobuf::internal::WireFormatLite::WriteString(
6225       1, this->long_alpha_ons(), output);
6226   }
6227
6228   // optional string short_alpha_ons = 2;
6229   if (_has_bit(1)) {
6230     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
6231       this->short_alpha_ons().data(), this->short_alpha_ons().length(),
6232       ::google::protobuf::internal::WireFormat::SERIALIZE);
6233     ::google::protobuf::internal::WireFormatLite::WriteString(
6234       2, this->short_alpha_ons(), output);
6235   }
6236
6237   // optional string mcc_mnc = 3;
6238   if (_has_bit(2)) {
6239     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
6240       this->mcc_mnc().data(), this->mcc_mnc().length(),
6241       ::google::protobuf::internal::WireFormat::SERIALIZE);
6242     ::google::protobuf::internal::WireFormatLite::WriteString(
6243       3, this->mcc_mnc(), output);
6244   }
6245
6246   if (!unknown_fields().empty()) {
6247     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
6248         unknown_fields(), output);
6249   }
6250 }
6251
6252 ::google::protobuf::uint8* RspOperator::SerializeWithCachedSizesToArray(
6253     ::google::protobuf::uint8* target) const {
6254   // optional string long_alpha_ons = 1;
6255   if (_has_bit(0)) {
6256     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
6257       this->long_alpha_ons().data(), this->long_alpha_ons().length(),
6258       ::google::protobuf::internal::WireFormat::SERIALIZE);
6259     target =
6260       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
6261         1, this->long_alpha_ons(), target);
6262   }
6263
6264   // optional string short_alpha_ons = 2;
6265   if (_has_bit(1)) {
6266     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
6267       this->short_alpha_ons().data(), this->short_alpha_ons().length(),
6268       ::google::protobuf::internal::WireFormat::SERIALIZE);
6269     target =
6270       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
6271         2, this->short_alpha_ons(), target);
6272   }
6273
6274   // optional string mcc_mnc = 3;
6275   if (_has_bit(2)) {
6276     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
6277       this->mcc_mnc().data(), this->mcc_mnc().length(),
6278       ::google::protobuf::internal::WireFormat::SERIALIZE);
6279     target =
6280       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
6281         3, this->mcc_mnc(), target);
6282   }
6283
6284   if (!unknown_fields().empty()) {
6285     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
6286         unknown_fields(), target);
6287   }
6288   return target;
6289 }
6290
6291 int RspOperator::ByteSize() const {
6292   int total_size = 0;
6293
6294   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6295     // optional string long_alpha_ons = 1;
6296     if (has_long_alpha_ons()) {
6297       total_size += 1 +
6298         ::google::protobuf::internal::WireFormatLite::StringSize(
6299           this->long_alpha_ons());
6300     }
6301
6302     // optional string short_alpha_ons = 2;
6303     if (has_short_alpha_ons()) {
6304       total_size += 1 +
6305         ::google::protobuf::internal::WireFormatLite::StringSize(
6306           this->short_alpha_ons());
6307     }
6308
6309     // optional string mcc_mnc = 3;
6310     if (has_mcc_mnc()) {
6311       total_size += 1 +
6312         ::google::protobuf::internal::WireFormatLite::StringSize(
6313           this->mcc_mnc());
6314     }
6315
6316   }
6317   if (!unknown_fields().empty()) {
6318     total_size +=
6319       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
6320         unknown_fields());
6321   }
6322   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
6323   _cached_size_ = total_size;
6324   GOOGLE_SAFE_CONCURRENT_WRITES_END();
6325   return total_size;
6326 }
6327
6328 void RspOperator::MergeFrom(const ::google::protobuf::Message& from) {
6329   GOOGLE_CHECK_NE(&from, this);
6330   const RspOperator* source =
6331     ::google::protobuf::internal::dynamic_cast_if_available<const RspOperator*>(
6332       &from);
6333   if (source == NULL) {
6334     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
6335   } else {
6336     MergeFrom(*source);
6337   }
6338 }
6339
6340 void RspOperator::MergeFrom(const RspOperator& from) {
6341   GOOGLE_CHECK_NE(&from, this);
6342   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6343     if (from._has_bit(0)) {
6344       set_long_alpha_ons(from.long_alpha_ons());
6345     }
6346     if (from._has_bit(1)) {
6347       set_short_alpha_ons(from.short_alpha_ons());
6348     }
6349     if (from._has_bit(2)) {
6350       set_mcc_mnc(from.mcc_mnc());
6351     }
6352   }
6353   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
6354 }
6355
6356 void RspOperator::CopyFrom(const ::google::protobuf::Message& from) {
6357   if (&from == this) return;
6358   Clear();
6359   MergeFrom(from);
6360 }
6361
6362 void RspOperator::CopyFrom(const RspOperator& from) {
6363   if (&from == this) return;
6364   Clear();
6365   MergeFrom(from);
6366 }
6367
6368 bool RspOperator::IsInitialized() const {
6369
6370   return true;
6371 }
6372
6373 void RspOperator::Swap(RspOperator* other) {
6374   if (other != this) {
6375     std::swap(long_alpha_ons_, other->long_alpha_ons_);
6376     std::swap(short_alpha_ons_, other->short_alpha_ons_);
6377     std::swap(mcc_mnc_, other->mcc_mnc_);
6378     std::swap(_has_bits_[0], other->_has_bits_[0]);
6379     _unknown_fields_.Swap(&other->_unknown_fields_);
6380     std::swap(_cached_size_, other->_cached_size_);
6381   }
6382 }
6383
6384 ::google::protobuf::Metadata RspOperator::GetMetadata() const {
6385   protobuf_AssignDescriptorsOnce();
6386   ::google::protobuf::Metadata metadata;
6387   metadata.descriptor = RspOperator_descriptor_;
6388   metadata.reflection = RspOperator_reflection_;
6389   return metadata;
6390 }
6391
6392
6393 // ===================================================================
6394
6395 #ifndef _MSC_VER
6396 const int ReqSeparateConnection::kIndexFieldNumber;
6397 #endif  // !_MSC_VER
6398
6399 ReqSeparateConnection::ReqSeparateConnection()
6400   : ::google::protobuf::Message() {
6401   SharedCtor();
6402 }
6403
6404 void ReqSeparateConnection::InitAsDefaultInstance() {
6405 }
6406
6407 ReqSeparateConnection::ReqSeparateConnection(const ReqSeparateConnection& from)
6408   : ::google::protobuf::Message() {
6409   SharedCtor();
6410   MergeFrom(from);
6411 }
6412
6413 void ReqSeparateConnection::SharedCtor() {
6414   _cached_size_ = 0;
6415   index_ = 0;
6416   ::memset(_has_bits_, 0, sizeof(_has_bits_));
6417 }
6418
6419 ReqSeparateConnection::~ReqSeparateConnection() {
6420   SharedDtor();
6421 }
6422
6423 void ReqSeparateConnection::SharedDtor() {
6424   if (this != default_instance_) {
6425   }
6426 }
6427
6428 void ReqSeparateConnection::SetCachedSize(int size) const {
6429   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
6430   _cached_size_ = size;
6431   GOOGLE_SAFE_CONCURRENT_WRITES_END();
6432 }
6433 const ::google::protobuf::Descriptor* ReqSeparateConnection::descriptor() {
6434   protobuf_AssignDescriptorsOnce();
6435   return ReqSeparateConnection_descriptor_;
6436 }
6437
6438 const ReqSeparateConnection& ReqSeparateConnection::default_instance() {
6439   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
6440 }
6441
6442 ReqSeparateConnection* ReqSeparateConnection::default_instance_ = NULL;
6443
6444 ReqSeparateConnection* ReqSeparateConnection::New() const {
6445   return new ReqSeparateConnection;
6446 }
6447
6448 void ReqSeparateConnection::Clear() {
6449   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6450     index_ = 0;
6451   }
6452   ::memset(_has_bits_, 0, sizeof(_has_bits_));
6453   mutable_unknown_fields()->Clear();
6454 }
6455
6456 bool ReqSeparateConnection::MergePartialFromCodedStream(
6457     ::google::protobuf::io::CodedInputStream* input) {
6458 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
6459   ::google::protobuf::uint32 tag;
6460   while ((tag = input->ReadTag()) != 0) {
6461     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
6462       // required int32 index = 1;
6463       case 1: {
6464         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6465             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
6466           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
6467                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
6468                  input, &index_)));
6469           _set_bit(0);
6470         } else {
6471           goto handle_uninterpreted;
6472         }
6473         if (input->ExpectAtEnd()) return true;
6474         break;
6475       }
6476
6477       default: {
6478       handle_uninterpreted:
6479         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6480             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
6481           return true;
6482         }
6483         DO_(::google::protobuf::internal::WireFormat::SkipField(
6484               input, tag, mutable_unknown_fields()));
6485         break;
6486       }
6487     }
6488   }
6489   return true;
6490 #undef DO_
6491 }
6492
6493 void ReqSeparateConnection::SerializeWithCachedSizes(
6494     ::google::protobuf::io::CodedOutputStream* output) const {
6495   // required int32 index = 1;
6496   if (_has_bit(0)) {
6497     ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->index(), output);
6498   }
6499
6500   if (!unknown_fields().empty()) {
6501     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
6502         unknown_fields(), output);
6503   }
6504 }
6505
6506 ::google::protobuf::uint8* ReqSeparateConnection::SerializeWithCachedSizesToArray(
6507     ::google::protobuf::uint8* target) const {
6508   // required int32 index = 1;
6509   if (_has_bit(0)) {
6510     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->index(), target);
6511   }
6512
6513   if (!unknown_fields().empty()) {
6514     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
6515         unknown_fields(), target);
6516   }
6517   return target;
6518 }
6519
6520 int ReqSeparateConnection::ByteSize() const {
6521   int total_size = 0;
6522
6523   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6524     // required int32 index = 1;
6525     if (has_index()) {
6526       total_size += 1 +
6527         ::google::protobuf::internal::WireFormatLite::Int32Size(
6528           this->index());
6529     }
6530
6531   }
6532   if (!unknown_fields().empty()) {
6533     total_size +=
6534       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
6535         unknown_fields());
6536   }
6537   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
6538   _cached_size_ = total_size;
6539   GOOGLE_SAFE_CONCURRENT_WRITES_END();
6540   return total_size;
6541 }
6542
6543 void ReqSeparateConnection::MergeFrom(const ::google::protobuf::Message& from) {
6544   GOOGLE_CHECK_NE(&from, this);
6545   const ReqSeparateConnection* source =
6546     ::google::protobuf::internal::dynamic_cast_if_available<const ReqSeparateConnection*>(
6547       &from);
6548   if (source == NULL) {
6549     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
6550   } else {
6551     MergeFrom(*source);
6552   }
6553 }
6554
6555 void ReqSeparateConnection::MergeFrom(const ReqSeparateConnection& from) {
6556   GOOGLE_CHECK_NE(&from, this);
6557   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6558     if (from._has_bit(0)) {
6559       set_index(from.index());
6560     }
6561   }
6562   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
6563 }
6564
6565 void ReqSeparateConnection::CopyFrom(const ::google::protobuf::Message& from) {
6566   if (&from == this) return;
6567   Clear();
6568   MergeFrom(from);
6569 }
6570
6571 void ReqSeparateConnection::CopyFrom(const ReqSeparateConnection& from) {
6572   if (&from == this) return;
6573   Clear();
6574   MergeFrom(from);
6575 }
6576
6577 bool ReqSeparateConnection::IsInitialized() const {
6578   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
6579
6580   return true;
6581 }
6582
6583 void ReqSeparateConnection::Swap(ReqSeparateConnection* other) {
6584   if (other != this) {
6585     std::swap(index_, other->index_);
6586     std::swap(_has_bits_[0], other->_has_bits_[0]);
6587     _unknown_fields_.Swap(&other->_unknown_fields_);
6588     std::swap(_cached_size_, other->_cached_size_);
6589   }
6590 }
6591
6592 ::google::protobuf::Metadata ReqSeparateConnection::GetMetadata() const {
6593   protobuf_AssignDescriptorsOnce();
6594   ::google::protobuf::Metadata metadata;
6595   metadata.descriptor = ReqSeparateConnection_descriptor_;
6596   metadata.reflection = ReqSeparateConnection_reflection_;
6597   return metadata;
6598 }
6599
6600
6601 // ===================================================================
6602
6603 #ifndef _MSC_VER
6604 const int ReqSetMute::kStateFieldNumber;
6605 #endif  // !_MSC_VER
6606
6607 ReqSetMute::ReqSetMute()
6608   : ::google::protobuf::Message() {
6609   SharedCtor();
6610 }
6611
6612 void ReqSetMute::InitAsDefaultInstance() {
6613 }
6614
6615 ReqSetMute::ReqSetMute(const ReqSetMute& from)
6616   : ::google::protobuf::Message() {
6617   SharedCtor();
6618   MergeFrom(from);
6619 }
6620
6621 void ReqSetMute::SharedCtor() {
6622   _cached_size_ = 0;
6623   state_ = false;
6624   ::memset(_has_bits_, 0, sizeof(_has_bits_));
6625 }
6626
6627 ReqSetMute::~ReqSetMute() {
6628   SharedDtor();
6629 }
6630
6631 void ReqSetMute::SharedDtor() {
6632   if (this != default_instance_) {
6633   }
6634 }
6635
6636 void ReqSetMute::SetCachedSize(int size) const {
6637   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
6638   _cached_size_ = size;
6639   GOOGLE_SAFE_CONCURRENT_WRITES_END();
6640 }
6641 const ::google::protobuf::Descriptor* ReqSetMute::descriptor() {
6642   protobuf_AssignDescriptorsOnce();
6643   return ReqSetMute_descriptor_;
6644 }
6645
6646 const ReqSetMute& ReqSetMute::default_instance() {
6647   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
6648 }
6649
6650 ReqSetMute* ReqSetMute::default_instance_ = NULL;
6651
6652 ReqSetMute* ReqSetMute::New() const {
6653   return new ReqSetMute;
6654 }
6655
6656 void ReqSetMute::Clear() {
6657   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6658     state_ = false;
6659   }
6660   ::memset(_has_bits_, 0, sizeof(_has_bits_));
6661   mutable_unknown_fields()->Clear();
6662 }
6663
6664 bool ReqSetMute::MergePartialFromCodedStream(
6665     ::google::protobuf::io::CodedInputStream* input) {
6666 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
6667   ::google::protobuf::uint32 tag;
6668   while ((tag = input->ReadTag()) != 0) {
6669     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
6670       // required bool state = 1;
6671       case 1: {
6672         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6673             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
6674           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
6675                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
6676                  input, &state_)));
6677           _set_bit(0);
6678         } else {
6679           goto handle_uninterpreted;
6680         }
6681         if (input->ExpectAtEnd()) return true;
6682         break;
6683       }
6684
6685       default: {
6686       handle_uninterpreted:
6687         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6688             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
6689           return true;
6690         }
6691         DO_(::google::protobuf::internal::WireFormat::SkipField(
6692               input, tag, mutable_unknown_fields()));
6693         break;
6694       }
6695     }
6696   }
6697   return true;
6698 #undef DO_
6699 }
6700
6701 void ReqSetMute::SerializeWithCachedSizes(
6702     ::google::protobuf::io::CodedOutputStream* output) const {
6703   // required bool state = 1;
6704   if (_has_bit(0)) {
6705     ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->state(), output);
6706   }
6707
6708   if (!unknown_fields().empty()) {
6709     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
6710         unknown_fields(), output);
6711   }
6712 }
6713
6714 ::google::protobuf::uint8* ReqSetMute::SerializeWithCachedSizesToArray(
6715     ::google::protobuf::uint8* target) const {
6716   // required bool state = 1;
6717   if (_has_bit(0)) {
6718     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->state(), target);
6719   }
6720
6721   if (!unknown_fields().empty()) {
6722     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
6723         unknown_fields(), target);
6724   }
6725   return target;
6726 }
6727
6728 int ReqSetMute::ByteSize() const {
6729   int total_size = 0;
6730
6731   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6732     // required bool state = 1;
6733     if (has_state()) {
6734       total_size += 1 + 1;
6735     }
6736
6737   }
6738   if (!unknown_fields().empty()) {
6739     total_size +=
6740       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
6741         unknown_fields());
6742   }
6743   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
6744   _cached_size_ = total_size;
6745   GOOGLE_SAFE_CONCURRENT_WRITES_END();
6746   return total_size;
6747 }
6748
6749 void ReqSetMute::MergeFrom(const ::google::protobuf::Message& from) {
6750   GOOGLE_CHECK_NE(&from, this);
6751   const ReqSetMute* source =
6752     ::google::protobuf::internal::dynamic_cast_if_available<const ReqSetMute*>(
6753       &from);
6754   if (source == NULL) {
6755     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
6756   } else {
6757     MergeFrom(*source);
6758   }
6759 }
6760
6761 void ReqSetMute::MergeFrom(const ReqSetMute& from) {
6762   GOOGLE_CHECK_NE(&from, this);
6763   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6764     if (from._has_bit(0)) {
6765       set_state(from.state());
6766     }
6767   }
6768   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
6769 }
6770
6771 void ReqSetMute::CopyFrom(const ::google::protobuf::Message& from) {
6772   if (&from == this) return;
6773   Clear();
6774   MergeFrom(from);
6775 }
6776
6777 void ReqSetMute::CopyFrom(const ReqSetMute& from) {
6778   if (&from == this) return;
6779   Clear();
6780   MergeFrom(from);
6781 }
6782
6783 bool ReqSetMute::IsInitialized() const {
6784   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
6785
6786   return true;
6787 }
6788
6789 void ReqSetMute::Swap(ReqSetMute* other) {
6790   if (other != this) {
6791     std::swap(state_, other->state_);
6792     std::swap(_has_bits_[0], other->_has_bits_[0]);
6793     _unknown_fields_.Swap(&other->_unknown_fields_);
6794     std::swap(_cached_size_, other->_cached_size_);
6795   }
6796 }
6797
6798 ::google::protobuf::Metadata ReqSetMute::GetMetadata() const {
6799   protobuf_AssignDescriptorsOnce();
6800   ::google::protobuf::Metadata metadata;
6801   metadata.descriptor = ReqSetMute_descriptor_;
6802   metadata.reflection = ReqSetMute_reflection_;
6803   return metadata;
6804 }
6805
6806
6807 // ===================================================================
6808
6809 #ifndef _MSC_VER
6810 const int ReqScreenState::kStateFieldNumber;
6811 #endif  // !_MSC_VER
6812
6813 ReqScreenState::ReqScreenState()
6814   : ::google::protobuf::Message() {
6815   SharedCtor();
6816 }
6817
6818 void ReqScreenState::InitAsDefaultInstance() {
6819 }
6820
6821 ReqScreenState::ReqScreenState(const ReqScreenState& from)
6822   : ::google::protobuf::Message() {
6823   SharedCtor();
6824   MergeFrom(from);
6825 }
6826
6827 void ReqScreenState::SharedCtor() {
6828   _cached_size_ = 0;
6829   state_ = false;
6830   ::memset(_has_bits_, 0, sizeof(_has_bits_));
6831 }
6832
6833 ReqScreenState::~ReqScreenState() {
6834   SharedDtor();
6835 }
6836
6837 void ReqScreenState::SharedDtor() {
6838   if (this != default_instance_) {
6839   }
6840 }
6841
6842 void ReqScreenState::SetCachedSize(int size) const {
6843   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
6844   _cached_size_ = size;
6845   GOOGLE_SAFE_CONCURRENT_WRITES_END();
6846 }
6847 const ::google::protobuf::Descriptor* ReqScreenState::descriptor() {
6848   protobuf_AssignDescriptorsOnce();
6849   return ReqScreenState_descriptor_;
6850 }
6851
6852 const ReqScreenState& ReqScreenState::default_instance() {
6853   if (default_instance_ == NULL) protobuf_AddDesc_ril_2eproto();  return *default_instance_;
6854 }
6855
6856 ReqScreenState* ReqScreenState::default_instance_ = NULL;
6857
6858 ReqScreenState* ReqScreenState::New() const {
6859   return new ReqScreenState;
6860 }
6861
6862 void ReqScreenState::Clear() {
6863   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6864     state_ = false;
6865   }
6866   ::memset(_has_bits_, 0, sizeof(_has_bits_));
6867   mutable_unknown_fields()->Clear();
6868 }
6869
6870 bool ReqScreenState::MergePartialFromCodedStream(
6871     ::google::protobuf::io::CodedInputStream* input) {
6872 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
6873   ::google::protobuf::uint32 tag;
6874   while ((tag = input->ReadTag()) != 0) {
6875     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
6876       // required bool state = 1;
6877       case 1: {
6878         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6879             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
6880           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
6881                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
6882                  input, &state_)));
6883           _set_bit(0);
6884         } else {
6885           goto handle_uninterpreted;
6886         }
6887         if (input->ExpectAtEnd()) return true;
6888         break;
6889       }
6890
6891       default: {
6892       handle_uninterpreted:
6893         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6894             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
6895           return true;
6896         }
6897         DO_(::google::protobuf::internal::WireFormat::SkipField(
6898               input, tag, mutable_unknown_fields()));
6899         break;
6900       }
6901     }
6902   }
6903   return true;
6904 #undef DO_
6905 }
6906
6907 void ReqScreenState::SerializeWithCachedSizes(
6908     ::google::protobuf::io::CodedOutputStream* output) const {
6909   // required bool state = 1;
6910   if (_has_bit(0)) {
6911     ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->state(), output);
6912   }
6913
6914   if (!unknown_fields().empty()) {
6915     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
6916         unknown_fields(), output);
6917   }
6918 }
6919
6920 ::google::protobuf::uint8* ReqScreenState::SerializeWithCachedSizesToArray(
6921     ::google::protobuf::uint8* target) const {
6922   // required bool state = 1;
6923   if (_has_bit(0)) {
6924     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->state(), target);
6925   }
6926
6927   if (!unknown_fields().empty()) {
6928     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
6929         unknown_fields(), target);
6930   }
6931   return target;
6932 }
6933
6934 int ReqScreenState::ByteSize() const {
6935   int total_size = 0;
6936
6937   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6938     // required bool state = 1;
6939     if (has_state()) {
6940       total_size += 1 + 1;
6941     }
6942
6943   }
6944   if (!unknown_fields().empty()) {
6945     total_size +=
6946       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
6947         unknown_fields());
6948   }
6949   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
6950   _cached_size_ = total_size;
6951   GOOGLE_SAFE_CONCURRENT_WRITES_END();
6952   return total_size;
6953 }
6954
6955 void ReqScreenState::MergeFrom(const ::google::protobuf::Message& from) {
6956   GOOGLE_CHECK_NE(&from, this);
6957   const ReqScreenState* source =
6958     ::google::protobuf::internal::dynamic_cast_if_available<const ReqScreenState*>(
6959       &from);
6960   if (source == NULL) {
6961     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
6962   } else {
6963     MergeFrom(*source);
6964   }
6965 }
6966
6967 void ReqScreenState::MergeFrom(const ReqScreenState& from) {
6968   GOOGLE_CHECK_NE(&from, this);
6969   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6970     if (from._has_bit(0)) {
6971       set_state(from.state());
6972     }
6973   }
6974   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
6975 }
6976
6977 void ReqScreenState::CopyFrom(const ::google::protobuf::Message& from) {
6978   if (&from == this) return;
6979   Clear();
6980   MergeFrom(from);
6981 }
6982
6983 void ReqScreenState::CopyFrom(const ReqScreenState& from) {
6984   if (&from == this) return;
6985   Clear();
6986   MergeFrom(from);
6987 }
6988
6989 bool ReqScreenState::IsInitialized() const {
6990   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
6991
6992   return true;
6993 }
6994
6995 void ReqScreenState::Swap(ReqScreenState* other) {
6996   if (other != this) {
6997     std::swap(state_, other->state_);
6998     std::swap(_has_bits_[0], other->_has_bits_[0]);
6999     _unknown_fields_.Swap(&other->_unknown_fields_);
7000     std::swap(_cached_size_, other->_cached_size_);
7001   }
7002 }
7003
7004 ::google::protobuf::Metadata ReqScreenState::GetMetadata() const {
7005   protobuf_AssignDescriptorsOnce();
7006   ::google::protobuf::Metadata metadata;
7007   metadata.descriptor = ReqScreenState_descriptor_;
7008   metadata.reflection = ReqScreenState_reflection_;
7009   return metadata;
7010 }
7011
7012
7013 // @@protoc_insertion_point(namespace_scope)
7014
7015 }  // namespace ril_proto
7016
7017 // @@protoc_insertion_point(global_scope)