ext/protobuf/api.pb.h

   1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
   2 // source: api.proto
   3
   4 #ifndef PROTOBUF_INCLUDED_api_2eproto
   5 #define PROTOBUF_INCLUDED_api_2eproto
   6
   7 #include <string>
   8
   9 #include <google/protobuf/stubs/common.h>
  10
  11 #if GOOGLE_PROTOBUF_VERSION < 3006001
  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 3006001 < 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/io/coded_stream.h>
  23 #include <google/protobuf/arena.h>
  24 #include <google/protobuf/arenastring.h>
  25 #include <google/protobuf/generated_message_table_driven.h>
  26 #include <google/protobuf/generated_message_util.h>
  27 #include <google/protobuf/inlined_string_field.h>
  28 #include <google/protobuf/metadata.h>
  29 #include <google/protobuf/message.h>
  30 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
  31 #include <google/protobuf/extension_set.h>  // IWYU pragma: export
  32 #include <google/protobuf/generated_enum_reflection.h>
  33 #include <google/protobuf/unknown_field_set.h>
  34 // @@protoc_insertion_point(includes)
  35 #define PROTOBUF_INTERNAL_EXPORT_protobuf_api_2eproto
  36
  37 namespace protobuf_api_2eproto {
  38 // Internal implementation detail -- do not use these members.
  39 struct TableStruct {
  40   static const ::google::protobuf::internal::ParseTableField entries[];
  41   static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  42   static const ::google::protobuf::internal::ParseTable schema[5];
  43   static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  44   static const ::google::protobuf::internal::SerializationTable serialization_table[];
  45   static const ::google::protobuf::uint32 offsets[];
  46 };
  47 void AddDescriptors();
  48 }  // namespace protobuf_api_2eproto
  49 namespace api {
  50 class RICControlHeader;
  51 class RICControlHeaderDefaultTypeInternal;
  52 extern RICControlHeaderDefaultTypeInternal _RICControlHeader_default_instance_;
  53 class RICControlMessage;
  54 class RICControlMessageDefaultTypeInternal;
  55 extern RICControlMessageDefaultTypeInternal _RICControlMessage_default_instance_;
  56 class RICE2APHeader;
  57 class RICE2APHeaderDefaultTypeInternal;
  58 extern RICE2APHeaderDefaultTypeInternal _RICE2APHeader_default_instance_;
  59 class RicControlGrpcReq;
  60 class RicControlGrpcReqDefaultTypeInternal;
  61 extern RicControlGrpcReqDefaultTypeInternal _RicControlGrpcReq_default_instance_;
  62 class RicControlGrpcRsp;
  63 class RicControlGrpcRspDefaultTypeInternal;
  64 extern RicControlGrpcRspDefaultTypeInternal _RicControlGrpcRsp_default_instance_;
  65 }  // namespace api
  66 namespace google {
  67 namespace protobuf {
  68 template<> ::api::RICControlHeader* Arena::CreateMaybeMessage<::api::RICControlHeader>(Arena*);
  69 template<> ::api::RICControlMessage* Arena::CreateMaybeMessage<::api::RICControlMessage>(Arena*);
  70 template<> ::api::RICE2APHeader* Arena::CreateMaybeMessage<::api::RICE2APHeader>(Arena*);
  71 template<> ::api::RicControlGrpcReq* Arena::CreateMaybeMessage<::api::RicControlGrpcReq>(Arena*);
  72 template<> ::api::RicControlGrpcRsp* Arena::CreateMaybeMessage<::api::RicControlGrpcRsp>(Arena*);
  73 }  // namespace protobuf
  74 }  // namespace google
  75 namespace api {
  76
  77 enum RICControlCellTypeEnum {
  78   RIC_CONTROL_CELL_UNKWON = 0,
  79   RIC_CONTROL_NR_CELL = 1,
  80   RIC_CONTROL_EUTRAN_CELL = 2,
  81   RICControlCellTypeEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  82   RICControlCellTypeEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
  83 };
  84 bool RICControlCellTypeEnum_IsValid(int value);
  85 const RICControlCellTypeEnum RICControlCellTypeEnum_MIN = RIC_CONTROL_CELL_UNKWON;
  86 const RICControlCellTypeEnum RICControlCellTypeEnum_MAX = RIC_CONTROL_EUTRAN_CELL;
  87 const int RICControlCellTypeEnum_ARRAYSIZE = RICControlCellTypeEnum_MAX + 1;
  88
  89 const ::google::protobuf::EnumDescriptor* RICControlCellTypeEnum_descriptor();
  90 inline const ::std::string& RICControlCellTypeEnum_Name(RICControlCellTypeEnum value) {
  91   return ::google::protobuf::internal::NameOfEnum(
  92     RICControlCellTypeEnum_descriptor(), value);
  93 }
  94 inline bool RICControlCellTypeEnum_Parse(
  95     const ::std::string& name, RICControlCellTypeEnum* value) {
  96   return ::google::protobuf::internal::ParseNamedEnum<RICControlCellTypeEnum>(
  97     RICControlCellTypeEnum_descriptor(), name, value);
  98 }
  99 enum RICControlAckEnum {
 100   RIC_CONTROL_ACK_UNKWON = 0,
 101   RIC_CONTROL_NO_ACK = 1,
 102   RIC_CONTROL_ACK = 2,
 103   RIC_CONTROL_NACK = 3,
 104   RICControlAckEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
 105   RICControlAckEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
 106 };
 107 bool RICControlAckEnum_IsValid(int value);
 108 const RICControlAckEnum RICControlAckEnum_MIN = RIC_CONTROL_ACK_UNKWON;
 109 const RICControlAckEnum RICControlAckEnum_MAX = RIC_CONTROL_NACK;
 110 const int RICControlAckEnum_ARRAYSIZE = RICControlAckEnum_MAX + 1;
 111
 112 const ::google::protobuf::EnumDescriptor* RICControlAckEnum_descriptor();
 113 inline const ::std::string& RICControlAckEnum_Name(RICControlAckEnum value) {
 114   return ::google::protobuf::internal::NameOfEnum(
 115     RICControlAckEnum_descriptor(), value);
 116 }
 117 inline bool RICControlAckEnum_Parse(
 118     const ::std::string& name, RICControlAckEnum* value) {
 119   return ::google::protobuf::internal::ParseNamedEnum<RICControlAckEnum>(
 120     RICControlAckEnum_descriptor(), name, value);
 121 }
 122 // ===================================================================
 123
 124 class RICE2APHeader : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:api.RICE2APHeader) */ {
 125  public:
 126   RICE2APHeader();
 127   virtual ~RICE2APHeader();
 128
 129   RICE2APHeader(const RICE2APHeader& from);
 130
 131   inline RICE2APHeader& operator=(const RICE2APHeader& from) {
 132     CopyFrom(from);
 133     return *this;
 134   }
 135   #if LANG_CXX11
 136   RICE2APHeader(RICE2APHeader&& from) noexcept
 137     : RICE2APHeader() {
 138     *this = ::std::move(from);
 139   }
 140
 141   inline RICE2APHeader& operator=(RICE2APHeader&& from) noexcept {
 142     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
 143       if (this != &from) InternalSwap(&from);
 144     } else {
 145       CopyFrom(from);
 146     }
 147     return *this;
 148   }
 149   #endif
 150   static const ::google::protobuf::Descriptor* descriptor();
 151   static const RICE2APHeader& default_instance();
 152
 153   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
 154   static inline const RICE2APHeader* internal_default_instance() {
 155     return reinterpret_cast<const RICE2APHeader*>(
 156                &_RICE2APHeader_default_instance_);
 157   }
 158   static constexpr int kIndexInFileMessages =
 159     0;
 160
 161   void Swap(RICE2APHeader* other);
 162   friend void swap(RICE2APHeader& a, RICE2APHeader& b) {
 163     a.Swap(&b);
 164   }
 165
 166   // implements Message ----------------------------------------------
 167
 168   inline RICE2APHeader* New() const final {
 169     return CreateMaybeMessage<RICE2APHeader>(NULL);
 170   }
 171
 172   RICE2APHeader* New(::google::protobuf::Arena* arena) const final {
 173     return CreateMaybeMessage<RICE2APHeader>(arena);
 174   }
 175   void CopyFrom(const ::google::protobuf::Message& from) final;
 176   void MergeFrom(const ::google::protobuf::Message& from) final;
 177   void CopyFrom(const RICE2APHeader& from);
 178   void MergeFrom(const RICE2APHeader& from);
 179   void Clear() final;
 180   bool IsInitialized() const final;
 181
 182   size_t ByteSizeLong() const final;
 183   bool MergePartialFromCodedStream(
 184       ::google::protobuf::io::CodedInputStream* input) final;
 185   void SerializeWithCachedSizes(
 186       ::google::protobuf::io::CodedOutputStream* output) const final;
 187   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
 188       bool deterministic, ::google::protobuf::uint8* target) const final;
 189   int GetCachedSize() const final { return _cached_size_.Get(); }
 190
 191   private:
 192   void SharedCtor();
 193   void SharedDtor();
 194   void SetCachedSize(int size) const final;
 195   void InternalSwap(RICE2APHeader* other);
 196   private:
 197   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
 198     return NULL;
 199   }
 200   inline void* MaybeArenaPtr() const {
 201     return NULL;
 202   }
 203   public:
 204
 205   ::google::protobuf::Metadata GetMetadata() const final;
 206
 207   // nested types ----------------------------------------------------
 208
 209   // accessors -------------------------------------------------------
 210
 211   // int64 RanFuncId = 1;
 212   void clear_ranfuncid();
 213   static const int kRanFuncIdFieldNumber = 1;
 214   ::google::protobuf::int64 ranfuncid() const;
 215   void set_ranfuncid(::google::protobuf::int64 value);
 216
 217   // int64 RICRequestorID = 2;
 218   void clear_ricrequestorid();
 219   static const int kRICRequestorIDFieldNumber = 2;
 220   ::google::protobuf::int64 ricrequestorid() const;
 221   void set_ricrequestorid(::google::protobuf::int64 value);
 222
 223   // @@protoc_insertion_point(class_scope:api.RICE2APHeader)
 224  private:
 225
 226   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
 227   ::google::protobuf::int64 ranfuncid_;
 228   ::google::protobuf::int64 ricrequestorid_;
 229   mutable ::google::protobuf::internal::CachedSize _cached_size_;
 230   friend struct ::protobuf_api_2eproto::TableStruct;
 231 };
 232 // -------------------------------------------------------------------
 233
 234 class RICControlHeader : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:api.RICControlHeader) */ {
 235  public:
 236   RICControlHeader();
 237   virtual ~RICControlHeader();
 238
 239   RICControlHeader(const RICControlHeader& from);
 240
 241   inline RICControlHeader& operator=(const RICControlHeader& from) {
 242     CopyFrom(from);
 243     return *this;
 244   }
 245   #if LANG_CXX11
 246   RICControlHeader(RICControlHeader&& from) noexcept
 247     : RICControlHeader() {
 248     *this = ::std::move(from);
 249   }
 250
 251   inline RICControlHeader& operator=(RICControlHeader&& from) noexcept {
 252     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
 253       if (this != &from) InternalSwap(&from);
 254     } else {
 255       CopyFrom(from);
 256     }
 257     return *this;
 258   }
 259   #endif
 260   static const ::google::protobuf::Descriptor* descriptor();
 261   static const RICControlHeader& default_instance();
 262
 263   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
 264   static inline const RICControlHeader* internal_default_instance() {
 265     return reinterpret_cast<const RICControlHeader*>(
 266                &_RICControlHeader_default_instance_);
 267   }
 268   static constexpr int kIndexInFileMessages =
 269     1;
 270
 271   void Swap(RICControlHeader* other);
 272   friend void swap(RICControlHeader& a, RICControlHeader& b) {
 273     a.Swap(&b);
 274   }
 275
 276   // implements Message ----------------------------------------------
 277
 278   inline RICControlHeader* New() const final {
 279     return CreateMaybeMessage<RICControlHeader>(NULL);
 280   }
 281
 282   RICControlHeader* New(::google::protobuf::Arena* arena) const final {
 283     return CreateMaybeMessage<RICControlHeader>(arena);
 284   }
 285   void CopyFrom(const ::google::protobuf::Message& from) final;
 286   void MergeFrom(const ::google::protobuf::Message& from) final;
 287   void CopyFrom(const RICControlHeader& from);
 288   void MergeFrom(const RICControlHeader& from);
 289   void Clear() final;
 290   bool IsInitialized() const final;
 291
 292   size_t ByteSizeLong() const final;
 293   bool MergePartialFromCodedStream(
 294       ::google::protobuf::io::CodedInputStream* input) final;
 295   void SerializeWithCachedSizes(
 296       ::google::protobuf::io::CodedOutputStream* output) const final;
 297   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
 298       bool deterministic, ::google::protobuf::uint8* target) const final;
 299   int GetCachedSize() const final { return _cached_size_.Get(); }
 300
 301   private:
 302   void SharedCtor();
 303   void SharedDtor();
 304   void SetCachedSize(int size) const final;
 305   void InternalSwap(RICControlHeader* other);
 306   private:
 307   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
 308     return NULL;
 309   }
 310   inline void* MaybeArenaPtr() const {
 311     return NULL;
 312   }
 313   public:
 314
 315   ::google::protobuf::Metadata GetMetadata() const final;
 316
 317   // nested types ----------------------------------------------------
 318
 319   // accessors -------------------------------------------------------
 320
 321   // string UEID = 3;
 322   void clear_ueid();
 323   static const int kUEIDFieldNumber = 3;
 324   const ::std::string& ueid() const;
 325   void set_ueid(const ::std::string& value);
 326   #if LANG_CXX11
 327   void set_ueid(::std::string&& value);
 328   #endif
 329   void set_ueid(const char* value);
 330   void set_ueid(const char* value, size_t size);
 331   ::std::string* mutable_ueid();
 332   ::std::string* release_ueid();
 333   void set_allocated_ueid(::std::string* ueid);
 334
 335   // int64 ControlStyle = 1;
 336   void clear_controlstyle();
 337   static const int kControlStyleFieldNumber = 1;
 338   ::google::protobuf::int64 controlstyle() const;
 339   void set_controlstyle(::google::protobuf::int64 value);
 340
 341   // int64 ControlActionId = 2;
 342   void clear_controlactionid();
 343   static const int kControlActionIdFieldNumber = 2;
 344   ::google::protobuf::int64 controlactionid() const;
 345   void set_controlactionid(::google::protobuf::int64 value);
 346
 347   // @@protoc_insertion_point(class_scope:api.RICControlHeader)
 348  private:
 349
 350   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
 351   ::google::protobuf::internal::ArenaStringPtr ueid_;
 352   ::google::protobuf::int64 controlstyle_;
 353   ::google::protobuf::int64 controlactionid_;
 354   mutable ::google::protobuf::internal::CachedSize _cached_size_;
 355   friend struct ::protobuf_api_2eproto::TableStruct;
 356 };
 357 // -------------------------------------------------------------------
 358
 359 class RICControlMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:api.RICControlMessage) */ {
 360  public:
 361   RICControlMessage();
 362   virtual ~RICControlMessage();
 363
 364   RICControlMessage(const RICControlMessage& from);
 365
 366   inline RICControlMessage& operator=(const RICControlMessage& from) {
 367     CopyFrom(from);
 368     return *this;
 369   }
 370   #if LANG_CXX11
 371   RICControlMessage(RICControlMessage&& from) noexcept
 372     : RICControlMessage() {
 373     *this = ::std::move(from);
 374   }
 375
 376   inline RICControlMessage& operator=(RICControlMessage&& from) noexcept {
 377     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
 378       if (this != &from) InternalSwap(&from);
 379     } else {
 380       CopyFrom(from);
 381     }
 382     return *this;
 383   }
 384   #endif
 385   static const ::google::protobuf::Descriptor* descriptor();
 386   static const RICControlMessage& default_instance();
 387
 388   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
 389   static inline const RICControlMessage* internal_default_instance() {
 390     return reinterpret_cast<const RICControlMessage*>(
 391                &_RICControlMessage_default_instance_);
 392   }
 393   static constexpr int kIndexInFileMessages =
 394     2;
 395
 396   void Swap(RICControlMessage* other);
 397   friend void swap(RICControlMessage& a, RICControlMessage& b) {
 398     a.Swap(&b);
 399   }
 400
 401   // implements Message ----------------------------------------------
 402
 403   inline RICControlMessage* New() const final {
 404     return CreateMaybeMessage<RICControlMessage>(NULL);
 405   }
 406
 407   RICControlMessage* New(::google::protobuf::Arena* arena) const final {
 408     return CreateMaybeMessage<RICControlMessage>(arena);
 409   }
 410   void CopyFrom(const ::google::protobuf::Message& from) final;
 411   void MergeFrom(const ::google::protobuf::Message& from) final;
 412   void CopyFrom(const RICControlMessage& from);
 413   void MergeFrom(const RICControlMessage& from);
 414   void Clear() final;
 415   bool IsInitialized() const final;
 416
 417   size_t ByteSizeLong() const final;
 418   bool MergePartialFromCodedStream(
 419       ::google::protobuf::io::CodedInputStream* input) final;
 420   void SerializeWithCachedSizes(
 421       ::google::protobuf::io::CodedOutputStream* output) const final;
 422   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
 423       bool deterministic, ::google::protobuf::uint8* target) const final;
 424   int GetCachedSize() const final { return _cached_size_.Get(); }
 425
 426   private:
 427   void SharedCtor();
 428   void SharedDtor();
 429   void SetCachedSize(int size) const final;
 430   void InternalSwap(RICControlMessage* other);
 431   private:
 432   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
 433     return NULL;
 434   }
 435   inline void* MaybeArenaPtr() const {
 436     return NULL;
 437   }
 438   public:
 439
 440   ::google::protobuf::Metadata GetMetadata() const final;
 441
 442   // nested types ----------------------------------------------------
 443
 444   // accessors -------------------------------------------------------
 445
 446   // string TargetCellID = 2;
 447   void clear_targetcellid();
 448   static const int kTargetCellIDFieldNumber = 2;
 449   const ::std::string& targetcellid() const;
 450   void set_targetcellid(const ::std::string& value);
 451   #if LANG_CXX11
 452   void set_targetcellid(::std::string&& value);
 453   #endif
 454   void set_targetcellid(const char* value);
 455   void set_targetcellid(const char* value, size_t size);
 456   ::std::string* mutable_targetcellid();
 457   ::std::string* release_targetcellid();
 458   void set_allocated_targetcellid(::std::string* targetcellid);
 459
 460   // .api.RICControlCellTypeEnum RICControlCellTypeVal = 1;
 461   void clear_riccontrolcelltypeval();
 462   static const int kRICControlCellTypeValFieldNumber = 1;
 463   ::api::RICControlCellTypeEnum riccontrolcelltypeval() const;
 464   void set_riccontrolcelltypeval(::api::RICControlCellTypeEnum value);
 465
 466   // @@protoc_insertion_point(class_scope:api.RICControlMessage)
 467  private:
 468
 469   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
 470   ::google::protobuf::internal::ArenaStringPtr targetcellid_;
 471   int riccontrolcelltypeval_;
 472   mutable ::google::protobuf::internal::CachedSize _cached_size_;
 473   friend struct ::protobuf_api_2eproto::TableStruct;
 474 };
 475 // -------------------------------------------------------------------
 476
 477 class RicControlGrpcReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:api.RicControlGrpcReq) */ {
 478  public:
 479   RicControlGrpcReq();
 480   virtual ~RicControlGrpcReq();
 481
 482   RicControlGrpcReq(const RicControlGrpcReq& from);
 483
 484   inline RicControlGrpcReq& operator=(const RicControlGrpcReq& from) {
 485     CopyFrom(from);
 486     return *this;
 487   }
 488   #if LANG_CXX11
 489   RicControlGrpcReq(RicControlGrpcReq&& from) noexcept
 490     : RicControlGrpcReq() {
 491     *this = ::std::move(from);
 492   }
 493
 494   inline RicControlGrpcReq& operator=(RicControlGrpcReq&& from) noexcept {
 495     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
 496       if (this != &from) InternalSwap(&from);
 497     } else {
 498       CopyFrom(from);
 499     }
 500     return *this;
 501   }
 502   #endif
 503   static const ::google::protobuf::Descriptor* descriptor();
 504   static const RicControlGrpcReq& default_instance();
 505
 506   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
 507   static inline const RicControlGrpcReq* internal_default_instance() {
 508     return reinterpret_cast<const RicControlGrpcReq*>(
 509                &_RicControlGrpcReq_default_instance_);
 510   }
 511   static constexpr int kIndexInFileMessages =
 512     3;
 513
 514   void Swap(RicControlGrpcReq* other);
 515   friend void swap(RicControlGrpcReq& a, RicControlGrpcReq& b) {
 516     a.Swap(&b);
 517   }
 518
 519   // implements Message ----------------------------------------------
 520
 521   inline RicControlGrpcReq* New() const final {
 522     return CreateMaybeMessage<RicControlGrpcReq>(NULL);
 523   }
 524
 525   RicControlGrpcReq* New(::google::protobuf::Arena* arena) const final {
 526     return CreateMaybeMessage<RicControlGrpcReq>(arena);
 527   }
 528   void CopyFrom(const ::google::protobuf::Message& from) final;
 529   void MergeFrom(const ::google::protobuf::Message& from) final;
 530   void CopyFrom(const RicControlGrpcReq& from);
 531   void MergeFrom(const RicControlGrpcReq& from);
 532   void Clear() final;
 533   bool IsInitialized() const final;
 534
 535   size_t ByteSizeLong() const final;
 536   bool MergePartialFromCodedStream(
 537       ::google::protobuf::io::CodedInputStream* input) final;
 538   void SerializeWithCachedSizes(
 539       ::google::protobuf::io::CodedOutputStream* output) const final;
 540   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
 541       bool deterministic, ::google::protobuf::uint8* target) const final;
 542   int GetCachedSize() const final { return _cached_size_.Get(); }
 543
 544   private:
 545   void SharedCtor();
 546   void SharedDtor();
 547   void SetCachedSize(int size) const final;
 548   void InternalSwap(RicControlGrpcReq* other);
 549   private:
 550   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
 551     return NULL;
 552   }
 553   inline void* MaybeArenaPtr() const {
 554     return NULL;
 555   }
 556   public:
 557
 558   ::google::protobuf::Metadata GetMetadata() const final;
 559
 560   // nested types ----------------------------------------------------
 561
 562   // accessors -------------------------------------------------------
 563
 564   // string e2NodeID = 1;
 565   void clear_e2nodeid();
 566   static const int kE2NodeIDFieldNumber = 1;
 567   const ::std::string& e2nodeid() const;
 568   void set_e2nodeid(const ::std::string& value);
 569   #if LANG_CXX11
 570   void set_e2nodeid(::std::string&& value);
 571   #endif
 572   void set_e2nodeid(const char* value);
 573   void set_e2nodeid(const char* value, size_t size);
 574   ::std::string* mutable_e2nodeid();
 575   ::std::string* release_e2nodeid();
 576   void set_allocated_e2nodeid(::std::string* e2nodeid);
 577
 578   // string plmnID = 2;
 579   void clear_plmnid();
 580   static const int kPlmnIDFieldNumber = 2;
 581   const ::std::string& plmnid() const;
 582   void set_plmnid(const ::std::string& value);
 583   #if LANG_CXX11
 584   void set_plmnid(::std::string&& value);
 585   #endif
 586   void set_plmnid(const char* value);
 587   void set_plmnid(const char* value, size_t size);
 588   ::std::string* mutable_plmnid();
 589   ::std::string* release_plmnid();
 590   void set_allocated_plmnid(::std::string* plmnid);
 591
 592   // string ranName = 3;
 593   void clear_ranname();
 594   static const int kRanNameFieldNumber = 3;
 595   const ::std::string& ranname() const;
 596   void set_ranname(const ::std::string& value);
 597   #if LANG_CXX11
 598   void set_ranname(::std::string&& value);
 599   #endif
 600   void set_ranname(const char* value);
 601   void set_ranname(const char* value, size_t size);
 602   ::std::string* mutable_ranname();
 603   ::std::string* release_ranname();
 604   void set_allocated_ranname(::std::string* ranname);
 605
 606   // .api.RICE2APHeader RICE2APHeaderData = 4;
 607   bool has_rice2apheaderdata() const;
 608   void clear_rice2apheaderdata();
 609   static const int kRICE2APHeaderDataFieldNumber = 4;
 610   private:
 611   const ::api::RICE2APHeader& _internal_rice2apheaderdata() const;
 612   public:
 613   const ::api::RICE2APHeader& rice2apheaderdata() const;
 614   ::api::RICE2APHeader* release_rice2apheaderdata();
 615   ::api::RICE2APHeader* mutable_rice2apheaderdata();
 616   void set_allocated_rice2apheaderdata(::api::RICE2APHeader* rice2apheaderdata);
 617
 618   // .api.RICControlHeader RICControlHeaderData = 5;
 619   bool has_riccontrolheaderdata() const;
 620   void clear_riccontrolheaderdata();
 621   static const int kRICControlHeaderDataFieldNumber = 5;
 622   private:
 623   const ::api::RICControlHeader& _internal_riccontrolheaderdata() const;
 624   public:
 625   const ::api::RICControlHeader& riccontrolheaderdata() const;
 626   ::api::RICControlHeader* release_riccontrolheaderdata();
 627   ::api::RICControlHeader* mutable_riccontrolheaderdata();
 628   void set_allocated_riccontrolheaderdata(::api::RICControlHeader* riccontrolheaderdata);
 629
 630   // .api.RICControlMessage RICControlMessageData = 6;
 631   bool has_riccontrolmessagedata() const;
 632   void clear_riccontrolmessagedata();
 633   static const int kRICControlMessageDataFieldNumber = 6;
 634   private:
 635   const ::api::RICControlMessage& _internal_riccontrolmessagedata() const;
 636   public:
 637   const ::api::RICControlMessage& riccontrolmessagedata() const;
 638   ::api::RICControlMessage* release_riccontrolmessagedata();
 639   ::api::RICControlMessage* mutable_riccontrolmessagedata();
 640   void set_allocated_riccontrolmessagedata(::api::RICControlMessage* riccontrolmessagedata);
 641
 642   // .api.RICControlAckEnum RICControlAckReqVal = 7;
 643   void clear_riccontrolackreqval();
 644   static const int kRICControlAckReqValFieldNumber = 7;
 645   ::api::RICControlAckEnum riccontrolackreqval() const;
 646   void set_riccontrolackreqval(::api::RICControlAckEnum value);
 647
 648   // @@protoc_insertion_point(class_scope:api.RicControlGrpcReq)
 649  private:
 650
 651   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
 652   ::google::protobuf::internal::ArenaStringPtr e2nodeid_;
 653   ::google::protobuf::internal::ArenaStringPtr plmnid_;
 654   ::google::protobuf::internal::ArenaStringPtr ranname_;
 655   ::api::RICE2APHeader* rice2apheaderdata_;
 656   ::api::RICControlHeader* riccontrolheaderdata_;
 657   ::api::RICControlMessage* riccontrolmessagedata_;
 658   int riccontrolackreqval_;
 659   mutable ::google::protobuf::internal::CachedSize _cached_size_;
 660   friend struct ::protobuf_api_2eproto::TableStruct;
 661 };
 662 // -------------------------------------------------------------------
 663
 664 class RicControlGrpcRsp : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:api.RicControlGrpcRsp) */ {
 665  public:
 666   RicControlGrpcRsp();
 667   virtual ~RicControlGrpcRsp();
 668
 669   RicControlGrpcRsp(const RicControlGrpcRsp& from);
 670
 671   inline RicControlGrpcRsp& operator=(const RicControlGrpcRsp& from) {
 672     CopyFrom(from);
 673     return *this;
 674   }
 675   #if LANG_CXX11
 676   RicControlGrpcRsp(RicControlGrpcRsp&& from) noexcept
 677     : RicControlGrpcRsp() {
 678     *this = ::std::move(from);
 679   }
 680
 681   inline RicControlGrpcRsp& operator=(RicControlGrpcRsp&& from) noexcept {
 682     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
 683       if (this != &from) InternalSwap(&from);
 684     } else {
 685       CopyFrom(from);
 686     }
 687     return *this;
 688   }
 689   #endif
 690   static const ::google::protobuf::Descriptor* descriptor();
 691   static const RicControlGrpcRsp& default_instance();
 692
 693   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
 694   static inline const RicControlGrpcRsp* internal_default_instance() {
 695     return reinterpret_cast<const RicControlGrpcRsp*>(
 696                &_RicControlGrpcRsp_default_instance_);
 697   }
 698   static constexpr int kIndexInFileMessages =
 699     4;
 700
 701   void Swap(RicControlGrpcRsp* other);
 702   friend void swap(RicControlGrpcRsp& a, RicControlGrpcRsp& b) {
 703     a.Swap(&b);
 704   }
 705
 706   // implements Message ----------------------------------------------
 707
 708   inline RicControlGrpcRsp* New() const final {
 709     return CreateMaybeMessage<RicControlGrpcRsp>(NULL);
 710   }
 711
 712   RicControlGrpcRsp* New(::google::protobuf::Arena* arena) const final {
 713     return CreateMaybeMessage<RicControlGrpcRsp>(arena);
 714   }
 715   void CopyFrom(const ::google::protobuf::Message& from) final;
 716   void MergeFrom(const ::google::protobuf::Message& from) final;
 717   void CopyFrom(const RicControlGrpcRsp& from);
 718   void MergeFrom(const RicControlGrpcRsp& from);
 719   void Clear() final;
 720   bool IsInitialized() const final;
 721
 722   size_t ByteSizeLong() const final;
 723   bool MergePartialFromCodedStream(
 724       ::google::protobuf::io::CodedInputStream* input) final;
 725   void SerializeWithCachedSizes(
 726       ::google::protobuf::io::CodedOutputStream* output) const final;
 727   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
 728       bool deterministic, ::google::protobuf::uint8* target) const final;
 729   int GetCachedSize() const final { return _cached_size_.Get(); }
 730
 731   private:
 732   void SharedCtor();
 733   void SharedDtor();
 734   void SetCachedSize(int size) const final;
 735   void InternalSwap(RicControlGrpcRsp* other);
 736   private:
 737   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
 738     return NULL;
 739   }
 740   inline void* MaybeArenaPtr() const {
 741     return NULL;
 742   }
 743   public:
 744
 745   ::google::protobuf::Metadata GetMetadata() const final;
 746
 747   // nested types ----------------------------------------------------
 748
 749   // accessors -------------------------------------------------------
 750
 751   // string description = 2;
 752   void clear_description();
 753   static const int kDescriptionFieldNumber = 2;
 754   const ::std::string& description() const;
 755   void set_description(const ::std::string& value);
 756   #if LANG_CXX11
 757   void set_description(::std::string&& value);
 758   #endif
 759   void set_description(const char* value);
 760   void set_description(const char* value, size_t size);
 761   ::std::string* mutable_description();
 762   ::std::string* release_description();
 763   void set_allocated_description(::std::string* description);
 764
 765   // int32 rspCode = 1;
 766   void clear_rspcode();
 767   static const int kRspCodeFieldNumber = 1;
 768   ::google::protobuf::int32 rspcode() const;
 769   void set_rspcode(::google::protobuf::int32 value);
 770
 771   // @@protoc_insertion_point(class_scope:api.RicControlGrpcRsp)
 772  private:
 773
 774   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
 775   ::google::protobuf::internal::ArenaStringPtr description_;
 776   ::google::protobuf::int32 rspcode_;
 777   mutable ::google::protobuf::internal::CachedSize _cached_size_;
 778   friend struct ::protobuf_api_2eproto::TableStruct;
 779 };
 780 // ===================================================================
 781
 782
 783 // ===================================================================
 784
 785 #ifdef __GNUC__
 786   #pragma GCC diagnostic push
 787   #pragma GCC diagnostic ignored "-Wstrict-aliasing"
 788 #endif  // __GNUC__
 789 // RICE2APHeader
 790
 791 // int64 RanFuncId = 1;
 792 inline void RICE2APHeader::clear_ranfuncid() {
 793   ranfuncid_ = GOOGLE_LONGLONG(0);
 794 }
 795 inline ::google::protobuf::int64 RICE2APHeader::ranfuncid() const {
 796   // @@protoc_insertion_point(field_get:api.RICE2APHeader.RanFuncId)
 797   return ranfuncid_;
 798 }
 799 inline void RICE2APHeader::set_ranfuncid(::google::protobuf::int64 value) {
 800
 801   ranfuncid_ = value;
 802   // @@protoc_insertion_point(field_set:api.RICE2APHeader.RanFuncId)
 803 }
 804
 805 // int64 RICRequestorID = 2;
 806 inline void RICE2APHeader::clear_ricrequestorid() {
 807   ricrequestorid_ = GOOGLE_LONGLONG(0);
 808 }
 809 inline ::google::protobuf::int64 RICE2APHeader::ricrequestorid() const {
 810   // @@protoc_insertion_point(field_get:api.RICE2APHeader.RICRequestorID)
 811   return ricrequestorid_;
 812 }
 813 inline void RICE2APHeader::set_ricrequestorid(::google::protobuf::int64 value) {
 814
 815   ricrequestorid_ = value;
 816   // @@protoc_insertion_point(field_set:api.RICE2APHeader.RICRequestorID)
 817 }
 818
 819 // -------------------------------------------------------------------
 820
 821 // RICControlHeader
 822
 823 // int64 ControlStyle = 1;
 824 inline void RICControlHeader::clear_controlstyle() {
 825   controlstyle_ = GOOGLE_LONGLONG(0);
 826 }
 827 inline ::google::protobuf::int64 RICControlHeader::controlstyle() const {
 828   // @@protoc_insertion_point(field_get:api.RICControlHeader.ControlStyle)
 829   return controlstyle_;
 830 }
 831 inline void RICControlHeader::set_controlstyle(::google::protobuf::int64 value) {
 832
 833   controlstyle_ = value;
 834   // @@protoc_insertion_point(field_set:api.RICControlHeader.ControlStyle)
 835 }
 836
 837 // int64 ControlActionId = 2;
 838 inline void RICControlHeader::clear_controlactionid() {
 839   controlactionid_ = GOOGLE_LONGLONG(0);
 840 }
 841 inline ::google::protobuf::int64 RICControlHeader::controlactionid() const {
 842   // @@protoc_insertion_point(field_get:api.RICControlHeader.ControlActionId)
 843   return controlactionid_;
 844 }
 845 inline void RICControlHeader::set_controlactionid(::google::protobuf::int64 value) {
 846
 847   controlactionid_ = value;
 848   // @@protoc_insertion_point(field_set:api.RICControlHeader.ControlActionId)
 849 }
 850
 851 // string UEID = 3;
 852 inline void RICControlHeader::clear_ueid() {
 853   ueid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 854 }
 855 inline const ::std::string& RICControlHeader::ueid() const {
 856   // @@protoc_insertion_point(field_get:api.RICControlHeader.UEID)
 857   return ueid_.GetNoArena();
 858 }
 859 inline void RICControlHeader::set_ueid(const ::std::string& value) {
 860
 861   ueid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
 862   // @@protoc_insertion_point(field_set:api.RICControlHeader.UEID)
 863 }
 864 #if LANG_CXX11
 865 inline void RICControlHeader::set_ueid(::std::string&& value) {
 866
 867   ueid_.SetNoArena(
 868     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
 869   // @@protoc_insertion_point(field_set_rvalue:api.RICControlHeader.UEID)
 870 }
 871 #endif
 872 inline void RICControlHeader::set_ueid(const char* value) {
 873   GOOGLE_DCHECK(value != NULL);
 874
 875   ueid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
 876   // @@protoc_insertion_point(field_set_char:api.RICControlHeader.UEID)
 877 }
 878 inline void RICControlHeader::set_ueid(const char* value, size_t size) {
 879
 880   ueid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
 881       ::std::string(reinterpret_cast<const char*>(value), size));
 882   // @@protoc_insertion_point(field_set_pointer:api.RICControlHeader.UEID)
 883 }
 884 inline ::std::string* RICControlHeader::mutable_ueid() {
 885
 886   // @@protoc_insertion_point(field_mutable:api.RICControlHeader.UEID)
 887   return ueid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 888 }
 889 inline ::std::string* RICControlHeader::release_ueid() {
 890   // @@protoc_insertion_point(field_release:api.RICControlHeader.UEID)
 891
 892   return ueid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 893 }
 894 inline void RICControlHeader::set_allocated_ueid(::std::string* ueid) {
 895   if (ueid != NULL) {
 896
 897   } else {
 898
 899   }
 900   ueid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ueid);
 901   // @@protoc_insertion_point(field_set_allocated:api.RICControlHeader.UEID)
 902 }
 903
 904 // -------------------------------------------------------------------
 905
 906 // RICControlMessage
 907
 908 // .api.RICControlCellTypeEnum RICControlCellTypeVal = 1;
 909 inline void RICControlMessage::clear_riccontrolcelltypeval() {
 910   riccontrolcelltypeval_ = 0;
 911 }
 912 inline ::api::RICControlCellTypeEnum RICControlMessage::riccontrolcelltypeval() const {
 913   // @@protoc_insertion_point(field_get:api.RICControlMessage.RICControlCellTypeVal)
 914   return static_cast< ::api::RICControlCellTypeEnum >(riccontrolcelltypeval_);
 915 }
 916 inline void RICControlMessage::set_riccontrolcelltypeval(::api::RICControlCellTypeEnum value) {
 917
 918   riccontrolcelltypeval_ = value;
 919   // @@protoc_insertion_point(field_set:api.RICControlMessage.RICControlCellTypeVal)
 920 }
 921
 922 // string TargetCellID = 2;
 923 inline void RICControlMessage::clear_targetcellid() {
 924   targetcellid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 925 }
 926 inline const ::std::string& RICControlMessage::targetcellid() const {
 927   // @@protoc_insertion_point(field_get:api.RICControlMessage.TargetCellID)
 928   return targetcellid_.GetNoArena();
 929 }
 930 inline void RICControlMessage::set_targetcellid(const ::std::string& value) {
 931
 932   targetcellid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
 933   // @@protoc_insertion_point(field_set:api.RICControlMessage.TargetCellID)
 934 }
 935 #if LANG_CXX11
 936 inline void RICControlMessage::set_targetcellid(::std::string&& value) {
 937
 938   targetcellid_.SetNoArena(
 939     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
 940   // @@protoc_insertion_point(field_set_rvalue:api.RICControlMessage.TargetCellID)
 941 }
 942 #endif
 943 inline void RICControlMessage::set_targetcellid(const char* value) {
 944   GOOGLE_DCHECK(value != NULL);
 945
 946   targetcellid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
 947   // @@protoc_insertion_point(field_set_char:api.RICControlMessage.TargetCellID)
 948 }
 949 inline void RICControlMessage::set_targetcellid(const char* value, size_t size) {
 950
 951   targetcellid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
 952       ::std::string(reinterpret_cast<const char*>(value), size));
 953   // @@protoc_insertion_point(field_set_pointer:api.RICControlMessage.TargetCellID)
 954 }
 955 inline ::std::string* RICControlMessage::mutable_targetcellid() {
 956
 957   // @@protoc_insertion_point(field_mutable:api.RICControlMessage.TargetCellID)
 958   return targetcellid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 959 }
 960 inline ::std::string* RICControlMessage::release_targetcellid() {
 961   // @@protoc_insertion_point(field_release:api.RICControlMessage.TargetCellID)
 962
 963   return targetcellid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 964 }
 965 inline void RICControlMessage::set_allocated_targetcellid(::std::string* targetcellid) {
 966   if (targetcellid != NULL) {
 967
 968   } else {
 969
 970   }
 971   targetcellid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), targetcellid);
 972   // @@protoc_insertion_point(field_set_allocated:api.RICControlMessage.TargetCellID)
 973 }
 974
 975 // -------------------------------------------------------------------
 976
 977 // RicControlGrpcReq
 978
 979 // string e2NodeID = 1;
 980 inline void RicControlGrpcReq::clear_e2nodeid() {
 981   e2nodeid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 982 }
 983 inline const ::std::string& RicControlGrpcReq::e2nodeid() const {
 984   // @@protoc_insertion_point(field_get:api.RicControlGrpcReq.e2NodeID)
 985   return e2nodeid_.GetNoArena();
 986 }
 987 inline void RicControlGrpcReq::set_e2nodeid(const ::std::string& value) {
 988
 989   e2nodeid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
 990   // @@protoc_insertion_point(field_set:api.RicControlGrpcReq.e2NodeID)
 991 }
 992 #if LANG_CXX11
 993 inline void RicControlGrpcReq::set_e2nodeid(::std::string&& value) {
 994
 995   e2nodeid_.SetNoArena(
 996     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
 997   // @@protoc_insertion_point(field_set_rvalue:api.RicControlGrpcReq.e2NodeID)
 998 }
 999 #endif
1000 inline void RicControlGrpcReq::set_e2nodeid(const char* value) {
1001   GOOGLE_DCHECK(value != NULL);
1002
1003   e2nodeid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1004   // @@protoc_insertion_point(field_set_char:api.RicControlGrpcReq.e2NodeID)
1005 }
1006 inline void RicControlGrpcReq::set_e2nodeid(const char* value, size_t size) {
1007
1008   e2nodeid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1009       ::std::string(reinterpret_cast<const char*>(value), size));
1010   // @@protoc_insertion_point(field_set_pointer:api.RicControlGrpcReq.e2NodeID)
1011 }
1012 inline ::std::string* RicControlGrpcReq::mutable_e2nodeid() {
1013
1014   // @@protoc_insertion_point(field_mutable:api.RicControlGrpcReq.e2NodeID)
1015   return e2nodeid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1016 }
1017 inline ::std::string* RicControlGrpcReq::release_e2nodeid() {
1018   // @@protoc_insertion_point(field_release:api.RicControlGrpcReq.e2NodeID)
1019
1020   return e2nodeid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1021 }
1022 inline void RicControlGrpcReq::set_allocated_e2nodeid(::std::string* e2nodeid) {
1023   if (e2nodeid != NULL) {
1024
1025   } else {
1026
1027   }
1028   e2nodeid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), e2nodeid);
1029   // @@protoc_insertion_point(field_set_allocated:api.RicControlGrpcReq.e2NodeID)
1030 }
1031
1032 // string plmnID = 2;
1033 inline void RicControlGrpcReq::clear_plmnid() {
1034   plmnid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1035 }
1036 inline const ::std::string& RicControlGrpcReq::plmnid() const {
1037   // @@protoc_insertion_point(field_get:api.RicControlGrpcReq.plmnID)
1038   return plmnid_.GetNoArena();
1039 }
1040 inline void RicControlGrpcReq::set_plmnid(const ::std::string& value) {
1041
1042   plmnid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1043   // @@protoc_insertion_point(field_set:api.RicControlGrpcReq.plmnID)
1044 }
1045 #if LANG_CXX11
1046 inline void RicControlGrpcReq::set_plmnid(::std::string&& value) {
1047
1048   plmnid_.SetNoArena(
1049     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1050   // @@protoc_insertion_point(field_set_rvalue:api.RicControlGrpcReq.plmnID)
1051 }
1052 #endif
1053 inline void RicControlGrpcReq::set_plmnid(const char* value) {
1054   GOOGLE_DCHECK(value != NULL);
1055
1056   plmnid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1057   // @@protoc_insertion_point(field_set_char:api.RicControlGrpcReq.plmnID)
1058 }
1059 inline void RicControlGrpcReq::set_plmnid(const char* value, size_t size) {
1060
1061   plmnid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1062       ::std::string(reinterpret_cast<const char*>(value), size));
1063   // @@protoc_insertion_point(field_set_pointer:api.RicControlGrpcReq.plmnID)
1064 }
1065 inline ::std::string* RicControlGrpcReq::mutable_plmnid() {
1066
1067   // @@protoc_insertion_point(field_mutable:api.RicControlGrpcReq.plmnID)
1068   return plmnid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1069 }
1070 inline ::std::string* RicControlGrpcReq::release_plmnid() {
1071   // @@protoc_insertion_point(field_release:api.RicControlGrpcReq.plmnID)
1072
1073   return plmnid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1074 }
1075 inline void RicControlGrpcReq::set_allocated_plmnid(::std::string* plmnid) {
1076   if (plmnid != NULL) {
1077
1078   } else {
1079
1080   }
1081   plmnid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), plmnid);
1082   // @@protoc_insertion_point(field_set_allocated:api.RicControlGrpcReq.plmnID)
1083 }
1084
1085 // string ranName = 3;
1086 inline void RicControlGrpcReq::clear_ranname() {
1087   ranname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1088 }
1089 inline const ::std::string& RicControlGrpcReq::ranname() const {
1090   // @@protoc_insertion_point(field_get:api.RicControlGrpcReq.ranName)
1091   return ranname_.GetNoArena();
1092 }
1093 inline void RicControlGrpcReq::set_ranname(const ::std::string& value) {
1094
1095   ranname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1096   // @@protoc_insertion_point(field_set:api.RicControlGrpcReq.ranName)
1097 }
1098 #if LANG_CXX11
1099 inline void RicControlGrpcReq::set_ranname(::std::string&& value) {
1100
1101   ranname_.SetNoArena(
1102     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1103   // @@protoc_insertion_point(field_set_rvalue:api.RicControlGrpcReq.ranName)
1104 }
1105 #endif
1106 inline void RicControlGrpcReq::set_ranname(const char* value) {
1107   GOOGLE_DCHECK(value != NULL);
1108
1109   ranname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1110   // @@protoc_insertion_point(field_set_char:api.RicControlGrpcReq.ranName)
1111 }
1112 inline void RicControlGrpcReq::set_ranname(const char* value, size_t size) {
1113
1114   ranname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1115       ::std::string(reinterpret_cast<const char*>(value), size));
1116   // @@protoc_insertion_point(field_set_pointer:api.RicControlGrpcReq.ranName)
1117 }
1118 inline ::std::string* RicControlGrpcReq::mutable_ranname() {
1119
1120   // @@protoc_insertion_point(field_mutable:api.RicControlGrpcReq.ranName)
1121   return ranname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1122 }
1123 inline ::std::string* RicControlGrpcReq::release_ranname() {
1124   // @@protoc_insertion_point(field_release:api.RicControlGrpcReq.ranName)
1125
1126   return ranname_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1127 }
1128 inline void RicControlGrpcReq::set_allocated_ranname(::std::string* ranname) {
1129   if (ranname != NULL) {
1130
1131   } else {
1132
1133   }
1134   ranname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ranname);
1135   // @@protoc_insertion_point(field_set_allocated:api.RicControlGrpcReq.ranName)
1136 }
1137
1138 // .api.RICE2APHeader RICE2APHeaderData = 4;
1139 inline bool RicControlGrpcReq::has_rice2apheaderdata() const {
1140   return this != internal_default_instance() && rice2apheaderdata_ != NULL;
1141 }
1142 inline void RicControlGrpcReq::clear_rice2apheaderdata() {
1143   if (GetArenaNoVirtual() == NULL && rice2apheaderdata_ != NULL) {
1144     delete rice2apheaderdata_;
1145   }
1146   rice2apheaderdata_ = NULL;
1147 }
1148 inline const ::api::RICE2APHeader& RicControlGrpcReq::_internal_rice2apheaderdata() const {
1149   return *rice2apheaderdata_;
1150 }
1151 inline const ::api::RICE2APHeader& RicControlGrpcReq::rice2apheaderdata() const {
1152   const ::api::RICE2APHeader* p = rice2apheaderdata_;
1153   // @@protoc_insertion_point(field_get:api.RicControlGrpcReq.RICE2APHeaderData)
1154   return p != NULL ? *p : *reinterpret_cast<const ::api::RICE2APHeader*>(
1155       &::api::_RICE2APHeader_default_instance_);
1156 }
1157 inline ::api::RICE2APHeader* RicControlGrpcReq::release_rice2apheaderdata() {
1158   // @@protoc_insertion_point(field_release:api.RicControlGrpcReq.RICE2APHeaderData)
1159
1160   ::api::RICE2APHeader* temp = rice2apheaderdata_;
1161   rice2apheaderdata_ = NULL;
1162   return temp;
1163 }
1164 inline ::api::RICE2APHeader* RicControlGrpcReq::mutable_rice2apheaderdata() {
1165
1166   if (rice2apheaderdata_ == NULL) {
1167     auto* p = CreateMaybeMessage<::api::RICE2APHeader>(GetArenaNoVirtual());
1168     rice2apheaderdata_ = p;
1169   }
1170   // @@protoc_insertion_point(field_mutable:api.RicControlGrpcReq.RICE2APHeaderData)
1171   return rice2apheaderdata_;
1172 }
1173 inline void RicControlGrpcReq::set_allocated_rice2apheaderdata(::api::RICE2APHeader* rice2apheaderdata) {
1174   ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
1175   if (message_arena == NULL) {
1176     delete rice2apheaderdata_;
1177   }
1178   if (rice2apheaderdata) {
1179     ::google::protobuf::Arena* submessage_arena = NULL;
1180     if (message_arena != submessage_arena) {
1181       rice2apheaderdata = ::google::protobuf::internal::GetOwnedMessage(
1182           message_arena, rice2apheaderdata, submessage_arena);
1183     }
1184
1185   } else {
1186
1187   }
1188   rice2apheaderdata_ = rice2apheaderdata;
1189   // @@protoc_insertion_point(field_set_allocated:api.RicControlGrpcReq.RICE2APHeaderData)
1190 }
1191
1192 // .api.RICControlHeader RICControlHeaderData = 5;
1193 inline bool RicControlGrpcReq::has_riccontrolheaderdata() const {
1194   return this != internal_default_instance() && riccontrolheaderdata_ != NULL;
1195 }
1196 inline void RicControlGrpcReq::clear_riccontrolheaderdata() {
1197   if (GetArenaNoVirtual() == NULL && riccontrolheaderdata_ != NULL) {
1198     delete riccontrolheaderdata_;
1199   }
1200   riccontrolheaderdata_ = NULL;
1201 }
1202 inline const ::api::RICControlHeader& RicControlGrpcReq::_internal_riccontrolheaderdata() const {
1203   return *riccontrolheaderdata_;
1204 }
1205 inline const ::api::RICControlHeader& RicControlGrpcReq::riccontrolheaderdata() const {
1206   const ::api::RICControlHeader* p = riccontrolheaderdata_;
1207   // @@protoc_insertion_point(field_get:api.RicControlGrpcReq.RICControlHeaderData)
1208   return p != NULL ? *p : *reinterpret_cast<const ::api::RICControlHeader*>(
1209       &::api::_RICControlHeader_default_instance_);
1210 }
1211 inline ::api::RICControlHeader* RicControlGrpcReq::release_riccontrolheaderdata() {
1212   // @@protoc_insertion_point(field_release:api.RicControlGrpcReq.RICControlHeaderData)
1213
1214   ::api::RICControlHeader* temp = riccontrolheaderdata_;
1215   riccontrolheaderdata_ = NULL;
1216   return temp;
1217 }
1218 inline ::api::RICControlHeader* RicControlGrpcReq::mutable_riccontrolheaderdata() {
1219
1220   if (riccontrolheaderdata_ == NULL) {
1221     auto* p = CreateMaybeMessage<::api::RICControlHeader>(GetArenaNoVirtual());
1222     riccontrolheaderdata_ = p;
1223   }
1224   // @@protoc_insertion_point(field_mutable:api.RicControlGrpcReq.RICControlHeaderData)
1225   return riccontrolheaderdata_;
1226 }
1227 inline void RicControlGrpcReq::set_allocated_riccontrolheaderdata(::api::RICControlHeader* riccontrolheaderdata) {
1228   ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
1229   if (message_arena == NULL) {
1230     delete riccontrolheaderdata_;
1231   }
1232   if (riccontrolheaderdata) {
1233     ::google::protobuf::Arena* submessage_arena = NULL;
1234     if (message_arena != submessage_arena) {
1235       riccontrolheaderdata = ::google::protobuf::internal::GetOwnedMessage(
1236           message_arena, riccontrolheaderdata, submessage_arena);
1237     }
1238
1239   } else {
1240
1241   }
1242   riccontrolheaderdata_ = riccontrolheaderdata;
1243   // @@protoc_insertion_point(field_set_allocated:api.RicControlGrpcReq.RICControlHeaderData)
1244 }
1245
1246 // .api.RICControlMessage RICControlMessageData = 6;
1247 inline bool RicControlGrpcReq::has_riccontrolmessagedata() const {
1248   return this != internal_default_instance() && riccontrolmessagedata_ != NULL;
1249 }
1250 inline void RicControlGrpcReq::clear_riccontrolmessagedata() {
1251   if (GetArenaNoVirtual() == NULL && riccontrolmessagedata_ != NULL) {
1252     delete riccontrolmessagedata_;
1253   }
1254   riccontrolmessagedata_ = NULL;
1255 }
1256 inline const ::api::RICControlMessage& RicControlGrpcReq::_internal_riccontrolmessagedata() const {
1257   return *riccontrolmessagedata_;
1258 }
1259 inline const ::api::RICControlMessage& RicControlGrpcReq::riccontrolmessagedata() const {
1260   const ::api::RICControlMessage* p = riccontrolmessagedata_;
1261   // @@protoc_insertion_point(field_get:api.RicControlGrpcReq.RICControlMessageData)
1262   return p != NULL ? *p : *reinterpret_cast<const ::api::RICControlMessage*>(
1263       &::api::_RICControlMessage_default_instance_);
1264 }
1265 inline ::api::RICControlMessage* RicControlGrpcReq::release_riccontrolmessagedata() {
1266   // @@protoc_insertion_point(field_release:api.RicControlGrpcReq.RICControlMessageData)
1267
1268   ::api::RICControlMessage* temp = riccontrolmessagedata_;
1269   riccontrolmessagedata_ = NULL;
1270   return temp;
1271 }
1272 inline ::api::RICControlMessage* RicControlGrpcReq::mutable_riccontrolmessagedata() {
1273
1274   if (riccontrolmessagedata_ == NULL) {
1275     auto* p = CreateMaybeMessage<::api::RICControlMessage>(GetArenaNoVirtual());
1276     riccontrolmessagedata_ = p;
1277   }
1278   // @@protoc_insertion_point(field_mutable:api.RicControlGrpcReq.RICControlMessageData)
1279   return riccontrolmessagedata_;
1280 }
1281 inline void RicControlGrpcReq::set_allocated_riccontrolmessagedata(::api::RICControlMessage* riccontrolmessagedata) {
1282   ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
1283   if (message_arena == NULL) {
1284     delete riccontrolmessagedata_;
1285   }
1286   if (riccontrolmessagedata) {
1287     ::google::protobuf::Arena* submessage_arena = NULL;
1288     if (message_arena != submessage_arena) {
1289       riccontrolmessagedata = ::google::protobuf::internal::GetOwnedMessage(
1290           message_arena, riccontrolmessagedata, submessage_arena);
1291     }
1292
1293   } else {
1294
1295   }
1296   riccontrolmessagedata_ = riccontrolmessagedata;
1297   // @@protoc_insertion_point(field_set_allocated:api.RicControlGrpcReq.RICControlMessageData)
1298 }
1299
1300 // .api.RICControlAckEnum RICControlAckReqVal = 7;
1301 inline void RicControlGrpcReq::clear_riccontrolackreqval() {
1302   riccontrolackreqval_ = 0;
1303 }
1304 inline ::api::RICControlAckEnum RicControlGrpcReq::riccontrolackreqval() const {
1305   // @@protoc_insertion_point(field_get:api.RicControlGrpcReq.RICControlAckReqVal)
1306   return static_cast< ::api::RICControlAckEnum >(riccontrolackreqval_);
1307 }
1308 inline void RicControlGrpcReq::set_riccontrolackreqval(::api::RICControlAckEnum value) {
1309
1310   riccontrolackreqval_ = value;
1311   // @@protoc_insertion_point(field_set:api.RicControlGrpcReq.RICControlAckReqVal)
1312 }
1313
1314 // -------------------------------------------------------------------
1315
1316 // RicControlGrpcRsp
1317
1318 // int32 rspCode = 1;
1319 inline void RicControlGrpcRsp::clear_rspcode() {
1320   rspcode_ = 0;
1321 }
1322 inline ::google::protobuf::int32 RicControlGrpcRsp::rspcode() const {
1323   // @@protoc_insertion_point(field_get:api.RicControlGrpcRsp.rspCode)
1324   return rspcode_;
1325 }
1326 inline void RicControlGrpcRsp::set_rspcode(::google::protobuf::int32 value) {
1327
1328   rspcode_ = value;
1329   // @@protoc_insertion_point(field_set:api.RicControlGrpcRsp.rspCode)
1330 }
1331
1332 // string description = 2;
1333 inline void RicControlGrpcRsp::clear_description() {
1334   description_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1335 }
1336 inline const ::std::string& RicControlGrpcRsp::description() const {
1337   // @@protoc_insertion_point(field_get:api.RicControlGrpcRsp.description)
1338   return description_.GetNoArena();
1339 }
1340 inline void RicControlGrpcRsp::set_description(const ::std::string& value) {
1341
1342   description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1343   // @@protoc_insertion_point(field_set:api.RicControlGrpcRsp.description)
1344 }
1345 #if LANG_CXX11
1346 inline void RicControlGrpcRsp::set_description(::std::string&& value) {
1347
1348   description_.SetNoArena(
1349     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1350   // @@protoc_insertion_point(field_set_rvalue:api.RicControlGrpcRsp.description)
1351 }
1352 #endif
1353 inline void RicControlGrpcRsp::set_description(const char* value) {
1354   GOOGLE_DCHECK(value != NULL);
1355
1356   description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1357   // @@protoc_insertion_point(field_set_char:api.RicControlGrpcRsp.description)
1358 }
1359 inline void RicControlGrpcRsp::set_description(const char* value, size_t size) {
1360
1361   description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1362       ::std::string(reinterpret_cast<const char*>(value), size));
1363   // @@protoc_insertion_point(field_set_pointer:api.RicControlGrpcRsp.description)
1364 }
1365 inline ::std::string* RicControlGrpcRsp::mutable_description() {
1366
1367   // @@protoc_insertion_point(field_mutable:api.RicControlGrpcRsp.description)
1368   return description_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1369 }
1370 inline ::std::string* RicControlGrpcRsp::release_description() {
1371   // @@protoc_insertion_point(field_release:api.RicControlGrpcRsp.description)
1372
1373   return description_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1374 }
1375 inline void RicControlGrpcRsp::set_allocated_description(::std::string* description) {
1376   if (description != NULL) {
1377
1378   } else {
1379
1380   }
1381   description_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description);
1382   // @@protoc_insertion_point(field_set_allocated:api.RicControlGrpcRsp.description)
1383 }
1384
1385 #ifdef __GNUC__
1386   #pragma GCC diagnostic pop
1387 #endif  // __GNUC__
1388 // -------------------------------------------------------------------
1389
1390 // -------------------------------------------------------------------
1391
1392 // -------------------------------------------------------------------
1393
1394 // -------------------------------------------------------------------
1395
1396
1397 // @@protoc_insertion_point(namespace_scope)
1398
1399 }  // namespace api
1400
1401 namespace google {
1402 namespace protobuf {
1403
1404 template <> struct is_proto_enum< ::api::RICControlCellTypeEnum> : ::std::true_type {};
1405 template <>
1406 inline const EnumDescriptor* GetEnumDescriptor< ::api::RICControlCellTypeEnum>() {
1407   return ::api::RICControlCellTypeEnum_descriptor();
1408 }
1409 template <> struct is_proto_enum< ::api::RICControlAckEnum> : ::std::true_type {};
1410 template <>
1411 inline const EnumDescriptor* GetEnumDescriptor< ::api::RICControlAckEnum>() {
1412   return ::api::RICControlAckEnum_descriptor();
1413 }
1414
1415 }  // namespace protobuf
1416 }  // namespace google
1417
1418 // @@protoc_insertion_point(global_scope)
1419
1420 #endif  // PROTOBUF_INCLUDED_api_2eproto