1 // Generated by the protocol buffer compiler. DO NOT EDIT! 2 3 #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION 4 #include "ctrl.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* CtrlReqRadioState_descriptor_ = NULL; 18 const ::google::protobuf::internal::GeneratedMessageReflection* 19 CtrlReqRadioState_reflection_ = NULL; 20 const ::google::protobuf::Descriptor* CtrlRspRadioState_descriptor_ = NULL; 21 const ::google::protobuf::internal::GeneratedMessageReflection* 22 CtrlRspRadioState_reflection_ = NULL; 23 const ::google::protobuf::Descriptor* CtrlReqSetMTCall_descriptor_ = NULL; 24 const ::google::protobuf::internal::GeneratedMessageReflection* 25 CtrlReqSetMTCall_reflection_ = NULL; 26 const ::google::protobuf::Descriptor* CtrlHangupConnRemote_descriptor_ = NULL; 27 const ::google::protobuf::internal::GeneratedMessageReflection* 28 CtrlHangupConnRemote_reflection_ = NULL; 29 const ::google::protobuf::Descriptor* CtrlSetCallTransitionFlag_descriptor_ = NULL; 30 const ::google::protobuf::internal::GeneratedMessageReflection* 31 CtrlSetCallTransitionFlag_reflection_ = NULL; 32 const ::google::protobuf::Descriptor* CtrlReqAddDialingCall_descriptor_ = NULL; 33 const ::google::protobuf::internal::GeneratedMessageReflection* 34 CtrlReqAddDialingCall_reflection_ = NULL; 35 const ::google::protobuf::EnumDescriptor* CtrlCmd_descriptor_ = NULL; 36 const ::google::protobuf::EnumDescriptor* CtrlStatus_descriptor_ = NULL; 37 38 } // namespace 39 40 41 void protobuf_AssignDesc_ctrl_2eproto() { 42 protobuf_AddDesc_ctrl_2eproto(); 43 const ::google::protobuf::FileDescriptor* file = 44 ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( 45 "ctrl.proto"); 46 GOOGLE_CHECK(file != NULL); 47 CtrlReqRadioState_descriptor_ = file->message_type(0); 48 static const int CtrlReqRadioState_offsets_[1] = { 49 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlReqRadioState, state_), 50 }; 51 CtrlReqRadioState_reflection_ = 52 new ::google::protobuf::internal::GeneratedMessageReflection( 53 CtrlReqRadioState_descriptor_, 54 CtrlReqRadioState::default_instance_, 55 CtrlReqRadioState_offsets_, 56 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlReqRadioState, _has_bits_[0]), 57 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlReqRadioState, _unknown_fields_), 58 -1, 59 ::google::protobuf::DescriptorPool::generated_pool(), 60 ::google::protobuf::MessageFactory::generated_factory(), 61 sizeof(CtrlReqRadioState)); 62 CtrlRspRadioState_descriptor_ = file->message_type(1); 63 static const int CtrlRspRadioState_offsets_[1] = { 64 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlRspRadioState, state_), 65 }; 66 CtrlRspRadioState_reflection_ = 67 new ::google::protobuf::internal::GeneratedMessageReflection( 68 CtrlRspRadioState_descriptor_, 69 CtrlRspRadioState::default_instance_, 70 CtrlRspRadioState_offsets_, 71 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlRspRadioState, _has_bits_[0]), 72 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlRspRadioState, _unknown_fields_), 73 -1, 74 ::google::protobuf::DescriptorPool::generated_pool(), 75 ::google::protobuf::MessageFactory::generated_factory(), 76 sizeof(CtrlRspRadioState)); 77 CtrlReqSetMTCall_descriptor_ = file->message_type(2); 78 static const int CtrlReqSetMTCall_offsets_[1] = { 79 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlReqSetMTCall, phone_number_), 80 }; 81 CtrlReqSetMTCall_reflection_ = 82 new ::google::protobuf::internal::GeneratedMessageReflection( 83 CtrlReqSetMTCall_descriptor_, 84 CtrlReqSetMTCall::default_instance_, 85 CtrlReqSetMTCall_offsets_, 86 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlReqSetMTCall, _has_bits_[0]), 87 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlReqSetMTCall, _unknown_fields_), 88 -1, 89 ::google::protobuf::DescriptorPool::generated_pool(), 90 ::google::protobuf::MessageFactory::generated_factory(), 91 sizeof(CtrlReqSetMTCall)); 92 CtrlHangupConnRemote_descriptor_ = file->message_type(3); 93 static const int CtrlHangupConnRemote_offsets_[2] = { 94 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlHangupConnRemote, connection_id_), 95 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlHangupConnRemote, call_fail_cause_), 96 }; 97 CtrlHangupConnRemote_reflection_ = 98 new ::google::protobuf::internal::GeneratedMessageReflection( 99 CtrlHangupConnRemote_descriptor_, 100 CtrlHangupConnRemote::default_instance_, 101 CtrlHangupConnRemote_offsets_, 102 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlHangupConnRemote, _has_bits_[0]), 103 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlHangupConnRemote, _unknown_fields_), 104 -1, 105 ::google::protobuf::DescriptorPool::generated_pool(), 106 ::google::protobuf::MessageFactory::generated_factory(), 107 sizeof(CtrlHangupConnRemote)); 108 CtrlSetCallTransitionFlag_descriptor_ = file->message_type(4); 109 static const int CtrlSetCallTransitionFlag_offsets_[1] = { 110 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlSetCallTransitionFlag, flag_), 111 }; 112 CtrlSetCallTransitionFlag_reflection_ = 113 new ::google::protobuf::internal::GeneratedMessageReflection( 114 CtrlSetCallTransitionFlag_descriptor_, 115 CtrlSetCallTransitionFlag::default_instance_, 116 CtrlSetCallTransitionFlag_offsets_, 117 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlSetCallTransitionFlag, _has_bits_[0]), 118 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlSetCallTransitionFlag, _unknown_fields_), 119 -1, 120 ::google::protobuf::DescriptorPool::generated_pool(), 121 ::google::protobuf::MessageFactory::generated_factory(), 122 sizeof(CtrlSetCallTransitionFlag)); 123 CtrlReqAddDialingCall_descriptor_ = file->message_type(5); 124 static const int CtrlReqAddDialingCall_offsets_[1] = { 125 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlReqAddDialingCall, phone_number_), 126 }; 127 CtrlReqAddDialingCall_reflection_ = 128 new ::google::protobuf::internal::GeneratedMessageReflection( 129 CtrlReqAddDialingCall_descriptor_, 130 CtrlReqAddDialingCall::default_instance_, 131 CtrlReqAddDialingCall_offsets_, 132 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlReqAddDialingCall, _has_bits_[0]), 133 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlReqAddDialingCall, _unknown_fields_), 134 -1, 135 ::google::protobuf::DescriptorPool::generated_pool(), 136 ::google::protobuf::MessageFactory::generated_factory(), 137 sizeof(CtrlReqAddDialingCall)); 138 CtrlCmd_descriptor_ = file->enum_type(0); 139 CtrlStatus_descriptor_ = file->enum_type(1); 140 } 141 142 namespace { 143 144 GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); 145 inline void protobuf_AssignDescriptorsOnce() { 146 ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, 147 &protobuf_AssignDesc_ctrl_2eproto); 148 } 149 150 void protobuf_RegisterTypes(const ::std::string&) { 151 protobuf_AssignDescriptorsOnce(); 152 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( 153 CtrlReqRadioState_descriptor_, &CtrlReqRadioState::default_instance()); 154 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( 155 CtrlRspRadioState_descriptor_, &CtrlRspRadioState::default_instance()); 156 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( 157 CtrlReqSetMTCall_descriptor_, &CtrlReqSetMTCall::default_instance()); 158 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( 159 CtrlHangupConnRemote_descriptor_, &CtrlHangupConnRemote::default_instance()); 160 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( 161 CtrlSetCallTransitionFlag_descriptor_, &CtrlSetCallTransitionFlag::default_instance()); 162 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( 163 CtrlReqAddDialingCall_descriptor_, &CtrlReqAddDialingCall::default_instance()); 164 } 165 166 } // namespace 167 168 void protobuf_ShutdownFile_ctrl_2eproto() { 169 delete CtrlReqRadioState::default_instance_; 170 delete CtrlReqRadioState_reflection_; 171 delete CtrlRspRadioState::default_instance_; 172 delete CtrlRspRadioState_reflection_; 173 delete CtrlReqSetMTCall::default_instance_; 174 delete CtrlReqSetMTCall_reflection_; 175 delete CtrlHangupConnRemote::default_instance_; 176 delete CtrlHangupConnRemote_reflection_; 177 delete CtrlSetCallTransitionFlag::default_instance_; 178 delete CtrlSetCallTransitionFlag_reflection_; 179 delete CtrlReqAddDialingCall::default_instance_; 180 delete CtrlReqAddDialingCall_reflection_; 181 } 182 183 void protobuf_AddDesc_ctrl_2eproto() { 184 static bool already_here = false; 185 if (already_here) return; 186 already_here = true; 187 GOOGLE_PROTOBUF_VERIFY_VERSION; 188 189 ::ril_proto::protobuf_AddDesc_ril_2eproto(); 190 ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( 191 "\n\nctrl.proto\022\tril_proto\032\tril.proto\"9\n\021Ct" 192 "rlReqRadioState\022$\n\005state\030\001 \002(\0162\025.ril_pro" 193 "to.RadioState\"9\n\021CtrlRspRadioState\022$\n\005st" 194 "ate\030\001 \002(\0162\025.ril_proto.RadioState\"(\n\020Ctrl" 195 "ReqSetMTCall\022\024\n\014phone_number\030\001 \002(\t\"F\n\024Ct" 196 "rlHangupConnRemote\022\025\n\rconnection_id\030\001 \002(" 197 "\005\022\027\n\017call_fail_cause\030\002 \002(\005\")\n\031CtrlSetCal" 198 "lTransitionFlag\022\014\n\004flag\030\001 \002(\010\"-\n\025CtrlReq" 199 "AddDialingCall\022\024\n\014phone_number\030\001 \002(\t*\232\002\n" 200 "\007CtrlCmd\022\021\n\rCTRL_CMD_ECHO\020\000\022\034\n\030CTRL_CMD_" 201 "GET_RADIO_STATE\020\001\022\034\n\030CTRL_CMD_SET_RADIO_" 202 "STATE\020\002\022\031\n\024CTRL_CMD_SET_MT_CALL\020\351\007\022 \n\033CT" 203 "RL_CMD_HANGUP_CONN_REMOTE\020\352\007\022&\n!CTRL_CMD" 204 "_SET_CALL_TRANSITION_FLAG\020\353\007\022\034\n\027CTRL_CMD" 205 "_SET_CALL_ALERT\020\354\007\022\035\n\030CTRL_CMD_SET_CALL_" 206 "ACTIVE\020\355\007\022\036\n\031CTRL_CMD_ADD_DIALING_CALL\020\356" 207 "\007*5\n\nCtrlStatus\022\022\n\016CTRL_STATUS_OK\020\000\022\023\n\017C" 208 "TRL_STATUS_ERR\020\001B7\n(com.android.internal" 209 ".telephony.ril_protoB\013RilCtrlCmds", 753); 210 ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( 211 "ctrl.proto", &protobuf_RegisterTypes); 212 CtrlReqRadioState::default_instance_ = new CtrlReqRadioState(); 213 CtrlRspRadioState::default_instance_ = new CtrlRspRadioState(); 214 CtrlReqSetMTCall::default_instance_ = new CtrlReqSetMTCall(); 215 CtrlHangupConnRemote::default_instance_ = new CtrlHangupConnRemote(); 216 CtrlSetCallTransitionFlag::default_instance_ = new CtrlSetCallTransitionFlag(); 217 CtrlReqAddDialingCall::default_instance_ = new CtrlReqAddDialingCall(); 218 CtrlReqRadioState::default_instance_->InitAsDefaultInstance(); 219 CtrlRspRadioState::default_instance_->InitAsDefaultInstance(); 220 CtrlReqSetMTCall::default_instance_->InitAsDefaultInstance(); 221 CtrlHangupConnRemote::default_instance_->InitAsDefaultInstance(); 222 CtrlSetCallTransitionFlag::default_instance_->InitAsDefaultInstance(); 223 CtrlReqAddDialingCall::default_instance_->InitAsDefaultInstance(); 224 ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_ctrl_2eproto); 225 } 226 227 // Force AddDescriptors() to be called at static initialization time. 228 struct StaticDescriptorInitializer_ctrl_2eproto { 229 StaticDescriptorInitializer_ctrl_2eproto() { 230 protobuf_AddDesc_ctrl_2eproto(); 231 } 232 } static_descriptor_initializer_ctrl_2eproto_; 233 234 const ::google::protobuf::EnumDescriptor* CtrlCmd_descriptor() { 235 protobuf_AssignDescriptorsOnce(); 236 return CtrlCmd_descriptor_; 237 } 238 bool CtrlCmd_IsValid(int value) { 239 switch(value) { 240 case 0: 241 case 1: 242 case 2: 243 case 1001: 244 case 1002: 245 case 1003: 246 case 1004: 247 case 1005: 248 case 1006: 249 return true; 250 default: 251 return false; 252 } 253 } 254 255 const ::google::protobuf::EnumDescriptor* CtrlStatus_descriptor() { 256 protobuf_AssignDescriptorsOnce(); 257 return CtrlStatus_descriptor_; 258 } 259 bool CtrlStatus_IsValid(int value) { 260 switch(value) { 261 case 0: 262 case 1: 263 return true; 264 default: 265 return false; 266 } 267 } 268 269 270 // =================================================================== 271 272 #ifndef _MSC_VER 273 const int CtrlReqRadioState::kStateFieldNumber; 274 #endif // !_MSC_VER 275 276 CtrlReqRadioState::CtrlReqRadioState() 277 : ::google::protobuf::Message() { 278 SharedCtor(); 279 } 280 281 void CtrlReqRadioState::InitAsDefaultInstance() { 282 } 283 284 CtrlReqRadioState::CtrlReqRadioState(const CtrlReqRadioState& from) 285 : ::google::protobuf::Message() { 286 SharedCtor(); 287 MergeFrom(from); 288 } 289 290 void CtrlReqRadioState::SharedCtor() { 291 _cached_size_ = 0; 292 state_ = 0; 293 ::memset(_has_bits_, 0, sizeof(_has_bits_)); 294 } 295 296 CtrlReqRadioState::~CtrlReqRadioState() { 297 SharedDtor(); 298 } 299 300 void CtrlReqRadioState::SharedDtor() { 301 if (this != default_instance_) { 302 } 303 } 304 305 void CtrlReqRadioState::SetCachedSize(int size) const { 306 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); 307 _cached_size_ = size; 308 GOOGLE_SAFE_CONCURRENT_WRITES_END(); 309 } 310 const ::google::protobuf::Descriptor* CtrlReqRadioState::descriptor() { 311 protobuf_AssignDescriptorsOnce(); 312 return CtrlReqRadioState_descriptor_; 313 } 314 315 const CtrlReqRadioState& CtrlReqRadioState::default_instance() { 316 if (default_instance_ == NULL) protobuf_AddDesc_ctrl_2eproto(); return *default_instance_; 317 } 318 319 CtrlReqRadioState* CtrlReqRadioState::default_instance_ = NULL; 320 321 CtrlReqRadioState* CtrlReqRadioState::New() const { 322 return new CtrlReqRadioState; 323 } 324 325 void CtrlReqRadioState::Clear() { 326 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { 327 state_ = 0; 328 } 329 ::memset(_has_bits_, 0, sizeof(_has_bits_)); 330 mutable_unknown_fields()->Clear(); 331 } 332 333 bool CtrlReqRadioState::MergePartialFromCodedStream( 334 ::google::protobuf::io::CodedInputStream* input) { 335 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false 336 ::google::protobuf::uint32 tag; 337 while ((tag = input->ReadTag()) != 0) { 338 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { 339 // required .ril_proto.RadioState state = 1; 340 case 1: { 341 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == 342 ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { 343 int value; 344 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< 345 int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( 346 input, &value))); 347 if (ril_proto::RadioState_IsValid(value)) { 348 set_state(static_cast< ril_proto::RadioState >(value)); 349 } else { 350 mutable_unknown_fields()->AddVarint(1, value); 351 } 352 } else { 353 goto handle_uninterpreted; 354 } 355 if (input->ExpectAtEnd()) return true; 356 break; 357 } 358 359 default: { 360 handle_uninterpreted: 361 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == 362 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { 363 return true; 364 } 365 DO_(::google::protobuf::internal::WireFormat::SkipField( 366 input, tag, mutable_unknown_fields())); 367 break; 368 } 369 } 370 } 371 return true; 372 #undef DO_ 373 } 374 375 void CtrlReqRadioState::SerializeWithCachedSizes( 376 ::google::protobuf::io::CodedOutputStream* output) const { 377 // required .ril_proto.RadioState state = 1; 378 if (_has_bit(0)) { 379 ::google::protobuf::internal::WireFormatLite::WriteEnum( 380 1, this->state(), output); 381 } 382 383 if (!unknown_fields().empty()) { 384 ::google::protobuf::internal::WireFormat::SerializeUnknownFields( 385 unknown_fields(), output); 386 } 387 } 388 389 ::google::protobuf::uint8* CtrlReqRadioState::SerializeWithCachedSizesToArray( 390 ::google::protobuf::uint8* target) const { 391 // required .ril_proto.RadioState state = 1; 392 if (_has_bit(0)) { 393 target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( 394 1, this->state(), target); 395 } 396 397 if (!unknown_fields().empty()) { 398 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( 399 unknown_fields(), target); 400 } 401 return target; 402 } 403 404 int CtrlReqRadioState::ByteSize() const { 405 int total_size = 0; 406 407 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { 408 // required .ril_proto.RadioState state = 1; 409 if (has_state()) { 410 total_size += 1 + 411 ::google::protobuf::internal::WireFormatLite::EnumSize(this->state()); 412 } 413 414 } 415 if (!unknown_fields().empty()) { 416 total_size += 417 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( 418 unknown_fields()); 419 } 420 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); 421 _cached_size_ = total_size; 422 GOOGLE_SAFE_CONCURRENT_WRITES_END(); 423 return total_size; 424 } 425 426 void CtrlReqRadioState::MergeFrom(const ::google::protobuf::Message& from) { 427 GOOGLE_CHECK_NE(&from, this); 428 const CtrlReqRadioState* source = 429 ::google::protobuf::internal::dynamic_cast_if_available<const CtrlReqRadioState*>( 430 &from); 431 if (source == NULL) { 432 ::google::protobuf::internal::ReflectionOps::Merge(from, this); 433 } else { 434 MergeFrom(*source); 435 } 436 } 437 438 void CtrlReqRadioState::MergeFrom(const CtrlReqRadioState& from) { 439 GOOGLE_CHECK_NE(&from, this); 440 if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { 441 if (from._has_bit(0)) { 442 set_state(from.state()); 443 } 444 } 445 mutable_unknown_fields()->MergeFrom(from.unknown_fields()); 446 } 447 448 void CtrlReqRadioState::CopyFrom(const ::google::protobuf::Message& from) { 449 if (&from == this) return; 450 Clear(); 451 MergeFrom(from); 452 } 453 454 void CtrlReqRadioState::CopyFrom(const CtrlReqRadioState& from) { 455 if (&from == this) return; 456 Clear(); 457 MergeFrom(from); 458 } 459 460 bool CtrlReqRadioState::IsInitialized() const { 461 if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; 462 463 return true; 464 } 465 466 void CtrlReqRadioState::Swap(CtrlReqRadioState* other) { 467 if (other != this) { 468 std::swap(state_, other->state_); 469 std::swap(_has_bits_[0], other->_has_bits_[0]); 470 _unknown_fields_.Swap(&other->_unknown_fields_); 471 std::swap(_cached_size_, other->_cached_size_); 472 } 473 } 474 475 ::google::protobuf::Metadata CtrlReqRadioState::GetMetadata() const { 476 protobuf_AssignDescriptorsOnce(); 477 ::google::protobuf::Metadata metadata; 478 metadata.descriptor = CtrlReqRadioState_descriptor_; 479 metadata.reflection = CtrlReqRadioState_reflection_; 480 return metadata; 481 } 482 483 484 // =================================================================== 485 486 #ifndef _MSC_VER 487 const int CtrlRspRadioState::kStateFieldNumber; 488 #endif // !_MSC_VER 489 490 CtrlRspRadioState::CtrlRspRadioState() 491 : ::google::protobuf::Message() { 492 SharedCtor(); 493 } 494 495 void CtrlRspRadioState::InitAsDefaultInstance() { 496 } 497 498 CtrlRspRadioState::CtrlRspRadioState(const CtrlRspRadioState& from) 499 : ::google::protobuf::Message() { 500 SharedCtor(); 501 MergeFrom(from); 502 } 503 504 void CtrlRspRadioState::SharedCtor() { 505 _cached_size_ = 0; 506 state_ = 0; 507 ::memset(_has_bits_, 0, sizeof(_has_bits_)); 508 } 509 510 CtrlRspRadioState::~CtrlRspRadioState() { 511 SharedDtor(); 512 } 513 514 void CtrlRspRadioState::SharedDtor() { 515 if (this != default_instance_) { 516 } 517 } 518 519 void CtrlRspRadioState::SetCachedSize(int size) const { 520 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); 521 _cached_size_ = size; 522 GOOGLE_SAFE_CONCURRENT_WRITES_END(); 523 } 524 const ::google::protobuf::Descriptor* CtrlRspRadioState::descriptor() { 525 protobuf_AssignDescriptorsOnce(); 526 return CtrlRspRadioState_descriptor_; 527 } 528 529 const CtrlRspRadioState& CtrlRspRadioState::default_instance() { 530 if (default_instance_ == NULL) protobuf_AddDesc_ctrl_2eproto(); return *default_instance_; 531 } 532 533 CtrlRspRadioState* CtrlRspRadioState::default_instance_ = NULL; 534 535 CtrlRspRadioState* CtrlRspRadioState::New() const { 536 return new CtrlRspRadioState; 537 } 538 539 void CtrlRspRadioState::Clear() { 540 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { 541 state_ = 0; 542 } 543 ::memset(_has_bits_, 0, sizeof(_has_bits_)); 544 mutable_unknown_fields()->Clear(); 545 } 546 547 bool CtrlRspRadioState::MergePartialFromCodedStream( 548 ::google::protobuf::io::CodedInputStream* input) { 549 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false 550 ::google::protobuf::uint32 tag; 551 while ((tag = input->ReadTag()) != 0) { 552 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { 553 // required .ril_proto.RadioState state = 1; 554 case 1: { 555 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == 556 ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { 557 int value; 558 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< 559 int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( 560 input, &value))); 561 if (ril_proto::RadioState_IsValid(value)) { 562 set_state(static_cast< ril_proto::RadioState >(value)); 563 } else { 564 mutable_unknown_fields()->AddVarint(1, value); 565 } 566 } else { 567 goto handle_uninterpreted; 568 } 569 if (input->ExpectAtEnd()) return true; 570 break; 571 } 572 573 default: { 574 handle_uninterpreted: 575 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == 576 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { 577 return true; 578 } 579 DO_(::google::protobuf::internal::WireFormat::SkipField( 580 input, tag, mutable_unknown_fields())); 581 break; 582 } 583 } 584 } 585 return true; 586 #undef DO_ 587 } 588 589 void CtrlRspRadioState::SerializeWithCachedSizes( 590 ::google::protobuf::io::CodedOutputStream* output) const { 591 // required .ril_proto.RadioState state = 1; 592 if (_has_bit(0)) { 593 ::google::protobuf::internal::WireFormatLite::WriteEnum( 594 1, this->state(), output); 595 } 596 597 if (!unknown_fields().empty()) { 598 ::google::protobuf::internal::WireFormat::SerializeUnknownFields( 599 unknown_fields(), output); 600 } 601 } 602 603 ::google::protobuf::uint8* CtrlRspRadioState::SerializeWithCachedSizesToArray( 604 ::google::protobuf::uint8* target) const { 605 // required .ril_proto.RadioState state = 1; 606 if (_has_bit(0)) { 607 target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( 608 1, this->state(), target); 609 } 610 611 if (!unknown_fields().empty()) { 612 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( 613 unknown_fields(), target); 614 } 615 return target; 616 } 617 618 int CtrlRspRadioState::ByteSize() const { 619 int total_size = 0; 620 621 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { 622 // required .ril_proto.RadioState state = 1; 623 if (has_state()) { 624 total_size += 1 + 625 ::google::protobuf::internal::WireFormatLite::EnumSize(this->state()); 626 } 627 628 } 629 if (!unknown_fields().empty()) { 630 total_size += 631 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( 632 unknown_fields()); 633 } 634 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); 635 _cached_size_ = total_size; 636 GOOGLE_SAFE_CONCURRENT_WRITES_END(); 637 return total_size; 638 } 639 640 void CtrlRspRadioState::MergeFrom(const ::google::protobuf::Message& from) { 641 GOOGLE_CHECK_NE(&from, this); 642 const CtrlRspRadioState* source = 643 ::google::protobuf::internal::dynamic_cast_if_available<const CtrlRspRadioState*>( 644 &from); 645 if (source == NULL) { 646 ::google::protobuf::internal::ReflectionOps::Merge(from, this); 647 } else { 648 MergeFrom(*source); 649 } 650 } 651 652 void CtrlRspRadioState::MergeFrom(const CtrlRspRadioState& from) { 653 GOOGLE_CHECK_NE(&from, this); 654 if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { 655 if (from._has_bit(0)) { 656 set_state(from.state()); 657 } 658 } 659 mutable_unknown_fields()->MergeFrom(from.unknown_fields()); 660 } 661 662 void CtrlRspRadioState::CopyFrom(const ::google::protobuf::Message& from) { 663 if (&from == this) return; 664 Clear(); 665 MergeFrom(from); 666 } 667 668 void CtrlRspRadioState::CopyFrom(const CtrlRspRadioState& from) { 669 if (&from == this) return; 670 Clear(); 671 MergeFrom(from); 672 } 673 674 bool CtrlRspRadioState::IsInitialized() const { 675 if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; 676 677 return true; 678 } 679 680 void CtrlRspRadioState::Swap(CtrlRspRadioState* other) { 681 if (other != this) { 682 std::swap(state_, other->state_); 683 std::swap(_has_bits_[0], other->_has_bits_[0]); 684 _unknown_fields_.Swap(&other->_unknown_fields_); 685 std::swap(_cached_size_, other->_cached_size_); 686 } 687 } 688 689 ::google::protobuf::Metadata CtrlRspRadioState::GetMetadata() const { 690 protobuf_AssignDescriptorsOnce(); 691 ::google::protobuf::Metadata metadata; 692 metadata.descriptor = CtrlRspRadioState_descriptor_; 693 metadata.reflection = CtrlRspRadioState_reflection_; 694 return metadata; 695 } 696 697 698 // =================================================================== 699 700 const ::std::string CtrlReqSetMTCall::_default_phone_number_; 701 #ifndef _MSC_VER 702 const int CtrlReqSetMTCall::kPhoneNumberFieldNumber; 703 #endif // !_MSC_VER 704 705 CtrlReqSetMTCall::CtrlReqSetMTCall() 706 : ::google::protobuf::Message() { 707 SharedCtor(); 708 } 709 710 void CtrlReqSetMTCall::InitAsDefaultInstance() { 711 } 712 713 CtrlReqSetMTCall::CtrlReqSetMTCall(const CtrlReqSetMTCall& from) 714 : ::google::protobuf::Message() { 715 SharedCtor(); 716 MergeFrom(from); 717 } 718 719 void CtrlReqSetMTCall::SharedCtor() { 720 _cached_size_ = 0; 721 phone_number_ = const_cast< ::std::string*>(&_default_phone_number_); 722 ::memset(_has_bits_, 0, sizeof(_has_bits_)); 723 } 724 725 CtrlReqSetMTCall::~CtrlReqSetMTCall() { 726 SharedDtor(); 727 } 728 729 void CtrlReqSetMTCall::SharedDtor() { 730 if (phone_number_ != &_default_phone_number_) { 731 delete phone_number_; 732 } 733 if (this != default_instance_) { 734 } 735 } 736 737 void CtrlReqSetMTCall::SetCachedSize(int size) const { 738 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); 739 _cached_size_ = size; 740 GOOGLE_SAFE_CONCURRENT_WRITES_END(); 741 } 742 const ::google::protobuf::Descriptor* CtrlReqSetMTCall::descriptor() { 743 protobuf_AssignDescriptorsOnce(); 744 return CtrlReqSetMTCall_descriptor_; 745 } 746 747 const CtrlReqSetMTCall& CtrlReqSetMTCall::default_instance() { 748 if (default_instance_ == NULL) protobuf_AddDesc_ctrl_2eproto(); return *default_instance_; 749 } 750 751 CtrlReqSetMTCall* CtrlReqSetMTCall::default_instance_ = NULL; 752 753 CtrlReqSetMTCall* CtrlReqSetMTCall::New() const { 754 return new CtrlReqSetMTCall; 755 } 756 757 void CtrlReqSetMTCall::Clear() { 758 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { 759 if (_has_bit(0)) { 760 if (phone_number_ != &_default_phone_number_) { 761 phone_number_->clear(); 762 } 763 } 764 } 765 ::memset(_has_bits_, 0, sizeof(_has_bits_)); 766 mutable_unknown_fields()->Clear(); 767 } 768 769 bool CtrlReqSetMTCall::MergePartialFromCodedStream( 770 ::google::protobuf::io::CodedInputStream* input) { 771 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false 772 ::google::protobuf::uint32 tag; 773 while ((tag = input->ReadTag()) != 0) { 774 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { 775 // required string phone_number = 1; 776 case 1: { 777 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == 778 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { 779 DO_(::google::protobuf::internal::WireFormatLite::ReadString( 780 input, this->mutable_phone_number())); 781 ::google::protobuf::internal::WireFormat::VerifyUTF8String( 782 this->phone_number().data(), this->phone_number().length(), 783 ::google::protobuf::internal::WireFormat::PARSE); 784 } else { 785 goto handle_uninterpreted; 786 } 787 if (input->ExpectAtEnd()) return true; 788 break; 789 } 790 791 default: { 792 handle_uninterpreted: 793 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == 794 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { 795 return true; 796 } 797 DO_(::google::protobuf::internal::WireFormat::SkipField( 798 input, tag, mutable_unknown_fields())); 799 break; 800 } 801 } 802 } 803 return true; 804 #undef DO_ 805 } 806 807 void CtrlReqSetMTCall::SerializeWithCachedSizes( 808 ::google::protobuf::io::CodedOutputStream* output) const { 809 // required string phone_number = 1; 810 if (_has_bit(0)) { 811 ::google::protobuf::internal::WireFormat::VerifyUTF8String( 812 this->phone_number().data(), this->phone_number().length(), 813 ::google::protobuf::internal::WireFormat::SERIALIZE); 814 ::google::protobuf::internal::WireFormatLite::WriteString( 815 1, this->phone_number(), output); 816 } 817 818 if (!unknown_fields().empty()) { 819 ::google::protobuf::internal::WireFormat::SerializeUnknownFields( 820 unknown_fields(), output); 821 } 822 } 823 824 ::google::protobuf::uint8* CtrlReqSetMTCall::SerializeWithCachedSizesToArray( 825 ::google::protobuf::uint8* target) const { 826 // required string phone_number = 1; 827 if (_has_bit(0)) { 828 ::google::protobuf::internal::WireFormat::VerifyUTF8String( 829 this->phone_number().data(), this->phone_number().length(), 830 ::google::protobuf::internal::WireFormat::SERIALIZE); 831 target = 832 ::google::protobuf::internal::WireFormatLite::WriteStringToArray( 833 1, this->phone_number(), target); 834 } 835 836 if (!unknown_fields().empty()) { 837 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( 838 unknown_fields(), target); 839 } 840 return target; 841 } 842 843 int CtrlReqSetMTCall::ByteSize() const { 844 int total_size = 0; 845 846 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { 847 // required string phone_number = 1; 848 if (has_phone_number()) { 849 total_size += 1 + 850 ::google::protobuf::internal::WireFormatLite::StringSize( 851 this->phone_number()); 852 } 853 854 } 855 if (!unknown_fields().empty()) { 856 total_size += 857 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( 858 unknown_fields()); 859 } 860 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); 861 _cached_size_ = total_size; 862 GOOGLE_SAFE_CONCURRENT_WRITES_END(); 863 return total_size; 864 } 865 866 void CtrlReqSetMTCall::MergeFrom(const ::google::protobuf::Message& from) { 867 GOOGLE_CHECK_NE(&from, this); 868 const CtrlReqSetMTCall* source = 869 ::google::protobuf::internal::dynamic_cast_if_available<const CtrlReqSetMTCall*>( 870 &from); 871 if (source == NULL) { 872 ::google::protobuf::internal::ReflectionOps::Merge(from, this); 873 } else { 874 MergeFrom(*source); 875 } 876 } 877 878 void CtrlReqSetMTCall::MergeFrom(const CtrlReqSetMTCall& from) { 879 GOOGLE_CHECK_NE(&from, this); 880 if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { 881 if (from._has_bit(0)) { 882 set_phone_number(from.phone_number()); 883 } 884 } 885 mutable_unknown_fields()->MergeFrom(from.unknown_fields()); 886 } 887 888 void CtrlReqSetMTCall::CopyFrom(const ::google::protobuf::Message& from) { 889 if (&from == this) return; 890 Clear(); 891 MergeFrom(from); 892 } 893 894 void CtrlReqSetMTCall::CopyFrom(const CtrlReqSetMTCall& from) { 895 if (&from == this) return; 896 Clear(); 897 MergeFrom(from); 898 } 899 900 bool CtrlReqSetMTCall::IsInitialized() const { 901 if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; 902 903 return true; 904 } 905 906 void CtrlReqSetMTCall::Swap(CtrlReqSetMTCall* other) { 907 if (other != this) { 908 std::swap(phone_number_, other->phone_number_); 909 std::swap(_has_bits_[0], other->_has_bits_[0]); 910 _unknown_fields_.Swap(&other->_unknown_fields_); 911 std::swap(_cached_size_, other->_cached_size_); 912 } 913 } 914 915 ::google::protobuf::Metadata CtrlReqSetMTCall::GetMetadata() const { 916 protobuf_AssignDescriptorsOnce(); 917 ::google::protobuf::Metadata metadata; 918 metadata.descriptor = CtrlReqSetMTCall_descriptor_; 919 metadata.reflection = CtrlReqSetMTCall_reflection_; 920 return metadata; 921 } 922 923 924 // =================================================================== 925 926 #ifndef _MSC_VER 927 const int CtrlHangupConnRemote::kConnectionIdFieldNumber; 928 const int CtrlHangupConnRemote::kCallFailCauseFieldNumber; 929 #endif // !_MSC_VER 930 931 CtrlHangupConnRemote::CtrlHangupConnRemote() 932 : ::google::protobuf::Message() { 933 SharedCtor(); 934 } 935 936 void CtrlHangupConnRemote::InitAsDefaultInstance() { 937 } 938 939 CtrlHangupConnRemote::CtrlHangupConnRemote(const CtrlHangupConnRemote& from) 940 : ::google::protobuf::Message() { 941 SharedCtor(); 942 MergeFrom(from); 943 } 944 945 void CtrlHangupConnRemote::SharedCtor() { 946 _cached_size_ = 0; 947 connection_id_ = 0; 948 call_fail_cause_ = 0; 949 ::memset(_has_bits_, 0, sizeof(_has_bits_)); 950 } 951 952 CtrlHangupConnRemote::~CtrlHangupConnRemote() { 953 SharedDtor(); 954 } 955 956 void CtrlHangupConnRemote::SharedDtor() { 957 if (this != default_instance_) { 958 } 959 } 960 961 void CtrlHangupConnRemote::SetCachedSize(int size) const { 962 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); 963 _cached_size_ = size; 964 GOOGLE_SAFE_CONCURRENT_WRITES_END(); 965 } 966 const ::google::protobuf::Descriptor* CtrlHangupConnRemote::descriptor() { 967 protobuf_AssignDescriptorsOnce(); 968 return CtrlHangupConnRemote_descriptor_; 969 } 970 971 const CtrlHangupConnRemote& CtrlHangupConnRemote::default_instance() { 972 if (default_instance_ == NULL) protobuf_AddDesc_ctrl_2eproto(); return *default_instance_; 973 } 974 975 CtrlHangupConnRemote* CtrlHangupConnRemote::default_instance_ = NULL; 976 977 CtrlHangupConnRemote* CtrlHangupConnRemote::New() const { 978 return new CtrlHangupConnRemote; 979 } 980 981 void CtrlHangupConnRemote::Clear() { 982 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { 983 connection_id_ = 0; 984 call_fail_cause_ = 0; 985 } 986 ::memset(_has_bits_, 0, sizeof(_has_bits_)); 987 mutable_unknown_fields()->Clear(); 988 } 989 990 bool CtrlHangupConnRemote::MergePartialFromCodedStream( 991 ::google::protobuf::io::CodedInputStream* input) { 992 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false 993 ::google::protobuf::uint32 tag; 994 while ((tag = input->ReadTag()) != 0) { 995 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { 996 // required int32 connection_id = 1; 997 case 1: { 998 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == 999 ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { 1000 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< 1001 ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( 1002 input, &connection_id_))); 1003 _set_bit(0); 1004 } else { 1005 goto handle_uninterpreted; 1006 } 1007 if (input->ExpectTag(16)) goto parse_call_fail_cause; 1008 break; 1009 } 1010 1011 // required int32 call_fail_cause = 2; 1012 case 2: { 1013 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == 1014 ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { 1015 parse_call_fail_cause: 1016 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< 1017 ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( 1018 input, &call_fail_cause_))); 1019 _set_bit(1); 1020 } else { 1021 goto handle_uninterpreted; 1022 } 1023 if (input->ExpectAtEnd()) return true; 1024 break; 1025 } 1026 1027 default: { 1028 handle_uninterpreted: 1029 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == 1030 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { 1031 return true; 1032 } 1033 DO_(::google::protobuf::internal::WireFormat::SkipField( 1034 input, tag, mutable_unknown_fields())); 1035 break; 1036 } 1037 } 1038 } 1039 return true; 1040 #undef DO_ 1041 } 1042 1043 void CtrlHangupConnRemote::SerializeWithCachedSizes( 1044 ::google::protobuf::io::CodedOutputStream* output) const { 1045 // required int32 connection_id = 1; 1046 if (_has_bit(0)) { 1047 ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->connection_id(), output); 1048 } 1049 1050 // required int32 call_fail_cause = 2; 1051 if (_has_bit(1)) { 1052 ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->call_fail_cause(), output); 1053 } 1054 1055 if (!unknown_fields().empty()) { 1056 ::google::protobuf::internal::WireFormat::SerializeUnknownFields( 1057 unknown_fields(), output); 1058 } 1059 } 1060 1061 ::google::protobuf::uint8* CtrlHangupConnRemote::SerializeWithCachedSizesToArray( 1062 ::google::protobuf::uint8* target) const { 1063 // required int32 connection_id = 1; 1064 if (_has_bit(0)) { 1065 target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->connection_id(), target); 1066 } 1067 1068 // required int32 call_fail_cause = 2; 1069 if (_has_bit(1)) { 1070 target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->call_fail_cause(), target); 1071 } 1072 1073 if (!unknown_fields().empty()) { 1074 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( 1075 unknown_fields(), target); 1076 } 1077 return target; 1078 } 1079 1080 int CtrlHangupConnRemote::ByteSize() const { 1081 int total_size = 0; 1082 1083 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { 1084 // required int32 connection_id = 1; 1085 if (has_connection_id()) { 1086 total_size += 1 + 1087 ::google::protobuf::internal::WireFormatLite::Int32Size( 1088 this->connection_id()); 1089 } 1090 1091 // required int32 call_fail_cause = 2; 1092 if (has_call_fail_cause()) { 1093 total_size += 1 + 1094 ::google::protobuf::internal::WireFormatLite::Int32Size( 1095 this->call_fail_cause()); 1096 } 1097 1098 } 1099 if (!unknown_fields().empty()) { 1100 total_size += 1101 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( 1102 unknown_fields()); 1103 } 1104 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); 1105 _cached_size_ = total_size; 1106 GOOGLE_SAFE_CONCURRENT_WRITES_END(); 1107 return total_size; 1108 } 1109 1110 void CtrlHangupConnRemote::MergeFrom(const ::google::protobuf::Message& from) { 1111 GOOGLE_CHECK_NE(&from, this); 1112 const CtrlHangupConnRemote* source = 1113 ::google::protobuf::internal::dynamic_cast_if_available<const CtrlHangupConnRemote*>( 1114 &from); 1115 if (source == NULL) { 1116 ::google::protobuf::internal::ReflectionOps::Merge(from, this); 1117 } else { 1118 MergeFrom(*source); 1119 } 1120 } 1121 1122 void CtrlHangupConnRemote::MergeFrom(const CtrlHangupConnRemote& from) { 1123 GOOGLE_CHECK_NE(&from, this); 1124 if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { 1125 if (from._has_bit(0)) { 1126 set_connection_id(from.connection_id()); 1127 } 1128 if (from._has_bit(1)) { 1129 set_call_fail_cause(from.call_fail_cause()); 1130 } 1131 } 1132 mutable_unknown_fields()->MergeFrom(from.unknown_fields()); 1133 } 1134 1135 void CtrlHangupConnRemote::CopyFrom(const ::google::protobuf::Message& from) { 1136 if (&from == this) return; 1137 Clear(); 1138 MergeFrom(from); 1139 } 1140 1141 void CtrlHangupConnRemote::CopyFrom(const CtrlHangupConnRemote& from) { 1142 if (&from == this) return; 1143 Clear(); 1144 MergeFrom(from); 1145 } 1146 1147 bool CtrlHangupConnRemote::IsInitialized() const { 1148 if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; 1149 1150 return true; 1151 } 1152 1153 void CtrlHangupConnRemote::Swap(CtrlHangupConnRemote* other) { 1154 if (other != this) { 1155 std::swap(connection_id_, other->connection_id_); 1156 std::swap(call_fail_cause_, other->call_fail_cause_); 1157 std::swap(_has_bits_[0], other->_has_bits_[0]); 1158 _unknown_fields_.Swap(&other->_unknown_fields_); 1159 std::swap(_cached_size_, other->_cached_size_); 1160 } 1161 } 1162 1163 ::google::protobuf::Metadata CtrlHangupConnRemote::GetMetadata() const { 1164 protobuf_AssignDescriptorsOnce(); 1165 ::google::protobuf::Metadata metadata; 1166 metadata.descriptor = CtrlHangupConnRemote_descriptor_; 1167 metadata.reflection = CtrlHangupConnRemote_reflection_; 1168 return metadata; 1169 } 1170 1171 1172 // =================================================================== 1173 1174 #ifndef _MSC_VER 1175 const int CtrlSetCallTransitionFlag::kFlagFieldNumber; 1176 #endif // !_MSC_VER 1177 1178 CtrlSetCallTransitionFlag::CtrlSetCallTransitionFlag() 1179 : ::google::protobuf::Message() { 1180 SharedCtor(); 1181 } 1182 1183 void CtrlSetCallTransitionFlag::InitAsDefaultInstance() { 1184 } 1185 1186 CtrlSetCallTransitionFlag::CtrlSetCallTransitionFlag(const CtrlSetCallTransitionFlag& from) 1187 : ::google::protobuf::Message() { 1188 SharedCtor(); 1189 MergeFrom(from); 1190 } 1191 1192 void CtrlSetCallTransitionFlag::SharedCtor() { 1193 _cached_size_ = 0; 1194 flag_ = false; 1195 ::memset(_has_bits_, 0, sizeof(_has_bits_)); 1196 } 1197 1198 CtrlSetCallTransitionFlag::~CtrlSetCallTransitionFlag() { 1199 SharedDtor(); 1200 } 1201 1202 void CtrlSetCallTransitionFlag::SharedDtor() { 1203 if (this != default_instance_) { 1204 } 1205 } 1206 1207 void CtrlSetCallTransitionFlag::SetCachedSize(int size) const { 1208 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); 1209 _cached_size_ = size; 1210 GOOGLE_SAFE_CONCURRENT_WRITES_END(); 1211 } 1212 const ::google::protobuf::Descriptor* CtrlSetCallTransitionFlag::descriptor() { 1213 protobuf_AssignDescriptorsOnce(); 1214 return CtrlSetCallTransitionFlag_descriptor_; 1215 } 1216 1217 const CtrlSetCallTransitionFlag& CtrlSetCallTransitionFlag::default_instance() { 1218 if (default_instance_ == NULL) protobuf_AddDesc_ctrl_2eproto(); return *default_instance_; 1219 } 1220 1221 CtrlSetCallTransitionFlag* CtrlSetCallTransitionFlag::default_instance_ = NULL; 1222 1223 CtrlSetCallTransitionFlag* CtrlSetCallTransitionFlag::New() const { 1224 return new CtrlSetCallTransitionFlag; 1225 } 1226 1227 void CtrlSetCallTransitionFlag::Clear() { 1228 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { 1229 flag_ = false; 1230 } 1231 ::memset(_has_bits_, 0, sizeof(_has_bits_)); 1232 mutable_unknown_fields()->Clear(); 1233 } 1234 1235 bool CtrlSetCallTransitionFlag::MergePartialFromCodedStream( 1236 ::google::protobuf::io::CodedInputStream* input) { 1237 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false 1238 ::google::protobuf::uint32 tag; 1239 while ((tag = input->ReadTag()) != 0) { 1240 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { 1241 // required bool flag = 1; 1242 case 1: { 1243 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == 1244 ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { 1245 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< 1246 bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( 1247 input, &flag_))); 1248 _set_bit(0); 1249 } else { 1250 goto handle_uninterpreted; 1251 } 1252 if (input->ExpectAtEnd()) return true; 1253 break; 1254 } 1255 1256 default: { 1257 handle_uninterpreted: 1258 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == 1259 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { 1260 return true; 1261 } 1262 DO_(::google::protobuf::internal::WireFormat::SkipField( 1263 input, tag, mutable_unknown_fields())); 1264 break; 1265 } 1266 } 1267 } 1268 return true; 1269 #undef DO_ 1270 } 1271 1272 void CtrlSetCallTransitionFlag::SerializeWithCachedSizes( 1273 ::google::protobuf::io::CodedOutputStream* output) const { 1274 // required bool flag = 1; 1275 if (_has_bit(0)) { 1276 ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->flag(), output); 1277 } 1278 1279 if (!unknown_fields().empty()) { 1280 ::google::protobuf::internal::WireFormat::SerializeUnknownFields( 1281 unknown_fields(), output); 1282 } 1283 } 1284 1285 ::google::protobuf::uint8* CtrlSetCallTransitionFlag::SerializeWithCachedSizesToArray( 1286 ::google::protobuf::uint8* target) const { 1287 // required bool flag = 1; 1288 if (_has_bit(0)) { 1289 target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->flag(), target); 1290 } 1291 1292 if (!unknown_fields().empty()) { 1293 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( 1294 unknown_fields(), target); 1295 } 1296 return target; 1297 } 1298 1299 int CtrlSetCallTransitionFlag::ByteSize() const { 1300 int total_size = 0; 1301 1302 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { 1303 // required bool flag = 1; 1304 if (has_flag()) { 1305 total_size += 1 + 1; 1306 } 1307 1308 } 1309 if (!unknown_fields().empty()) { 1310 total_size += 1311 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( 1312 unknown_fields()); 1313 } 1314 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); 1315 _cached_size_ = total_size; 1316 GOOGLE_SAFE_CONCURRENT_WRITES_END(); 1317 return total_size; 1318 } 1319 1320 void CtrlSetCallTransitionFlag::MergeFrom(const ::google::protobuf::Message& from) { 1321 GOOGLE_CHECK_NE(&from, this); 1322 const CtrlSetCallTransitionFlag* source = 1323 ::google::protobuf::internal::dynamic_cast_if_available<const CtrlSetCallTransitionFlag*>( 1324 &from); 1325 if (source == NULL) { 1326 ::google::protobuf::internal::ReflectionOps::Merge(from, this); 1327 } else { 1328 MergeFrom(*source); 1329 } 1330 } 1331 1332 void CtrlSetCallTransitionFlag::MergeFrom(const CtrlSetCallTransitionFlag& from) { 1333 GOOGLE_CHECK_NE(&from, this); 1334 if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { 1335 if (from._has_bit(0)) { 1336 set_flag(from.flag()); 1337 } 1338 } 1339 mutable_unknown_fields()->MergeFrom(from.unknown_fields()); 1340 } 1341 1342 void CtrlSetCallTransitionFlag::CopyFrom(const ::google::protobuf::Message& from) { 1343 if (&from == this) return; 1344 Clear(); 1345 MergeFrom(from); 1346 } 1347 1348 void CtrlSetCallTransitionFlag::CopyFrom(const CtrlSetCallTransitionFlag& from) { 1349 if (&from == this) return; 1350 Clear(); 1351 MergeFrom(from); 1352 } 1353 1354 bool CtrlSetCallTransitionFlag::IsInitialized() const { 1355 if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; 1356 1357 return true; 1358 } 1359 1360 void CtrlSetCallTransitionFlag::Swap(CtrlSetCallTransitionFlag* other) { 1361 if (other != this) { 1362 std::swap(flag_, other->flag_); 1363 std::swap(_has_bits_[0], other->_has_bits_[0]); 1364 _unknown_fields_.Swap(&other->_unknown_fields_); 1365 std::swap(_cached_size_, other->_cached_size_); 1366 } 1367 } 1368 1369 ::google::protobuf::Metadata CtrlSetCallTransitionFlag::GetMetadata() const { 1370 protobuf_AssignDescriptorsOnce(); 1371 ::google::protobuf::Metadata metadata; 1372 metadata.descriptor = CtrlSetCallTransitionFlag_descriptor_; 1373 metadata.reflection = CtrlSetCallTransitionFlag_reflection_; 1374 return metadata; 1375 } 1376 1377 1378 // =================================================================== 1379 1380 const ::std::string CtrlReqAddDialingCall::_default_phone_number_; 1381 #ifndef _MSC_VER 1382 const int CtrlReqAddDialingCall::kPhoneNumberFieldNumber; 1383 #endif // !_MSC_VER 1384 1385 CtrlReqAddDialingCall::CtrlReqAddDialingCall() 1386 : ::google::protobuf::Message() { 1387 SharedCtor(); 1388 } 1389 1390 void CtrlReqAddDialingCall::InitAsDefaultInstance() { 1391 } 1392 1393 CtrlReqAddDialingCall::CtrlReqAddDialingCall(const CtrlReqAddDialingCall& from) 1394 : ::google::protobuf::Message() { 1395 SharedCtor(); 1396 MergeFrom(from); 1397 } 1398 1399 void CtrlReqAddDialingCall::SharedCtor() { 1400 _cached_size_ = 0; 1401 phone_number_ = const_cast< ::std::string*>(&_default_phone_number_); 1402 ::memset(_has_bits_, 0, sizeof(_has_bits_)); 1403 } 1404 1405 CtrlReqAddDialingCall::~CtrlReqAddDialingCall() { 1406 SharedDtor(); 1407 } 1408 1409 void CtrlReqAddDialingCall::SharedDtor() { 1410 if (phone_number_ != &_default_phone_number_) { 1411 delete phone_number_; 1412 } 1413 if (this != default_instance_) { 1414 } 1415 } 1416 1417 void CtrlReqAddDialingCall::SetCachedSize(int size) const { 1418 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); 1419 _cached_size_ = size; 1420 GOOGLE_SAFE_CONCURRENT_WRITES_END(); 1421 } 1422 const ::google::protobuf::Descriptor* CtrlReqAddDialingCall::descriptor() { 1423 protobuf_AssignDescriptorsOnce(); 1424 return CtrlReqAddDialingCall_descriptor_; 1425 } 1426 1427 const CtrlReqAddDialingCall& CtrlReqAddDialingCall::default_instance() { 1428 if (default_instance_ == NULL) protobuf_AddDesc_ctrl_2eproto(); return *default_instance_; 1429 } 1430 1431 CtrlReqAddDialingCall* CtrlReqAddDialingCall::default_instance_ = NULL; 1432 1433 CtrlReqAddDialingCall* CtrlReqAddDialingCall::New() const { 1434 return new CtrlReqAddDialingCall; 1435 } 1436 1437 void CtrlReqAddDialingCall::Clear() { 1438 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { 1439 if (_has_bit(0)) { 1440 if (phone_number_ != &_default_phone_number_) { 1441 phone_number_->clear(); 1442 } 1443 } 1444 } 1445 ::memset(_has_bits_, 0, sizeof(_has_bits_)); 1446 mutable_unknown_fields()->Clear(); 1447 } 1448 1449 bool CtrlReqAddDialingCall::MergePartialFromCodedStream( 1450 ::google::protobuf::io::CodedInputStream* input) { 1451 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false 1452 ::google::protobuf::uint32 tag; 1453 while ((tag = input->ReadTag()) != 0) { 1454 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { 1455 // required string phone_number = 1; 1456 case 1: { 1457 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == 1458 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { 1459 DO_(::google::protobuf::internal::WireFormatLite::ReadString( 1460 input, this->mutable_phone_number())); 1461 ::google::protobuf::internal::WireFormat::VerifyUTF8String( 1462 this->phone_number().data(), this->phone_number().length(), 1463 ::google::protobuf::internal::WireFormat::PARSE); 1464 } else { 1465 goto handle_uninterpreted; 1466 } 1467 if (input->ExpectAtEnd()) return true; 1468 break; 1469 } 1470 1471 default: { 1472 handle_uninterpreted: 1473 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == 1474 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { 1475 return true; 1476 } 1477 DO_(::google::protobuf::internal::WireFormat::SkipField( 1478 input, tag, mutable_unknown_fields())); 1479 break; 1480 } 1481 } 1482 } 1483 return true; 1484 #undef DO_ 1485 } 1486 1487 void CtrlReqAddDialingCall::SerializeWithCachedSizes( 1488 ::google::protobuf::io::CodedOutputStream* output) const { 1489 // required string phone_number = 1; 1490 if (_has_bit(0)) { 1491 ::google::protobuf::internal::WireFormat::VerifyUTF8String( 1492 this->phone_number().data(), this->phone_number().length(), 1493 ::google::protobuf::internal::WireFormat::SERIALIZE); 1494 ::google::protobuf::internal::WireFormatLite::WriteString( 1495 1, this->phone_number(), output); 1496 } 1497 1498 if (!unknown_fields().empty()) { 1499 ::google::protobuf::internal::WireFormat::SerializeUnknownFields( 1500 unknown_fields(), output); 1501 } 1502 } 1503 1504 ::google::protobuf::uint8* CtrlReqAddDialingCall::SerializeWithCachedSizesToArray( 1505 ::google::protobuf::uint8* target) const { 1506 // required string phone_number = 1; 1507 if (_has_bit(0)) { 1508 ::google::protobuf::internal::WireFormat::VerifyUTF8String( 1509 this->phone_number().data(), this->phone_number().length(), 1510 ::google::protobuf::internal::WireFormat::SERIALIZE); 1511 target = 1512 ::google::protobuf::internal::WireFormatLite::WriteStringToArray( 1513 1, this->phone_number(), target); 1514 } 1515 1516 if (!unknown_fields().empty()) { 1517 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( 1518 unknown_fields(), target); 1519 } 1520 return target; 1521 } 1522 1523 int CtrlReqAddDialingCall::ByteSize() const { 1524 int total_size = 0; 1525 1526 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { 1527 // required string phone_number = 1; 1528 if (has_phone_number()) { 1529 total_size += 1 + 1530 ::google::protobuf::internal::WireFormatLite::StringSize( 1531 this->phone_number()); 1532 } 1533 1534 } 1535 if (!unknown_fields().empty()) { 1536 total_size += 1537 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( 1538 unknown_fields()); 1539 } 1540 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); 1541 _cached_size_ = total_size; 1542 GOOGLE_SAFE_CONCURRENT_WRITES_END(); 1543 return total_size; 1544 } 1545 1546 void CtrlReqAddDialingCall::MergeFrom(const ::google::protobuf::Message& from) { 1547 GOOGLE_CHECK_NE(&from, this); 1548 const CtrlReqAddDialingCall* source = 1549 ::google::protobuf::internal::dynamic_cast_if_available<const CtrlReqAddDialingCall*>( 1550 &from); 1551 if (source == NULL) { 1552 ::google::protobuf::internal::ReflectionOps::Merge(from, this); 1553 } else { 1554 MergeFrom(*source); 1555 } 1556 } 1557 1558 void CtrlReqAddDialingCall::MergeFrom(const CtrlReqAddDialingCall& from) { 1559 GOOGLE_CHECK_NE(&from, this); 1560 if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { 1561 if (from._has_bit(0)) { 1562 set_phone_number(from.phone_number()); 1563 } 1564 } 1565 mutable_unknown_fields()->MergeFrom(from.unknown_fields()); 1566 } 1567 1568 void CtrlReqAddDialingCall::CopyFrom(const ::google::protobuf::Message& from) { 1569 if (&from == this) return; 1570 Clear(); 1571 MergeFrom(from); 1572 } 1573 1574 void CtrlReqAddDialingCall::CopyFrom(const CtrlReqAddDialingCall& from) { 1575 if (&from == this) return; 1576 Clear(); 1577 MergeFrom(from); 1578 } 1579 1580 bool CtrlReqAddDialingCall::IsInitialized() const { 1581 if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; 1582 1583 return true; 1584 } 1585 1586 void CtrlReqAddDialingCall::Swap(CtrlReqAddDialingCall* other) { 1587 if (other != this) { 1588 std::swap(phone_number_, other->phone_number_); 1589 std::swap(_has_bits_[0], other->_has_bits_[0]); 1590 _unknown_fields_.Swap(&other->_unknown_fields_); 1591 std::swap(_cached_size_, other->_cached_size_); 1592 } 1593 } 1594 1595 ::google::protobuf::Metadata CtrlReqAddDialingCall::GetMetadata() const { 1596 protobuf_AssignDescriptorsOnce(); 1597 ::google::protobuf::Metadata metadata; 1598 metadata.descriptor = CtrlReqAddDialingCall_descriptor_; 1599 metadata.reflection = CtrlReqAddDialingCall_reflection_; 1600 return metadata; 1601 } 1602 1603 1604 // @@protoc_insertion_point(namespace_scope) 1605 1606 } // namespace ril_proto 1607 1608 // @@protoc_insertion_point(global_scope) 1609
