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

   1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
   2 // source: ctrl.proto
   3
   4 #ifndef PROTOBUF_ctrl_2eproto__INCLUDED
   5 #define PROTOBUF_ctrl_2eproto__INCLUDED
   6
   7 #include <string>
   8
   9 #include <google/protobuf/stubs/common.h>
  10
  11 #if GOOGLE_PROTOBUF_VERSION < 2003000
  12 #error This file was generated by a newer version of protoc which is
  13 #error incompatible with your Protocol Buffer headers.  Please update
  14 #error your headers.
  15 #endif
  16 #if 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
  17 #error This file was generated by an older version of protoc which is
  18 #error incompatible with your Protocol Buffer headers.  Please
  19 #error regenerate this file with a newer version of protoc.
  20 #endif
  21
  22 #include <google/protobuf/generated_message_util.h>
  23 #include <google/protobuf/repeated_field.h>
  24 #include <google/protobuf/extension_set.h>
  25 #include <google/protobuf/generated_message_reflection.h>
  26 #include "ril.pb.h"
  27 // @@protoc_insertion_point(includes)
  28
  29 namespace ril_proto {
  30
  31 // Internal implementation detail -- do not call these.
  32 void  protobuf_AddDesc_ctrl_2eproto();
  33 void protobuf_AssignDesc_ctrl_2eproto();
  34 void protobuf_ShutdownFile_ctrl_2eproto();
  35
  36 class CtrlReqRadioState;
  37 class CtrlRspRadioState;
  38 class CtrlReqSetMTCall;
  39
  40 enum CtrlCmd {
  41   CTRL_CMD_ECHO = 0,
  42   CTRL_CMD_GET_RADIO_STATE = 1,
  43   CTRL_CMD_SET_RADIO_STATE = 2,
  44   CTRL_CMD_SET_MT_CALL = 1001
  45 };
  46 bool CtrlCmd_IsValid(int value);
  47 const CtrlCmd CtrlCmd_MIN = CTRL_CMD_ECHO;
  48 const CtrlCmd CtrlCmd_MAX = CTRL_CMD_SET_MT_CALL;
  49 const int CtrlCmd_ARRAYSIZE = CtrlCmd_MAX + 1;
  50
  51 const ::google::protobuf::EnumDescriptor* CtrlCmd_descriptor();
  52 inline const ::std::string& CtrlCmd_Name(CtrlCmd value) {
  53   return ::google::protobuf::internal::NameOfEnum(
  54     CtrlCmd_descriptor(), value);
  55 }
  56 inline bool CtrlCmd_Parse(
  57     const ::std::string& name, CtrlCmd* value) {
  58   return ::google::protobuf::internal::ParseNamedEnum<CtrlCmd>(
  59     CtrlCmd_descriptor(), name, value);
  60 }
  61 enum CtrlStatus {
  62   CTRL_STATUS_OK = 0,
  63   CTRL_STATUS_ERR = 1
  64 };
  65 bool CtrlStatus_IsValid(int value);
  66 const CtrlStatus CtrlStatus_MIN = CTRL_STATUS_OK;
  67 const CtrlStatus CtrlStatus_MAX = CTRL_STATUS_ERR;
  68 const int CtrlStatus_ARRAYSIZE = CtrlStatus_MAX + 1;
  69
  70 const ::google::protobuf::EnumDescriptor* CtrlStatus_descriptor();
  71 inline const ::std::string& CtrlStatus_Name(CtrlStatus value) {
  72   return ::google::protobuf::internal::NameOfEnum(
  73     CtrlStatus_descriptor(), value);
  74 }
  75 inline bool CtrlStatus_Parse(
  76     const ::std::string& name, CtrlStatus* value) {
  77   return ::google::protobuf::internal::ParseNamedEnum<CtrlStatus>(
  78     CtrlStatus_descriptor(), name, value);
  79 }
  80 // ===================================================================
  81
  82 class CtrlReqRadioState : public ::google::protobuf::Message {
  83  public:
  84   CtrlReqRadioState();
  85   virtual ~CtrlReqRadioState();
  86
  87   CtrlReqRadioState(const CtrlReqRadioState& from);
  88
  89   inline CtrlReqRadioState& operator=(const CtrlReqRadioState& from) {
  90     CopyFrom(from);
  91     return *this;
  92   }
  93
  94   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
  95     return _unknown_fields_;
  96   }
  97
  98   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
  99     return &_unknown_fields_;
 100   }
 101
 102   static const ::google::protobuf::Descriptor* descriptor();
 103   static const CtrlReqRadioState& default_instance();
 104
 105   void Swap(CtrlReqRadioState* other);
 106
 107   // implements Message ----------------------------------------------
 108
 109   CtrlReqRadioState* New() const;
 110   void CopyFrom(const ::google::protobuf::Message& from);
 111   void MergeFrom(const ::google::protobuf::Message& from);
 112   void CopyFrom(const CtrlReqRadioState& from);
 113   void MergeFrom(const CtrlReqRadioState& from);
 114   void Clear();
 115   bool IsInitialized() const;
 116
 117   int ByteSize() const;
 118   bool MergePartialFromCodedStream(
 119       ::google::protobuf::io::CodedInputStream* input);
 120   void SerializeWithCachedSizes(
 121       ::google::protobuf::io::CodedOutputStream* output) const;
 122   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 123   int GetCachedSize() const { return _cached_size_; }
 124   private:
 125   void SharedCtor();
 126   void SharedDtor();
 127   void SetCachedSize(int size) const;
 128   public:
 129
 130   ::google::protobuf::Metadata GetMetadata() const;
 131
 132   // nested types ----------------------------------------------------
 133
 134   // accessors -------------------------------------------------------
 135
 136   // required .ril_proto.RadioState state = 1;
 137   inline bool has_state() const;
 138   inline void clear_state();
 139   static const int kStateFieldNumber = 1;
 140   inline ril_proto::RadioState state() const;
 141   inline void set_state(ril_proto::RadioState value);
 142
 143   // @@protoc_insertion_point(class_scope:ril_proto.CtrlReqRadioState)
 144  private:
 145   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 146   mutable int _cached_size_;
 147
 148   int state_;
 149   friend void  protobuf_AddDesc_ctrl_2eproto();
 150   friend void protobuf_AssignDesc_ctrl_2eproto();
 151   friend void protobuf_ShutdownFile_ctrl_2eproto();
 152
 153   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
 154
 155   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
 156   inline bool _has_bit(int index) const {
 157     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
 158   }
 159   inline void _set_bit(int index) {
 160     _has_bits_[index / 32] |= (1u << (index % 32));
 161   }
 162   inline void _clear_bit(int index) {
 163     _has_bits_[index / 32] &= ~(1u << (index % 32));
 164   }
 165
 166   void InitAsDefaultInstance();
 167   static CtrlReqRadioState* default_instance_;
 168 };
 169 // -------------------------------------------------------------------
 170
 171 class CtrlRspRadioState : public ::google::protobuf::Message {
 172  public:
 173   CtrlRspRadioState();
 174   virtual ~CtrlRspRadioState();
 175
 176   CtrlRspRadioState(const CtrlRspRadioState& from);
 177
 178   inline CtrlRspRadioState& operator=(const CtrlRspRadioState& from) {
 179     CopyFrom(from);
 180     return *this;
 181   }
 182
 183   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 184     return _unknown_fields_;
 185   }
 186
 187   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 188     return &_unknown_fields_;
 189   }
 190
 191   static const ::google::protobuf::Descriptor* descriptor();
 192   static const CtrlRspRadioState& default_instance();
 193
 194   void Swap(CtrlRspRadioState* other);
 195
 196   // implements Message ----------------------------------------------
 197
 198   CtrlRspRadioState* New() const;
 199   void CopyFrom(const ::google::protobuf::Message& from);
 200   void MergeFrom(const ::google::protobuf::Message& from);
 201   void CopyFrom(const CtrlRspRadioState& from);
 202   void MergeFrom(const CtrlRspRadioState& from);
 203   void Clear();
 204   bool IsInitialized() const;
 205
 206   int ByteSize() const;
 207   bool MergePartialFromCodedStream(
 208       ::google::protobuf::io::CodedInputStream* input);
 209   void SerializeWithCachedSizes(
 210       ::google::protobuf::io::CodedOutputStream* output) const;
 211   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 212   int GetCachedSize() const { return _cached_size_; }
 213   private:
 214   void SharedCtor();
 215   void SharedDtor();
 216   void SetCachedSize(int size) const;
 217   public:
 218
 219   ::google::protobuf::Metadata GetMetadata() const;
 220
 221   // nested types ----------------------------------------------------
 222
 223   // accessors -------------------------------------------------------
 224
 225   // required .ril_proto.RadioState state = 1;
 226   inline bool has_state() const;
 227   inline void clear_state();
 228   static const int kStateFieldNumber = 1;
 229   inline ril_proto::RadioState state() const;
 230   inline void set_state(ril_proto::RadioState value);
 231
 232   // @@protoc_insertion_point(class_scope:ril_proto.CtrlRspRadioState)
 233  private:
 234   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 235   mutable int _cached_size_;
 236
 237   int state_;
 238   friend void  protobuf_AddDesc_ctrl_2eproto();
 239   friend void protobuf_AssignDesc_ctrl_2eproto();
 240   friend void protobuf_ShutdownFile_ctrl_2eproto();
 241
 242   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
 243
 244   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
 245   inline bool _has_bit(int index) const {
 246     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
 247   }
 248   inline void _set_bit(int index) {
 249     _has_bits_[index / 32] |= (1u << (index % 32));
 250   }
 251   inline void _clear_bit(int index) {
 252     _has_bits_[index / 32] &= ~(1u << (index % 32));
 253   }
 254
 255   void InitAsDefaultInstance();
 256   static CtrlRspRadioState* default_instance_;
 257 };
 258 // -------------------------------------------------------------------
 259
 260 class CtrlReqSetMTCall : public ::google::protobuf::Message {
 261  public:
 262   CtrlReqSetMTCall();
 263   virtual ~CtrlReqSetMTCall();
 264
 265   CtrlReqSetMTCall(const CtrlReqSetMTCall& from);
 266
 267   inline CtrlReqSetMTCall& operator=(const CtrlReqSetMTCall& from) {
 268     CopyFrom(from);
 269     return *this;
 270   }
 271
 272   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 273     return _unknown_fields_;
 274   }
 275
 276   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 277     return &_unknown_fields_;
 278   }
 279
 280   static const ::google::protobuf::Descriptor* descriptor();
 281   static const CtrlReqSetMTCall& default_instance();
 282
 283   void Swap(CtrlReqSetMTCall* other);
 284
 285   // implements Message ----------------------------------------------
 286
 287   CtrlReqSetMTCall* New() const;
 288   void CopyFrom(const ::google::protobuf::Message& from);
 289   void MergeFrom(const ::google::protobuf::Message& from);
 290   void CopyFrom(const CtrlReqSetMTCall& from);
 291   void MergeFrom(const CtrlReqSetMTCall& from);
 292   void Clear();
 293   bool IsInitialized() const;
 294
 295   int ByteSize() const;
 296   bool MergePartialFromCodedStream(
 297       ::google::protobuf::io::CodedInputStream* input);
 298   void SerializeWithCachedSizes(
 299       ::google::protobuf::io::CodedOutputStream* output) const;
 300   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 301   int GetCachedSize() const { return _cached_size_; }
 302   private:
 303   void SharedCtor();
 304   void SharedDtor();
 305   void SetCachedSize(int size) const;
 306   public:
 307
 308   ::google::protobuf::Metadata GetMetadata() const;
 309
 310   // nested types ----------------------------------------------------
 311
 312   // accessors -------------------------------------------------------
 313
 314   // required string phone_number = 1;
 315   inline bool has_phone_number() const;
 316   inline void clear_phone_number();
 317   static const int kPhoneNumberFieldNumber = 1;
 318   inline const ::std::string& phone_number() const;
 319   inline void set_phone_number(const ::std::string& value);
 320   inline void set_phone_number(const char* value);
 321   inline void set_phone_number(const char* value, size_t size);
 322   inline ::std::string* mutable_phone_number();
 323
 324   // @@protoc_insertion_point(class_scope:ril_proto.CtrlReqSetMTCall)
 325  private:
 326   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 327   mutable int _cached_size_;
 328
 329   ::std::string* phone_number_;
 330   static const ::std::string _default_phone_number_;
 331   friend void  protobuf_AddDesc_ctrl_2eproto();
 332   friend void protobuf_AssignDesc_ctrl_2eproto();
 333   friend void protobuf_ShutdownFile_ctrl_2eproto();
 334
 335   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
 336
 337   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
 338   inline bool _has_bit(int index) const {
 339     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
 340   }
 341   inline void _set_bit(int index) {
 342     _has_bits_[index / 32] |= (1u << (index % 32));
 343   }
 344   inline void _clear_bit(int index) {
 345     _has_bits_[index / 32] &= ~(1u << (index % 32));
 346   }
 347
 348   void InitAsDefaultInstance();
 349   static CtrlReqSetMTCall* default_instance_;
 350 };
 351 // ===================================================================
 352
 353
 354 // ===================================================================
 355
 356 // CtrlReqRadioState
 357
 358 // required .ril_proto.RadioState state = 1;
 359 inline bool CtrlReqRadioState::has_state() const {
 360   return _has_bit(0);
 361 }
 362 inline void CtrlReqRadioState::clear_state() {
 363   state_ = 0;
 364   _clear_bit(0);
 365 }
 366 inline ril_proto::RadioState CtrlReqRadioState::state() const {
 367   return static_cast< ril_proto::RadioState >(state_);
 368 }
 369 inline void CtrlReqRadioState::set_state(ril_proto::RadioState value) {
 370   GOOGLE_DCHECK(ril_proto::RadioState_IsValid(value));
 371   _set_bit(0);
 372   state_ = value;
 373 }
 374
 375 // -------------------------------------------------------------------
 376
 377 // CtrlRspRadioState
 378
 379 // required .ril_proto.RadioState state = 1;
 380 inline bool CtrlRspRadioState::has_state() const {
 381   return _has_bit(0);
 382 }
 383 inline void CtrlRspRadioState::clear_state() {
 384   state_ = 0;
 385   _clear_bit(0);
 386 }
 387 inline ril_proto::RadioState CtrlRspRadioState::state() const {
 388   return static_cast< ril_proto::RadioState >(state_);
 389 }
 390 inline void CtrlRspRadioState::set_state(ril_proto::RadioState value) {
 391   GOOGLE_DCHECK(ril_proto::RadioState_IsValid(value));
 392   _set_bit(0);
 393   state_ = value;
 394 }
 395
 396 // -------------------------------------------------------------------
 397
 398 // CtrlReqSetMTCall
 399
 400 // required string phone_number = 1;
 401 inline bool CtrlReqSetMTCall::has_phone_number() const {
 402   return _has_bit(0);
 403 }
 404 inline void CtrlReqSetMTCall::clear_phone_number() {
 405   if (phone_number_ != &_default_phone_number_) {
 406     phone_number_->clear();
 407   }
 408   _clear_bit(0);
 409 }
 410 inline const ::std::string& CtrlReqSetMTCall::phone_number() const {
 411   return *phone_number_;
 412 }
 413 inline void CtrlReqSetMTCall::set_phone_number(const ::std::string& value) {
 414   _set_bit(0);
 415   if (phone_number_ == &_default_phone_number_) {
 416     phone_number_ = new ::std::string;
 417   }
 418   phone_number_->assign(value);
 419 }
 420 inline void CtrlReqSetMTCall::set_phone_number(const char* value) {
 421   _set_bit(0);
 422   if (phone_number_ == &_default_phone_number_) {
 423     phone_number_ = new ::std::string;
 424   }
 425   phone_number_->assign(value);
 426 }
 427 inline void CtrlReqSetMTCall::set_phone_number(const char* value, size_t size) {
 428   _set_bit(0);
 429   if (phone_number_ == &_default_phone_number_) {
 430     phone_number_ = new ::std::string;
 431   }
 432   phone_number_->assign(reinterpret_cast<const char*>(value), size);
 433 }
 434 inline ::std::string* CtrlReqSetMTCall::mutable_phone_number() {
 435   _set_bit(0);
 436   if (phone_number_ == &_default_phone_number_) {
 437     phone_number_ = new ::std::string;
 438   }
 439   return phone_number_;
 440 }
 441
 442
 443 // @@protoc_insertion_point(namespace_scope)
 444
 445 }  // namespace ril_proto
 446
 447 #ifndef SWIG
 448 namespace google {
 449 namespace protobuf {
 450
 451 template <>
 452 inline const EnumDescriptor* GetEnumDescriptor< ril_proto::CtrlCmd>() {
 453   return ril_proto::CtrlCmd_descriptor();
 454 }
 455 template <>
 456 inline const EnumDescriptor* GetEnumDescriptor< ril_proto::CtrlStatus>() {
 457   return ril_proto::CtrlStatus_descriptor();
 458 }
 459
 460 }  // namespace google
 461 }  // namespace protobuf
 462 #endif  // SWIG
 463
 464 // @@protoc_insertion_point(global_scope)
 465
 466 #endif  // PROTOBUF_ctrl_2eproto__INCLUDED