ext/protobuf/rc.pb.h

   1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
   2 // source: rc.proto
   3
   4 #ifndef PROTOBUF_INCLUDED_rc_2eproto
   5 #define PROTOBUF_INCLUDED_rc_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_rc_2eproto
  36
  37 namespace protobuf_rc_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[8];
  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_rc_2eproto
  49 namespace rc {
  50 class Guami;
  51 class GuamiDefaultTypeInternal;
  52 extern GuamiDefaultTypeInternal _Guami_default_instance_;
  53 class RICControlHeader;
  54 class RICControlHeaderDefaultTypeInternal;
  55 extern RICControlHeaderDefaultTypeInternal _RICControlHeader_default_instance_;
  56 class RICControlMessage;
  57 class RICControlMessageDefaultTypeInternal;
  58 extern RICControlMessageDefaultTypeInternal _RICControlMessage_default_instance_;
  59 class RICE2APHeader;
  60 class RICE2APHeaderDefaultTypeInternal;
  61 extern RICE2APHeaderDefaultTypeInternal _RICE2APHeader_default_instance_;
  62 class RicControlGrpcReq;
  63 class RicControlGrpcReqDefaultTypeInternal;
  64 extern RicControlGrpcReqDefaultTypeInternal _RicControlGrpcReq_default_instance_;
  65 class RicControlGrpcRsp;
  66 class RicControlGrpcRspDefaultTypeInternal;
  67 extern RicControlGrpcRspDefaultTypeInternal _RicControlGrpcRsp_default_instance_;
  68 class UeId;
  69 class UeIdDefaultTypeInternal;
  70 extern UeIdDefaultTypeInternal _UeId_default_instance_;
  71 class gNBUEID;
  72 class gNBUEIDDefaultTypeInternal;
  73 extern gNBUEIDDefaultTypeInternal _gNBUEID_default_instance_;
  74 }  // namespace rc
  75 namespace google {
  76 namespace protobuf {
  77 template<> ::rc::Guami* Arena::CreateMaybeMessage<::rc::Guami>(Arena*);
  78 template<> ::rc::RICControlHeader* Arena::CreateMaybeMessage<::rc::RICControlHeader>(Arena*);
  79 template<> ::rc::RICControlMessage* Arena::CreateMaybeMessage<::rc::RICControlMessage>(Arena*);
  80 template<> ::rc::RICE2APHeader* Arena::CreateMaybeMessage<::rc::RICE2APHeader>(Arena*);
  81 template<> ::rc::RicControlGrpcReq* Arena::CreateMaybeMessage<::rc::RicControlGrpcReq>(Arena*);
  82 template<> ::rc::RicControlGrpcRsp* Arena::CreateMaybeMessage<::rc::RicControlGrpcRsp>(Arena*);
  83 template<> ::rc::UeId* Arena::CreateMaybeMessage<::rc::UeId>(Arena*);
  84 template<> ::rc::gNBUEID* Arena::CreateMaybeMessage<::rc::gNBUEID>(Arena*);
  85 }  // namespace protobuf
  86 }  // namespace google
  87 namespace rc {
  88
  89 enum RICControlCellTypeEnum {
  90   RIC_CONTROL_CELL_UNKWON = 0,
  91   RIC_CONTROL_NR_CELL = 1,
  92   RIC_CONTROL_EUTRAN_CELL = 2,
  93   RICControlCellTypeEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  94   RICControlCellTypeEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
  95 };
  96 bool RICControlCellTypeEnum_IsValid(int value);
  97 const RICControlCellTypeEnum RICControlCellTypeEnum_MIN = RIC_CONTROL_CELL_UNKWON;
  98 const RICControlCellTypeEnum RICControlCellTypeEnum_MAX = RIC_CONTROL_EUTRAN_CELL;
  99 const int RICControlCellTypeEnum_ARRAYSIZE = RICControlCellTypeEnum_MAX + 1;
 100
 101 const ::google::protobuf::EnumDescriptor* RICControlCellTypeEnum_descriptor();
 102 inline const ::std::string& RICControlCellTypeEnum_Name(RICControlCellTypeEnum value) {
 103   return ::google::protobuf::internal::NameOfEnum(
 104     RICControlCellTypeEnum_descriptor(), value);
 105 }
 106 inline bool RICControlCellTypeEnum_Parse(
 107     const ::std::string& name, RICControlCellTypeEnum* value) {
 108   return ::google::protobuf::internal::ParseNamedEnum<RICControlCellTypeEnum>(
 109     RICControlCellTypeEnum_descriptor(), name, value);
 110 }
 111 enum RICControlAckEnum {
 112   RIC_CONTROL_ACK_UNKWON = 0,
 113   RIC_CONTROL_NO_ACK = 1,
 114   RIC_CONTROL_ACK = 2,
 115   RIC_CONTROL_NACK = 3,
 116   RICControlAckEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
 117   RICControlAckEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
 118 };
 119 bool RICControlAckEnum_IsValid(int value);
 120 const RICControlAckEnum RICControlAckEnum_MIN = RIC_CONTROL_ACK_UNKWON;
 121 const RICControlAckEnum RICControlAckEnum_MAX = RIC_CONTROL_NACK;
 122 const int RICControlAckEnum_ARRAYSIZE = RICControlAckEnum_MAX + 1;
 123
 124 const ::google::protobuf::EnumDescriptor* RICControlAckEnum_descriptor();
 125 inline const ::std::string& RICControlAckEnum_Name(RICControlAckEnum value) {
 126   return ::google::protobuf::internal::NameOfEnum(
 127     RICControlAckEnum_descriptor(), value);
 128 }
 129 inline bool RICControlAckEnum_Parse(
 130     const ::std::string& name, RICControlAckEnum* value) {
 131   return ::google::protobuf::internal::ParseNamedEnum<RICControlAckEnum>(
 132     RICControlAckEnum_descriptor(), name, value);
 133 }
 134 // ===================================================================
 135
 136 class RICE2APHeader : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rc.RICE2APHeader) */ {
 137  public:
 138   RICE2APHeader();
 139   virtual ~RICE2APHeader();
 140
 141   RICE2APHeader(const RICE2APHeader& from);
 142
 143   inline RICE2APHeader& operator=(const RICE2APHeader& from) {
 144     CopyFrom(from);
 145     return *this;
 146   }
 147   #if LANG_CXX11
 148   RICE2APHeader(RICE2APHeader&& from) noexcept
 149     : RICE2APHeader() {
 150     *this = ::std::move(from);
 151   }
 152
 153   inline RICE2APHeader& operator=(RICE2APHeader&& from) noexcept {
 154     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
 155       if (this != &from) InternalSwap(&from);
 156     } else {
 157       CopyFrom(from);
 158     }
 159     return *this;
 160   }
 161   #endif
 162   static const ::google::protobuf::Descriptor* descriptor();
 163   static const RICE2APHeader& default_instance();
 164
 165   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
 166   static inline const RICE2APHeader* internal_default_instance() {
 167     return reinterpret_cast<const RICE2APHeader*>(
 168                &_RICE2APHeader_default_instance_);
 169   }
 170   static constexpr int kIndexInFileMessages =
 171     0;
 172
 173   void Swap(RICE2APHeader* other);
 174   friend void swap(RICE2APHeader& a, RICE2APHeader& b) {
 175     a.Swap(&b);
 176   }
 177
 178   // implements Message ----------------------------------------------
 179
 180   inline RICE2APHeader* New() const final {
 181     return CreateMaybeMessage<RICE2APHeader>(NULL);
 182   }
 183
 184   RICE2APHeader* New(::google::protobuf::Arena* arena) const final {
 185     return CreateMaybeMessage<RICE2APHeader>(arena);
 186   }
 187   void CopyFrom(const ::google::protobuf::Message& from) final;
 188   void MergeFrom(const ::google::protobuf::Message& from) final;
 189   void CopyFrom(const RICE2APHeader& from);
 190   void MergeFrom(const RICE2APHeader& from);
 191   void Clear() final;
 192   bool IsInitialized() const final;
 193
 194   size_t ByteSizeLong() const final;
 195   bool MergePartialFromCodedStream(
 196       ::google::protobuf::io::CodedInputStream* input) final;
 197   void SerializeWithCachedSizes(
 198       ::google::protobuf::io::CodedOutputStream* output) const final;
 199   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
 200       bool deterministic, ::google::protobuf::uint8* target) const final;
 201   int GetCachedSize() const final { return _cached_size_.Get(); }
 202
 203   private:
 204   void SharedCtor();
 205   void SharedDtor();
 206   void SetCachedSize(int size) const final;
 207   void InternalSwap(RICE2APHeader* other);
 208   private:
 209   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
 210     return NULL;
 211   }
 212   inline void* MaybeArenaPtr() const {
 213     return NULL;
 214   }
 215   public:
 216
 217   ::google::protobuf::Metadata GetMetadata() const final;
 218
 219   // nested types ----------------------------------------------------
 220
 221   // accessors -------------------------------------------------------
 222
 223   // int64 RanFuncId = 1;
 224   void clear_ranfuncid();
 225   static const int kRanFuncIdFieldNumber = 1;
 226   ::google::protobuf::int64 ranfuncid() const;
 227   void set_ranfuncid(::google::protobuf::int64 value);
 228
 229   // int64 RICRequestorID = 2;
 230   void clear_ricrequestorid();
 231   static const int kRICRequestorIDFieldNumber = 2;
 232   ::google::protobuf::int64 ricrequestorid() const;
 233   void set_ricrequestorid(::google::protobuf::int64 value);
 234
 235   // @@protoc_insertion_point(class_scope:rc.RICE2APHeader)
 236  private:
 237
 238   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
 239   ::google::protobuf::int64 ranfuncid_;
 240   ::google::protobuf::int64 ricrequestorid_;
 241   mutable ::google::protobuf::internal::CachedSize _cached_size_;
 242   friend struct ::protobuf_rc_2eproto::TableStruct;
 243 };
 244 // -------------------------------------------------------------------
 245
 246 class RICControlHeader : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rc.RICControlHeader) */ {
 247  public:
 248   RICControlHeader();
 249   virtual ~RICControlHeader();
 250
 251   RICControlHeader(const RICControlHeader& from);
 252
 253   inline RICControlHeader& operator=(const RICControlHeader& from) {
 254     CopyFrom(from);
 255     return *this;
 256   }
 257   #if LANG_CXX11
 258   RICControlHeader(RICControlHeader&& from) noexcept
 259     : RICControlHeader() {
 260     *this = ::std::move(from);
 261   }
 262
 263   inline RICControlHeader& operator=(RICControlHeader&& from) noexcept {
 264     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
 265       if (this != &from) InternalSwap(&from);
 266     } else {
 267       CopyFrom(from);
 268     }
 269     return *this;
 270   }
 271   #endif
 272   static const ::google::protobuf::Descriptor* descriptor();
 273   static const RICControlHeader& default_instance();
 274
 275   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
 276   static inline const RICControlHeader* internal_default_instance() {
 277     return reinterpret_cast<const RICControlHeader*>(
 278                &_RICControlHeader_default_instance_);
 279   }
 280   static constexpr int kIndexInFileMessages =
 281     1;
 282
 283   void Swap(RICControlHeader* other);
 284   friend void swap(RICControlHeader& a, RICControlHeader& b) {
 285     a.Swap(&b);
 286   }
 287
 288   // implements Message ----------------------------------------------
 289
 290   inline RICControlHeader* New() const final {
 291     return CreateMaybeMessage<RICControlHeader>(NULL);
 292   }
 293
 294   RICControlHeader* New(::google::protobuf::Arena* arena) const final {
 295     return CreateMaybeMessage<RICControlHeader>(arena);
 296   }
 297   void CopyFrom(const ::google::protobuf::Message& from) final;
 298   void MergeFrom(const ::google::protobuf::Message& from) final;
 299   void CopyFrom(const RICControlHeader& from);
 300   void MergeFrom(const RICControlHeader& from);
 301   void Clear() final;
 302   bool IsInitialized() const final;
 303
 304   size_t ByteSizeLong() const final;
 305   bool MergePartialFromCodedStream(
 306       ::google::protobuf::io::CodedInputStream* input) final;
 307   void SerializeWithCachedSizes(
 308       ::google::protobuf::io::CodedOutputStream* output) const final;
 309   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
 310       bool deterministic, ::google::protobuf::uint8* target) const final;
 311   int GetCachedSize() const final { return _cached_size_.Get(); }
 312
 313   private:
 314   void SharedCtor();
 315   void SharedDtor();
 316   void SetCachedSize(int size) const final;
 317   void InternalSwap(RICControlHeader* other);
 318   private:
 319   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
 320     return NULL;
 321   }
 322   inline void* MaybeArenaPtr() const {
 323     return NULL;
 324   }
 325   public:
 326
 327   ::google::protobuf::Metadata GetMetadata() const final;
 328
 329   // nested types ----------------------------------------------------
 330
 331   // accessors -------------------------------------------------------
 332
 333   // .rc.UeId UEID = 3;
 334   bool has_ueid() const;
 335   void clear_ueid();
 336   static const int kUEIDFieldNumber = 3;
 337   private:
 338   const ::rc::UeId& _internal_ueid() const;
 339   public:
 340   const ::rc::UeId& ueid() const;
 341   ::rc::UeId* release_ueid();
 342   ::rc::UeId* mutable_ueid();
 343   void set_allocated_ueid(::rc::UeId* ueid);
 344
 345   // int64 ControlStyle = 1;
 346   void clear_controlstyle();
 347   static const int kControlStyleFieldNumber = 1;
 348   ::google::protobuf::int64 controlstyle() const;
 349   void set_controlstyle(::google::protobuf::int64 value);
 350
 351   // int64 ControlActionId = 2;
 352   void clear_controlactionid();
 353   static const int kControlActionIdFieldNumber = 2;
 354   ::google::protobuf::int64 controlactionid() const;
 355   void set_controlactionid(::google::protobuf::int64 value);
 356
 357   // @@protoc_insertion_point(class_scope:rc.RICControlHeader)
 358  private:
 359
 360   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
 361   ::rc::UeId* ueid_;
 362   ::google::protobuf::int64 controlstyle_;
 363   ::google::protobuf::int64 controlactionid_;
 364   mutable ::google::protobuf::internal::CachedSize _cached_size_;
 365   friend struct ::protobuf_rc_2eproto::TableStruct;
 366 };
 367 // -------------------------------------------------------------------
 368
 369 class UeId : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rc.UeId) */ {
 370  public:
 371   UeId();
 372   virtual ~UeId();
 373
 374   UeId(const UeId& from);
 375
 376   inline UeId& operator=(const UeId& from) {
 377     CopyFrom(from);
 378     return *this;
 379   }
 380   #if LANG_CXX11
 381   UeId(UeId&& from) noexcept
 382     : UeId() {
 383     *this = ::std::move(from);
 384   }
 385
 386   inline UeId& operator=(UeId&& from) noexcept {
 387     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
 388       if (this != &from) InternalSwap(&from);
 389     } else {
 390       CopyFrom(from);
 391     }
 392     return *this;
 393   }
 394   #endif
 395   static const ::google::protobuf::Descriptor* descriptor();
 396   static const UeId& default_instance();
 397
 398   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
 399   static inline const UeId* internal_default_instance() {
 400     return reinterpret_cast<const UeId*>(
 401                &_UeId_default_instance_);
 402   }
 403   static constexpr int kIndexInFileMessages =
 404     2;
 405
 406   void Swap(UeId* other);
 407   friend void swap(UeId& a, UeId& b) {
 408     a.Swap(&b);
 409   }
 410
 411   // implements Message ----------------------------------------------
 412
 413   inline UeId* New() const final {
 414     return CreateMaybeMessage<UeId>(NULL);
 415   }
 416
 417   UeId* New(::google::protobuf::Arena* arena) const final {
 418     return CreateMaybeMessage<UeId>(arena);
 419   }
 420   void CopyFrom(const ::google::protobuf::Message& from) final;
 421   void MergeFrom(const ::google::protobuf::Message& from) final;
 422   void CopyFrom(const UeId& from);
 423   void MergeFrom(const UeId& from);
 424   void Clear() final;
 425   bool IsInitialized() const final;
 426
 427   size_t ByteSizeLong() const final;
 428   bool MergePartialFromCodedStream(
 429       ::google::protobuf::io::CodedInputStream* input) final;
 430   void SerializeWithCachedSizes(
 431       ::google::protobuf::io::CodedOutputStream* output) const final;
 432   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
 433       bool deterministic, ::google::protobuf::uint8* target) const final;
 434   int GetCachedSize() const final { return _cached_size_.Get(); }
 435
 436   private:
 437   void SharedCtor();
 438   void SharedDtor();
 439   void SetCachedSize(int size) const final;
 440   void InternalSwap(UeId* other);
 441   private:
 442   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
 443     return NULL;
 444   }
 445   inline void* MaybeArenaPtr() const {
 446     return NULL;
 447   }
 448   public:
 449
 450   ::google::protobuf::Metadata GetMetadata() const final;
 451
 452   // nested types ----------------------------------------------------
 453
 454   // accessors -------------------------------------------------------
 455
 456   // .rc.gNBUEID GnbUEID = 1;
 457   bool has_gnbueid() const;
 458   void clear_gnbueid();
 459   static const int kGnbUEIDFieldNumber = 1;
 460   private:
 461   const ::rc::gNBUEID& _internal_gnbueid() const;
 462   public:
 463   const ::rc::gNBUEID& gnbueid() const;
 464   ::rc::gNBUEID* release_gnbueid();
 465   ::rc::gNBUEID* mutable_gnbueid();
 466   void set_allocated_gnbueid(::rc::gNBUEID* gnbueid);
 467
 468   // @@protoc_insertion_point(class_scope:rc.UeId)
 469  private:
 470
 471   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
 472   ::rc::gNBUEID* gnbueid_;
 473   mutable ::google::protobuf::internal::CachedSize _cached_size_;
 474   friend struct ::protobuf_rc_2eproto::TableStruct;
 475 };
 476 // -------------------------------------------------------------------
 477
 478 class gNBUEID : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rc.gNBUEID) */ {
 479  public:
 480   gNBUEID();
 481   virtual ~gNBUEID();
 482
 483   gNBUEID(const gNBUEID& from);
 484
 485   inline gNBUEID& operator=(const gNBUEID& from) {
 486     CopyFrom(from);
 487     return *this;
 488   }
 489   #if LANG_CXX11
 490   gNBUEID(gNBUEID&& from) noexcept
 491     : gNBUEID() {
 492     *this = ::std::move(from);
 493   }
 494
 495   inline gNBUEID& operator=(gNBUEID&& from) noexcept {
 496     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
 497       if (this != &from) InternalSwap(&from);
 498     } else {
 499       CopyFrom(from);
 500     }
 501     return *this;
 502   }
 503   #endif
 504   static const ::google::protobuf::Descriptor* descriptor();
 505   static const gNBUEID& default_instance();
 506
 507   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
 508   static inline const gNBUEID* internal_default_instance() {
 509     return reinterpret_cast<const gNBUEID*>(
 510                &_gNBUEID_default_instance_);
 511   }
 512   static constexpr int kIndexInFileMessages =
 513     3;
 514
 515   void Swap(gNBUEID* other);
 516   friend void swap(gNBUEID& a, gNBUEID& b) {
 517     a.Swap(&b);
 518   }
 519
 520   // implements Message ----------------------------------------------
 521
 522   inline gNBUEID* New() const final {
 523     return CreateMaybeMessage<gNBUEID>(NULL);
 524   }
 525
 526   gNBUEID* New(::google::protobuf::Arena* arena) const final {
 527     return CreateMaybeMessage<gNBUEID>(arena);
 528   }
 529   void CopyFrom(const ::google::protobuf::Message& from) final;
 530   void MergeFrom(const ::google::protobuf::Message& from) final;
 531   void CopyFrom(const gNBUEID& from);
 532   void MergeFrom(const gNBUEID& from);
 533   void Clear() final;
 534   bool IsInitialized() const final;
 535
 536   size_t ByteSizeLong() const final;
 537   bool MergePartialFromCodedStream(
 538       ::google::protobuf::io::CodedInputStream* input) final;
 539   void SerializeWithCachedSizes(
 540       ::google::protobuf::io::CodedOutputStream* output) const final;
 541   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
 542       bool deterministic, ::google::protobuf::uint8* target) const final;
 543   int GetCachedSize() const final { return _cached_size_.Get(); }
 544
 545   private:
 546   void SharedCtor();
 547   void SharedDtor();
 548   void SetCachedSize(int size) const final;
 549   void InternalSwap(gNBUEID* other);
 550   private:
 551   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
 552     return NULL;
 553   }
 554   inline void* MaybeArenaPtr() const {
 555     return NULL;
 556   }
 557   public:
 558
 559   ::google::protobuf::Metadata GetMetadata() const final;
 560
 561   // nested types ----------------------------------------------------
 562
 563   // accessors -------------------------------------------------------
 564
 565   // repeated int64 gNBCUUEF1APID = 3;
 566   int gnbcuuef1apid_size() const;
 567   void clear_gnbcuuef1apid();
 568   static const int kGNBCUUEF1APIDFieldNumber = 3;
 569   ::google::protobuf::int64 gnbcuuef1apid(int index) const;
 570   void set_gnbcuuef1apid(int index, ::google::protobuf::int64 value);
 571   void add_gnbcuuef1apid(::google::protobuf::int64 value);
 572   const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
 573       gnbcuuef1apid() const;
 574   ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
 575       mutable_gnbcuuef1apid();
 576
 577   // repeated int64 gNBCUCPUEE1APID = 4;
 578   int gnbcucpuee1apid_size() const;
 579   void clear_gnbcucpuee1apid();
 580   static const int kGNBCUCPUEE1APIDFieldNumber = 4;
 581   ::google::protobuf::int64 gnbcucpuee1apid(int index) const;
 582   void set_gnbcucpuee1apid(int index, ::google::protobuf::int64 value);
 583   void add_gnbcucpuee1apid(::google::protobuf::int64 value);
 584   const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
 585       gnbcucpuee1apid() const;
 586   ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
 587       mutable_gnbcucpuee1apid();
 588
 589   // .rc.Guami guami = 2;
 590   bool has_guami() const;
 591   void clear_guami();
 592   static const int kGuamiFieldNumber = 2;
 593   private:
 594   const ::rc::Guami& _internal_guami() const;
 595   public:
 596   const ::rc::Guami& guami() const;
 597   ::rc::Guami* release_guami();
 598   ::rc::Guami* mutable_guami();
 599   void set_allocated_guami(::rc::Guami* guami);
 600
 601   // int64 amfUENGAPID = 1;
 602   void clear_amfuengapid();
 603   static const int kAmfUENGAPIDFieldNumber = 1;
 604   ::google::protobuf::int64 amfuengapid() const;
 605   void set_amfuengapid(::google::protobuf::int64 value);
 606
 607   // @@protoc_insertion_point(class_scope:rc.gNBUEID)
 608  private:
 609
 610   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
 611   ::google::protobuf::RepeatedField< ::google::protobuf::int64 > gnbcuuef1apid_;
 612   mutable int _gnbcuuef1apid_cached_byte_size_;
 613   ::google::protobuf::RepeatedField< ::google::protobuf::int64 > gnbcucpuee1apid_;
 614   mutable int _gnbcucpuee1apid_cached_byte_size_;
 615   ::rc::Guami* guami_;
 616   ::google::protobuf::int64 amfuengapid_;
 617   mutable ::google::protobuf::internal::CachedSize _cached_size_;
 618   friend struct ::protobuf_rc_2eproto::TableStruct;
 619 };
 620 // -------------------------------------------------------------------
 621
 622 class Guami : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rc.Guami) */ {
 623  public:
 624   Guami();
 625   virtual ~Guami();
 626
 627   Guami(const Guami& from);
 628
 629   inline Guami& operator=(const Guami& from) {
 630     CopyFrom(from);
 631     return *this;
 632   }
 633   #if LANG_CXX11
 634   Guami(Guami&& from) noexcept
 635     : Guami() {
 636     *this = ::std::move(from);
 637   }
 638
 639   inline Guami& operator=(Guami&& from) noexcept {
 640     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
 641       if (this != &from) InternalSwap(&from);
 642     } else {
 643       CopyFrom(from);
 644     }
 645     return *this;
 646   }
 647   #endif
 648   static const ::google::protobuf::Descriptor* descriptor();
 649   static const Guami& default_instance();
 650
 651   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
 652   static inline const Guami* internal_default_instance() {
 653     return reinterpret_cast<const Guami*>(
 654                &_Guami_default_instance_);
 655   }
 656   static constexpr int kIndexInFileMessages =
 657     4;
 658
 659   void Swap(Guami* other);
 660   friend void swap(Guami& a, Guami& b) {
 661     a.Swap(&b);
 662   }
 663
 664   // implements Message ----------------------------------------------
 665
 666   inline Guami* New() const final {
 667     return CreateMaybeMessage<Guami>(NULL);
 668   }
 669
 670   Guami* New(::google::protobuf::Arena* arena) const final {
 671     return CreateMaybeMessage<Guami>(arena);
 672   }
 673   void CopyFrom(const ::google::protobuf::Message& from) final;
 674   void MergeFrom(const ::google::protobuf::Message& from) final;
 675   void CopyFrom(const Guami& from);
 676   void MergeFrom(const Guami& from);
 677   void Clear() final;
 678   bool IsInitialized() const final;
 679
 680   size_t ByteSizeLong() const final;
 681   bool MergePartialFromCodedStream(
 682       ::google::protobuf::io::CodedInputStream* input) final;
 683   void SerializeWithCachedSizes(
 684       ::google::protobuf::io::CodedOutputStream* output) const final;
 685   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
 686       bool deterministic, ::google::protobuf::uint8* target) const final;
 687   int GetCachedSize() const final { return _cached_size_.Get(); }
 688
 689   private:
 690   void SharedCtor();
 691   void SharedDtor();
 692   void SetCachedSize(int size) const final;
 693   void InternalSwap(Guami* other);
 694   private:
 695   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
 696     return NULL;
 697   }
 698   inline void* MaybeArenaPtr() const {
 699     return NULL;
 700   }
 701   public:
 702
 703   ::google::protobuf::Metadata GetMetadata() const final;
 704
 705   // nested types ----------------------------------------------------
 706
 707   // accessors -------------------------------------------------------
 708
 709   // string pLMNIdentity = 1;
 710   void clear_plmnidentity();
 711   static const int kPLMNIdentityFieldNumber = 1;
 712   const ::std::string& plmnidentity() const;
 713   void set_plmnidentity(const ::std::string& value);
 714   #if LANG_CXX11
 715   void set_plmnidentity(::std::string&& value);
 716   #endif
 717   void set_plmnidentity(const char* value);
 718   void set_plmnidentity(const char* value, size_t size);
 719   ::std::string* mutable_plmnidentity();
 720   ::std::string* release_plmnidentity();
 721   void set_allocated_plmnidentity(::std::string* plmnidentity);
 722
 723   // string aMFRegionID = 2;
 724   void clear_amfregionid();
 725   static const int kAMFRegionIDFieldNumber = 2;
 726   const ::std::string& amfregionid() const;
 727   void set_amfregionid(const ::std::string& value);
 728   #if LANG_CXX11
 729   void set_amfregionid(::std::string&& value);
 730   #endif
 731   void set_amfregionid(const char* value);
 732   void set_amfregionid(const char* value, size_t size);
 733   ::std::string* mutable_amfregionid();
 734   ::std::string* release_amfregionid();
 735   void set_allocated_amfregionid(::std::string* amfregionid);
 736
 737   // string aMFSetID = 3;
 738   void clear_amfsetid();
 739   static const int kAMFSetIDFieldNumber = 3;
 740   const ::std::string& amfsetid() const;
 741   void set_amfsetid(const ::std::string& value);
 742   #if LANG_CXX11
 743   void set_amfsetid(::std::string&& value);
 744   #endif
 745   void set_amfsetid(const char* value);
 746   void set_amfsetid(const char* value, size_t size);
 747   ::std::string* mutable_amfsetid();
 748   ::std::string* release_amfsetid();
 749   void set_allocated_amfsetid(::std::string* amfsetid);
 750
 751   // string aMFPointer = 4;
 752   void clear_amfpointer();
 753   static const int kAMFPointerFieldNumber = 4;
 754   const ::std::string& amfpointer() const;
 755   void set_amfpointer(const ::std::string& value);
 756   #if LANG_CXX11
 757   void set_amfpointer(::std::string&& value);
 758   #endif
 759   void set_amfpointer(const char* value);
 760   void set_amfpointer(const char* value, size_t size);
 761   ::std::string* mutable_amfpointer();
 762   ::std::string* release_amfpointer();
 763   void set_allocated_amfpointer(::std::string* amfpointer);
 764
 765   // @@protoc_insertion_point(class_scope:rc.Guami)
 766  private:
 767
 768   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
 769   ::google::protobuf::internal::ArenaStringPtr plmnidentity_;
 770   ::google::protobuf::internal::ArenaStringPtr amfregionid_;
 771   ::google::protobuf::internal::ArenaStringPtr amfsetid_;
 772   ::google::protobuf::internal::ArenaStringPtr amfpointer_;
 773   mutable ::google::protobuf::internal::CachedSize _cached_size_;
 774   friend struct ::protobuf_rc_2eproto::TableStruct;
 775 };
 776 // -------------------------------------------------------------------
 777
 778 class RICControlMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rc.RICControlMessage) */ {
 779  public:
 780   RICControlMessage();
 781   virtual ~RICControlMessage();
 782
 783   RICControlMessage(const RICControlMessage& from);
 784
 785   inline RICControlMessage& operator=(const RICControlMessage& from) {
 786     CopyFrom(from);
 787     return *this;
 788   }
 789   #if LANG_CXX11
 790   RICControlMessage(RICControlMessage&& from) noexcept
 791     : RICControlMessage() {
 792     *this = ::std::move(from);
 793   }
 794
 795   inline RICControlMessage& operator=(RICControlMessage&& from) noexcept {
 796     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
 797       if (this != &from) InternalSwap(&from);
 798     } else {
 799       CopyFrom(from);
 800     }
 801     return *this;
 802   }
 803   #endif
 804   static const ::google::protobuf::Descriptor* descriptor();
 805   static const RICControlMessage& default_instance();
 806
 807   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
 808   static inline const RICControlMessage* internal_default_instance() {
 809     return reinterpret_cast<const RICControlMessage*>(
 810                &_RICControlMessage_default_instance_);
 811   }
 812   static constexpr int kIndexInFileMessages =
 813     5;
 814
 815   void Swap(RICControlMessage* other);
 816   friend void swap(RICControlMessage& a, RICControlMessage& b) {
 817     a.Swap(&b);
 818   }
 819
 820   // implements Message ----------------------------------------------
 821
 822   inline RICControlMessage* New() const final {
 823     return CreateMaybeMessage<RICControlMessage>(NULL);
 824   }
 825
 826   RICControlMessage* New(::google::protobuf::Arena* arena) const final {
 827     return CreateMaybeMessage<RICControlMessage>(arena);
 828   }
 829   void CopyFrom(const ::google::protobuf::Message& from) final;
 830   void MergeFrom(const ::google::protobuf::Message& from) final;
 831   void CopyFrom(const RICControlMessage& from);
 832   void MergeFrom(const RICControlMessage& from);
 833   void Clear() final;
 834   bool IsInitialized() const final;
 835
 836   size_t ByteSizeLong() const final;
 837   bool MergePartialFromCodedStream(
 838       ::google::protobuf::io::CodedInputStream* input) final;
 839   void SerializeWithCachedSizes(
 840       ::google::protobuf::io::CodedOutputStream* output) const final;
 841   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
 842       bool deterministic, ::google::protobuf::uint8* target) const final;
 843   int GetCachedSize() const final { return _cached_size_.Get(); }
 844
 845   private:
 846   void SharedCtor();
 847   void SharedDtor();
 848   void SetCachedSize(int size) const final;
 849   void InternalSwap(RICControlMessage* other);
 850   private:
 851   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
 852     return NULL;
 853   }
 854   inline void* MaybeArenaPtr() const {
 855     return NULL;
 856   }
 857   public:
 858
 859   ::google::protobuf::Metadata GetMetadata() const final;
 860
 861   // nested types ----------------------------------------------------
 862
 863   // accessors -------------------------------------------------------
 864
 865   // string TargetCellID = 2;
 866   void clear_targetcellid();
 867   static const int kTargetCellIDFieldNumber = 2;
 868   const ::std::string& targetcellid() const;
 869   void set_targetcellid(const ::std::string& value);
 870   #if LANG_CXX11
 871   void set_targetcellid(::std::string&& value);
 872   #endif
 873   void set_targetcellid(const char* value);
 874   void set_targetcellid(const char* value, size_t size);
 875   ::std::string* mutable_targetcellid();
 876   ::std::string* release_targetcellid();
 877   void set_allocated_targetcellid(::std::string* targetcellid);
 878
 879   // .rc.RICControlCellTypeEnum RICControlCellTypeVal = 1;
 880   void clear_riccontrolcelltypeval();
 881   static const int kRICControlCellTypeValFieldNumber = 1;
 882   ::rc::RICControlCellTypeEnum riccontrolcelltypeval() const;
 883   void set_riccontrolcelltypeval(::rc::RICControlCellTypeEnum value);
 884
 885   // @@protoc_insertion_point(class_scope:rc.RICControlMessage)
 886  private:
 887
 888   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
 889   ::google::protobuf::internal::ArenaStringPtr targetcellid_;
 890   int riccontrolcelltypeval_;
 891   mutable ::google::protobuf::internal::CachedSize _cached_size_;
 892   friend struct ::protobuf_rc_2eproto::TableStruct;
 893 };
 894 // -------------------------------------------------------------------
 895
 896 class RicControlGrpcReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rc.RicControlGrpcReq) */ {
 897  public:
 898   RicControlGrpcReq();
 899   virtual ~RicControlGrpcReq();
 900
 901   RicControlGrpcReq(const RicControlGrpcReq& from);
 902
 903   inline RicControlGrpcReq& operator=(const RicControlGrpcReq& from) {
 904     CopyFrom(from);
 905     return *this;
 906   }
 907   #if LANG_CXX11
 908   RicControlGrpcReq(RicControlGrpcReq&& from) noexcept
 909     : RicControlGrpcReq() {
 910     *this = ::std::move(from);
 911   }
 912
 913   inline RicControlGrpcReq& operator=(RicControlGrpcReq&& from) noexcept {
 914     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
 915       if (this != &from) InternalSwap(&from);
 916     } else {
 917       CopyFrom(from);
 918     }
 919     return *this;
 920   }
 921   #endif
 922   static const ::google::protobuf::Descriptor* descriptor();
 923   static const RicControlGrpcReq& default_instance();
 924
 925   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
 926   static inline const RicControlGrpcReq* internal_default_instance() {
 927     return reinterpret_cast<const RicControlGrpcReq*>(
 928                &_RicControlGrpcReq_default_instance_);
 929   }
 930   static constexpr int kIndexInFileMessages =
 931     6;
 932
 933   void Swap(RicControlGrpcReq* other);
 934   friend void swap(RicControlGrpcReq& a, RicControlGrpcReq& b) {
 935     a.Swap(&b);
 936   }
 937
 938   // implements Message ----------------------------------------------
 939
 940   inline RicControlGrpcReq* New() const final {
 941     return CreateMaybeMessage<RicControlGrpcReq>(NULL);
 942   }
 943
 944   RicControlGrpcReq* New(::google::protobuf::Arena* arena) const final {
 945     return CreateMaybeMessage<RicControlGrpcReq>(arena);
 946   }
 947   void CopyFrom(const ::google::protobuf::Message& from) final;
 948   void MergeFrom(const ::google::protobuf::Message& from) final;
 949   void CopyFrom(const RicControlGrpcReq& from);
 950   void MergeFrom(const RicControlGrpcReq& from);
 951   void Clear() final;
 952   bool IsInitialized() const final;
 953
 954   size_t ByteSizeLong() const final;
 955   bool MergePartialFromCodedStream(
 956       ::google::protobuf::io::CodedInputStream* input) final;
 957   void SerializeWithCachedSizes(
 958       ::google::protobuf::io::CodedOutputStream* output) const final;
 959   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
 960       bool deterministic, ::google::protobuf::uint8* target) const final;
 961   int GetCachedSize() const final { return _cached_size_.Get(); }
 962
 963   private:
 964   void SharedCtor();
 965   void SharedDtor();
 966   void SetCachedSize(int size) const final;
 967   void InternalSwap(RicControlGrpcReq* other);
 968   private:
 969   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
 970     return NULL;
 971   }
 972   inline void* MaybeArenaPtr() const {
 973     return NULL;
 974   }
 975   public:
 976
 977   ::google::protobuf::Metadata GetMetadata() const final;
 978
 979   // nested types ----------------------------------------------------
 980
 981   // accessors -------------------------------------------------------
 982
 983   // string e2NodeID = 1;
 984   void clear_e2nodeid();
 985   static const int kE2NodeIDFieldNumber = 1;
 986   const ::std::string& e2nodeid() const;
 987   void set_e2nodeid(const ::std::string& value);
 988   #if LANG_CXX11
 989   void set_e2nodeid(::std::string&& value);
 990   #endif
 991   void set_e2nodeid(const char* value);
 992   void set_e2nodeid(const char* value, size_t size);
 993   ::std::string* mutable_e2nodeid();
 994   ::std::string* release_e2nodeid();
 995   void set_allocated_e2nodeid(::std::string* e2nodeid);
 996
 997   // string plmnID = 2;
 998   void clear_plmnid();
 999   static const int kPlmnIDFieldNumber = 2;
1000   const ::std::string& plmnid() const;
1001   void set_plmnid(const ::std::string& value);
1002   #if LANG_CXX11
1003   void set_plmnid(::std::string&& value);
1004   #endif
1005   void set_plmnid(const char* value);
1006   void set_plmnid(const char* value, size_t size);
1007   ::std::string* mutable_plmnid();
1008   ::std::string* release_plmnid();
1009   void set_allocated_plmnid(::std::string* plmnid);
1010
1011   // string ranName = 3;
1012   void clear_ranname();
1013   static const int kRanNameFieldNumber = 3;
1014   const ::std::string& ranname() const;
1015   void set_ranname(const ::std::string& value);
1016   #if LANG_CXX11
1017   void set_ranname(::std::string&& value);
1018   #endif
1019   void set_ranname(const char* value);
1020   void set_ranname(const char* value, size_t size);
1021   ::std::string* mutable_ranname();
1022   ::std::string* release_ranname();
1023   void set_allocated_ranname(::std::string* ranname);
1024
1025   // .rc.RICE2APHeader RICE2APHeaderData = 4;
1026   bool has_rice2apheaderdata() const;
1027   void clear_rice2apheaderdata();
1028   static const int kRICE2APHeaderDataFieldNumber = 4;
1029   private:
1030   const ::rc::RICE2APHeader& _internal_rice2apheaderdata() const;
1031   public:
1032   const ::rc::RICE2APHeader& rice2apheaderdata() const;
1033   ::rc::RICE2APHeader* release_rice2apheaderdata();
1034   ::rc::RICE2APHeader* mutable_rice2apheaderdata();
1035   void set_allocated_rice2apheaderdata(::rc::RICE2APHeader* rice2apheaderdata);
1036
1037   // .rc.RICControlHeader RICControlHeaderData = 5;
1038   bool has_riccontrolheaderdata() const;
1039   void clear_riccontrolheaderdata();
1040   static const int kRICControlHeaderDataFieldNumber = 5;
1041   private:
1042   const ::rc::RICControlHeader& _internal_riccontrolheaderdata() const;
1043   public:
1044   const ::rc::RICControlHeader& riccontrolheaderdata() const;
1045   ::rc::RICControlHeader* release_riccontrolheaderdata();
1046   ::rc::RICControlHeader* mutable_riccontrolheaderdata();
1047   void set_allocated_riccontrolheaderdata(::rc::RICControlHeader* riccontrolheaderdata);
1048
1049   // .rc.RICControlMessage RICControlMessageData = 6;
1050   bool has_riccontrolmessagedata() const;
1051   void clear_riccontrolmessagedata();
1052   static const int kRICControlMessageDataFieldNumber = 6;
1053   private:
1054   const ::rc::RICControlMessage& _internal_riccontrolmessagedata() const;
1055   public:
1056   const ::rc::RICControlMessage& riccontrolmessagedata() const;
1057   ::rc::RICControlMessage* release_riccontrolmessagedata();
1058   ::rc::RICControlMessage* mutable_riccontrolmessagedata();
1059   void set_allocated_riccontrolmessagedata(::rc::RICControlMessage* riccontrolmessagedata);
1060
1061   // .rc.RICControlAckEnum RICControlAckReqVal = 7;
1062   void clear_riccontrolackreqval();
1063   static const int kRICControlAckReqValFieldNumber = 7;
1064   ::rc::RICControlAckEnum riccontrolackreqval() const;
1065   void set_riccontrolackreqval(::rc::RICControlAckEnum value);
1066
1067   // @@protoc_insertion_point(class_scope:rc.RicControlGrpcReq)
1068  private:
1069
1070   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1071   ::google::protobuf::internal::ArenaStringPtr e2nodeid_;
1072   ::google::protobuf::internal::ArenaStringPtr plmnid_;
1073   ::google::protobuf::internal::ArenaStringPtr ranname_;
1074   ::rc::RICE2APHeader* rice2apheaderdata_;
1075   ::rc::RICControlHeader* riccontrolheaderdata_;
1076   ::rc::RICControlMessage* riccontrolmessagedata_;
1077   int riccontrolackreqval_;
1078   mutable ::google::protobuf::internal::CachedSize _cached_size_;
1079   friend struct ::protobuf_rc_2eproto::TableStruct;
1080 };
1081 // -------------------------------------------------------------------
1082
1083 class RicControlGrpcRsp : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rc.RicControlGrpcRsp) */ {
1084  public:
1085   RicControlGrpcRsp();
1086   virtual ~RicControlGrpcRsp();
1087
1088   RicControlGrpcRsp(const RicControlGrpcRsp& from);
1089
1090   inline RicControlGrpcRsp& operator=(const RicControlGrpcRsp& from) {
1091     CopyFrom(from);
1092     return *this;
1093   }
1094   #if LANG_CXX11
1095   RicControlGrpcRsp(RicControlGrpcRsp&& from) noexcept
1096     : RicControlGrpcRsp() {
1097     *this = ::std::move(from);
1098   }
1099
1100   inline RicControlGrpcRsp& operator=(RicControlGrpcRsp&& from) noexcept {
1101     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1102       if (this != &from) InternalSwap(&from);
1103     } else {
1104       CopyFrom(from);
1105     }
1106     return *this;
1107   }
1108   #endif
1109   static const ::google::protobuf::Descriptor* descriptor();
1110   static const RicControlGrpcRsp& default_instance();
1111
1112   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
1113   static inline const RicControlGrpcRsp* internal_default_instance() {
1114     return reinterpret_cast<const RicControlGrpcRsp*>(
1115                &_RicControlGrpcRsp_default_instance_);
1116   }
1117   static constexpr int kIndexInFileMessages =
1118     7;
1119
1120   void Swap(RicControlGrpcRsp* other);
1121   friend void swap(RicControlGrpcRsp& a, RicControlGrpcRsp& b) {
1122     a.Swap(&b);
1123   }
1124
1125   // implements Message ----------------------------------------------
1126
1127   inline RicControlGrpcRsp* New() const final {
1128     return CreateMaybeMessage<RicControlGrpcRsp>(NULL);
1129   }
1130
1131   RicControlGrpcRsp* New(::google::protobuf::Arena* arena) const final {
1132     return CreateMaybeMessage<RicControlGrpcRsp>(arena);
1133   }
1134   void CopyFrom(const ::google::protobuf::Message& from) final;
1135   void MergeFrom(const ::google::protobuf::Message& from) final;
1136   void CopyFrom(const RicControlGrpcRsp& from);
1137   void MergeFrom(const RicControlGrpcRsp& from);
1138   void Clear() final;
1139   bool IsInitialized() const final;
1140
1141   size_t ByteSizeLong() const final;
1142   bool MergePartialFromCodedStream(
1143       ::google::protobuf::io::CodedInputStream* input) final;
1144   void SerializeWithCachedSizes(
1145       ::google::protobuf::io::CodedOutputStream* output) const final;
1146   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1147       bool deterministic, ::google::protobuf::uint8* target) const final;
1148   int GetCachedSize() const final { return _cached_size_.Get(); }
1149
1150   private:
1151   void SharedCtor();
1152   void SharedDtor();
1153   void SetCachedSize(int size) const final;
1154   void InternalSwap(RicControlGrpcRsp* other);
1155   private:
1156   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1157     return NULL;
1158   }
1159   inline void* MaybeArenaPtr() const {
1160     return NULL;
1161   }
1162   public:
1163
1164   ::google::protobuf::Metadata GetMetadata() const final;
1165
1166   // nested types ----------------------------------------------------
1167
1168   // accessors -------------------------------------------------------
1169
1170   // string description = 2;
1171   void clear_description();
1172   static const int kDescriptionFieldNumber = 2;
1173   const ::std::string& description() const;
1174   void set_description(const ::std::string& value);
1175   #if LANG_CXX11
1176   void set_description(::std::string&& value);
1177   #endif
1178   void set_description(const char* value);
1179   void set_description(const char* value, size_t size);
1180   ::std::string* mutable_description();
1181   ::std::string* release_description();
1182   void set_allocated_description(::std::string* description);
1183
1184   // int32 rspCode = 1;
1185   void clear_rspcode();
1186   static const int kRspCodeFieldNumber = 1;
1187   ::google::protobuf::int32 rspcode() const;
1188   void set_rspcode(::google::protobuf::int32 value);
1189
1190   // @@protoc_insertion_point(class_scope:rc.RicControlGrpcRsp)
1191  private:
1192
1193   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1194   ::google::protobuf::internal::ArenaStringPtr description_;
1195   ::google::protobuf::int32 rspcode_;
1196   mutable ::google::protobuf::internal::CachedSize _cached_size_;
1197   friend struct ::protobuf_rc_2eproto::TableStruct;
1198 };
1199 // ===================================================================
1200
1201
1202 // ===================================================================
1203
1204 #ifdef __GNUC__
1205   #pragma GCC diagnostic push
1206   #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1207 #endif  // __GNUC__
1208 // RICE2APHeader
1209
1210 // int64 RanFuncId = 1;
1211 inline void RICE2APHeader::clear_ranfuncid() {
1212   ranfuncid_ = GOOGLE_LONGLONG(0);
1213 }
1214 inline ::google::protobuf::int64 RICE2APHeader::ranfuncid() const {
1215   // @@protoc_insertion_point(field_get:rc.RICE2APHeader.RanFuncId)
1216   return ranfuncid_;
1217 }
1218 inline void RICE2APHeader::set_ranfuncid(::google::protobuf::int64 value) {
1219
1220   ranfuncid_ = value;
1221   // @@protoc_insertion_point(field_set:rc.RICE2APHeader.RanFuncId)
1222 }
1223
1224 // int64 RICRequestorID = 2;
1225 inline void RICE2APHeader::clear_ricrequestorid() {
1226   ricrequestorid_ = GOOGLE_LONGLONG(0);
1227 }
1228 inline ::google::protobuf::int64 RICE2APHeader::ricrequestorid() const {
1229   // @@protoc_insertion_point(field_get:rc.RICE2APHeader.RICRequestorID)
1230   return ricrequestorid_;
1231 }
1232 inline void RICE2APHeader::set_ricrequestorid(::google::protobuf::int64 value) {
1233
1234   ricrequestorid_ = value;
1235   // @@protoc_insertion_point(field_set:rc.RICE2APHeader.RICRequestorID)
1236 }
1237
1238 // -------------------------------------------------------------------
1239
1240 // RICControlHeader
1241
1242 // int64 ControlStyle = 1;
1243 inline void RICControlHeader::clear_controlstyle() {
1244   controlstyle_ = GOOGLE_LONGLONG(0);
1245 }
1246 inline ::google::protobuf::int64 RICControlHeader::controlstyle() const {
1247   // @@protoc_insertion_point(field_get:rc.RICControlHeader.ControlStyle)
1248   return controlstyle_;
1249 }
1250 inline void RICControlHeader::set_controlstyle(::google::protobuf::int64 value) {
1251
1252   controlstyle_ = value;
1253   // @@protoc_insertion_point(field_set:rc.RICControlHeader.ControlStyle)
1254 }
1255
1256 // int64 ControlActionId = 2;
1257 inline void RICControlHeader::clear_controlactionid() {
1258   controlactionid_ = GOOGLE_LONGLONG(0);
1259 }
1260 inline ::google::protobuf::int64 RICControlHeader::controlactionid() const {
1261   // @@protoc_insertion_point(field_get:rc.RICControlHeader.ControlActionId)
1262   return controlactionid_;
1263 }
1264 inline void RICControlHeader::set_controlactionid(::google::protobuf::int64 value) {
1265
1266   controlactionid_ = value;
1267   // @@protoc_insertion_point(field_set:rc.RICControlHeader.ControlActionId)
1268 }
1269
1270 // .rc.UeId UEID = 3;
1271 inline bool RICControlHeader::has_ueid() const {
1272   return this != internal_default_instance() && ueid_ != NULL;
1273 }
1274 inline void RICControlHeader::clear_ueid() {
1275   if (GetArenaNoVirtual() == NULL && ueid_ != NULL) {
1276     delete ueid_;
1277   }
1278   ueid_ = NULL;
1279 }
1280 inline const ::rc::UeId& RICControlHeader::_internal_ueid() const {
1281   return *ueid_;
1282 }
1283 inline const ::rc::UeId& RICControlHeader::ueid() const {
1284   const ::rc::UeId* p = ueid_;
1285   // @@protoc_insertion_point(field_get:rc.RICControlHeader.UEID)
1286   return p != NULL ? *p : *reinterpret_cast<const ::rc::UeId*>(
1287       &::rc::_UeId_default_instance_);
1288 }
1289 inline ::rc::UeId* RICControlHeader::release_ueid() {
1290   // @@protoc_insertion_point(field_release:rc.RICControlHeader.UEID)
1291
1292   ::rc::UeId* temp = ueid_;
1293   ueid_ = NULL;
1294   return temp;
1295 }
1296 inline ::rc::UeId* RICControlHeader::mutable_ueid() {
1297
1298   if (ueid_ == NULL) {
1299     auto* p = CreateMaybeMessage<::rc::UeId>(GetArenaNoVirtual());
1300     ueid_ = p;
1301   }
1302   // @@protoc_insertion_point(field_mutable:rc.RICControlHeader.UEID)
1303   return ueid_;
1304 }
1305 inline void RICControlHeader::set_allocated_ueid(::rc::UeId* ueid) {
1306   ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
1307   if (message_arena == NULL) {
1308     delete ueid_;
1309   }
1310   if (ueid) {
1311     ::google::protobuf::Arena* submessage_arena = NULL;
1312     if (message_arena != submessage_arena) {
1313       ueid = ::google::protobuf::internal::GetOwnedMessage(
1314           message_arena, ueid, submessage_arena);
1315     }
1316
1317   } else {
1318
1319   }
1320   ueid_ = ueid;
1321   // @@protoc_insertion_point(field_set_allocated:rc.RICControlHeader.UEID)
1322 }
1323
1324 // -------------------------------------------------------------------
1325
1326 // UeId
1327
1328 // .rc.gNBUEID GnbUEID = 1;
1329 inline bool UeId::has_gnbueid() const {
1330   return this != internal_default_instance() && gnbueid_ != NULL;
1331 }
1332 inline void UeId::clear_gnbueid() {
1333   if (GetArenaNoVirtual() == NULL && gnbueid_ != NULL) {
1334     delete gnbueid_;
1335   }
1336   gnbueid_ = NULL;
1337 }
1338 inline const ::rc::gNBUEID& UeId::_internal_gnbueid() const {
1339   return *gnbueid_;
1340 }
1341 inline const ::rc::gNBUEID& UeId::gnbueid() const {
1342   const ::rc::gNBUEID* p = gnbueid_;
1343   // @@protoc_insertion_point(field_get:rc.UeId.GnbUEID)
1344   return p != NULL ? *p : *reinterpret_cast<const ::rc::gNBUEID*>(
1345       &::rc::_gNBUEID_default_instance_);
1346 }
1347 inline ::rc::gNBUEID* UeId::release_gnbueid() {
1348   // @@protoc_insertion_point(field_release:rc.UeId.GnbUEID)
1349
1350   ::rc::gNBUEID* temp = gnbueid_;
1351   gnbueid_ = NULL;
1352   return temp;
1353 }
1354 inline ::rc::gNBUEID* UeId::mutable_gnbueid() {
1355
1356   if (gnbueid_ == NULL) {
1357     auto* p = CreateMaybeMessage<::rc::gNBUEID>(GetArenaNoVirtual());
1358     gnbueid_ = p;
1359   }
1360   // @@protoc_insertion_point(field_mutable:rc.UeId.GnbUEID)
1361   return gnbueid_;
1362 }
1363 inline void UeId::set_allocated_gnbueid(::rc::gNBUEID* gnbueid) {
1364   ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
1365   if (message_arena == NULL) {
1366     delete gnbueid_;
1367   }
1368   if (gnbueid) {
1369     ::google::protobuf::Arena* submessage_arena = NULL;
1370     if (message_arena != submessage_arena) {
1371       gnbueid = ::google::protobuf::internal::GetOwnedMessage(
1372           message_arena, gnbueid, submessage_arena);
1373     }
1374
1375   } else {
1376
1377   }
1378   gnbueid_ = gnbueid;
1379   // @@protoc_insertion_point(field_set_allocated:rc.UeId.GnbUEID)
1380 }
1381
1382 // -------------------------------------------------------------------
1383
1384 // gNBUEID
1385
1386 // int64 amfUENGAPID = 1;
1387 inline void gNBUEID::clear_amfuengapid() {
1388   amfuengapid_ = GOOGLE_LONGLONG(0);
1389 }
1390 inline ::google::protobuf::int64 gNBUEID::amfuengapid() const {
1391   // @@protoc_insertion_point(field_get:rc.gNBUEID.amfUENGAPID)
1392   return amfuengapid_;
1393 }
1394 inline void gNBUEID::set_amfuengapid(::google::protobuf::int64 value) {
1395
1396   amfuengapid_ = value;
1397   // @@protoc_insertion_point(field_set:rc.gNBUEID.amfUENGAPID)
1398 }
1399
1400 // .rc.Guami guami = 2;
1401 inline bool gNBUEID::has_guami() const {
1402   return this != internal_default_instance() && guami_ != NULL;
1403 }
1404 inline void gNBUEID::clear_guami() {
1405   if (GetArenaNoVirtual() == NULL && guami_ != NULL) {
1406     delete guami_;
1407   }
1408   guami_ = NULL;
1409 }
1410 inline const ::rc::Guami& gNBUEID::_internal_guami() const {
1411   return *guami_;
1412 }
1413 inline const ::rc::Guami& gNBUEID::guami() const {
1414   const ::rc::Guami* p = guami_;
1415   // @@protoc_insertion_point(field_get:rc.gNBUEID.guami)
1416   return p != NULL ? *p : *reinterpret_cast<const ::rc::Guami*>(
1417       &::rc::_Guami_default_instance_);
1418 }
1419 inline ::rc::Guami* gNBUEID::release_guami() {
1420   // @@protoc_insertion_point(field_release:rc.gNBUEID.guami)
1421
1422   ::rc::Guami* temp = guami_;
1423   guami_ = NULL;
1424   return temp;
1425 }
1426 inline ::rc::Guami* gNBUEID::mutable_guami() {
1427
1428   if (guami_ == NULL) {
1429     auto* p = CreateMaybeMessage<::rc::Guami>(GetArenaNoVirtual());
1430     guami_ = p;
1431   }
1432   // @@protoc_insertion_point(field_mutable:rc.gNBUEID.guami)
1433   return guami_;
1434 }
1435 inline void gNBUEID::set_allocated_guami(::rc::Guami* guami) {
1436   ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
1437   if (message_arena == NULL) {
1438     delete guami_;
1439   }
1440   if (guami) {
1441     ::google::protobuf::Arena* submessage_arena = NULL;
1442     if (message_arena != submessage_arena) {
1443       guami = ::google::protobuf::internal::GetOwnedMessage(
1444           message_arena, guami, submessage_arena);
1445     }
1446
1447   } else {
1448
1449   }
1450   guami_ = guami;
1451   // @@protoc_insertion_point(field_set_allocated:rc.gNBUEID.guami)
1452 }
1453
1454 // repeated int64 gNBCUUEF1APID = 3;
1455 inline int gNBUEID::gnbcuuef1apid_size() const {
1456   return gnbcuuef1apid_.size();
1457 }
1458 inline void gNBUEID::clear_gnbcuuef1apid() {
1459   gnbcuuef1apid_.Clear();
1460 }
1461 inline ::google::protobuf::int64 gNBUEID::gnbcuuef1apid(int index) const {
1462   // @@protoc_insertion_point(field_get:rc.gNBUEID.gNBCUUEF1APID)
1463   return gnbcuuef1apid_.Get(index);
1464 }
1465 inline void gNBUEID::set_gnbcuuef1apid(int index, ::google::protobuf::int64 value) {
1466   gnbcuuef1apid_.Set(index, value);
1467   // @@protoc_insertion_point(field_set:rc.gNBUEID.gNBCUUEF1APID)
1468 }
1469 inline void gNBUEID::add_gnbcuuef1apid(::google::protobuf::int64 value) {
1470   gnbcuuef1apid_.Add(value);
1471   // @@protoc_insertion_point(field_add:rc.gNBUEID.gNBCUUEF1APID)
1472 }
1473 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
1474 gNBUEID::gnbcuuef1apid() const {
1475   // @@protoc_insertion_point(field_list:rc.gNBUEID.gNBCUUEF1APID)
1476   return gnbcuuef1apid_;
1477 }
1478 inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
1479 gNBUEID::mutable_gnbcuuef1apid() {
1480   // @@protoc_insertion_point(field_mutable_list:rc.gNBUEID.gNBCUUEF1APID)
1481   return &gnbcuuef1apid_;
1482 }
1483
1484 // repeated int64 gNBCUCPUEE1APID = 4;
1485 inline int gNBUEID::gnbcucpuee1apid_size() const {
1486   return gnbcucpuee1apid_.size();
1487 }
1488 inline void gNBUEID::clear_gnbcucpuee1apid() {
1489   gnbcucpuee1apid_.Clear();
1490 }
1491 inline ::google::protobuf::int64 gNBUEID::gnbcucpuee1apid(int index) const {
1492   // @@protoc_insertion_point(field_get:rc.gNBUEID.gNBCUCPUEE1APID)
1493   return gnbcucpuee1apid_.Get(index);
1494 }
1495 inline void gNBUEID::set_gnbcucpuee1apid(int index, ::google::protobuf::int64 value) {
1496   gnbcucpuee1apid_.Set(index, value);
1497   // @@protoc_insertion_point(field_set:rc.gNBUEID.gNBCUCPUEE1APID)
1498 }
1499 inline void gNBUEID::add_gnbcucpuee1apid(::google::protobuf::int64 value) {
1500   gnbcucpuee1apid_.Add(value);
1501   // @@protoc_insertion_point(field_add:rc.gNBUEID.gNBCUCPUEE1APID)
1502 }
1503 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
1504 gNBUEID::gnbcucpuee1apid() const {
1505   // @@protoc_insertion_point(field_list:rc.gNBUEID.gNBCUCPUEE1APID)
1506   return gnbcucpuee1apid_;
1507 }
1508 inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
1509 gNBUEID::mutable_gnbcucpuee1apid() {
1510   // @@protoc_insertion_point(field_mutable_list:rc.gNBUEID.gNBCUCPUEE1APID)
1511   return &gnbcucpuee1apid_;
1512 }
1513
1514 // -------------------------------------------------------------------
1515
1516 // Guami
1517
1518 // string pLMNIdentity = 1;
1519 inline void Guami::clear_plmnidentity() {
1520   plmnidentity_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1521 }
1522 inline const ::std::string& Guami::plmnidentity() const {
1523   // @@protoc_insertion_point(field_get:rc.Guami.pLMNIdentity)
1524   return plmnidentity_.GetNoArena();
1525 }
1526 inline void Guami::set_plmnidentity(const ::std::string& value) {
1527
1528   plmnidentity_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1529   // @@protoc_insertion_point(field_set:rc.Guami.pLMNIdentity)
1530 }
1531 #if LANG_CXX11
1532 inline void Guami::set_plmnidentity(::std::string&& value) {
1533
1534   plmnidentity_.SetNoArena(
1535     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1536   // @@protoc_insertion_point(field_set_rvalue:rc.Guami.pLMNIdentity)
1537 }
1538 #endif
1539 inline void Guami::set_plmnidentity(const char* value) {
1540   GOOGLE_DCHECK(value != NULL);
1541
1542   plmnidentity_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1543   // @@protoc_insertion_point(field_set_char:rc.Guami.pLMNIdentity)
1544 }
1545 inline void Guami::set_plmnidentity(const char* value, size_t size) {
1546
1547   plmnidentity_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1548       ::std::string(reinterpret_cast<const char*>(value), size));
1549   // @@protoc_insertion_point(field_set_pointer:rc.Guami.pLMNIdentity)
1550 }
1551 inline ::std::string* Guami::mutable_plmnidentity() {
1552
1553   // @@protoc_insertion_point(field_mutable:rc.Guami.pLMNIdentity)
1554   return plmnidentity_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1555 }
1556 inline ::std::string* Guami::release_plmnidentity() {
1557   // @@protoc_insertion_point(field_release:rc.Guami.pLMNIdentity)
1558
1559   return plmnidentity_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1560 }
1561 inline void Guami::set_allocated_plmnidentity(::std::string* plmnidentity) {
1562   if (plmnidentity != NULL) {
1563
1564   } else {
1565
1566   }
1567   plmnidentity_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), plmnidentity);
1568   // @@protoc_insertion_point(field_set_allocated:rc.Guami.pLMNIdentity)
1569 }
1570
1571 // string aMFRegionID = 2;
1572 inline void Guami::clear_amfregionid() {
1573   amfregionid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1574 }
1575 inline const ::std::string& Guami::amfregionid() const {
1576   // @@protoc_insertion_point(field_get:rc.Guami.aMFRegionID)
1577   return amfregionid_.GetNoArena();
1578 }
1579 inline void Guami::set_amfregionid(const ::std::string& value) {
1580
1581   amfregionid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1582   // @@protoc_insertion_point(field_set:rc.Guami.aMFRegionID)
1583 }
1584 #if LANG_CXX11
1585 inline void Guami::set_amfregionid(::std::string&& value) {
1586
1587   amfregionid_.SetNoArena(
1588     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1589   // @@protoc_insertion_point(field_set_rvalue:rc.Guami.aMFRegionID)
1590 }
1591 #endif
1592 inline void Guami::set_amfregionid(const char* value) {
1593   GOOGLE_DCHECK(value != NULL);
1594
1595   amfregionid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1596   // @@protoc_insertion_point(field_set_char:rc.Guami.aMFRegionID)
1597 }
1598 inline void Guami::set_amfregionid(const char* value, size_t size) {
1599
1600   amfregionid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1601       ::std::string(reinterpret_cast<const char*>(value), size));
1602   // @@protoc_insertion_point(field_set_pointer:rc.Guami.aMFRegionID)
1603 }
1604 inline ::std::string* Guami::mutable_amfregionid() {
1605
1606   // @@protoc_insertion_point(field_mutable:rc.Guami.aMFRegionID)
1607   return amfregionid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1608 }
1609 inline ::std::string* Guami::release_amfregionid() {
1610   // @@protoc_insertion_point(field_release:rc.Guami.aMFRegionID)
1611
1612   return amfregionid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1613 }
1614 inline void Guami::set_allocated_amfregionid(::std::string* amfregionid) {
1615   if (amfregionid != NULL) {
1616
1617   } else {
1618
1619   }
1620   amfregionid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), amfregionid);
1621   // @@protoc_insertion_point(field_set_allocated:rc.Guami.aMFRegionID)
1622 }
1623
1624 // string aMFSetID = 3;
1625 inline void Guami::clear_amfsetid() {
1626   amfsetid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1627 }
1628 inline const ::std::string& Guami::amfsetid() const {
1629   // @@protoc_insertion_point(field_get:rc.Guami.aMFSetID)
1630   return amfsetid_.GetNoArena();
1631 }
1632 inline void Guami::set_amfsetid(const ::std::string& value) {
1633
1634   amfsetid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1635   // @@protoc_insertion_point(field_set:rc.Guami.aMFSetID)
1636 }
1637 #if LANG_CXX11
1638 inline void Guami::set_amfsetid(::std::string&& value) {
1639
1640   amfsetid_.SetNoArena(
1641     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1642   // @@protoc_insertion_point(field_set_rvalue:rc.Guami.aMFSetID)
1643 }
1644 #endif
1645 inline void Guami::set_amfsetid(const char* value) {
1646   GOOGLE_DCHECK(value != NULL);
1647
1648   amfsetid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1649   // @@protoc_insertion_point(field_set_char:rc.Guami.aMFSetID)
1650 }
1651 inline void Guami::set_amfsetid(const char* value, size_t size) {
1652
1653   amfsetid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1654       ::std::string(reinterpret_cast<const char*>(value), size));
1655   // @@protoc_insertion_point(field_set_pointer:rc.Guami.aMFSetID)
1656 }
1657 inline ::std::string* Guami::mutable_amfsetid() {
1658
1659   // @@protoc_insertion_point(field_mutable:rc.Guami.aMFSetID)
1660   return amfsetid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1661 }
1662 inline ::std::string* Guami::release_amfsetid() {
1663   // @@protoc_insertion_point(field_release:rc.Guami.aMFSetID)
1664
1665   return amfsetid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1666 }
1667 inline void Guami::set_allocated_amfsetid(::std::string* amfsetid) {
1668   if (amfsetid != NULL) {
1669
1670   } else {
1671
1672   }
1673   amfsetid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), amfsetid);
1674   // @@protoc_insertion_point(field_set_allocated:rc.Guami.aMFSetID)
1675 }
1676
1677 // string aMFPointer = 4;
1678 inline void Guami::clear_amfpointer() {
1679   amfpointer_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1680 }
1681 inline const ::std::string& Guami::amfpointer() const {
1682   // @@protoc_insertion_point(field_get:rc.Guami.aMFPointer)
1683   return amfpointer_.GetNoArena();
1684 }
1685 inline void Guami::set_amfpointer(const ::std::string& value) {
1686
1687   amfpointer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1688   // @@protoc_insertion_point(field_set:rc.Guami.aMFPointer)
1689 }
1690 #if LANG_CXX11
1691 inline void Guami::set_amfpointer(::std::string&& value) {
1692
1693   amfpointer_.SetNoArena(
1694     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1695   // @@protoc_insertion_point(field_set_rvalue:rc.Guami.aMFPointer)
1696 }
1697 #endif
1698 inline void Guami::set_amfpointer(const char* value) {
1699   GOOGLE_DCHECK(value != NULL);
1700
1701   amfpointer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1702   // @@protoc_insertion_point(field_set_char:rc.Guami.aMFPointer)
1703 }
1704 inline void Guami::set_amfpointer(const char* value, size_t size) {
1705
1706   amfpointer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1707       ::std::string(reinterpret_cast<const char*>(value), size));
1708   // @@protoc_insertion_point(field_set_pointer:rc.Guami.aMFPointer)
1709 }
1710 inline ::std::string* Guami::mutable_amfpointer() {
1711
1712   // @@protoc_insertion_point(field_mutable:rc.Guami.aMFPointer)
1713   return amfpointer_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1714 }
1715 inline ::std::string* Guami::release_amfpointer() {
1716   // @@protoc_insertion_point(field_release:rc.Guami.aMFPointer)
1717
1718   return amfpointer_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1719 }
1720 inline void Guami::set_allocated_amfpointer(::std::string* amfpointer) {
1721   if (amfpointer != NULL) {
1722
1723   } else {
1724
1725   }
1726   amfpointer_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), amfpointer);
1727   // @@protoc_insertion_point(field_set_allocated:rc.Guami.aMFPointer)
1728 }
1729
1730 // -------------------------------------------------------------------
1731
1732 // RICControlMessage
1733
1734 // .rc.RICControlCellTypeEnum RICControlCellTypeVal = 1;
1735 inline void RICControlMessage::clear_riccontrolcelltypeval() {
1736   riccontrolcelltypeval_ = 0;
1737 }
1738 inline ::rc::RICControlCellTypeEnum RICControlMessage::riccontrolcelltypeval() const {
1739   // @@protoc_insertion_point(field_get:rc.RICControlMessage.RICControlCellTypeVal)
1740   return static_cast< ::rc::RICControlCellTypeEnum >(riccontrolcelltypeval_);
1741 }
1742 inline void RICControlMessage::set_riccontrolcelltypeval(::rc::RICControlCellTypeEnum value) {
1743
1744   riccontrolcelltypeval_ = value;
1745   // @@protoc_insertion_point(field_set:rc.RICControlMessage.RICControlCellTypeVal)
1746 }
1747
1748 // string TargetCellID = 2;
1749 inline void RICControlMessage::clear_targetcellid() {
1750   targetcellid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1751 }
1752 inline const ::std::string& RICControlMessage::targetcellid() const {
1753   // @@protoc_insertion_point(field_get:rc.RICControlMessage.TargetCellID)
1754   return targetcellid_.GetNoArena();
1755 }
1756 inline void RICControlMessage::set_targetcellid(const ::std::string& value) {
1757
1758   targetcellid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1759   // @@protoc_insertion_point(field_set:rc.RICControlMessage.TargetCellID)
1760 }
1761 #if LANG_CXX11
1762 inline void RICControlMessage::set_targetcellid(::std::string&& value) {
1763
1764   targetcellid_.SetNoArena(
1765     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1766   // @@protoc_insertion_point(field_set_rvalue:rc.RICControlMessage.TargetCellID)
1767 }
1768 #endif
1769 inline void RICControlMessage::set_targetcellid(const char* value) {
1770   GOOGLE_DCHECK(value != NULL);
1771
1772   targetcellid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1773   // @@protoc_insertion_point(field_set_char:rc.RICControlMessage.TargetCellID)
1774 }
1775 inline void RICControlMessage::set_targetcellid(const char* value, size_t size) {
1776
1777   targetcellid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1778       ::std::string(reinterpret_cast<const char*>(value), size));
1779   // @@protoc_insertion_point(field_set_pointer:rc.RICControlMessage.TargetCellID)
1780 }
1781 inline ::std::string* RICControlMessage::mutable_targetcellid() {
1782
1783   // @@protoc_insertion_point(field_mutable:rc.RICControlMessage.TargetCellID)
1784   return targetcellid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1785 }
1786 inline ::std::string* RICControlMessage::release_targetcellid() {
1787   // @@protoc_insertion_point(field_release:rc.RICControlMessage.TargetCellID)
1788
1789   return targetcellid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1790 }
1791 inline void RICControlMessage::set_allocated_targetcellid(::std::string* targetcellid) {
1792   if (targetcellid != NULL) {
1793
1794   } else {
1795
1796   }
1797   targetcellid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), targetcellid);
1798   // @@protoc_insertion_point(field_set_allocated:rc.RICControlMessage.TargetCellID)
1799 }
1800
1801 // -------------------------------------------------------------------
1802
1803 // RicControlGrpcReq
1804
1805 // string e2NodeID = 1;
1806 inline void RicControlGrpcReq::clear_e2nodeid() {
1807   e2nodeid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1808 }
1809 inline const ::std::string& RicControlGrpcReq::e2nodeid() const {
1810   // @@protoc_insertion_point(field_get:rc.RicControlGrpcReq.e2NodeID)
1811   return e2nodeid_.GetNoArena();
1812 }
1813 inline void RicControlGrpcReq::set_e2nodeid(const ::std::string& value) {
1814
1815   e2nodeid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1816   // @@protoc_insertion_point(field_set:rc.RicControlGrpcReq.e2NodeID)
1817 }
1818 #if LANG_CXX11
1819 inline void RicControlGrpcReq::set_e2nodeid(::std::string&& value) {
1820
1821   e2nodeid_.SetNoArena(
1822     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1823   // @@protoc_insertion_point(field_set_rvalue:rc.RicControlGrpcReq.e2NodeID)
1824 }
1825 #endif
1826 inline void RicControlGrpcReq::set_e2nodeid(const char* value) {
1827   GOOGLE_DCHECK(value != NULL);
1828
1829   e2nodeid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1830   // @@protoc_insertion_point(field_set_char:rc.RicControlGrpcReq.e2NodeID)
1831 }
1832 inline void RicControlGrpcReq::set_e2nodeid(const char* value, size_t size) {
1833
1834   e2nodeid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1835       ::std::string(reinterpret_cast<const char*>(value), size));
1836   // @@protoc_insertion_point(field_set_pointer:rc.RicControlGrpcReq.e2NodeID)
1837 }
1838 inline ::std::string* RicControlGrpcReq::mutable_e2nodeid() {
1839
1840   // @@protoc_insertion_point(field_mutable:rc.RicControlGrpcReq.e2NodeID)
1841   return e2nodeid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1842 }
1843 inline ::std::string* RicControlGrpcReq::release_e2nodeid() {
1844   // @@protoc_insertion_point(field_release:rc.RicControlGrpcReq.e2NodeID)
1845
1846   return e2nodeid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1847 }
1848 inline void RicControlGrpcReq::set_allocated_e2nodeid(::std::string* e2nodeid) {
1849   if (e2nodeid != NULL) {
1850
1851   } else {
1852
1853   }
1854   e2nodeid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), e2nodeid);
1855   // @@protoc_insertion_point(field_set_allocated:rc.RicControlGrpcReq.e2NodeID)
1856 }
1857
1858 // string plmnID = 2;
1859 inline void RicControlGrpcReq::clear_plmnid() {
1860   plmnid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1861 }
1862 inline const ::std::string& RicControlGrpcReq::plmnid() const {
1863   // @@protoc_insertion_point(field_get:rc.RicControlGrpcReq.plmnID)
1864   return plmnid_.GetNoArena();
1865 }
1866 inline void RicControlGrpcReq::set_plmnid(const ::std::string& value) {
1867
1868   plmnid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1869   // @@protoc_insertion_point(field_set:rc.RicControlGrpcReq.plmnID)
1870 }
1871 #if LANG_CXX11
1872 inline void RicControlGrpcReq::set_plmnid(::std::string&& value) {
1873
1874   plmnid_.SetNoArena(
1875     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1876   // @@protoc_insertion_point(field_set_rvalue:rc.RicControlGrpcReq.plmnID)
1877 }
1878 #endif
1879 inline void RicControlGrpcReq::set_plmnid(const char* value) {
1880   GOOGLE_DCHECK(value != NULL);
1881
1882   plmnid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1883   // @@protoc_insertion_point(field_set_char:rc.RicControlGrpcReq.plmnID)
1884 }
1885 inline void RicControlGrpcReq::set_plmnid(const char* value, size_t size) {
1886
1887   plmnid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1888       ::std::string(reinterpret_cast<const char*>(value), size));
1889   // @@protoc_insertion_point(field_set_pointer:rc.RicControlGrpcReq.plmnID)
1890 }
1891 inline ::std::string* RicControlGrpcReq::mutable_plmnid() {
1892
1893   // @@protoc_insertion_point(field_mutable:rc.RicControlGrpcReq.plmnID)
1894   return plmnid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1895 }
1896 inline ::std::string* RicControlGrpcReq::release_plmnid() {
1897   // @@protoc_insertion_point(field_release:rc.RicControlGrpcReq.plmnID)
1898
1899   return plmnid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1900 }
1901 inline void RicControlGrpcReq::set_allocated_plmnid(::std::string* plmnid) {
1902   if (plmnid != NULL) {
1903
1904   } else {
1905
1906   }
1907   plmnid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), plmnid);
1908   // @@protoc_insertion_point(field_set_allocated:rc.RicControlGrpcReq.plmnID)
1909 }
1910
1911 // string ranName = 3;
1912 inline void RicControlGrpcReq::clear_ranname() {
1913   ranname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1914 }
1915 inline const ::std::string& RicControlGrpcReq::ranname() const {
1916   // @@protoc_insertion_point(field_get:rc.RicControlGrpcReq.ranName)
1917   return ranname_.GetNoArena();
1918 }
1919 inline void RicControlGrpcReq::set_ranname(const ::std::string& value) {
1920
1921   ranname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
1922   // @@protoc_insertion_point(field_set:rc.RicControlGrpcReq.ranName)
1923 }
1924 #if LANG_CXX11
1925 inline void RicControlGrpcReq::set_ranname(::std::string&& value) {
1926
1927   ranname_.SetNoArena(
1928     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
1929   // @@protoc_insertion_point(field_set_rvalue:rc.RicControlGrpcReq.ranName)
1930 }
1931 #endif
1932 inline void RicControlGrpcReq::set_ranname(const char* value) {
1933   GOOGLE_DCHECK(value != NULL);
1934
1935   ranname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
1936   // @@protoc_insertion_point(field_set_char:rc.RicControlGrpcReq.ranName)
1937 }
1938 inline void RicControlGrpcReq::set_ranname(const char* value, size_t size) {
1939
1940   ranname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1941       ::std::string(reinterpret_cast<const char*>(value), size));
1942   // @@protoc_insertion_point(field_set_pointer:rc.RicControlGrpcReq.ranName)
1943 }
1944 inline ::std::string* RicControlGrpcReq::mutable_ranname() {
1945
1946   // @@protoc_insertion_point(field_mutable:rc.RicControlGrpcReq.ranName)
1947   return ranname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1948 }
1949 inline ::std::string* RicControlGrpcReq::release_ranname() {
1950   // @@protoc_insertion_point(field_release:rc.RicControlGrpcReq.ranName)
1951
1952   return ranname_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1953 }
1954 inline void RicControlGrpcReq::set_allocated_ranname(::std::string* ranname) {
1955   if (ranname != NULL) {
1956
1957   } else {
1958
1959   }
1960   ranname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ranname);
1961   // @@protoc_insertion_point(field_set_allocated:rc.RicControlGrpcReq.ranName)
1962 }
1963
1964 // .rc.RICE2APHeader RICE2APHeaderData = 4;
1965 inline bool RicControlGrpcReq::has_rice2apheaderdata() const {
1966   return this != internal_default_instance() && rice2apheaderdata_ != NULL;
1967 }
1968 inline void RicControlGrpcReq::clear_rice2apheaderdata() {
1969   if (GetArenaNoVirtual() == NULL && rice2apheaderdata_ != NULL) {
1970     delete rice2apheaderdata_;
1971   }
1972   rice2apheaderdata_ = NULL;
1973 }
1974 inline const ::rc::RICE2APHeader& RicControlGrpcReq::_internal_rice2apheaderdata() const {
1975   return *rice2apheaderdata_;
1976 }
1977 inline const ::rc::RICE2APHeader& RicControlGrpcReq::rice2apheaderdata() const {
1978   const ::rc::RICE2APHeader* p = rice2apheaderdata_;
1979   // @@protoc_insertion_point(field_get:rc.RicControlGrpcReq.RICE2APHeaderData)
1980   return p != NULL ? *p : *reinterpret_cast<const ::rc::RICE2APHeader*>(
1981       &::rc::_RICE2APHeader_default_instance_);
1982 }
1983 inline ::rc::RICE2APHeader* RicControlGrpcReq::release_rice2apheaderdata() {
1984   // @@protoc_insertion_point(field_release:rc.RicControlGrpcReq.RICE2APHeaderData)
1985
1986   ::rc::RICE2APHeader* temp = rice2apheaderdata_;
1987   rice2apheaderdata_ = NULL;
1988   return temp;
1989 }
1990 inline ::rc::RICE2APHeader* RicControlGrpcReq::mutable_rice2apheaderdata() {
1991
1992   if (rice2apheaderdata_ == NULL) {
1993     auto* p = CreateMaybeMessage<::rc::RICE2APHeader>(GetArenaNoVirtual());
1994     rice2apheaderdata_ = p;
1995   }
1996   // @@protoc_insertion_point(field_mutable:rc.RicControlGrpcReq.RICE2APHeaderData)
1997   return rice2apheaderdata_;
1998 }
1999 inline void RicControlGrpcReq::set_allocated_rice2apheaderdata(::rc::RICE2APHeader* rice2apheaderdata) {
2000   ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
2001   if (message_arena == NULL) {
2002     delete rice2apheaderdata_;
2003   }
2004   if (rice2apheaderdata) {
2005     ::google::protobuf::Arena* submessage_arena = NULL;
2006     if (message_arena != submessage_arena) {
2007       rice2apheaderdata = ::google::protobuf::internal::GetOwnedMessage(
2008           message_arena, rice2apheaderdata, submessage_arena);
2009     }
2010
2011   } else {
2012
2013   }
2014   rice2apheaderdata_ = rice2apheaderdata;
2015   // @@protoc_insertion_point(field_set_allocated:rc.RicControlGrpcReq.RICE2APHeaderData)
2016 }
2017
2018 // .rc.RICControlHeader RICControlHeaderData = 5;
2019 inline bool RicControlGrpcReq::has_riccontrolheaderdata() const {
2020   return this != internal_default_instance() && riccontrolheaderdata_ != NULL;
2021 }
2022 inline void RicControlGrpcReq::clear_riccontrolheaderdata() {
2023   if (GetArenaNoVirtual() == NULL && riccontrolheaderdata_ != NULL) {
2024     delete riccontrolheaderdata_;
2025   }
2026   riccontrolheaderdata_ = NULL;
2027 }
2028 inline const ::rc::RICControlHeader& RicControlGrpcReq::_internal_riccontrolheaderdata() const {
2029   return *riccontrolheaderdata_;
2030 }
2031 inline const ::rc::RICControlHeader& RicControlGrpcReq::riccontrolheaderdata() const {
2032   const ::rc::RICControlHeader* p = riccontrolheaderdata_;
2033   // @@protoc_insertion_point(field_get:rc.RicControlGrpcReq.RICControlHeaderData)
2034   return p != NULL ? *p : *reinterpret_cast<const ::rc::RICControlHeader*>(
2035       &::rc::_RICControlHeader_default_instance_);
2036 }
2037 inline ::rc::RICControlHeader* RicControlGrpcReq::release_riccontrolheaderdata() {
2038   // @@protoc_insertion_point(field_release:rc.RicControlGrpcReq.RICControlHeaderData)
2039
2040   ::rc::RICControlHeader* temp = riccontrolheaderdata_;
2041   riccontrolheaderdata_ = NULL;
2042   return temp;
2043 }
2044 inline ::rc::RICControlHeader* RicControlGrpcReq::mutable_riccontrolheaderdata() {
2045
2046   if (riccontrolheaderdata_ == NULL) {
2047     auto* p = CreateMaybeMessage<::rc::RICControlHeader>(GetArenaNoVirtual());
2048     riccontrolheaderdata_ = p;
2049   }
2050   // @@protoc_insertion_point(field_mutable:rc.RicControlGrpcReq.RICControlHeaderData)
2051   return riccontrolheaderdata_;
2052 }
2053 inline void RicControlGrpcReq::set_allocated_riccontrolheaderdata(::rc::RICControlHeader* riccontrolheaderdata) {
2054   ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
2055   if (message_arena == NULL) {
2056     delete riccontrolheaderdata_;
2057   }
2058   if (riccontrolheaderdata) {
2059     ::google::protobuf::Arena* submessage_arena = NULL;
2060     if (message_arena != submessage_arena) {
2061       riccontrolheaderdata = ::google::protobuf::internal::GetOwnedMessage(
2062           message_arena, riccontrolheaderdata, submessage_arena);
2063     }
2064
2065   } else {
2066
2067   }
2068   riccontrolheaderdata_ = riccontrolheaderdata;
2069   // @@protoc_insertion_point(field_set_allocated:rc.RicControlGrpcReq.RICControlHeaderData)
2070 }
2071
2072 // .rc.RICControlMessage RICControlMessageData = 6;
2073 inline bool RicControlGrpcReq::has_riccontrolmessagedata() const {
2074   return this != internal_default_instance() && riccontrolmessagedata_ != NULL;
2075 }
2076 inline void RicControlGrpcReq::clear_riccontrolmessagedata() {
2077   if (GetArenaNoVirtual() == NULL && riccontrolmessagedata_ != NULL) {
2078     delete riccontrolmessagedata_;
2079   }
2080   riccontrolmessagedata_ = NULL;
2081 }
2082 inline const ::rc::RICControlMessage& RicControlGrpcReq::_internal_riccontrolmessagedata() const {
2083   return *riccontrolmessagedata_;
2084 }
2085 inline const ::rc::RICControlMessage& RicControlGrpcReq::riccontrolmessagedata() const {
2086   const ::rc::RICControlMessage* p = riccontrolmessagedata_;
2087   // @@protoc_insertion_point(field_get:rc.RicControlGrpcReq.RICControlMessageData)
2088   return p != NULL ? *p : *reinterpret_cast<const ::rc::RICControlMessage*>(
2089       &::rc::_RICControlMessage_default_instance_);
2090 }
2091 inline ::rc::RICControlMessage* RicControlGrpcReq::release_riccontrolmessagedata() {
2092   // @@protoc_insertion_point(field_release:rc.RicControlGrpcReq.RICControlMessageData)
2093
2094   ::rc::RICControlMessage* temp = riccontrolmessagedata_;
2095   riccontrolmessagedata_ = NULL;
2096   return temp;
2097 }
2098 inline ::rc::RICControlMessage* RicControlGrpcReq::mutable_riccontrolmessagedata() {
2099
2100   if (riccontrolmessagedata_ == NULL) {
2101     auto* p = CreateMaybeMessage<::rc::RICControlMessage>(GetArenaNoVirtual());
2102     riccontrolmessagedata_ = p;
2103   }
2104   // @@protoc_insertion_point(field_mutable:rc.RicControlGrpcReq.RICControlMessageData)
2105   return riccontrolmessagedata_;
2106 }
2107 inline void RicControlGrpcReq::set_allocated_riccontrolmessagedata(::rc::RICControlMessage* riccontrolmessagedata) {
2108   ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
2109   if (message_arena == NULL) {
2110     delete riccontrolmessagedata_;
2111   }
2112   if (riccontrolmessagedata) {
2113     ::google::protobuf::Arena* submessage_arena = NULL;
2114     if (message_arena != submessage_arena) {
2115       riccontrolmessagedata = ::google::protobuf::internal::GetOwnedMessage(
2116           message_arena, riccontrolmessagedata, submessage_arena);
2117     }
2118
2119   } else {
2120
2121   }
2122   riccontrolmessagedata_ = riccontrolmessagedata;
2123   // @@protoc_insertion_point(field_set_allocated:rc.RicControlGrpcReq.RICControlMessageData)
2124 }
2125
2126 // .rc.RICControlAckEnum RICControlAckReqVal = 7;
2127 inline void RicControlGrpcReq::clear_riccontrolackreqval() {
2128   riccontrolackreqval_ = 0;
2129 }
2130 inline ::rc::RICControlAckEnum RicControlGrpcReq::riccontrolackreqval() const {
2131   // @@protoc_insertion_point(field_get:rc.RicControlGrpcReq.RICControlAckReqVal)
2132   return static_cast< ::rc::RICControlAckEnum >(riccontrolackreqval_);
2133 }
2134 inline void RicControlGrpcReq::set_riccontrolackreqval(::rc::RICControlAckEnum value) {
2135
2136   riccontrolackreqval_ = value;
2137   // @@protoc_insertion_point(field_set:rc.RicControlGrpcReq.RICControlAckReqVal)
2138 }
2139
2140 // -------------------------------------------------------------------
2141
2142 // RicControlGrpcRsp
2143
2144 // int32 rspCode = 1;
2145 inline void RicControlGrpcRsp::clear_rspcode() {
2146   rspcode_ = 0;
2147 }
2148 inline ::google::protobuf::int32 RicControlGrpcRsp::rspcode() const {
2149   // @@protoc_insertion_point(field_get:rc.RicControlGrpcRsp.rspCode)
2150   return rspcode_;
2151 }
2152 inline void RicControlGrpcRsp::set_rspcode(::google::protobuf::int32 value) {
2153
2154   rspcode_ = value;
2155   // @@protoc_insertion_point(field_set:rc.RicControlGrpcRsp.rspCode)
2156 }
2157
2158 // string description = 2;
2159 inline void RicControlGrpcRsp::clear_description() {
2160   description_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2161 }
2162 inline const ::std::string& RicControlGrpcRsp::description() const {
2163   // @@protoc_insertion_point(field_get:rc.RicControlGrpcRsp.description)
2164   return description_.GetNoArena();
2165 }
2166 inline void RicControlGrpcRsp::set_description(const ::std::string& value) {
2167
2168   description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2169   // @@protoc_insertion_point(field_set:rc.RicControlGrpcRsp.description)
2170 }
2171 #if LANG_CXX11
2172 inline void RicControlGrpcRsp::set_description(::std::string&& value) {
2173
2174   description_.SetNoArena(
2175     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2176   // @@protoc_insertion_point(field_set_rvalue:rc.RicControlGrpcRsp.description)
2177 }
2178 #endif
2179 inline void RicControlGrpcRsp::set_description(const char* value) {
2180   GOOGLE_DCHECK(value != NULL);
2181
2182   description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2183   // @@protoc_insertion_point(field_set_char:rc.RicControlGrpcRsp.description)
2184 }
2185 inline void RicControlGrpcRsp::set_description(const char* value, size_t size) {
2186
2187   description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2188       ::std::string(reinterpret_cast<const char*>(value), size));
2189   // @@protoc_insertion_point(field_set_pointer:rc.RicControlGrpcRsp.description)
2190 }
2191 inline ::std::string* RicControlGrpcRsp::mutable_description() {
2192
2193   // @@protoc_insertion_point(field_mutable:rc.RicControlGrpcRsp.description)
2194   return description_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2195 }
2196 inline ::std::string* RicControlGrpcRsp::release_description() {
2197   // @@protoc_insertion_point(field_release:rc.RicControlGrpcRsp.description)
2198
2199   return description_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2200 }
2201 inline void RicControlGrpcRsp::set_allocated_description(::std::string* description) {
2202   if (description != NULL) {
2203
2204   } else {
2205
2206   }
2207   description_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description);
2208   // @@protoc_insertion_point(field_set_allocated:rc.RicControlGrpcRsp.description)
2209 }
2210
2211 #ifdef __GNUC__
2212   #pragma GCC diagnostic pop
2213 #endif  // __GNUC__
2214 // -------------------------------------------------------------------
2215
2216 // -------------------------------------------------------------------
2217
2218 // -------------------------------------------------------------------
2219
2220 // -------------------------------------------------------------------
2221
2222 // -------------------------------------------------------------------
2223
2224 // -------------------------------------------------------------------
2225
2226 // -------------------------------------------------------------------
2227
2228
2229 // @@protoc_insertion_point(namespace_scope)
2230
2231 }  // namespace rc
2232
2233 namespace google {
2234 namespace protobuf {
2235
2236 template <> struct is_proto_enum< ::rc::RICControlCellTypeEnum> : ::std::true_type {};
2237 template <>
2238 inline const EnumDescriptor* GetEnumDescriptor< ::rc::RICControlCellTypeEnum>() {
2239   return ::rc::RICControlCellTypeEnum_descriptor();
2240 }
2241 template <> struct is_proto_enum< ::rc::RICControlAckEnum> : ::std::true_type {};
2242 template <>
2243 inline const EnumDescriptor* GetEnumDescriptor< ::rc::RICControlAckEnum>() {
2244   return ::rc::RICControlAckEnum_descriptor();
2245 }
2246
2247 }  // namespace protobuf
2248 }  // namespace google
2249
2250 // @@protoc_insertion_point(global_scope)
2251
2252 #endif  // PROTOBUF_INCLUDED_rc_2eproto