protocol/grpc/ricmsgcommrpc/rc/rc.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: rc.proto
   3
   4 package rc
   5
   6 import (
   7         context "context"
   8         fmt "fmt"
   9         proto "github.com/golang/protobuf/proto"
  10         grpc "google.golang.org/grpc"
  11         codes "google.golang.org/grpc/codes"
  12         status "google.golang.org/grpc/status"
  13         math "math"
  14 )
  15
  16 // Reference imports to suppress errors if they are not otherwise used.
  17 var _ = proto.Marshal
  18 var _ = fmt.Errorf
  19 var _ = math.Inf
  20
  21 // This is a compile-time assertion to ensure that this generated file
  22 // is compatible with the proto package it is being compiled against.
  23 // A compilation error at this line likely means your copy of the
  24 // proto package needs to be updated.
  25 const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
  26
  27 type RICControlCellTypeEnum int32
  28
  29 const (
  30         RICControlCellTypeEnum_RIC_CONTROL_CELL_UNKWON RICControlCellTypeEnum = 0
  31         RICControlCellTypeEnum_RIC_CONTROL_NR_CELL     RICControlCellTypeEnum = 1
  32         RICControlCellTypeEnum_RIC_CONTROL_EUTRAN_CELL RICControlCellTypeEnum = 2
  33 )
  34
  35 var RICControlCellTypeEnum_name = map[int32]string{
  36         0: "RIC_CONTROL_CELL_UNKWON",
  37         1: "RIC_CONTROL_NR_CELL",
  38         2: "RIC_CONTROL_EUTRAN_CELL",
  39 }
  40
  41 var RICControlCellTypeEnum_value = map[string]int32{
  42         "RIC_CONTROL_CELL_UNKWON": 0,
  43         "RIC_CONTROL_NR_CELL":     1,
  44         "RIC_CONTROL_EUTRAN_CELL": 2,
  45 }
  46
  47 func (x RICControlCellTypeEnum) String() string {
  48         return proto.EnumName(RICControlCellTypeEnum_name, int32(x))
  49 }
  50
  51 func (RICControlCellTypeEnum) EnumDescriptor() ([]byte, []int) {
  52         return fileDescriptor_a4fc9282119cff7c, []int{0}
  53 }
  54
  55 type RICControlAckEnum int32
  56
  57 const (
  58         RICControlAckEnum_RIC_CONTROL_ACK_UNKWON RICControlAckEnum = 0
  59         RICControlAckEnum_RIC_CONTROL_NO_ACK     RICControlAckEnum = 1
  60         RICControlAckEnum_RIC_CONTROL_ACK        RICControlAckEnum = 2
  61         RICControlAckEnum_RIC_CONTROL_NACK       RICControlAckEnum = 3
  62 )
  63
  64 var RICControlAckEnum_name = map[int32]string{
  65         0: "RIC_CONTROL_ACK_UNKWON",
  66         1: "RIC_CONTROL_NO_ACK",
  67         2: "RIC_CONTROL_ACK",
  68         3: "RIC_CONTROL_NACK",
  69 }
  70
  71 var RICControlAckEnum_value = map[string]int32{
  72         "RIC_CONTROL_ACK_UNKWON": 0,
  73         "RIC_CONTROL_NO_ACK":     1,
  74         "RIC_CONTROL_ACK":        2,
  75         "RIC_CONTROL_NACK":       3,
  76 }
  77
  78 func (x RICControlAckEnum) String() string {
  79         return proto.EnumName(RICControlAckEnum_name, int32(x))
  80 }
  81
  82 func (RICControlAckEnum) EnumDescriptor() ([]byte, []int) {
  83         return fileDescriptor_a4fc9282119cff7c, []int{1}
  84 }
  85
  86 type RICE2APHeader struct {
  87         RanFuncId            int64    `protobuf:"varint,1,opt,name=RanFuncId,proto3" json:"RanFuncId,omitempty"`
  88         RICRequestorID       int64    `protobuf:"varint,2,opt,name=RICRequestorID,proto3" json:"RICRequestorID,omitempty"`
  89         XXX_NoUnkeyedLiteral struct{} `json:"-"`
  90         XXX_unrecognized     []byte   `json:"-"`
  91         XXX_sizecache        int32    `json:"-"`
  92 }
  93
  94 func (m *RICE2APHeader) Reset()         { *m = RICE2APHeader{} }
  95 func (m *RICE2APHeader) String() string { return proto.CompactTextString(m) }
  96 func (*RICE2APHeader) ProtoMessage()    {}
  97 func (*RICE2APHeader) Descriptor() ([]byte, []int) {
  98         return fileDescriptor_a4fc9282119cff7c, []int{0}
  99 }
 100
 101 func (m *RICE2APHeader) XXX_Unmarshal(b []byte) error {
 102         return xxx_messageInfo_RICE2APHeader.Unmarshal(m, b)
 103 }
 104 func (m *RICE2APHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 105         return xxx_messageInfo_RICE2APHeader.Marshal(b, m, deterministic)
 106 }
 107 func (m *RICE2APHeader) XXX_Merge(src proto.Message) {
 108         xxx_messageInfo_RICE2APHeader.Merge(m, src)
 109 }
 110 func (m *RICE2APHeader) XXX_Size() int {
 111         return xxx_messageInfo_RICE2APHeader.Size(m)
 112 }
 113 func (m *RICE2APHeader) XXX_DiscardUnknown() {
 114         xxx_messageInfo_RICE2APHeader.DiscardUnknown(m)
 115 }
 116
 117 var xxx_messageInfo_RICE2APHeader proto.InternalMessageInfo
 118
 119 func (m *RICE2APHeader) GetRanFuncId() int64 {
 120         if m != nil {
 121                 return m.RanFuncId
 122         }
 123         return 0
 124 }
 125
 126 func (m *RICE2APHeader) GetRICRequestorID() int64 {
 127         if m != nil {
 128                 return m.RICRequestorID
 129         }
 130         return 0
 131 }
 132
 133 type RICControlHeader struct {
 134         ControlStyle         int64    `protobuf:"varint,1,opt,name=ControlStyle,proto3" json:"ControlStyle,omitempty"`
 135         ControlActionId      int64    `protobuf:"varint,2,opt,name=ControlActionId,proto3" json:"ControlActionId,omitempty"`
 136         UEID                 string   `protobuf:"bytes,3,opt,name=UEID,proto3" json:"UEID,omitempty"`
 137         XXX_NoUnkeyedLiteral struct{} `json:"-"`
 138         XXX_unrecognized     []byte   `json:"-"`
 139         XXX_sizecache        int32    `json:"-"`
 140 }
 141
 142 func (m *RICControlHeader) Reset()         { *m = RICControlHeader{} }
 143 func (m *RICControlHeader) String() string { return proto.CompactTextString(m) }
 144 func (*RICControlHeader) ProtoMessage()    {}
 145 func (*RICControlHeader) Descriptor() ([]byte, []int) {
 146         return fileDescriptor_a4fc9282119cff7c, []int{1}
 147 }
 148
 149 func (m *RICControlHeader) XXX_Unmarshal(b []byte) error {
 150         return xxx_messageInfo_RICControlHeader.Unmarshal(m, b)
 151 }
 152 func (m *RICControlHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 153         return xxx_messageInfo_RICControlHeader.Marshal(b, m, deterministic)
 154 }
 155 func (m *RICControlHeader) XXX_Merge(src proto.Message) {
 156         xxx_messageInfo_RICControlHeader.Merge(m, src)
 157 }
 158 func (m *RICControlHeader) XXX_Size() int {
 159         return xxx_messageInfo_RICControlHeader.Size(m)
 160 }
 161 func (m *RICControlHeader) XXX_DiscardUnknown() {
 162         xxx_messageInfo_RICControlHeader.DiscardUnknown(m)
 163 }
 164
 165 var xxx_messageInfo_RICControlHeader proto.InternalMessageInfo
 166
 167 func (m *RICControlHeader) GetControlStyle() int64 {
 168         if m != nil {
 169                 return m.ControlStyle
 170         }
 171         return 0
 172 }
 173
 174 func (m *RICControlHeader) GetControlActionId() int64 {
 175         if m != nil {
 176                 return m.ControlActionId
 177         }
 178         return 0
 179 }
 180
 181 func (m *RICControlHeader) GetUEID() string {
 182         if m != nil {
 183                 return m.UEID
 184         }
 185         return ""
 186 }
 187
 188 type RICControlMessage struct {
 189         RICControlCellTypeVal RICControlCellTypeEnum `protobuf:"varint,1,opt,name=RICControlCellTypeVal,proto3,enum=rc.RICControlCellTypeEnum" json:"RICControlCellTypeVal,omitempty"`
 190         TargetCellID          string                 `protobuf:"bytes,2,opt,name=TargetCellID,proto3" json:"TargetCellID,omitempty"`
 191         XXX_NoUnkeyedLiteral  struct{}               `json:"-"`
 192         XXX_unrecognized      []byte                 `json:"-"`
 193         XXX_sizecache         int32                  `json:"-"`
 194 }
 195
 196 func (m *RICControlMessage) Reset()         { *m = RICControlMessage{} }
 197 func (m *RICControlMessage) String() string { return proto.CompactTextString(m) }
 198 func (*RICControlMessage) ProtoMessage()    {}
 199 func (*RICControlMessage) Descriptor() ([]byte, []int) {
 200         return fileDescriptor_a4fc9282119cff7c, []int{2}
 201 }
 202
 203 func (m *RICControlMessage) XXX_Unmarshal(b []byte) error {
 204         return xxx_messageInfo_RICControlMessage.Unmarshal(m, b)
 205 }
 206 func (m *RICControlMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 207         return xxx_messageInfo_RICControlMessage.Marshal(b, m, deterministic)
 208 }
 209 func (m *RICControlMessage) XXX_Merge(src proto.Message) {
 210         xxx_messageInfo_RICControlMessage.Merge(m, src)
 211 }
 212 func (m *RICControlMessage) XXX_Size() int {
 213         return xxx_messageInfo_RICControlMessage.Size(m)
 214 }
 215 func (m *RICControlMessage) XXX_DiscardUnknown() {
 216         xxx_messageInfo_RICControlMessage.DiscardUnknown(m)
 217 }
 218
 219 var xxx_messageInfo_RICControlMessage proto.InternalMessageInfo
 220
 221 func (m *RICControlMessage) GetRICControlCellTypeVal() RICControlCellTypeEnum {
 222         if m != nil {
 223                 return m.RICControlCellTypeVal
 224         }
 225         return RICControlCellTypeEnum_RIC_CONTROL_CELL_UNKWON
 226 }
 227
 228 func (m *RICControlMessage) GetTargetCellID() string {
 229         if m != nil {
 230                 return m.TargetCellID
 231         }
 232         return ""
 233 }
 234
 235 //RicControl GRPC Req
 236 type RicControlGrpcReq struct {
 237         E2NodeID              string             `protobuf:"bytes,1,opt,name=e2NodeID,proto3" json:"e2NodeID,omitempty"`
 238         PlmnID                string             `protobuf:"bytes,2,opt,name=plmnID,proto3" json:"plmnID,omitempty"`
 239         RanName               string             `protobuf:"bytes,3,opt,name=ranName,proto3" json:"ranName,omitempty"`
 240         RICE2APHeaderData     *RICE2APHeader     `protobuf:"bytes,4,opt,name=RICE2APHeaderData,proto3" json:"RICE2APHeaderData,omitempty"`
 241         RICControlHeaderData  *RICControlHeader  `protobuf:"bytes,5,opt,name=RICControlHeaderData,proto3" json:"RICControlHeaderData,omitempty"`
 242         RICControlMessageData *RICControlMessage `protobuf:"bytes,6,opt,name=RICControlMessageData,proto3" json:"RICControlMessageData,omitempty"`
 243         RICControlAckReqVal   RICControlAckEnum  `protobuf:"varint,7,opt,name=RICControlAckReqVal,proto3,enum=rc.RICControlAckEnum" json:"RICControlAckReqVal,omitempty"`
 244         XXX_NoUnkeyedLiteral  struct{}           `json:"-"`
 245         XXX_unrecognized      []byte             `json:"-"`
 246         XXX_sizecache         int32              `json:"-"`
 247 }
 248
 249 func (m *RicControlGrpcReq) Reset()         { *m = RicControlGrpcReq{} }
 250 func (m *RicControlGrpcReq) String() string { return proto.CompactTextString(m) }
 251 func (*RicControlGrpcReq) ProtoMessage()    {}
 252 func (*RicControlGrpcReq) Descriptor() ([]byte, []int) {
 253         return fileDescriptor_a4fc9282119cff7c, []int{3}
 254 }
 255
 256 func (m *RicControlGrpcReq) XXX_Unmarshal(b []byte) error {
 257         return xxx_messageInfo_RicControlGrpcReq.Unmarshal(m, b)
 258 }
 259 func (m *RicControlGrpcReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 260         return xxx_messageInfo_RicControlGrpcReq.Marshal(b, m, deterministic)
 261 }
 262 func (m *RicControlGrpcReq) XXX_Merge(src proto.Message) {
 263         xxx_messageInfo_RicControlGrpcReq.Merge(m, src)
 264 }
 265 func (m *RicControlGrpcReq) XXX_Size() int {
 266         return xxx_messageInfo_RicControlGrpcReq.Size(m)
 267 }
 268 func (m *RicControlGrpcReq) XXX_DiscardUnknown() {
 269         xxx_messageInfo_RicControlGrpcReq.DiscardUnknown(m)
 270 }
 271
 272 var xxx_messageInfo_RicControlGrpcReq proto.InternalMessageInfo
 273
 274 func (m *RicControlGrpcReq) GetE2NodeID() string {
 275         if m != nil {
 276                 return m.E2NodeID
 277         }
 278         return ""
 279 }
 280
 281 func (m *RicControlGrpcReq) GetPlmnID() string {
 282         if m != nil {
 283                 return m.PlmnID
 284         }
 285         return ""
 286 }
 287
 288 func (m *RicControlGrpcReq) GetRanName() string {
 289         if m != nil {
 290                 return m.RanName
 291         }
 292         return ""
 293 }
 294
 295 func (m *RicControlGrpcReq) GetRICE2APHeaderData() *RICE2APHeader {
 296         if m != nil {
 297                 return m.RICE2APHeaderData
 298         }
 299         return nil
 300 }
 301
 302 func (m *RicControlGrpcReq) GetRICControlHeaderData() *RICControlHeader {
 303         if m != nil {
 304                 return m.RICControlHeaderData
 305         }
 306         return nil
 307 }
 308
 309 func (m *RicControlGrpcReq) GetRICControlMessageData() *RICControlMessage {
 310         if m != nil {
 311                 return m.RICControlMessageData
 312         }
 313         return nil
 314 }
 315
 316 func (m *RicControlGrpcReq) GetRICControlAckReqVal() RICControlAckEnum {
 317         if m != nil {
 318                 return m.RICControlAckReqVal
 319         }
 320         return RICControlAckEnum_RIC_CONTROL_ACK_UNKWON
 321 }
 322
 323 //RicControlGrpc Rsp
 324 type RicControlGrpcRsp struct {
 325         RspCode              int32    `protobuf:"varint,1,opt,name=rspCode,proto3" json:"rspCode,omitempty"`
 326         Description          string   `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
 327         XXX_NoUnkeyedLiteral struct{} `json:"-"`
 328         XXX_unrecognized     []byte   `json:"-"`
 329         XXX_sizecache        int32    `json:"-"`
 330 }
 331
 332 func (m *RicControlGrpcRsp) Reset()         { *m = RicControlGrpcRsp{} }
 333 func (m *RicControlGrpcRsp) String() string { return proto.CompactTextString(m) }
 334 func (*RicControlGrpcRsp) ProtoMessage()    {}
 335 func (*RicControlGrpcRsp) Descriptor() ([]byte, []int) {
 336         return fileDescriptor_a4fc9282119cff7c, []int{4}
 337 }
 338
 339 func (m *RicControlGrpcRsp) XXX_Unmarshal(b []byte) error {
 340         return xxx_messageInfo_RicControlGrpcRsp.Unmarshal(m, b)
 341 }
 342 func (m *RicControlGrpcRsp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 343         return xxx_messageInfo_RicControlGrpcRsp.Marshal(b, m, deterministic)
 344 }
 345 func (m *RicControlGrpcRsp) XXX_Merge(src proto.Message) {
 346         xxx_messageInfo_RicControlGrpcRsp.Merge(m, src)
 347 }
 348 func (m *RicControlGrpcRsp) XXX_Size() int {
 349         return xxx_messageInfo_RicControlGrpcRsp.Size(m)
 350 }
 351 func (m *RicControlGrpcRsp) XXX_DiscardUnknown() {
 352         xxx_messageInfo_RicControlGrpcRsp.DiscardUnknown(m)
 353 }
 354
 355 var xxx_messageInfo_RicControlGrpcRsp proto.InternalMessageInfo
 356
 357 func (m *RicControlGrpcRsp) GetRspCode() int32 {
 358         if m != nil {
 359                 return m.RspCode
 360         }
 361         return 0
 362 }
 363
 364 func (m *RicControlGrpcRsp) GetDescription() string {
 365         if m != nil {
 366                 return m.Description
 367         }
 368         return ""
 369 }
 370
 371 func init() {
 372         proto.RegisterEnum("rc.RICControlCellTypeEnum", RICControlCellTypeEnum_name, RICControlCellTypeEnum_value)
 373         proto.RegisterEnum("rc.RICControlAckEnum", RICControlAckEnum_name, RICControlAckEnum_value)
 374         proto.RegisterType((*RICE2APHeader)(nil), "rc.RICE2APHeader")
 375         proto.RegisterType((*RICControlHeader)(nil), "rc.RICControlHeader")
 376         proto.RegisterType((*RICControlMessage)(nil), "rc.RICControlMessage")
 377         proto.RegisterType((*RicControlGrpcReq)(nil), "rc.RicControlGrpcReq")
 378         proto.RegisterType((*RicControlGrpcRsp)(nil), "rc.RicControlGrpcRsp")
 379 }
 380
 381 func init() { proto.RegisterFile("rc.proto", fileDescriptor_a4fc9282119cff7c) }
 382
 383 var fileDescriptor_a4fc9282119cff7c = []byte{
 384         // 527 bytes of a gzipped FileDescriptorProto
 385         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x54, 0x4d, 0x6f, 0xda, 0x40,
 386         0x10, 0xad, 0x21, 0x5f, 0x4c, 0xda, 0x84, 0x4c, 0x08, 0x41, 0x34, 0x07, 0xe4, 0x43, 0x85, 0x72,
 387         0xe0, 0x40, 0x7f, 0x40, 0x65, 0x2d, 0x34, 0xb1, 0x20, 0x26, 0x1a, 0xa0, 0x39, 0x22, 0x77, 0xbd,
 388         0x42, 0x08, 0x63, 0x9b, 0xb5, 0xa9, 0x94, 0x6b, 0x6f, 0xfd, 0xd7, 0x95, 0x97, 0x0d, 0x06, 0xe3,
 389         0x1b, 0xf3, 0x66, 0xde, 0x9b, 0x9d, 0x79, 0x83, 0xe1, 0x42, 0xf2, 0x4e, 0x24, 0xc3, 0x24, 0xc4,
 390         0x92, 0xe4, 0xe6, 0x14, 0xbe, 0x90, 0xcd, 0xfa, 0x5d, 0xeb, 0xf5, 0x59, 0xb8, 0x9e, 0x90, 0xf8,
 391         0x00, 0x15, 0x72, 0x83, 0x9f, 0x9b, 0x80, 0xdb, 0x5e, 0xc3, 0x68, 0x19, 0xed, 0x32, 0x65, 0x00,
 392         0x7e, 0x83, 0x2b, 0xb2, 0x19, 0x89, 0xf5, 0x46, 0xc4, 0x49, 0x28, 0xed, 0x5e, 0xa3, 0xa4, 0x4a,
 393         0x72, 0xa8, 0x99, 0x40, 0x95, 0x6c, 0xc6, 0xc2, 0x20, 0x91, 0xa1, 0xaf, 0x95, 0x4d, 0xf8, 0xac,
 394         0x81, 0x71, 0xf2, 0xee, 0x0b, 0x2d, 0x7e, 0x80, 0x61, 0x1b, 0xae, 0x75, 0x6c, 0xf1, 0x64, 0x11,
 395         0x06, 0xb6, 0xa7, 0x1b, 0xe4, 0x61, 0x44, 0x38, 0x99, 0xf6, 0xed, 0x5e, 0xa3, 0xdc, 0x32, 0xda,
 396         0x15, 0x52, 0xbf, 0xcd, 0x7f, 0x06, 0xdc, 0x64, 0x6d, 0x5f, 0x44, 0x1c, 0xbb, 0x73, 0x81, 0xaf,
 397         0x70, 0x97, 0x81, 0x4c, 0xf8, 0xfe, 0xe4, 0x3d, 0x12, 0xbf, 0x5c, 0x5f, 0x3d, 0xe0, 0xaa, 0xdb,
 398         0xec, 0x48, 0xde, 0x39, 0x2e, 0xe8, 0x07, 0x9b, 0x15, 0x15, 0x13, 0xd3, 0x49, 0x26, 0xae, 0x9c,
 399         0x8b, 0x24, 0x05, 0xf5, 0x0e, 0x2a, 0x74, 0x80, 0x99, 0x7f, 0xcb, 0x70, 0x43, 0x0b, 0xae, 0xd9,
 400         0x4f, 0x32, 0xe2, 0x24, 0xd6, 0xd8, 0x84, 0x0b, 0xd1, 0x75, 0x42, 0x4f, 0xd8, 0x3d, 0xd5, 0xbe,
 401         0x42, 0xbb, 0x18, 0xeb, 0x70, 0x16, 0xf9, 0xab, 0x60, 0xa7, 0xa7, 0x23, 0x6c, 0xc0, 0xb9, 0x74,
 402         0x03, 0xc7, 0x5d, 0x09, 0x3d, 0xec, 0x47, 0x88, 0x3f, 0xd4, 0xb8, 0x99, 0x79, 0x3d, 0x37, 0x71,
 403         0x1b, 0x27, 0x2d, 0xa3, 0x7d, 0xd9, 0xbd, 0xd1, 0x53, 0x65, 0x49, 0x3a, 0xae, 0xc5, 0x67, 0xa8,
 404         0xe5, 0x6d, 0x52, 0x1a, 0xa7, 0x4a, 0xa3, 0x76, 0xb8, 0x19, 0x2d, 0x53, 0xc8, 0xc0, 0xc1, 0xfe,
 405         0x92, 0xf5, 0xe6, 0x95, 0xd4, 0x99, 0x92, 0xba, 0x3b, 0x94, 0xd2, 0x05, 0x54, 0xcc, 0xc1, 0x27,
 406         0xb8, 0xcd, 0x12, 0x16, 0x5f, 0x92, 0x58, 0xa7, 0x7e, 0x9d, 0x2b, 0xbf, 0x72, 0x52, 0x16, 0x5f,
 407         0x2a, 0xab, 0x8a, 0x18, 0xe6, 0xe8, 0xc8, 0x83, 0x38, 0x52, 0xfb, 0x8c, 0x23, 0x16, 0x7a, 0xdb,
 408         0x13, 0x3c, 0xa5, 0x8f, 0x10, 0x5b, 0x70, 0xe9, 0x89, 0x98, 0xcb, 0x45, 0x94, 0x1e, 0x99, 0xb6,
 409         0x61, 0x1f, 0x7a, 0x5c, 0x42, 0xbd, 0xf8, 0x54, 0xf0, 0x2b, 0xdc, 0x93, 0xcd, 0x66, 0x6c, 0xe4,
 410         0x4c, 0x68, 0x34, 0x9c, 0xb1, 0xfe, 0x70, 0x38, 0x9b, 0x3a, 0x83, 0xb7, 0x91, 0x53, 0xfd, 0x84,
 411         0xf7, 0x6a, 0xa0, 0x5d, 0xd2, 0x21, 0x95, 0xaf, 0x1a, 0x79, 0x56, 0x7f, 0x3a, 0x21, 0xcb, 0xd9,
 412         0x26, 0x4b, 0x8f, 0x72, 0xff, 0x9a, 0xf5, 0x9c, 0xd8, 0x54, 0x2f, 0xd8, 0x31, 0x2c, 0x36, 0xc8,
 413         0xda, 0xd4, 0x01, 0x0f, 0xda, 0x8c, 0xd2, 0x74, 0xd5, 0xc0, 0x5b, 0xb8, 0xce, 0x71, 0xaa, 0x25,
 414         0xac, 0xa9, 0xbf, 0x68, 0x56, 0x9c, 0xa2, 0xe5, 0xee, 0x1b, 0x9c, 0xbf, 0xc4, 0x73, 0x16, 0xae,
 415         0x56, 0x38, 0x84, 0x87, 0xb1, 0x08, 0xbc, 0xec, 0x09, 0x24, 0xd6, 0x63, 0x21, 0xff, 0x2c, 0xb8,
 416         0x48, 0x57, 0x89, 0x5b, 0x23, 0xf2, 0x27, 0xde, 0x2c, 0x82, 0xe3, 0xe8, 0xf7, 0x99, 0xfa, 0xe6,
 417         0x7c, 0xff, 0x1f, 0x00, 0x00, 0xff, 0xff, 0xd2, 0xb8, 0xbb, 0xfc, 0x7f, 0x04, 0x00, 0x00,
 418 }
 419
 420 // Reference imports to suppress errors if they are not otherwise used.
 421 var _ context.Context
 422 var _ grpc.ClientConn
 423
 424 // This is a compile-time assertion to ensure that this generated file
 425 // is compatible with the grpc package it is being compiled against.
 426 const _ = grpc.SupportPackageIsVersion4
 427
 428 // MsgCommClient is the client API for MsgComm service.
 429 //
 430 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
 431 type MsgCommClient interface {
 432         //gRPC call to Send RICControlReqServiceGrpc
 433         SendRICControlReqServiceGrpc(ctx context.Context, in *RicControlGrpcReq, opts ...grpc.CallOption) (*RicControlGrpcRsp, error)
 434 }
 435
 436 type msgCommClient struct {
 437         cc *grpc.ClientConn
 438 }
 439
 440 func NewMsgCommClient(cc *grpc.ClientConn) MsgCommClient {
 441         return &msgCommClient{cc}
 442 }
 443
 444 func (c *msgCommClient) SendRICControlReqServiceGrpc(ctx context.Context, in *RicControlGrpcReq, opts ...grpc.CallOption) (*RicControlGrpcRsp, error) {
 445         out := new(RicControlGrpcRsp)
 446         err := c.cc.Invoke(ctx, "/rc.MsgComm/SendRICControlReqServiceGrpc", in, out, opts...)
 447         if err != nil {
 448                 return nil, err
 449         }
 450         return out, nil
 451 }
 452
 453 // MsgCommServer is the server API for MsgComm service.
 454 type MsgCommServer interface {
 455         //gRPC call to Send RICControlReqServiceGrpc
 456         SendRICControlReqServiceGrpc(context.Context, *RicControlGrpcReq) (*RicControlGrpcRsp, error)
 457 }
 458
 459 // UnimplementedMsgCommServer can be embedded to have forward compatible implementations.
 460 type UnimplementedMsgCommServer struct {
 461 }
 462
 463 func (*UnimplementedMsgCommServer) SendRICControlReqServiceGrpc(ctx context.Context, req *RicControlGrpcReq) (*RicControlGrpcRsp, error) {
 464         return nil, status.Errorf(codes.Unimplemented, "method SendRICControlReqServiceGrpc not implemented")
 465 }
 466
 467 func RegisterMsgCommServer(s *grpc.Server, srv MsgCommServer) {
 468         s.RegisterService(&_MsgComm_serviceDesc, srv)
 469 }
 470
 471 func _MsgComm_SendRICControlReqServiceGrpc_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 472         in := new(RicControlGrpcReq)
 473         if err := dec(in); err != nil {
 474                 return nil, err
 475         }
 476         if interceptor == nil {
 477                 return srv.(MsgCommServer).SendRICControlReqServiceGrpc(ctx, in)
 478         }
 479         info := &grpc.UnaryServerInfo{
 480                 Server:     srv,
 481                 FullMethod: "/rc.MsgComm/SendRICControlReqServiceGrpc",
 482         }
 483         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 484                 return srv.(MsgCommServer).SendRICControlReqServiceGrpc(ctx, req.(*RicControlGrpcReq))
 485         }
 486         return interceptor(ctx, in, info, handler)
 487 }
 488
 489 var _MsgComm_serviceDesc = grpc.ServiceDesc{
 490         ServiceName: "rc.MsgComm",
 491         HandlerType: (*MsgCommServer)(nil),
 492         Methods: []grpc.MethodDesc{
 493                 {
 494                         MethodName: "SendRICControlReqServiceGrpc",
 495                         Handler:    _MsgComm_SendRICControlReqServiceGrpc_Handler,
 496                 },
 497         },
 498         Streams:  []grpc.StreamDesc{},
 499         Metadata: "rc.proto",
 500 }