ylink/call/rpc/pb/call.pb.go

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

package pb

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 ClientMsgReq struct {
	IdInfo               *IdInfo       `protobuf:"bytes,3,opt,name=id_info,json=idInfo,proto3" json:"id_info,omitempty"`
	Cmd                  []*CommandMsg `protobuf:"bytes,1,rep,name=cmd,proto3" json:"cmd,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_ClientMsgReq proto.InternalMessageInfo

func (m *ClientMsgReq) GetIdInfo() *IdInfo {
	if m != nil {
		return m.IdInfo
	}
	return nil
}

func (m *ClientMsgReq) GetCmd() []*CommandMsg {
	if m != nil {
		return m.Cmd
	}
	return nil
}

type ClientMsgRes struct {
	Cmd                  []*CommandMsg `protobuf:"bytes,1,rep,name=cmd,proto3" json:"cmd,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_ClientMsgRes proto.InternalMessageInfo

func (m *ClientMsgRes) GetCmd() []*CommandMsg {
	if m != nil {
		return m.Cmd
	}
	return nil
}

type ServiceMsgReq struct {
	IdInfo               *IdInfo       `protobuf:"bytes,3,opt,name=id_info,json=idInfo,proto3" json:"id_info,omitempty"`
	Cmd                  []*CommandMsg `protobuf:"bytes,1,rep,name=cmd,proto3" json:"cmd,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_ServiceMsgReq proto.InternalMessageInfo

func (m *ServiceMsgReq) GetIdInfo() *IdInfo {
	if m != nil {
		return m.IdInfo
	}
	return nil
}

func (m *ServiceMsgReq) GetCmd() []*CommandMsg {
	if m != nil {
		return m.Cmd
	}
	return nil
}

type ServiceMsgRes struct {
	Cmd                  []*CommandMsg `protobuf:"bytes,1,rep,name=cmd,proto3" json:"cmd,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_ServiceMsgRes proto.InternalMessageInfo

func (m *ServiceMsgRes) GetCmd() []*CommandMsg {
	if m != nil {
		return m.Cmd
	}
	return nil
}

func init() {
	proto.RegisterType((*ClientMsgReq)(nil), "pb.ClientMsgReq")
	proto.RegisterType((*ClientMsgRes)(nil), "pb.ClientMsgRes")
	proto.RegisterType((*ServiceMsgReq)(nil), "pb.ServiceMsgReq")
	proto.RegisterType((*ServiceMsgRes)(nil), "pb.ServiceMsgRes")
}

func init() { proto.RegisterFile("call.proto", fileDescriptor_caa5955d5eab2d2d) }

var fileDescriptor_caa5955d5eab2d2d = []byte{
	// 241 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x4a, 0x4e, 0xcc, 0xc9,
	0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x2a, 0x48, 0x92, 0xe2, 0xcd, 0x4d, 0x2d, 0x2e,
	0x4e, 0x4c, 0x4f, 0x85, 0x08, 0x29, 0x85, 0x72, 0xf1, 0x38, 0xe7, 0x64, 0xa6, 0xe6, 0x95, 0xf8,
	0x16, 0xa7, 0x07, 0xa5, 0x16, 0x0a, 0x29, 0x73, 0xb1, 0x67, 0xa6, 0xc4, 0x67, 0xe6, 0xa5, 0xe5,
	0x4b, 0x30, 0x2b, 0x30, 0x6a, 0x70, 0x1b, 0x71, 0xe9, 0x15, 0x24, 0xe9, 0x79, 0xa6, 0x78, 0xe6,
	0xa5, 0xe5, 0x07, 0xb1, 0x65, 0x82, 0x69, 0x21, 0x05, 0x2e, 0xe6, 0xe4, 0xdc, 0x14, 0x09, 0x46,
	0x05, 0x66, 0x0d, 0x6e, 0x23, 0x3e, 0x90, 0x02, 0xe7, 0xfc, 0xdc, 0xdc, 0xc4, 0xbc, 0x14, 0x90,
	0x21, 0x20, 0x29, 0x25, 0x03, 0x14, 0x63, 0x8b, 0x89, 0xd0, 0x11, 0xc6, 0xc5, 0x1b, 0x9c, 0x5a,
	0x54, 0x96, 0x99, 0x9c, 0x4a, 0x5d, 0x97, 0x18, 0xa2, 0x9a, 0x4b, 0x84, 0x53, 0x8c, 0x1e, 0x31,
	0x72, 0xb1, 0x38, 0x27, 0xe6, 0xe4, 0x08, 0x99, 0x72, 0x71, 0x43, 0x7c, 0xe1, 0x93, 0x9f, 0x9e,
	0x99, 0x27, 0x24, 0x00, 0x56, 0x8c, 0x14, 0x5a, 0x52, 0xe8, 0x22, 0xc5, 0x4a, 0x0c, 0x06, 0x8c,
	0x42, 0x46, 0x5c, 0x5c, 0x10, 0x31, 0xb0, 0x21, 0x44, 0xe9, 0x12, 0xb2, 0xe0, 0xe2, 0x81, 0x3a,
	0x13, 0x62, 0x97, 0x20, 0x48, 0x0d, 0x4a, 0x80, 0x48, 0x61, 0x08, 0x41, 0x6c, 0x33, 0xe5, 0xe2,
	0x86, 0x0a, 0x82, 0xad, 0x23, 0x52, 0xa3, 0x13, 0x6b, 0x14, 0xb3, 0x7e, 0x41, 0x52, 0x12, 0x1b,
	0x38, 0x19, 0x18, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x63, 0xe5, 0xf6, 0x2b, 0x27, 0x02, 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

// CallClient is the client API for Call service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type CallClient interface {
	ClientLogin(ctx context.Context, in *ClientMsgReq, opts ...grpc.CallOption) (Call_ClientLoginClient, error)
	ClientCall(ctx context.Context, in *ClientMsgReq, opts ...grpc.CallOption) (*ClientMsgRes, error)
	ServiceLogin(ctx context.Context, in *ServiceMsgReq, opts ...grpc.CallOption) (Call_ServiceLoginClient, error)
	ServiceCall(ctx context.Context, in *ServiceMsgReq, opts ...grpc.CallOption) (*ServiceMsgRes, error)
}

type callClient struct {
	cc *grpc.ClientConn
}

func NewCallClient(cc *grpc.ClientConn) CallClient {
	return &callClient{cc}
}

func (c *callClient) ClientLogin(ctx context.Context, in *ClientMsgReq, opts ...grpc.CallOption) (Call_ClientLoginClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Call_serviceDesc.Streams[0], "/pb.Call/ClientLogin", opts...)
	if err != nil {
		return nil, err
	}
	x := &callClientLoginClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Call_ClientLoginClient interface {
	Recv() (*ClientMsgRes, error)
	grpc.ClientStream
}

type callClientLoginClient struct {
	grpc.ClientStream
}

func (x *callClientLoginClient) Recv() (*ClientMsgRes, error) {
	m := new(ClientMsgRes)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *callClient) ClientCall(ctx context.Context, in *ClientMsgReq, opts ...grpc.CallOption) (*ClientMsgRes, error) {
	out := new(ClientMsgRes)
	err := c.cc.Invoke(ctx, "/pb.Call/ClientCall", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *callClient) ServiceLogin(ctx context.Context, in *ServiceMsgReq, opts ...grpc.CallOption) (Call_ServiceLoginClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Call_serviceDesc.Streams[1], "/pb.Call/ServiceLogin", opts...)
	if err != nil {
		return nil, err
	}
	x := &callServiceLoginClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Call_ServiceLoginClient interface {
	Recv() (*ServiceMsgRes, error)
	grpc.ClientStream
}

type callServiceLoginClient struct {
	grpc.ClientStream
}

func (x *callServiceLoginClient) Recv() (*ServiceMsgRes, error) {
	m := new(ServiceMsgRes)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *callClient) ServiceCall(ctx context.Context, in *ServiceMsgReq, opts ...grpc.CallOption) (*ServiceMsgRes, error) {
	out := new(ServiceMsgRes)
	err := c.cc.Invoke(ctx, "/pb.Call/ServiceCall", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CallServer is the server API for Call service.
type CallServer interface {
	ClientLogin(*ClientMsgReq, Call_ClientLoginServer) error
	ClientCall(context.Context, *ClientMsgReq) (*ClientMsgRes, error)
	ServiceLogin(*ServiceMsgReq, Call_ServiceLoginServer) error
	ServiceCall(context.Context, *ServiceMsgReq) (*ServiceMsgRes, error)
}

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

func (*UnimplementedCallServer) ClientLogin(req *ClientMsgReq, srv Call_ClientLoginServer) error {
	return status.Errorf(codes.Unimplemented, "method ClientLogin not implemented")
}
func (*UnimplementedCallServer) ClientCall(ctx context.Context, req *ClientMsgReq) (*ClientMsgRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ClientCall not implemented")
}
func (*UnimplementedCallServer) ServiceLogin(req *ServiceMsgReq, srv Call_ServiceLoginServer) error {
	return status.Errorf(codes.Unimplemented, "method ServiceLogin not implemented")
}
func (*UnimplementedCallServer) ServiceCall(ctx context.Context, req *ServiceMsgReq) (*ServiceMsgRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ServiceCall not implemented")
}

func RegisterCallServer(s *grpc.Server, srv CallServer) {
	s.RegisterService(&_Call_serviceDesc, srv)
}

func _Call_ClientLogin_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ClientMsgReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CallServer).ClientLogin(m, &callClientLoginServer{stream})
}

type Call_ClientLoginServer interface {
	Send(*ClientMsgRes) error
	grpc.ServerStream
}

type callClientLoginServer struct {
	grpc.ServerStream
}

func (x *callClientLoginServer) Send(m *ClientMsgRes) error {
	return x.ServerStream.SendMsg(m)
}

func _Call_ClientCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClientMsgReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CallServer).ClientCall(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Call/ClientCall",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CallServer).ClientCall(ctx, req.(*ClientMsgReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Call_ServiceLogin_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ServiceMsgReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CallServer).ServiceLogin(m, &callServiceLoginServer{stream})
}

type Call_ServiceLoginServer interface {
	Send(*ServiceMsgRes) error
	grpc.ServerStream
}

type callServiceLoginServer struct {
	grpc.ServerStream
}

func (x *callServiceLoginServer) Send(m *ServiceMsgRes) error {
	return x.ServerStream.SendMsg(m)
}

func _Call_ServiceCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServiceMsgReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CallServer).ServiceCall(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Call/ServiceCall",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CallServer).ServiceCall(ctx, req.(*ServiceMsgReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _Call_serviceDesc = grpc.ServiceDesc{
	ServiceName: "pb.Call",
	HandlerType: (*CallServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ClientCall",
			Handler:    _Call_ClientCall_Handler,
		},
		{
			MethodName: "ServiceCall",
			Handler:    _Call_ServiceCall_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ClientLogin",
			Handler:       _Call_ClientLogin_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ServiceLogin",
			Handler:       _Call_ServiceLogin_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "call.proto",
}