// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: rc.proto

#ifndef PROTOBUF_INCLUDED_rc_2eproto
#define PROTOBUF_INCLUDED_rc_2eproto

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3006001
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_rc_2eproto 

namespace protobuf_rc_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[8];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
}  // namespace protobuf_rc_2eproto
namespace rc {
class Guami;
class GuamiDefaultTypeInternal;
extern GuamiDefaultTypeInternal _Guami_default_instance_;
class RICControlHeader;
class RICControlHeaderDefaultTypeInternal;
extern RICControlHeaderDefaultTypeInternal _RICControlHeader_default_instance_;
class RICControlMessage;
class RICControlMessageDefaultTypeInternal;
extern RICControlMessageDefaultTypeInternal _RICControlMessage_default_instance_;
class RICE2APHeader;
class RICE2APHeaderDefaultTypeInternal;
extern RICE2APHeaderDefaultTypeInternal _RICE2APHeader_default_instance_;
class RicControlGrpcReq;
class RicControlGrpcReqDefaultTypeInternal;
extern RicControlGrpcReqDefaultTypeInternal _RicControlGrpcReq_default_instance_;
class RicControlGrpcRsp;
class RicControlGrpcRspDefaultTypeInternal;
extern RicControlGrpcRspDefaultTypeInternal _RicControlGrpcRsp_default_instance_;
class UeId;
class UeIdDefaultTypeInternal;
extern UeIdDefaultTypeInternal _UeId_default_instance_;
class gNBUEID;
class gNBUEIDDefaultTypeInternal;
extern gNBUEIDDefaultTypeInternal _gNBUEID_default_instance_;
}  // namespace rc
namespace google {
namespace protobuf {
template<> ::rc::Guami* Arena::CreateMaybeMessage<::rc::Guami>(Arena*);
template<> ::rc::RICControlHeader* Arena::CreateMaybeMessage<::rc::RICControlHeader>(Arena*);
template<> ::rc::RICControlMessage* Arena::CreateMaybeMessage<::rc::RICControlMessage>(Arena*);
template<> ::rc::RICE2APHeader* Arena::CreateMaybeMessage<::rc::RICE2APHeader>(Arena*);
template<> ::rc::RicControlGrpcReq* Arena::CreateMaybeMessage<::rc::RicControlGrpcReq>(Arena*);
template<> ::rc::RicControlGrpcRsp* Arena::CreateMaybeMessage<::rc::RicControlGrpcRsp>(Arena*);
template<> ::rc::UeId* Arena::CreateMaybeMessage<::rc::UeId>(Arena*);
template<> ::rc::gNBUEID* Arena::CreateMaybeMessage<::rc::gNBUEID>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace rc {

enum RICControlCellTypeEnum {
  RIC_CONTROL_CELL_UNKWON = 0,
  RIC_CONTROL_NR_CELL = 1,
  RIC_CONTROL_EUTRAN_CELL = 2,
  RICControlCellTypeEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  RICControlCellTypeEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool RICControlCellTypeEnum_IsValid(int value);
const RICControlCellTypeEnum RICControlCellTypeEnum_MIN = RIC_CONTROL_CELL_UNKWON;
const RICControlCellTypeEnum RICControlCellTypeEnum_MAX = RIC_CONTROL_EUTRAN_CELL;
const int RICControlCellTypeEnum_ARRAYSIZE = RICControlCellTypeEnum_MAX + 1;

const ::google::protobuf::EnumDescriptor* RICControlCellTypeEnum_descriptor();
inline const ::std::string& RICControlCellTypeEnum_Name(RICControlCellTypeEnum value) {
  return ::google::protobuf::internal::NameOfEnum(
    RICControlCellTypeEnum_descriptor(), value);
}
inline bool RICControlCellTypeEnum_Parse(
    const ::std::string& name, RICControlCellTypeEnum* value) {
  return ::google::protobuf::internal::ParseNamedEnum<RICControlCellTypeEnum>(
    RICControlCellTypeEnum_descriptor(), name, value);
}
enum RICControlAckEnum {
  RIC_CONTROL_ACK_UNKWON = 0,
  RIC_CONTROL_NO_ACK = 1,
  RIC_CONTROL_ACK = 2,
  RIC_CONTROL_NACK = 3,
  RICControlAckEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  RICControlAckEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool RICControlAckEnum_IsValid(int value);
const RICControlAckEnum RICControlAckEnum_MIN = RIC_CONTROL_ACK_UNKWON;
const RICControlAckEnum RICControlAckEnum_MAX = RIC_CONTROL_NACK;
const int RICControlAckEnum_ARRAYSIZE = RICControlAckEnum_MAX + 1;

const ::google::protobuf::EnumDescriptor* RICControlAckEnum_descriptor();
inline const ::std::string& RICControlAckEnum_Name(RICControlAckEnum value) {
  return ::google::protobuf::internal::NameOfEnum(
    RICControlAckEnum_descriptor(), value);
}
inline bool RICControlAckEnum_Parse(
    const ::std::string& name, RICControlAckEnum* value) {
  return ::google::protobuf::internal::ParseNamedEnum<RICControlAckEnum>(
    RICControlAckEnum_descriptor(), name, value);
}
// ===================================================================

class RICE2APHeader : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rc.RICE2APHeader) */ {
 public:
  RICE2APHeader();
  virtual ~RICE2APHeader();

  RICE2APHeader(const RICE2APHeader& from);

  inline RICE2APHeader& operator=(const RICE2APHeader& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RICE2APHeader(RICE2APHeader&& from) noexcept
    : RICE2APHeader() {
    *this = ::std::move(from);
  }

  inline RICE2APHeader& operator=(RICE2APHeader&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RICE2APHeader& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RICE2APHeader* internal_default_instance() {
    return reinterpret_cast<const RICE2APHeader*>(
               &_RICE2APHeader_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  void Swap(RICE2APHeader* other);
  friend void swap(RICE2APHeader& a, RICE2APHeader& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline RICE2APHeader* New() const final {
    return CreateMaybeMessage<RICE2APHeader>(NULL);
  }

  RICE2APHeader* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RICE2APHeader>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RICE2APHeader& from);
  void MergeFrom(const RICE2APHeader& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RICE2APHeader* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // int64 RanFuncId = 1;
  void clear_ranfuncid();
  static const int kRanFuncIdFieldNumber = 1;
  ::google::protobuf::int64 ranfuncid() const;
  void set_ranfuncid(::google::protobuf::int64 value);

  // int64 RICRequestorID = 2;
  void clear_ricrequestorid();
  static const int kRICRequestorIDFieldNumber = 2;
  ::google::protobuf::int64 ricrequestorid() const;
  void set_ricrequestorid(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:rc.RICE2APHeader)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int64 ranfuncid_;
  ::google::protobuf::int64 ricrequestorid_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_rc_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RICControlHeader : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rc.RICControlHeader) */ {
 public:
  RICControlHeader();
  virtual ~RICControlHeader();

  RICControlHeader(const RICControlHeader& from);

  inline RICControlHeader& operator=(const RICControlHeader& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RICControlHeader(RICControlHeader&& from) noexcept
    : RICControlHeader() {
    *this = ::std::move(from);
  }

  inline RICControlHeader& operator=(RICControlHeader&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RICControlHeader& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RICControlHeader* internal_default_instance() {
    return reinterpret_cast<const RICControlHeader*>(
               &_RICControlHeader_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  void Swap(RICControlHeader* other);
  friend void swap(RICControlHeader& a, RICControlHeader& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline RICControlHeader* New() const final {
    return CreateMaybeMessage<RICControlHeader>(NULL);
  }

  RICControlHeader* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RICControlHeader>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RICControlHeader& from);
  void MergeFrom(const RICControlHeader& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RICControlHeader* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // .rc.UeId UEID = 3;
  bool has_ueid() const;
  void clear_ueid();
  static const int kUEIDFieldNumber = 3;
  private:
  const ::rc::UeId& _internal_ueid() const;
  public:
  const ::rc::UeId& ueid() const;
  ::rc::UeId* release_ueid();
  ::rc::UeId* mutable_ueid();
  void set_allocated_ueid(::rc::UeId* ueid);

  // int64 ControlStyle = 1;
  void clear_controlstyle();
  static const int kControlStyleFieldNumber = 1;
  ::google::protobuf::int64 controlstyle() const;
  void set_controlstyle(::google::protobuf::int64 value);

  // int64 ControlActionId = 2;
  void clear_controlactionid();
  static const int kControlActionIdFieldNumber = 2;
  ::google::protobuf::int64 controlactionid() const;
  void set_controlactionid(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:rc.RICControlHeader)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::rc::UeId* ueid_;
  ::google::protobuf::int64 controlstyle_;
  ::google::protobuf::int64 controlactionid_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_rc_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class UeId : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rc.UeId) */ {
 public:
  UeId();
  virtual ~UeId();

  UeId(const UeId& from);

  inline UeId& operator=(const UeId& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  UeId(UeId&& from) noexcept
    : UeId() {
    *this = ::std::move(from);
  }

  inline UeId& operator=(UeId&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const UeId& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const UeId* internal_default_instance() {
    return reinterpret_cast<const UeId*>(
               &_UeId_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  void Swap(UeId* other);
  friend void swap(UeId& a, UeId& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline UeId* New() const final {
    return CreateMaybeMessage<UeId>(NULL);
  }

  UeId* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<UeId>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const UeId& from);
  void MergeFrom(const UeId& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(UeId* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // .rc.gNBUEID GnbUEID = 1;
  bool has_gnbueid() const;
  void clear_gnbueid();
  static const int kGnbUEIDFieldNumber = 1;
  private:
  const ::rc::gNBUEID& _internal_gnbueid() const;
  public:
  const ::rc::gNBUEID& gnbueid() const;
  ::rc::gNBUEID* release_gnbueid();
  ::rc::gNBUEID* mutable_gnbueid();
  void set_allocated_gnbueid(::rc::gNBUEID* gnbueid);

  // @@protoc_insertion_point(class_scope:rc.UeId)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::rc::gNBUEID* gnbueid_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_rc_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class gNBUEID : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rc.gNBUEID) */ {
 public:
  gNBUEID();
  virtual ~gNBUEID();

  gNBUEID(const gNBUEID& from);

  inline gNBUEID& operator=(const gNBUEID& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  gNBUEID(gNBUEID&& from) noexcept
    : gNBUEID() {
    *this = ::std::move(from);
  }

  inline gNBUEID& operator=(gNBUEID&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const gNBUEID& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const gNBUEID* internal_default_instance() {
    return reinterpret_cast<const gNBUEID*>(
               &_gNBUEID_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  void Swap(gNBUEID* other);
  friend void swap(gNBUEID& a, gNBUEID& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline gNBUEID* New() const final {
    return CreateMaybeMessage<gNBUEID>(NULL);
  }

  gNBUEID* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<gNBUEID>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const gNBUEID& from);
  void MergeFrom(const gNBUEID& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(gNBUEID* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int64 gNBCUUEF1APID = 3;
  int gnbcuuef1apid_size() const;
  void clear_gnbcuuef1apid();
  static const int kGNBCUUEF1APIDFieldNumber = 3;
  ::google::protobuf::int64 gnbcuuef1apid(int index) const;
  void set_gnbcuuef1apid(int index, ::google::protobuf::int64 value);
  void add_gnbcuuef1apid(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      gnbcuuef1apid() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_gnbcuuef1apid();

  // repeated int64 gNBCUCPUEE1APID = 4;
  int gnbcucpuee1apid_size() const;
  void clear_gnbcucpuee1apid();
  static const int kGNBCUCPUEE1APIDFieldNumber = 4;
  ::google::protobuf::int64 gnbcucpuee1apid(int index) const;
  void set_gnbcucpuee1apid(int index, ::google::protobuf::int64 value);
  void add_gnbcucpuee1apid(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      gnbcucpuee1apid() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_gnbcucpuee1apid();

  // .rc.Guami guami = 2;
  bool has_guami() const;
  void clear_guami();
  static const int kGuamiFieldNumber = 2;
  private:
  const ::rc::Guami& _internal_guami() const;
  public:
  const ::rc::Guami& guami() const;
  ::rc::Guami* release_guami();
  ::rc::Guami* mutable_guami();
  void set_allocated_guami(::rc::Guami* guami);

  // int64 amfUENGAPID = 1;
  void clear_amfuengapid();
  static const int kAmfUENGAPIDFieldNumber = 1;
  ::google::protobuf::int64 amfuengapid() const;
  void set_amfuengapid(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:rc.gNBUEID)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > gnbcuuef1apid_;
  mutable int _gnbcuuef1apid_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > gnbcucpuee1apid_;
  mutable int _gnbcucpuee1apid_cached_byte_size_;
  ::rc::Guami* guami_;
  ::google::protobuf::int64 amfuengapid_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_rc_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Guami : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rc.Guami) */ {
 public:
  Guami();
  virtual ~Guami();

  Guami(const Guami& from);

  inline Guami& operator=(const Guami& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Guami(Guami&& from) noexcept
    : Guami() {
    *this = ::std::move(from);
  }

  inline Guami& operator=(Guami&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const Guami& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Guami* internal_default_instance() {
    return reinterpret_cast<const Guami*>(
               &_Guami_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  void Swap(Guami* other);
  friend void swap(Guami& a, Guami& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline Guami* New() const final {
    return CreateMaybeMessage<Guami>(NULL);
  }

  Guami* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Guami>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const Guami& from);
  void MergeFrom(const Guami& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Guami* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string pLMNIdentity = 1;
  void clear_plmnidentity();
  static const int kPLMNIdentityFieldNumber = 1;
  const ::std::string& plmnidentity() const;
  void set_plmnidentity(const ::std::string& value);
  #if LANG_CXX11
  void set_plmnidentity(::std::string&& value);
  #endif
  void set_plmnidentity(const char* value);
  void set_plmnidentity(const char* value, size_t size);
  ::std::string* mutable_plmnidentity();
  ::std::string* release_plmnidentity();
  void set_allocated_plmnidentity(::std::string* plmnidentity);

  // string aMFRegionID = 2;
  void clear_amfregionid();
  static const int kAMFRegionIDFieldNumber = 2;
  const ::std::string& amfregionid() const;
  void set_amfregionid(const ::std::string& value);
  #if LANG_CXX11
  void set_amfregionid(::std::string&& value);
  #endif
  void set_amfregionid(const char* value);
  void set_amfregionid(const char* value, size_t size);
  ::std::string* mutable_amfregionid();
  ::std::string* release_amfregionid();
  void set_allocated_amfregionid(::std::string* amfregionid);

  // string aMFSetID = 3;
  void clear_amfsetid();
  static const int kAMFSetIDFieldNumber = 3;
  const ::std::string& amfsetid() const;
  void set_amfsetid(const ::std::string& value);
  #if LANG_CXX11
  void set_amfsetid(::std::string&& value);
  #endif
  void set_amfsetid(const char* value);
  void set_amfsetid(const char* value, size_t size);
  ::std::string* mutable_amfsetid();
  ::std::string* release_amfsetid();
  void set_allocated_amfsetid(::std::string* amfsetid);

  // string aMFPointer = 4;
  void clear_amfpointer();
  static const int kAMFPointerFieldNumber = 4;
  const ::std::string& amfpointer() const;
  void set_amfpointer(const ::std::string& value);
  #if LANG_CXX11
  void set_amfpointer(::std::string&& value);
  #endif
  void set_amfpointer(const char* value);
  void set_amfpointer(const char* value, size_t size);
  ::std::string* mutable_amfpointer();
  ::std::string* release_amfpointer();
  void set_allocated_amfpointer(::std::string* amfpointer);

  // @@protoc_insertion_point(class_scope:rc.Guami)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr plmnidentity_;
  ::google::protobuf::internal::ArenaStringPtr amfregionid_;
  ::google::protobuf::internal::ArenaStringPtr amfsetid_;
  ::google::protobuf::internal::ArenaStringPtr amfpointer_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_rc_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RICControlMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rc.RICControlMessage) */ {
 public:
  RICControlMessage();
  virtual ~RICControlMessage();

  RICControlMessage(const RICControlMessage& from);

  inline RICControlMessage& operator=(const RICControlMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RICControlMessage(RICControlMessage&& from) noexcept
    : RICControlMessage() {
    *this = ::std::move(from);
  }

  inline RICControlMessage& operator=(RICControlMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RICControlMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RICControlMessage* internal_default_instance() {
    return reinterpret_cast<const RICControlMessage*>(
               &_RICControlMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  void Swap(RICControlMessage* other);
  friend void swap(RICControlMessage& a, RICControlMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline RICControlMessage* New() const final {
    return CreateMaybeMessage<RICControlMessage>(NULL);
  }

  RICControlMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RICControlMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RICControlMessage& from);
  void MergeFrom(const RICControlMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RICControlMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string TargetCellID = 2;
  void clear_targetcellid();
  static const int kTargetCellIDFieldNumber = 2;
  const ::std::string& targetcellid() const;
  void set_targetcellid(const ::std::string& value);
  #if LANG_CXX11
  void set_targetcellid(::std::string&& value);
  #endif
  void set_targetcellid(const char* value);
  void set_targetcellid(const char* value, size_t size);
  ::std::string* mutable_targetcellid();
  ::std::string* release_targetcellid();
  void set_allocated_targetcellid(::std::string* targetcellid);

  // .rc.RICControlCellTypeEnum RICControlCellTypeVal = 1;
  void clear_riccontrolcelltypeval();
  static const int kRICControlCellTypeValFieldNumber = 1;
  ::rc::RICControlCellTypeEnum riccontrolcelltypeval() const;
  void set_riccontrolcelltypeval(::rc::RICControlCellTypeEnum value);

  // @@protoc_insertion_point(class_scope:rc.RICControlMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr targetcellid_;
  int riccontrolcelltypeval_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_rc_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RicControlGrpcReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rc.RicControlGrpcReq) */ {
 public:
  RicControlGrpcReq();
  virtual ~RicControlGrpcReq();

  RicControlGrpcReq(const RicControlGrpcReq& from);

  inline RicControlGrpcReq& operator=(const RicControlGrpcReq& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RicControlGrpcReq(RicControlGrpcReq&& from) noexcept
    : RicControlGrpcReq() {
    *this = ::std::move(from);
  }

  inline RicControlGrpcReq& operator=(RicControlGrpcReq&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RicControlGrpcReq& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RicControlGrpcReq* internal_default_instance() {
    return reinterpret_cast<const RicControlGrpcReq*>(
               &_RicControlGrpcReq_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  void Swap(RicControlGrpcReq* other);
  friend void swap(RicControlGrpcReq& a, RicControlGrpcReq& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline RicControlGrpcReq* New() const final {
    return CreateMaybeMessage<RicControlGrpcReq>(NULL);
  }

  RicControlGrpcReq* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RicControlGrpcReq>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RicControlGrpcReq& from);
  void MergeFrom(const RicControlGrpcReq& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RicControlGrpcReq* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string e2NodeID = 1;
  void clear_e2nodeid();
  static const int kE2NodeIDFieldNumber = 1;
  const ::std::string& e2nodeid() const;
  void set_e2nodeid(const ::std::string& value);
  #if LANG_CXX11
  void set_e2nodeid(::std::string&& value);
  #endif
  void set_e2nodeid(const char* value);
  void set_e2nodeid(const char* value, size_t size);
  ::std::string* mutable_e2nodeid();
  ::std::string* release_e2nodeid();
  void set_allocated_e2nodeid(::std::string* e2nodeid);

  // string plmnID = 2;
  void clear_plmnid();
  static const int kPlmnIDFieldNumber = 2;
  const ::std::string& plmnid() const;
  void set_plmnid(const ::std::string& value);
  #if LANG_CXX11
  void set_plmnid(::std::string&& value);
  #endif
  void set_plmnid(const char* value);
  void set_plmnid(const char* value, size_t size);
  ::std::string* mutable_plmnid();
  ::std::string* release_plmnid();
  void set_allocated_plmnid(::std::string* plmnid);

  // string ranName = 3;
  void clear_ranname();
  static const int kRanNameFieldNumber = 3;
  const ::std::string& ranname() const;
  void set_ranname(const ::std::string& value);
  #if LANG_CXX11
  void set_ranname(::std::string&& value);
  #endif
  void set_ranname(const char* value);
  void set_ranname(const char* value, size_t size);
  ::std::string* mutable_ranname();
  ::std::string* release_ranname();
  void set_allocated_ranname(::std::string* ranname);

  // .rc.RICE2APHeader RICE2APHeaderData = 4;
  bool has_rice2apheaderdata() const;
  void clear_rice2apheaderdata();
  static const int kRICE2APHeaderDataFieldNumber = 4;
  private:
  const ::rc::RICE2APHeader& _internal_rice2apheaderdata() const;
  public:
  const ::rc::RICE2APHeader& rice2apheaderdata() const;
  ::rc::RICE2APHeader* release_rice2apheaderdata();
  ::rc::RICE2APHeader* mutable_rice2apheaderdata();
  void set_allocated_rice2apheaderdata(::rc::RICE2APHeader* rice2apheaderdata);

  // .rc.RICControlHeader RICControlHeaderData = 5;
  bool has_riccontrolheaderdata() const;
  void clear_riccontrolheaderdata();
  static const int kRICControlHeaderDataFieldNumber = 5;
  private:
  const ::rc::RICControlHeader& _internal_riccontrolheaderdata() const;
  public:
  const ::rc::RICControlHeader& riccontrolheaderdata() const;
  ::rc::RICControlHeader* release_riccontrolheaderdata();
  ::rc::RICControlHeader* mutable_riccontrolheaderdata();
  void set_allocated_riccontrolheaderdata(::rc::RICControlHeader* riccontrolheaderdata);

  // .rc.RICControlMessage RICControlMessageData = 6;
  bool has_riccontrolmessagedata() const;
  void clear_riccontrolmessagedata();
  static const int kRICControlMessageDataFieldNumber = 6;
  private:
  const ::rc::RICControlMessage& _internal_riccontrolmessagedata() const;
  public:
  const ::rc::RICControlMessage& riccontrolmessagedata() const;
  ::rc::RICControlMessage* release_riccontrolmessagedata();
  ::rc::RICControlMessage* mutable_riccontrolmessagedata();
  void set_allocated_riccontrolmessagedata(::rc::RICControlMessage* riccontrolmessagedata);

  // .rc.RICControlAckEnum RICControlAckReqVal = 7;
  void clear_riccontrolackreqval();
  static const int kRICControlAckReqValFieldNumber = 7;
  ::rc::RICControlAckEnum riccontrolackreqval() const;
  void set_riccontrolackreqval(::rc::RICControlAckEnum value);

  // @@protoc_insertion_point(class_scope:rc.RicControlGrpcReq)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr e2nodeid_;
  ::google::protobuf::internal::ArenaStringPtr plmnid_;
  ::google::protobuf::internal::ArenaStringPtr ranname_;
  ::rc::RICE2APHeader* rice2apheaderdata_;
  ::rc::RICControlHeader* riccontrolheaderdata_;
  ::rc::RICControlMessage* riccontrolmessagedata_;
  int riccontrolackreqval_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_rc_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RicControlGrpcRsp : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rc.RicControlGrpcRsp) */ {
 public:
  RicControlGrpcRsp();
  virtual ~RicControlGrpcRsp();

  RicControlGrpcRsp(const RicControlGrpcRsp& from);

  inline RicControlGrpcRsp& operator=(const RicControlGrpcRsp& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RicControlGrpcRsp(RicControlGrpcRsp&& from) noexcept
    : RicControlGrpcRsp() {
    *this = ::std::move(from);
  }

  inline RicControlGrpcRsp& operator=(RicControlGrpcRsp&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RicControlGrpcRsp& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RicControlGrpcRsp* internal_default_instance() {
    return reinterpret_cast<const RicControlGrpcRsp*>(
               &_RicControlGrpcRsp_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  void Swap(RicControlGrpcRsp* other);
  friend void swap(RicControlGrpcRsp& a, RicControlGrpcRsp& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline RicControlGrpcRsp* New() const final {
    return CreateMaybeMessage<RicControlGrpcRsp>(NULL);
  }

  RicControlGrpcRsp* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RicControlGrpcRsp>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RicControlGrpcRsp& from);
  void MergeFrom(const RicControlGrpcRsp& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RicControlGrpcRsp* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string description = 2;
  void clear_description();
  static const int kDescriptionFieldNumber = 2;
  const ::std::string& description() const;
  void set_description(const ::std::string& value);
  #if LANG_CXX11
  void set_description(::std::string&& value);
  #endif
  void set_description(const char* value);
  void set_description(const char* value, size_t size);
  ::std::string* mutable_description();
  ::std::string* release_description();
  void set_allocated_description(::std::string* description);

  // int32 rspCode = 1;
  void clear_rspcode();
  static const int kRspCodeFieldNumber = 1;
  ::google::protobuf::int32 rspcode() const;
  void set_rspcode(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:rc.RicControlGrpcRsp)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr description_;
  ::google::protobuf::int32 rspcode_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_rc_2eproto::TableStruct;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// RICE2APHeader

// int64 RanFuncId = 1;
inline void RICE2APHeader::clear_ranfuncid() {
  ranfuncid_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 RICE2APHeader::ranfuncid() const {
  // @@protoc_insertion_point(field_get:rc.RICE2APHeader.RanFuncId)
  return ranfuncid_;
}
inline void RICE2APHeader::set_ranfuncid(::google::protobuf::int64 value) {
  
  ranfuncid_ = value;
  // @@protoc_insertion_point(field_set:rc.RICE2APHeader.RanFuncId)
}

// int64 RICRequestorID = 2;
inline void RICE2APHeader::clear_ricrequestorid() {
  ricrequestorid_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 RICE2APHeader::ricrequestorid() const {
  // @@protoc_insertion_point(field_get:rc.RICE2APHeader.RICRequestorID)
  return ricrequestorid_;
}
inline void RICE2APHeader::set_ricrequestorid(::google::protobuf::int64 value) {
  
  ricrequestorid_ = value;
  // @@protoc_insertion_point(field_set:rc.RICE2APHeader.RICRequestorID)
}

// -------------------------------------------------------------------

// RICControlHeader

// int64 ControlStyle = 1;
inline void RICControlHeader::clear_controlstyle() {
  controlstyle_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 RICControlHeader::controlstyle() const {
  // @@protoc_insertion_point(field_get:rc.RICControlHeader.ControlStyle)
  return controlstyle_;
}
inline void RICControlHeader::set_controlstyle(::google::protobuf::int64 value) {
  
  controlstyle_ = value;
  // @@protoc_insertion_point(field_set:rc.RICControlHeader.ControlStyle)
}

// int64 ControlActionId = 2;
inline void RICControlHeader::clear_controlactionid() {
  controlactionid_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 RICControlHeader::controlactionid() const {
  // @@protoc_insertion_point(field_get:rc.RICControlHeader.ControlActionId)
  return controlactionid_;
}
inline void RICControlHeader::set_controlactionid(::google::protobuf::int64 value) {
  
  controlactionid_ = value;
  // @@protoc_insertion_point(field_set:rc.RICControlHeader.ControlActionId)
}

// .rc.UeId UEID = 3;
inline bool RICControlHeader::has_ueid() const {
  return this != internal_default_instance() && ueid_ != NULL;
}
inline void RICControlHeader::clear_ueid() {
  if (GetArenaNoVirtual() == NULL && ueid_ != NULL) {
    delete ueid_;
  }
  ueid_ = NULL;
}
inline const ::rc::UeId& RICControlHeader::_internal_ueid() const {
  return *ueid_;
}
inline const ::rc::UeId& RICControlHeader::ueid() const {
  const ::rc::UeId* p = ueid_;
  // @@protoc_insertion_point(field_get:rc.RICControlHeader.UEID)
  return p != NULL ? *p : *reinterpret_cast<const ::rc::UeId*>(
      &::rc::_UeId_default_instance_);
}
inline ::rc::UeId* RICControlHeader::release_ueid() {
  // @@protoc_insertion_point(field_release:rc.RICControlHeader.UEID)
  
  ::rc::UeId* temp = ueid_;
  ueid_ = NULL;
  return temp;
}
inline ::rc::UeId* RICControlHeader::mutable_ueid() {
  
  if (ueid_ == NULL) {
    auto* p = CreateMaybeMessage<::rc::UeId>(GetArenaNoVirtual());
    ueid_ = p;
  }
  // @@protoc_insertion_point(field_mutable:rc.RICControlHeader.UEID)
  return ueid_;
}
inline void RICControlHeader::set_allocated_ueid(::rc::UeId* ueid) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete ueid_;
  }
  if (ueid) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      ueid = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, ueid, submessage_arena);
    }
    
  } else {
    
  }
  ueid_ = ueid;
  // @@protoc_insertion_point(field_set_allocated:rc.RICControlHeader.UEID)
}

// -------------------------------------------------------------------

// UeId

// .rc.gNBUEID GnbUEID = 1;
inline bool UeId::has_gnbueid() const {
  return this != internal_default_instance() && gnbueid_ != NULL;
}
inline void UeId::clear_gnbueid() {
  if (GetArenaNoVirtual() == NULL && gnbueid_ != NULL) {
    delete gnbueid_;
  }
  gnbueid_ = NULL;
}
inline const ::rc::gNBUEID& UeId::_internal_gnbueid() const {
  return *gnbueid_;
}
inline const ::rc::gNBUEID& UeId::gnbueid() const {
  const ::rc::gNBUEID* p = gnbueid_;
  // @@protoc_insertion_point(field_get:rc.UeId.GnbUEID)
  return p != NULL ? *p : *reinterpret_cast<const ::rc::gNBUEID*>(
      &::rc::_gNBUEID_default_instance_);
}
inline ::rc::gNBUEID* UeId::release_gnbueid() {
  // @@protoc_insertion_point(field_release:rc.UeId.GnbUEID)
  
  ::rc::gNBUEID* temp = gnbueid_;
  gnbueid_ = NULL;
  return temp;
}
inline ::rc::gNBUEID* UeId::mutable_gnbueid() {
  
  if (gnbueid_ == NULL) {
    auto* p = CreateMaybeMessage<::rc::gNBUEID>(GetArenaNoVirtual());
    gnbueid_ = p;
  }
  // @@protoc_insertion_point(field_mutable:rc.UeId.GnbUEID)
  return gnbueid_;
}
inline void UeId::set_allocated_gnbueid(::rc::gNBUEID* gnbueid) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete gnbueid_;
  }
  if (gnbueid) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      gnbueid = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, gnbueid, submessage_arena);
    }
    
  } else {
    
  }
  gnbueid_ = gnbueid;
  // @@protoc_insertion_point(field_set_allocated:rc.UeId.GnbUEID)
}

// -------------------------------------------------------------------

// gNBUEID

// int64 amfUENGAPID = 1;
inline void gNBUEID::clear_amfuengapid() {
  amfuengapid_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 gNBUEID::amfuengapid() const {
  // @@protoc_insertion_point(field_get:rc.gNBUEID.amfUENGAPID)
  return amfuengapid_;
}
inline void gNBUEID::set_amfuengapid(::google::protobuf::int64 value) {
  
  amfuengapid_ = value;
  // @@protoc_insertion_point(field_set:rc.gNBUEID.amfUENGAPID)
}

// .rc.Guami guami = 2;
inline bool gNBUEID::has_guami() const {
  return this != internal_default_instance() && guami_ != NULL;
}
inline void gNBUEID::clear_guami() {
  if (GetArenaNoVirtual() == NULL && guami_ != NULL) {
    delete guami_;
  }
  guami_ = NULL;
}
inline const ::rc::Guami& gNBUEID::_internal_guami() const {
  return *guami_;
}
inline const ::rc::Guami& gNBUEID::guami() const {
  const ::rc::Guami* p = guami_;
  // @@protoc_insertion_point(field_get:rc.gNBUEID.guami)
  return p != NULL ? *p : *reinterpret_cast<const ::rc::Guami*>(
      &::rc::_Guami_default_instance_);
}
inline ::rc::Guami* gNBUEID::release_guami() {
  // @@protoc_insertion_point(field_release:rc.gNBUEID.guami)
  
  ::rc::Guami* temp = guami_;
  guami_ = NULL;
  return temp;
}
inline ::rc::Guami* gNBUEID::mutable_guami() {
  
  if (guami_ == NULL) {
    auto* p = CreateMaybeMessage<::rc::Guami>(GetArenaNoVirtual());
    guami_ = p;
  }
  // @@protoc_insertion_point(field_mutable:rc.gNBUEID.guami)
  return guami_;
}
inline void gNBUEID::set_allocated_guami(::rc::Guami* guami) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete guami_;
  }
  if (guami) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      guami = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, guami, submessage_arena);
    }
    
  } else {
    
  }
  guami_ = guami;
  // @@protoc_insertion_point(field_set_allocated:rc.gNBUEID.guami)
}

// repeated int64 gNBCUUEF1APID = 3;
inline int gNBUEID::gnbcuuef1apid_size() const {
  return gnbcuuef1apid_.size();
}
inline void gNBUEID::clear_gnbcuuef1apid() {
  gnbcuuef1apid_.Clear();
}
inline ::google::protobuf::int64 gNBUEID::gnbcuuef1apid(int index) const {
  // @@protoc_insertion_point(field_get:rc.gNBUEID.gNBCUUEF1APID)
  return gnbcuuef1apid_.Get(index);
}
inline void gNBUEID::set_gnbcuuef1apid(int index, ::google::protobuf::int64 value) {
  gnbcuuef1apid_.Set(index, value);
  // @@protoc_insertion_point(field_set:rc.gNBUEID.gNBCUUEF1APID)
}
inline void gNBUEID::add_gnbcuuef1apid(::google::protobuf::int64 value) {
  gnbcuuef1apid_.Add(value);
  // @@protoc_insertion_point(field_add:rc.gNBUEID.gNBCUUEF1APID)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
gNBUEID::gnbcuuef1apid() const {
  // @@protoc_insertion_point(field_list:rc.gNBUEID.gNBCUUEF1APID)
  return gnbcuuef1apid_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
gNBUEID::mutable_gnbcuuef1apid() {
  // @@protoc_insertion_point(field_mutable_list:rc.gNBUEID.gNBCUUEF1APID)
  return &gnbcuuef1apid_;
}

// repeated int64 gNBCUCPUEE1APID = 4;
inline int gNBUEID::gnbcucpuee1apid_size() const {
  return gnbcucpuee1apid_.size();
}
inline void gNBUEID::clear_gnbcucpuee1apid() {
  gnbcucpuee1apid_.Clear();
}
inline ::google::protobuf::int64 gNBUEID::gnbcucpuee1apid(int index) const {
  // @@protoc_insertion_point(field_get:rc.gNBUEID.gNBCUCPUEE1APID)
  return gnbcucpuee1apid_.Get(index);
}
inline void gNBUEID::set_gnbcucpuee1apid(int index, ::google::protobuf::int64 value) {
  gnbcucpuee1apid_.Set(index, value);
  // @@protoc_insertion_point(field_set:rc.gNBUEID.gNBCUCPUEE1APID)
}
inline void gNBUEID::add_gnbcucpuee1apid(::google::protobuf::int64 value) {
  gnbcucpuee1apid_.Add(value);
  // @@protoc_insertion_point(field_add:rc.gNBUEID.gNBCUCPUEE1APID)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
gNBUEID::gnbcucpuee1apid() const {
  // @@protoc_insertion_point(field_list:rc.gNBUEID.gNBCUCPUEE1APID)
  return gnbcucpuee1apid_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
gNBUEID::mutable_gnbcucpuee1apid() {
  // @@protoc_insertion_point(field_mutable_list:rc.gNBUEID.gNBCUCPUEE1APID)
  return &gnbcucpuee1apid_;
}

// -------------------------------------------------------------------

// Guami

// string pLMNIdentity = 1;
inline void Guami::clear_plmnidentity() {
  plmnidentity_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Guami::plmnidentity() const {
  // @@protoc_insertion_point(field_get:rc.Guami.pLMNIdentity)
  return plmnidentity_.GetNoArena();
}
inline void Guami::set_plmnidentity(const ::std::string& value) {
  
  plmnidentity_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:rc.Guami.pLMNIdentity)
}
#if LANG_CXX11
inline void Guami::set_plmnidentity(::std::string&& value) {
  
  plmnidentity_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:rc.Guami.pLMNIdentity)
}
#endif
inline void Guami::set_plmnidentity(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  plmnidentity_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:rc.Guami.pLMNIdentity)
}
inline void Guami::set_plmnidentity(const char* value, size_t size) {
  
  plmnidentity_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:rc.Guami.pLMNIdentity)
}
inline ::std::string* Guami::mutable_plmnidentity() {
  
  // @@protoc_insertion_point(field_mutable:rc.Guami.pLMNIdentity)
  return plmnidentity_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Guami::release_plmnidentity() {
  // @@protoc_insertion_point(field_release:rc.Guami.pLMNIdentity)
  
  return plmnidentity_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Guami::set_allocated_plmnidentity(::std::string* plmnidentity) {
  if (plmnidentity != NULL) {
    
  } else {
    
  }
  plmnidentity_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), plmnidentity);
  // @@protoc_insertion_point(field_set_allocated:rc.Guami.pLMNIdentity)
}

// string aMFRegionID = 2;
inline void Guami::clear_amfregionid() {
  amfregionid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Guami::amfregionid() const {
  // @@protoc_insertion_point(field_get:rc.Guami.aMFRegionID)
  return amfregionid_.GetNoArena();
}
inline void Guami::set_amfregionid(const ::std::string& value) {
  
  amfregionid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:rc.Guami.aMFRegionID)
}
#if LANG_CXX11
inline void Guami::set_amfregionid(::std::string&& value) {
  
  amfregionid_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:rc.Guami.aMFRegionID)
}
#endif
inline void Guami::set_amfregionid(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  amfregionid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:rc.Guami.aMFRegionID)
}
inline void Guami::set_amfregionid(const char* value, size_t size) {
  
  amfregionid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:rc.Guami.aMFRegionID)
}
inline ::std::string* Guami::mutable_amfregionid() {
  
  // @@protoc_insertion_point(field_mutable:rc.Guami.aMFRegionID)
  return amfregionid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Guami::release_amfregionid() {
  // @@protoc_insertion_point(field_release:rc.Guami.aMFRegionID)
  
  return amfregionid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Guami::set_allocated_amfregionid(::std::string* amfregionid) {
  if (amfregionid != NULL) {
    
  } else {
    
  }
  amfregionid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), amfregionid);
  // @@protoc_insertion_point(field_set_allocated:rc.Guami.aMFRegionID)
}

// string aMFSetID = 3;
inline void Guami::clear_amfsetid() {
  amfsetid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Guami::amfsetid() const {
  // @@protoc_insertion_point(field_get:rc.Guami.aMFSetID)
  return amfsetid_.GetNoArena();
}
inline void Guami::set_amfsetid(const ::std::string& value) {
  
  amfsetid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:rc.Guami.aMFSetID)
}
#if LANG_CXX11
inline void Guami::set_amfsetid(::std::string&& value) {
  
  amfsetid_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:rc.Guami.aMFSetID)
}
#endif
inline void Guami::set_amfsetid(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  amfsetid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:rc.Guami.aMFSetID)
}
inline void Guami::set_amfsetid(const char* value, size_t size) {
  
  amfsetid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:rc.Guami.aMFSetID)
}
inline ::std::string* Guami::mutable_amfsetid() {
  
  // @@protoc_insertion_point(field_mutable:rc.Guami.aMFSetID)
  return amfsetid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Guami::release_amfsetid() {
  // @@protoc_insertion_point(field_release:rc.Guami.aMFSetID)
  
  return amfsetid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Guami::set_allocated_amfsetid(::std::string* amfsetid) {
  if (amfsetid != NULL) {
    
  } else {
    
  }
  amfsetid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), amfsetid);
  // @@protoc_insertion_point(field_set_allocated:rc.Guami.aMFSetID)
}

// string aMFPointer = 4;
inline void Guami::clear_amfpointer() {
  amfpointer_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Guami::amfpointer() const {
  // @@protoc_insertion_point(field_get:rc.Guami.aMFPointer)
  return amfpointer_.GetNoArena();
}
inline void Guami::set_amfpointer(const ::std::string& value) {
  
  amfpointer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:rc.Guami.aMFPointer)
}
#if LANG_CXX11
inline void Guami::set_amfpointer(::std::string&& value) {
  
  amfpointer_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:rc.Guami.aMFPointer)
}
#endif
inline void Guami::set_amfpointer(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  amfpointer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:rc.Guami.aMFPointer)
}
inline void Guami::set_amfpointer(const char* value, size_t size) {
  
  amfpointer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:rc.Guami.aMFPointer)
}
inline ::std::string* Guami::mutable_amfpointer() {
  
  // @@protoc_insertion_point(field_mutable:rc.Guami.aMFPointer)
  return amfpointer_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Guami::release_amfpointer() {
  // @@protoc_insertion_point(field_release:rc.Guami.aMFPointer)
  
  return amfpointer_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Guami::set_allocated_amfpointer(::std::string* amfpointer) {
  if (amfpointer != NULL) {
    
  } else {
    
  }
  amfpointer_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), amfpointer);
  // @@protoc_insertion_point(field_set_allocated:rc.Guami.aMFPointer)
}

// -------------------------------------------------------------------

// RICControlMessage

// .rc.RICControlCellTypeEnum RICControlCellTypeVal = 1;
inline void RICControlMessage::clear_riccontrolcelltypeval() {
  riccontrolcelltypeval_ = 0;
}
inline ::rc::RICControlCellTypeEnum RICControlMessage::riccontrolcelltypeval() const {
  // @@protoc_insertion_point(field_get:rc.RICControlMessage.RICControlCellTypeVal)
  return static_cast< ::rc::RICControlCellTypeEnum >(riccontrolcelltypeval_);
}
inline void RICControlMessage::set_riccontrolcelltypeval(::rc::RICControlCellTypeEnum value) {
  
  riccontrolcelltypeval_ = value;
  // @@protoc_insertion_point(field_set:rc.RICControlMessage.RICControlCellTypeVal)
}

// string TargetCellID = 2;
inline void RICControlMessage::clear_targetcellid() {
  targetcellid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RICControlMessage::targetcellid() const {
  // @@protoc_insertion_point(field_get:rc.RICControlMessage.TargetCellID)
  return targetcellid_.GetNoArena();
}
inline void RICControlMessage::set_targetcellid(const ::std::string& value) {
  
  targetcellid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:rc.RICControlMessage.TargetCellID)
}
#if LANG_CXX11
inline void RICControlMessage::set_targetcellid(::std::string&& value) {
  
  targetcellid_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:rc.RICControlMessage.TargetCellID)
}
#endif
inline void RICControlMessage::set_targetcellid(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  targetcellid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:rc.RICControlMessage.TargetCellID)
}
inline void RICControlMessage::set_targetcellid(const char* value, size_t size) {
  
  targetcellid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:rc.RICControlMessage.TargetCellID)
}
inline ::std::string* RICControlMessage::mutable_targetcellid() {
  
  // @@protoc_insertion_point(field_mutable:rc.RICControlMessage.TargetCellID)
  return targetcellid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RICControlMessage::release_targetcellid() {
  // @@protoc_insertion_point(field_release:rc.RICControlMessage.TargetCellID)
  
  return targetcellid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RICControlMessage::set_allocated_targetcellid(::std::string* targetcellid) {
  if (targetcellid != NULL) {
    
  } else {
    
  }
  targetcellid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), targetcellid);
  // @@protoc_insertion_point(field_set_allocated:rc.RICControlMessage.TargetCellID)
}

// -------------------------------------------------------------------

// RicControlGrpcReq

// string e2NodeID = 1;
inline void RicControlGrpcReq::clear_e2nodeid() {
  e2nodeid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RicControlGrpcReq::e2nodeid() const {
  // @@protoc_insertion_point(field_get:rc.RicControlGrpcReq.e2NodeID)
  return e2nodeid_.GetNoArena();
}
inline void RicControlGrpcReq::set_e2nodeid(const ::std::string& value) {
  
  e2nodeid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:rc.RicControlGrpcReq.e2NodeID)
}
#if LANG_CXX11
inline void RicControlGrpcReq::set_e2nodeid(::std::string&& value) {
  
  e2nodeid_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:rc.RicControlGrpcReq.e2NodeID)
}
#endif
inline void RicControlGrpcReq::set_e2nodeid(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  e2nodeid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:rc.RicControlGrpcReq.e2NodeID)
}
inline void RicControlGrpcReq::set_e2nodeid(const char* value, size_t size) {
  
  e2nodeid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:rc.RicControlGrpcReq.e2NodeID)
}
inline ::std::string* RicControlGrpcReq::mutable_e2nodeid() {
  
  // @@protoc_insertion_point(field_mutable:rc.RicControlGrpcReq.e2NodeID)
  return e2nodeid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RicControlGrpcReq::release_e2nodeid() {
  // @@protoc_insertion_point(field_release:rc.RicControlGrpcReq.e2NodeID)
  
  return e2nodeid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RicControlGrpcReq::set_allocated_e2nodeid(::std::string* e2nodeid) {
  if (e2nodeid != NULL) {
    
  } else {
    
  }
  e2nodeid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), e2nodeid);
  // @@protoc_insertion_point(field_set_allocated:rc.RicControlGrpcReq.e2NodeID)
}

// string plmnID = 2;
inline void RicControlGrpcReq::clear_plmnid() {
  plmnid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RicControlGrpcReq::plmnid() const {
  // @@protoc_insertion_point(field_get:rc.RicControlGrpcReq.plmnID)
  return plmnid_.GetNoArena();
}
inline void RicControlGrpcReq::set_plmnid(const ::std::string& value) {
  
  plmnid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:rc.RicControlGrpcReq.plmnID)
}
#if LANG_CXX11
inline void RicControlGrpcReq::set_plmnid(::std::string&& value) {
  
  plmnid_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:rc.RicControlGrpcReq.plmnID)
}
#endif
inline void RicControlGrpcReq::set_plmnid(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  plmnid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:rc.RicControlGrpcReq.plmnID)
}
inline void RicControlGrpcReq::set_plmnid(const char* value, size_t size) {
  
  plmnid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:rc.RicControlGrpcReq.plmnID)
}
inline ::std::string* RicControlGrpcReq::mutable_plmnid() {
  
  // @@protoc_insertion_point(field_mutable:rc.RicControlGrpcReq.plmnID)
  return plmnid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RicControlGrpcReq::release_plmnid() {
  // @@protoc_insertion_point(field_release:rc.RicControlGrpcReq.plmnID)
  
  return plmnid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RicControlGrpcReq::set_allocated_plmnid(::std::string* plmnid) {
  if (plmnid != NULL) {
    
  } else {
    
  }
  plmnid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), plmnid);
  // @@protoc_insertion_point(field_set_allocated:rc.RicControlGrpcReq.plmnID)
}

// string ranName = 3;
inline void RicControlGrpcReq::clear_ranname() {
  ranname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RicControlGrpcReq::ranname() const {
  // @@protoc_insertion_point(field_get:rc.RicControlGrpcReq.ranName)
  return ranname_.GetNoArena();
}
inline void RicControlGrpcReq::set_ranname(const ::std::string& value) {
  
  ranname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:rc.RicControlGrpcReq.ranName)
}
#if LANG_CXX11
inline void RicControlGrpcReq::set_ranname(::std::string&& value) {
  
  ranname_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:rc.RicControlGrpcReq.ranName)
}
#endif
inline void RicControlGrpcReq::set_ranname(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  ranname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:rc.RicControlGrpcReq.ranName)
}
inline void RicControlGrpcReq::set_ranname(const char* value, size_t size) {
  
  ranname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:rc.RicControlGrpcReq.ranName)
}
inline ::std::string* RicControlGrpcReq::mutable_ranname() {
  
  // @@protoc_insertion_point(field_mutable:rc.RicControlGrpcReq.ranName)
  return ranname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RicControlGrpcReq::release_ranname() {
  // @@protoc_insertion_point(field_release:rc.RicControlGrpcReq.ranName)
  
  return ranname_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RicControlGrpcReq::set_allocated_ranname(::std::string* ranname) {
  if (ranname != NULL) {
    
  } else {
    
  }
  ranname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ranname);
  // @@protoc_insertion_point(field_set_allocated:rc.RicControlGrpcReq.ranName)
}

// .rc.RICE2APHeader RICE2APHeaderData = 4;
inline bool RicControlGrpcReq::has_rice2apheaderdata() const {
  return this != internal_default_instance() && rice2apheaderdata_ != NULL;
}
inline void RicControlGrpcReq::clear_rice2apheaderdata() {
  if (GetArenaNoVirtual() == NULL && rice2apheaderdata_ != NULL) {
    delete rice2apheaderdata_;
  }
  rice2apheaderdata_ = NULL;
}
inline const ::rc::RICE2APHeader& RicControlGrpcReq::_internal_rice2apheaderdata() const {
  return *rice2apheaderdata_;
}
inline const ::rc::RICE2APHeader& RicControlGrpcReq::rice2apheaderdata() const {
  const ::rc::RICE2APHeader* p = rice2apheaderdata_;
  // @@protoc_insertion_point(field_get:rc.RicControlGrpcReq.RICE2APHeaderData)
  return p != NULL ? *p : *reinterpret_cast<const ::rc::RICE2APHeader*>(
      &::rc::_RICE2APHeader_default_instance_);
}
inline ::rc::RICE2APHeader* RicControlGrpcReq::release_rice2apheaderdata() {
  // @@protoc_insertion_point(field_release:rc.RicControlGrpcReq.RICE2APHeaderData)
  
  ::rc::RICE2APHeader* temp = rice2apheaderdata_;
  rice2apheaderdata_ = NULL;
  return temp;
}
inline ::rc::RICE2APHeader* RicControlGrpcReq::mutable_rice2apheaderdata() {
  
  if (rice2apheaderdata_ == NULL) {
    auto* p = CreateMaybeMessage<::rc::RICE2APHeader>(GetArenaNoVirtual());
    rice2apheaderdata_ = p;
  }
  // @@protoc_insertion_point(field_mutable:rc.RicControlGrpcReq.RICE2APHeaderData)
  return rice2apheaderdata_;
}
inline void RicControlGrpcReq::set_allocated_rice2apheaderdata(::rc::RICE2APHeader* rice2apheaderdata) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete rice2apheaderdata_;
  }
  if (rice2apheaderdata) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      rice2apheaderdata = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, rice2apheaderdata, submessage_arena);
    }
    
  } else {
    
  }
  rice2apheaderdata_ = rice2apheaderdata;
  // @@protoc_insertion_point(field_set_allocated:rc.RicControlGrpcReq.RICE2APHeaderData)
}

// .rc.RICControlHeader RICControlHeaderData = 5;
inline bool RicControlGrpcReq::has_riccontrolheaderdata() const {
  return this != internal_default_instance() && riccontrolheaderdata_ != NULL;
}
inline void RicControlGrpcReq::clear_riccontrolheaderdata() {
  if (GetArenaNoVirtual() == NULL && riccontrolheaderdata_ != NULL) {
    delete riccontrolheaderdata_;
  }
  riccontrolheaderdata_ = NULL;
}
inline const ::rc::RICControlHeader& RicControlGrpcReq::_internal_riccontrolheaderdata() const {
  return *riccontrolheaderdata_;
}
inline const ::rc::RICControlHeader& RicControlGrpcReq::riccontrolheaderdata() const {
  const ::rc::RICControlHeader* p = riccontrolheaderdata_;
  // @@protoc_insertion_point(field_get:rc.RicControlGrpcReq.RICControlHeaderData)
  return p != NULL ? *p : *reinterpret_cast<const ::rc::RICControlHeader*>(
      &::rc::_RICControlHeader_default_instance_);
}
inline ::rc::RICControlHeader* RicControlGrpcReq::release_riccontrolheaderdata() {
  // @@protoc_insertion_point(field_release:rc.RicControlGrpcReq.RICControlHeaderData)
  
  ::rc::RICControlHeader* temp = riccontrolheaderdata_;
  riccontrolheaderdata_ = NULL;
  return temp;
}
inline ::rc::RICControlHeader* RicControlGrpcReq::mutable_riccontrolheaderdata() {
  
  if (riccontrolheaderdata_ == NULL) {
    auto* p = CreateMaybeMessage<::rc::RICControlHeader>(GetArenaNoVirtual());
    riccontrolheaderdata_ = p;
  }
  // @@protoc_insertion_point(field_mutable:rc.RicControlGrpcReq.RICControlHeaderData)
  return riccontrolheaderdata_;
}
inline void RicControlGrpcReq::set_allocated_riccontrolheaderdata(::rc::RICControlHeader* riccontrolheaderdata) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete riccontrolheaderdata_;
  }
  if (riccontrolheaderdata) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      riccontrolheaderdata = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, riccontrolheaderdata, submessage_arena);
    }
    
  } else {
    
  }
  riccontrolheaderdata_ = riccontrolheaderdata;
  // @@protoc_insertion_point(field_set_allocated:rc.RicControlGrpcReq.RICControlHeaderData)
}

// .rc.RICControlMessage RICControlMessageData = 6;
inline bool RicControlGrpcReq::has_riccontrolmessagedata() const {
  return this != internal_default_instance() && riccontrolmessagedata_ != NULL;
}
inline void RicControlGrpcReq::clear_riccontrolmessagedata() {
  if (GetArenaNoVirtual() == NULL && riccontrolmessagedata_ != NULL) {
    delete riccontrolmessagedata_;
  }
  riccontrolmessagedata_ = NULL;
}
inline const ::rc::RICControlMessage& RicControlGrpcReq::_internal_riccontrolmessagedata() const {
  return *riccontrolmessagedata_;
}
inline const ::rc::RICControlMessage& RicControlGrpcReq::riccontrolmessagedata() const {
  const ::rc::RICControlMessage* p = riccontrolmessagedata_;
  // @@protoc_insertion_point(field_get:rc.RicControlGrpcReq.RICControlMessageData)
  return p != NULL ? *p : *reinterpret_cast<const ::rc::RICControlMessage*>(
      &::rc::_RICControlMessage_default_instance_);
}
inline ::rc::RICControlMessage* RicControlGrpcReq::release_riccontrolmessagedata() {
  // @@protoc_insertion_point(field_release:rc.RicControlGrpcReq.RICControlMessageData)
  
  ::rc::RICControlMessage* temp = riccontrolmessagedata_;
  riccontrolmessagedata_ = NULL;
  return temp;
}
inline ::rc::RICControlMessage* RicControlGrpcReq::mutable_riccontrolmessagedata() {
  
  if (riccontrolmessagedata_ == NULL) {
    auto* p = CreateMaybeMessage<::rc::RICControlMessage>(GetArenaNoVirtual());
    riccontrolmessagedata_ = p;
  }
  // @@protoc_insertion_point(field_mutable:rc.RicControlGrpcReq.RICControlMessageData)
  return riccontrolmessagedata_;
}
inline void RicControlGrpcReq::set_allocated_riccontrolmessagedata(::rc::RICControlMessage* riccontrolmessagedata) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete riccontrolmessagedata_;
  }
  if (riccontrolmessagedata) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      riccontrolmessagedata = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, riccontrolmessagedata, submessage_arena);
    }
    
  } else {
    
  }
  riccontrolmessagedata_ = riccontrolmessagedata;
  // @@protoc_insertion_point(field_set_allocated:rc.RicControlGrpcReq.RICControlMessageData)
}

// .rc.RICControlAckEnum RICControlAckReqVal = 7;
inline void RicControlGrpcReq::clear_riccontrolackreqval() {
  riccontrolackreqval_ = 0;
}
inline ::rc::RICControlAckEnum RicControlGrpcReq::riccontrolackreqval() const {
  // @@protoc_insertion_point(field_get:rc.RicControlGrpcReq.RICControlAckReqVal)
  return static_cast< ::rc::RICControlAckEnum >(riccontrolackreqval_);
}
inline void RicControlGrpcReq::set_riccontrolackreqval(::rc::RICControlAckEnum value) {
  
  riccontrolackreqval_ = value;
  // @@protoc_insertion_point(field_set:rc.RicControlGrpcReq.RICControlAckReqVal)
}

// -------------------------------------------------------------------

// RicControlGrpcRsp

// int32 rspCode = 1;
inline void RicControlGrpcRsp::clear_rspcode() {
  rspcode_ = 0;
}
inline ::google::protobuf::int32 RicControlGrpcRsp::rspcode() const {
  // @@protoc_insertion_point(field_get:rc.RicControlGrpcRsp.rspCode)
  return rspcode_;
}
inline void RicControlGrpcRsp::set_rspcode(::google::protobuf::int32 value) {
  
  rspcode_ = value;
  // @@protoc_insertion_point(field_set:rc.RicControlGrpcRsp.rspCode)
}

// string description = 2;
inline void RicControlGrpcRsp::clear_description() {
  description_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RicControlGrpcRsp::description() const {
  // @@protoc_insertion_point(field_get:rc.RicControlGrpcRsp.description)
  return description_.GetNoArena();
}
inline void RicControlGrpcRsp::set_description(const ::std::string& value) {
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:rc.RicControlGrpcRsp.description)
}
#if LANG_CXX11
inline void RicControlGrpcRsp::set_description(::std::string&& value) {
  
  description_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:rc.RicControlGrpcRsp.description)
}
#endif
inline void RicControlGrpcRsp::set_description(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:rc.RicControlGrpcRsp.description)
}
inline void RicControlGrpcRsp::set_description(const char* value, size_t size) {
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:rc.RicControlGrpcRsp.description)
}
inline ::std::string* RicControlGrpcRsp::mutable_description() {
  
  // @@protoc_insertion_point(field_mutable:rc.RicControlGrpcRsp.description)
  return description_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RicControlGrpcRsp::release_description() {
  // @@protoc_insertion_point(field_release:rc.RicControlGrpcRsp.description)
  
  return description_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RicControlGrpcRsp::set_allocated_description(::std::string* description) {
  if (description != NULL) {
    
  } else {
    
  }
  description_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description);
  // @@protoc_insertion_point(field_set_allocated:rc.RicControlGrpcRsp.description)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace rc

namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::rc::RICControlCellTypeEnum> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::rc::RICControlCellTypeEnum>() {
  return ::rc::RICControlCellTypeEnum_descriptor();
}
template <> struct is_proto_enum< ::rc::RICControlAckEnum> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::rc::RICControlAckEnum>() {
  return ::rc::RICControlAckEnum_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_INCLUDED_rc_2eproto