// Code generated by protoc-gen-go. DO NOT EDIT.
// source: rc.proto

package rc

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type RICControlCellTypeEnum int32

const (
	RICControlCellTypeEnum_RIC_CONTROL_CELL_UNKWON RICControlCellTypeEnum = 0
	RICControlCellTypeEnum_RIC_CONTROL_NR_CELL     RICControlCellTypeEnum = 1
	RICControlCellTypeEnum_RIC_CONTROL_EUTRAN_CELL RICControlCellTypeEnum = 2
)

var RICControlCellTypeEnum_name = map[int32]string{
	0: "RIC_CONTROL_CELL_UNKWON",
	1: "RIC_CONTROL_NR_CELL",
	2: "RIC_CONTROL_EUTRAN_CELL",
}

var RICControlCellTypeEnum_value = map[string]int32{
	"RIC_CONTROL_CELL_UNKWON": 0,
	"RIC_CONTROL_NR_CELL":     1,
	"RIC_CONTROL_EUTRAN_CELL": 2,
}

func (x RICControlCellTypeEnum) String() string {
	return proto.EnumName(RICControlCellTypeEnum_name, int32(x))
}

func (RICControlCellTypeEnum) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a4fc9282119cff7c, []int{0}
}

type RICControlAckEnum int32

const (
	RICControlAckEnum_RIC_CONTROL_ACK_UNKWON RICControlAckEnum = 0
	RICControlAckEnum_RIC_CONTROL_NO_ACK     RICControlAckEnum = 1
	RICControlAckEnum_RIC_CONTROL_ACK        RICControlAckEnum = 2
	RICControlAckEnum_RIC_CONTROL_NACK       RICControlAckEnum = 3
)

var RICControlAckEnum_name = map[int32]string{
	0: "RIC_CONTROL_ACK_UNKWON",
	1: "RIC_CONTROL_NO_ACK",
	2: "RIC_CONTROL_ACK",
	3: "RIC_CONTROL_NACK",
}

var RICControlAckEnum_value = map[string]int32{
	"RIC_CONTROL_ACK_UNKWON": 0,
	"RIC_CONTROL_NO_ACK":     1,
	"RIC_CONTROL_ACK":        2,
	"RIC_CONTROL_NACK":       3,
}

func (x RICControlAckEnum) String() string {
	return proto.EnumName(RICControlAckEnum_name, int32(x))
}

func (RICControlAckEnum) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a4fc9282119cff7c, []int{1}
}

type RICE2APHeader struct {
	RanFuncId            int64    `protobuf:"varint,1,opt,name=RanFuncId,proto3" json:"RanFuncId,omitempty"`
	RICRequestorID       int64    `protobuf:"varint,2,opt,name=RICRequestorID,proto3" json:"RICRequestorID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RICE2APHeader) Reset()         { *m = RICE2APHeader{} }
func (m *RICE2APHeader) String() string { return proto.CompactTextString(m) }
func (*RICE2APHeader) ProtoMessage()    {}
func (*RICE2APHeader) Descriptor() ([]byte, []int) {
	return fileDescriptor_a4fc9282119cff7c, []int{0}
}

func (m *RICE2APHeader) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RICE2APHeader.Unmarshal(m, b)
}
func (m *RICE2APHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RICE2APHeader.Marshal(b, m, deterministic)
}
func (m *RICE2APHeader) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RICE2APHeader.Merge(m, src)
}
func (m *RICE2APHeader) XXX_Size() int {
	return xxx_messageInfo_RICE2APHeader.Size(m)
}
func (m *RICE2APHeader) XXX_DiscardUnknown() {
	xxx_messageInfo_RICE2APHeader.DiscardUnknown(m)
}

var xxx_messageInfo_RICE2APHeader proto.InternalMessageInfo

func (m *RICE2APHeader) GetRanFuncId() int64 {
	if m != nil {
		return m.RanFuncId
	}
	return 0
}

func (m *RICE2APHeader) GetRICRequestorID() int64 {
	if m != nil {
		return m.RICRequestorID
	}
	return 0
}

type RICControlHeader struct {
	ControlStyle         int64    `protobuf:"varint,1,opt,name=ControlStyle,proto3" json:"ControlStyle,omitempty"`
	ControlActionId      int64    `protobuf:"varint,2,opt,name=ControlActionId,proto3" json:"ControlActionId,omitempty"`
	UEID                 string   `protobuf:"bytes,3,opt,name=UEID,proto3" json:"UEID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RICControlHeader) Reset()         { *m = RICControlHeader{} }
func (m *RICControlHeader) String() string { return proto.CompactTextString(m) }
func (*RICControlHeader) ProtoMessage()    {}
func (*RICControlHeader) Descriptor() ([]byte, []int) {
	return fileDescriptor_a4fc9282119cff7c, []int{1}
}

func (m *RICControlHeader) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RICControlHeader.Unmarshal(m, b)
}
func (m *RICControlHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RICControlHeader.Marshal(b, m, deterministic)
}
func (m *RICControlHeader) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RICControlHeader.Merge(m, src)
}
func (m *RICControlHeader) XXX_Size() int {
	return xxx_messageInfo_RICControlHeader.Size(m)
}
func (m *RICControlHeader) XXX_DiscardUnknown() {
	xxx_messageInfo_RICControlHeader.DiscardUnknown(m)
}

var xxx_messageInfo_RICControlHeader proto.InternalMessageInfo

func (m *RICControlHeader) GetControlStyle() int64 {
	if m != nil {
		return m.ControlStyle
	}
	return 0
}

func (m *RICControlHeader) GetControlActionId() int64 {
	if m != nil {
		return m.ControlActionId
	}
	return 0
}

func (m *RICControlHeader) GetUEID() string {
	if m != nil {
		return m.UEID
	}
	return ""
}

type RICControlMessage struct {
	RICControlCellTypeVal RICControlCellTypeEnum `protobuf:"varint,1,opt,name=RICControlCellTypeVal,proto3,enum=rc.RICControlCellTypeEnum" json:"RICControlCellTypeVal,omitempty"`
	TargetCellID          string                 `protobuf:"bytes,2,opt,name=TargetCellID,proto3" json:"TargetCellID,omitempty"`
	XXX_NoUnkeyedLiteral  struct{}               `json:"-"`
	XXX_unrecognized      []byte                 `json:"-"`
	XXX_sizecache         int32                  `json:"-"`
}

func (m *RICControlMessage) Reset()         { *m = RICControlMessage{} }
func (m *RICControlMessage) String() string { return proto.CompactTextString(m) }
func (*RICControlMessage) ProtoMessage()    {}
func (*RICControlMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_a4fc9282119cff7c, []int{2}
}

func (m *RICControlMessage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RICControlMessage.Unmarshal(m, b)
}
func (m *RICControlMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RICControlMessage.Marshal(b, m, deterministic)
}
func (m *RICControlMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RICControlMessage.Merge(m, src)
}
func (m *RICControlMessage) XXX_Size() int {
	return xxx_messageInfo_RICControlMessage.Size(m)
}
func (m *RICControlMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_RICControlMessage.DiscardUnknown(m)
}

var xxx_messageInfo_RICControlMessage proto.InternalMessageInfo

func (m *RICControlMessage) GetRICControlCellTypeVal() RICControlCellTypeEnum {
	if m != nil {
		return m.RICControlCellTypeVal
	}
	return RICControlCellTypeEnum_RIC_CONTROL_CELL_UNKWON
}

func (m *RICControlMessage) GetTargetCellID() string {
	if m != nil {
		return m.TargetCellID
	}
	return ""
}

//RicControl GRPC Req
type RicControlGrpcReq struct {
	E2NodeID              string             `protobuf:"bytes,1,opt,name=e2NodeID,proto3" json:"e2NodeID,omitempty"`
	PlmnID                string             `protobuf:"bytes,2,opt,name=plmnID,proto3" json:"plmnID,omitempty"`
	RanName               string             `protobuf:"bytes,3,opt,name=ranName,proto3" json:"ranName,omitempty"`
	RICE2APHeaderData     *RICE2APHeader     `protobuf:"bytes,4,opt,name=RICE2APHeaderData,proto3" json:"RICE2APHeaderData,omitempty"`
	RICControlHeaderData  *RICControlHeader  `protobuf:"bytes,5,opt,name=RICControlHeaderData,proto3" json:"RICControlHeaderData,omitempty"`
	RICControlMessageData *RICControlMessage `protobuf:"bytes,6,opt,name=RICControlMessageData,proto3" json:"RICControlMessageData,omitempty"`
	RICControlAckReqVal   RICControlAckEnum  `protobuf:"varint,7,opt,name=RICControlAckReqVal,proto3,enum=rc.RICControlAckEnum" json:"RICControlAckReqVal,omitempty"`
	XXX_NoUnkeyedLiteral  struct{}           `json:"-"`
	XXX_unrecognized      []byte             `json:"-"`
	XXX_sizecache         int32              `json:"-"`
}

func (m *RicControlGrpcReq) Reset()         { *m = RicControlGrpcReq{} }
func (m *RicControlGrpcReq) String() string { return proto.CompactTextString(m) }
func (*RicControlGrpcReq) ProtoMessage()    {}
func (*RicControlGrpcReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_a4fc9282119cff7c, []int{3}
}

func (m *RicControlGrpcReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RicControlGrpcReq.Unmarshal(m, b)
}
func (m *RicControlGrpcReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RicControlGrpcReq.Marshal(b, m, deterministic)
}
func (m *RicControlGrpcReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RicControlGrpcReq.Merge(m, src)
}
func (m *RicControlGrpcReq) XXX_Size() int {
	return xxx_messageInfo_RicControlGrpcReq.Size(m)
}
func (m *RicControlGrpcReq) XXX_DiscardUnknown() {
	xxx_messageInfo_RicControlGrpcReq.DiscardUnknown(m)
}

var xxx_messageInfo_RicControlGrpcReq proto.InternalMessageInfo

func (m *RicControlGrpcReq) GetE2NodeID() string {
	if m != nil {
		return m.E2NodeID
	}
	return ""
}

func (m *RicControlGrpcReq) GetPlmnID() string {
	if m != nil {
		return m.PlmnID
	}
	return ""
}

func (m *RicControlGrpcReq) GetRanName() string {
	if m != nil {
		return m.RanName
	}
	return ""
}

func (m *RicControlGrpcReq) GetRICE2APHeaderData() *RICE2APHeader {
	if m != nil {
		return m.RICE2APHeaderData
	}
	return nil
}

func (m *RicControlGrpcReq) GetRICControlHeaderData() *RICControlHeader {
	if m != nil {
		return m.RICControlHeaderData
	}
	return nil
}

func (m *RicControlGrpcReq) GetRICControlMessageData() *RICControlMessage {
	if m != nil {
		return m.RICControlMessageData
	}
	return nil
}

func (m *RicControlGrpcReq) GetRICControlAckReqVal() RICControlAckEnum {
	if m != nil {
		return m.RICControlAckReqVal
	}
	return RICControlAckEnum_RIC_CONTROL_ACK_UNKWON
}

//RicControlGrpc Rsp
type RicControlGrpcRsp struct {
	RspCode              int32    `protobuf:"varint,1,opt,name=rspCode,proto3" json:"rspCode,omitempty"`
	Description          string   `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RicControlGrpcRsp) Reset()         { *m = RicControlGrpcRsp{} }
func (m *RicControlGrpcRsp) String() string { return proto.CompactTextString(m) }
func (*RicControlGrpcRsp) ProtoMessage()    {}
func (*RicControlGrpcRsp) Descriptor() ([]byte, []int) {
	return fileDescriptor_a4fc9282119cff7c, []int{4}
}

func (m *RicControlGrpcRsp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RicControlGrpcRsp.Unmarshal(m, b)
}
func (m *RicControlGrpcRsp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RicControlGrpcRsp.Marshal(b, m, deterministic)
}
func (m *RicControlGrpcRsp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RicControlGrpcRsp.Merge(m, src)
}
func (m *RicControlGrpcRsp) XXX_Size() int {
	return xxx_messageInfo_RicControlGrpcRsp.Size(m)
}
func (m *RicControlGrpcRsp) XXX_DiscardUnknown() {
	xxx_messageInfo_RicControlGrpcRsp.DiscardUnknown(m)
}

var xxx_messageInfo_RicControlGrpcRsp proto.InternalMessageInfo

func (m *RicControlGrpcRsp) GetRspCode() int32 {
	if m != nil {
		return m.RspCode
	}
	return 0
}

func (m *RicControlGrpcRsp) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func init() {
	proto.RegisterEnum("rc.RICControlCellTypeEnum", RICControlCellTypeEnum_name, RICControlCellTypeEnum_value)
	proto.RegisterEnum("rc.RICControlAckEnum", RICControlAckEnum_name, RICControlAckEnum_value)
	proto.RegisterType((*RICE2APHeader)(nil), "rc.RICE2APHeader")
	proto.RegisterType((*RICControlHeader)(nil), "rc.RICControlHeader")
	proto.RegisterType((*RICControlMessage)(nil), "rc.RICControlMessage")
	proto.RegisterType((*RicControlGrpcReq)(nil), "rc.RicControlGrpcReq")
	proto.RegisterType((*RicControlGrpcRsp)(nil), "rc.RicControlGrpcRsp")
}

func init() { proto.RegisterFile("rc.proto", fileDescriptor_a4fc9282119cff7c) }

var fileDescriptor_a4fc9282119cff7c = []byte{
	// 527 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x54, 0x4d, 0x6f, 0xda, 0x40,
	0x10, 0xad, 0x21, 0x5f, 0x4c, 0xda, 0x84, 0x4c, 0x08, 0x41, 0x34, 0x07, 0xe4, 0x43, 0x85, 0x72,
	0xe0, 0x40, 0x7f, 0x40, 0x65, 0x2d, 0x34, 0xb1, 0x20, 0x26, 0x1a, 0xa0, 0x39, 0x22, 0x77, 0xbd,
	0x42, 0x08, 0x63, 0x9b, 0xb5, 0xa9, 0x94, 0x6b, 0x6f, 0xfd, 0xd7, 0x95, 0x97, 0x0d, 0x06, 0xe3,
	0x1b, 0xf3, 0x66, 0xde, 0x9b, 0x9d, 0x79, 0x83, 0xe1, 0x42, 0xf2, 0x4e, 0x24, 0xc3, 0x24, 0xc4,
	0x92, 0xe4, 0xe6, 0x14, 0xbe, 0x90, 0xcd, 0xfa, 0x5d, 0xeb, 0xf5, 0x59, 0xb8, 0x9e, 0x90, 0xf8,
	0x00, 0x15, 0x72, 0x83, 0x9f, 0x9b, 0x80, 0xdb, 0x5e, 0xc3, 0x68, 0x19, 0xed, 0x32, 0x65, 0x00,
	0x7e, 0x83, 0x2b, 0xb2, 0x19, 0x89, 0xf5, 0x46, 0xc4, 0x49, 0x28, 0xed, 0x5e, 0xa3, 0xa4, 0x4a,
	0x72, 0xa8, 0x99, 0x40, 0x95, 0x6c, 0xc6, 0xc2, 0x20, 0x91, 0xa1, 0xaf, 0x95, 0x4d, 0xf8, 0xac,
	0x81, 0x71, 0xf2, 0xee, 0x0b, 0x2d, 0x7e, 0x80, 0x61, 0x1b, 0xae, 0x75, 0x6c, 0xf1, 0x64, 0x11,
	0x06, 0xb6, 0xa7, 0x1b, 0xe4, 0x61, 0x44, 0x38, 0x99, 0xf6, 0xed, 0x5e, 0xa3, 0xdc, 0x32, 0xda,
	0x15, 0x52, 0xbf, 0xcd, 0x7f, 0x06, 0xdc, 0x64, 0x6d, 0x5f, 0x44, 0x1c, 0xbb, 0x73, 0x81, 0xaf,
	0x70, 0x97, 0x81, 0x4c, 0xf8, 0xfe, 0xe4, 0x3d, 0x12, 0xbf, 0x5c, 0x5f, 0x3d, 0xe0, 0xaa, 0xdb,
	0xec, 0x48, 0xde, 0x39, 0x2e, 0xe8, 0x07, 0x9b, 0x15, 0x15, 0x13, 0xd3, 0x49, 0x26, 0xae, 0x9c,
	0x8b, 0x24, 0x05, 0xf5, 0x0e, 0x2a, 0x74, 0x80, 0x99, 0x7f, 0xcb, 0x70, 0x43, 0x0b, 0xae, 0xd9,
	0x4f, 0x32, 0xe2, 0x24, 0xd6, 0xd8, 0x84, 0x0b, 0xd1, 0x75, 0x42, 0x4f, 0xd8, 0x3d, 0xd5, 0xbe,
	0x42, 0xbb, 0x18, 0xeb, 0x70, 0x16, 0xf9, 0xab, 0x60, 0xa7, 0xa7, 0x23, 0x6c, 0xc0, 0xb9, 0x74,
	0x03, 0xc7, 0x5d, 0x09, 0x3d, 0xec, 0x47, 0x88, 0x3f, 0xd4, 0xb8, 0x99, 0x79, 0x3d, 0x37, 0x71,
	0x1b, 0x27, 0x2d, 0xa3, 0x7d, 0xd9, 0xbd, 0xd1, 0x53, 0x65, 0x49, 0x3a, 0xae, 0xc5, 0x67, 0xa8,
	0xe5, 0x6d, 0x52, 0x1a, 0xa7, 0x4a, 0xa3, 0x76, 0xb8, 0x19, 0x2d, 0x53, 0xc8, 0xc0, 0xc1, 0xfe,
	0x92, 0xf5, 0xe6, 0x95, 0xd4, 0x99, 0x92, 0xba, 0x3b, 0x94, 0xd2, 0x05, 0x54, 0xcc, 0xc1, 0x27,
	0xb8, 0xcd, 0x12, 0x16, 0x5f, 0x92, 0x58, 0xa7, 0x7e, 0x9d, 0x2b, 0xbf, 0x72, 0x52, 0x16, 0x5f,
	0x2a, 0xab, 0x8a, 0x18, 0xe6, 0xe8, 0xc8, 0x83, 0x38, 0x52, 0xfb, 0x8c, 0x23, 0x16, 0x7a, 0xdb,
	0x13, 0x3c, 0xa5, 0x8f, 0x10, 0x5b, 0x70, 0xe9, 0x89, 0x98, 0xcb, 0x45, 0x94, 0x1e, 0x99, 0xb6,
	0x61, 0x1f, 0x7a, 0x5c, 0x42, 0xbd, 0xf8, 0x54, 0xf0, 0x2b, 0xdc, 0x93, 0xcd, 0x66, 0x6c, 0xe4,
	0x4c, 0x68, 0x34, 0x9c, 0xb1, 0xfe, 0x70, 0x38, 0x9b, 0x3a, 0x83, 0xb7, 0x91, 0x53, 0xfd, 0x84,
	0xf7, 0x6a, 0xa0, 0x5d, 0xd2, 0x21, 0x95, 0xaf, 0x1a, 0x79, 0x56, 0x7f, 0x3a, 0x21, 0xcb, 0xd9,
	0x26, 0x4b, 0x8f, 0x72, 0xff, 0x9a, 0xf5, 0x9c, 0xd8, 0x54, 0x2f, 0xd8, 0x31, 0x2c, 0x36, 0xc8,
	0xda, 0xd4, 0x01, 0x0f, 0xda, 0x8c, 0xd2, 0x74, 0xd5, 0xc0, 0x5b, 0xb8, 0xce, 0x71, 0xaa, 0x25,
	0xac, 0xa9, 0xbf, 0x68, 0x56, 0x9c, 0xa2, 0xe5, 0xee, 0x1b, 0x9c, 0xbf, 0xc4, 0x73, 0x16, 0xae,
	0x56, 0x38, 0x84, 0x87, 0xb1, 0x08, 0xbc, 0xec, 0x09, 0x24, 0xd6, 0x63, 0x21, 0xff, 0x2c, 0xb8,
	0x48, 0x57, 0x89, 0x5b, 0x23, 0xf2, 0x27, 0xde, 0x2c, 0x82, 0xe3, 0xe8, 0xf7, 0x99, 0xfa, 0xe6,
	0x7c, 0xff, 0x1f, 0x00, 0x00, 0xff, 0xff, 0xd2, 0xb8, 0xbb, 0xfc, 0x7f, 0x04, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// MsgCommClient is the client API for MsgComm service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MsgCommClient interface {
	//gRPC call to Send RICControlReqServiceGrpc
	SendRICControlReqServiceGrpc(ctx context.Context, in *RicControlGrpcReq, opts ...grpc.CallOption) (*RicControlGrpcRsp, error)
}

type msgCommClient struct {
	cc *grpc.ClientConn
}

func NewMsgCommClient(cc *grpc.ClientConn) MsgCommClient {
	return &msgCommClient{cc}
}

func (c *msgCommClient) SendRICControlReqServiceGrpc(ctx context.Context, in *RicControlGrpcReq, opts ...grpc.CallOption) (*RicControlGrpcRsp, error) {
	out := new(RicControlGrpcRsp)
	err := c.cc.Invoke(ctx, "/rc.MsgComm/SendRICControlReqServiceGrpc", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgCommServer is the server API for MsgComm service.
type MsgCommServer interface {
	//gRPC call to Send RICControlReqServiceGrpc
	SendRICControlReqServiceGrpc(context.Context, *RicControlGrpcReq) (*RicControlGrpcRsp, error)
}

// UnimplementedMsgCommServer can be embedded to have forward compatible implementations.
type UnimplementedMsgCommServer struct {
}

func (*UnimplementedMsgCommServer) SendRICControlReqServiceGrpc(ctx context.Context, req *RicControlGrpcReq) (*RicControlGrpcRsp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendRICControlReqServiceGrpc not implemented")
}

func RegisterMsgCommServer(s *grpc.Server, srv MsgCommServer) {
	s.RegisterService(&_MsgComm_serviceDesc, srv)
}

func _MsgComm_SendRICControlReqServiceGrpc_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RicControlGrpcReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgCommServer).SendRICControlReqServiceGrpc(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rc.MsgComm/SendRICControlReqServiceGrpc",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgCommServer).SendRICControlReqServiceGrpc(ctx, req.(*RicControlGrpcReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _MsgComm_serviceDesc = grpc.ServiceDesc{
	ServiceName: "rc.MsgComm",
	HandlerType: (*MsgCommServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SendRICControlReqServiceGrpc",
			Handler:    _MsgComm_SendRICControlReqServiceGrpc_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "rc.proto",
}