simple/grpc.pb.go

// Code generated by protoc-gen-gogo.
// source: grpc.proto
// DO NOT EDIT!

/*
	Package grpc is a generated protocol buffer package.

	It is generated from these files:
		grpc.proto

	It has these top-level messages:
		MyRequest
		MyResponse
		MyMsg
		MyMsg2
*/
package grpc

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import test "github.com/gogo/protobuf/test"

import (
	context "golang.org/x/net/context"
	grpc1 "google.golang.org/grpc"
)

// 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type MyRequest struct {
	Value int64 `protobuf:"varint,1,opt,name=Value,json=value,proto3" json:"Value,omitempty"`
}

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

type MyResponse struct {
	Value int64 `protobuf:"varint,1,opt,name=Value,json=value,proto3" json:"Value,omitempty"`
}

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

type MyMsg struct {
	Value int64 `protobuf:"varint,1,opt,name=Value,json=value,proto3" json:"Value,omitempty"`
}

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

type MyMsg2 struct {
	Value int64 `protobuf:"varint,1,opt,name=Value,json=value,proto3" json:"Value,omitempty"`
}

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

func init() {
	proto.RegisterType((*MyRequest)(nil), "grpc.MyRequest")
	proto.RegisterType((*MyResponse)(nil), "grpc.MyResponse")
	proto.RegisterType((*MyMsg)(nil), "grpc.MyMsg")
	proto.RegisterType((*MyMsg2)(nil), "grpc.MyMsg2")
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc1.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 _ = grpc1.SupportPackageIsVersion3

// Client API for MyTest service

type MyTestClient interface {
	UnaryCall(ctx context.Context, in *MyRequest, opts ...grpc1.CallOption) (*MyResponse, error)
	// This RPC streams from the server only.
	Downstream(ctx context.Context, in *MyRequest, opts ...grpc1.CallOption) (MyTest_DownstreamClient, error)
	// This RPC streams from the client.
	Upstream(ctx context.Context, opts ...grpc1.CallOption) (MyTest_UpstreamClient, error)
	// This one streams in both directions.
	Bidi(ctx context.Context, opts ...grpc1.CallOption) (MyTest_BidiClient, error)
}

type myTestClient struct {
	cc *grpc1.ClientConn
}

func NewMyTestClient(cc *grpc1.ClientConn) MyTestClient {
	return &myTestClient{cc}
}

func (c *myTestClient) UnaryCall(ctx context.Context, in *MyRequest, opts ...grpc1.CallOption) (*MyResponse, error) {
	out := new(MyResponse)
	err := grpc1.Invoke(ctx, "/grpc.MyTest/UnaryCall", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *myTestClient) Downstream(ctx context.Context, in *MyRequest, opts ...grpc1.CallOption) (MyTest_DownstreamClient, error) {
	stream, err := grpc1.NewClientStream(ctx, &_MyTest_serviceDesc.Streams[0], c.cc, "/grpc.MyTest/Downstream", opts...)
	if err != nil {
		return nil, err
	}
	x := &myTestDownstreamClient{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 MyTest_DownstreamClient interface {
	Recv() (*MyMsg, error)
	grpc1.ClientStream
}

type myTestDownstreamClient struct {
	grpc1.ClientStream
}

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

func (c *myTestClient) Upstream(ctx context.Context, opts ...grpc1.CallOption) (MyTest_UpstreamClient, error) {
	stream, err := grpc1.NewClientStream(ctx, &_MyTest_serviceDesc.Streams[1], c.cc, "/grpc.MyTest/Upstream", opts...)
	if err != nil {
		return nil, err
	}
	x := &myTestUpstreamClient{stream}
	return x, nil
}

type MyTest_UpstreamClient interface {
	Send(*MyMsg) error
	CloseAndRecv() (*MyResponse, error)
	grpc1.ClientStream
}

type myTestUpstreamClient struct {
	grpc1.ClientStream
}

func (x *myTestUpstreamClient) Send(m *MyMsg) error {
	return x.ClientStream.SendMsg(m)
}

func (x *myTestUpstreamClient) CloseAndRecv() (*MyResponse, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(MyResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *myTestClient) Bidi(ctx context.Context, opts ...grpc1.CallOption) (MyTest_BidiClient, error) {
	stream, err := grpc1.NewClientStream(ctx, &_MyTest_serviceDesc.Streams[2], c.cc, "/grpc.MyTest/Bidi", opts...)
	if err != nil {
		return nil, err
	}
	x := &myTestBidiClient{stream}
	return x, nil
}

type MyTest_BidiClient interface {
	Send(*MyMsg) error
	Recv() (*MyMsg2, error)
	grpc1.ClientStream
}

type myTestBidiClient struct {
	grpc1.ClientStream
}

func (x *myTestBidiClient) Send(m *MyMsg) error {
	return x.ClientStream.SendMsg(m)
}

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

// Server API for MyTest service

type MyTestServer interface {
	UnaryCall(context.Context, *MyRequest) (*MyResponse, error)
	// This RPC streams from the server only.
	Downstream(*MyRequest, MyTest_DownstreamServer) error
	// This RPC streams from the client.
	Upstream(MyTest_UpstreamServer) error
	// This one streams in both directions.
	Bidi(MyTest_BidiServer) error
}

func RegisterMyTestServer(s *grpc1.Server, srv MyTestServer) {
	s.RegisterService(&_MyTest_serviceDesc, srv)
}

func _MyTest_UnaryCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc1.UnaryServerInterceptor) (interface{}, error) {
	in := new(MyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MyTestServer).UnaryCall(ctx, in)
	}
	info := &grpc1.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/grpc.MyTest/UnaryCall",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MyTestServer).UnaryCall(ctx, req.(*MyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MyTest_Downstream_Handler(srv interface{}, stream grpc1.ServerStream) error {
	m := new(MyRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(MyTestServer).Downstream(m, &myTestDownstreamServer{stream})
}

type MyTest_DownstreamServer interface {
	Send(*MyMsg) error
	grpc1.ServerStream
}

type myTestDownstreamServer struct {
	grpc1.ServerStream
}

func (x *myTestDownstreamServer) Send(m *MyMsg) error {
	return x.ServerStream.SendMsg(m)
}

func _MyTest_Upstream_Handler(srv interface{}, stream grpc1.ServerStream) error {
	return srv.(MyTestServer).Upstream(&myTestUpstreamServer{stream})
}

type MyTest_UpstreamServer interface {
	SendAndClose(*MyResponse) error
	Recv() (*MyMsg, error)
	grpc1.ServerStream
}

type myTestUpstreamServer struct {
	grpc1.ServerStream
}

func (x *myTestUpstreamServer) SendAndClose(m *MyResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *myTestUpstreamServer) Recv() (*MyMsg, error) {
	m := new(MyMsg)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _MyTest_Bidi_Handler(srv interface{}, stream grpc1.ServerStream) error {
	return srv.(MyTestServer).Bidi(&myTestBidiServer{stream})
}

type MyTest_BidiServer interface {
	Send(*MyMsg2) error
	Recv() (*MyMsg, error)
	grpc1.ServerStream
}

type myTestBidiServer struct {
	grpc1.ServerStream
}

func (x *myTestBidiServer) Send(m *MyMsg2) error {
	return x.ServerStream.SendMsg(m)
}

func (x *myTestBidiServer) Recv() (*MyMsg, error) {
	m := new(MyMsg)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _MyTest_serviceDesc = grpc1.ServiceDesc{
	ServiceName: "grpc.MyTest",
	HandlerType: (*MyTestServer)(nil),
	Methods: []grpc1.MethodDesc{
		{
			MethodName: "UnaryCall",
			Handler:    _MyTest_UnaryCall_Handler,
		},
	},
	Streams: []grpc1.StreamDesc{
		{
			StreamName:    "Downstream",
			Handler:       _MyTest_Downstream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Upstream",
			Handler:       _MyTest_Upstream_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "Bidi",
			Handler:       _MyTest_Bidi_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: fileDescriptorGrpc,
}

// Client API for MyBench service

type MyBenchClient interface {
	Down(ctx context.Context, in *MyRequest, opts ...grpc1.CallOption) (MyBench_DownClient, error)
}

type myBenchClient struct {
	cc *grpc1.ClientConn
}

func NewMyBenchClient(cc *grpc1.ClientConn) MyBenchClient {
	return &myBenchClient{cc}
}

func (c *myBenchClient) Down(ctx context.Context, in *MyRequest, opts ...grpc1.CallOption) (MyBench_DownClient, error) {
	stream, err := grpc1.NewClientStream(ctx, &_MyBench_serviceDesc.Streams[0], c.cc, "/grpc.MyBench/Down", opts...)
	if err != nil {
		return nil, err
	}
	x := &myBenchDownClient{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 MyBench_DownClient interface {
	Recv() (*test.NinOptStruct, error)
	grpc1.ClientStream
}

type myBenchDownClient struct {
	grpc1.ClientStream
}

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

// Server API for MyBench service

type MyBenchServer interface {
	Down(*MyRequest, MyBench_DownServer) error
}

func RegisterMyBenchServer(s *grpc1.Server, srv MyBenchServer) {
	s.RegisterService(&_MyBench_serviceDesc, srv)
}

func _MyBench_Down_Handler(srv interface{}, stream grpc1.ServerStream) error {
	m := new(MyRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(MyBenchServer).Down(m, &myBenchDownServer{stream})
}

type MyBench_DownServer interface {
	Send(*test.NinOptStruct) error
	grpc1.ServerStream
}

type myBenchDownServer struct {
	grpc1.ServerStream
}

func (x *myBenchDownServer) Send(m *test.NinOptStruct) error {
	return x.ServerStream.SendMsg(m)
}

var _MyBench_serviceDesc = grpc1.ServiceDesc{
	ServiceName: "grpc.MyBench",
	HandlerType: (*MyBenchServer)(nil),
	Methods:     []grpc1.MethodDesc{},
	Streams: []grpc1.StreamDesc{
		{
			StreamName:    "Down",
			Handler:       _MyBench_Down_Handler,
			ServerStreams: true,
		},
	},
	Metadata: fileDescriptorGrpc,
}

func init() { proto.RegisterFile("grpc.proto", fileDescriptorGrpc) }

var fileDescriptorGrpc = []byte{
	// 267 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x74, 0x91, 0x41, 0x4b, 0xc3, 0x30,
	0x14, 0xc7, 0x09, 0xb6, 0xd3, 0x3d, 0x05, 0x25, 0x78, 0x90, 0x81, 0xa2, 0x05, 0xa1, 0x30, 0x6d,
	0x4b, 0xbd, 0x78, 0x9e, 0x5e, 0xab, 0x30, 0x9d, 0xf7, 0xb6, 0xc6, 0xb4, 0xd0, 0x25, 0x31, 0x79,
	0x51, 0xfa, 0xd5, 0xfc, 0x74, 0x92, 0x38, 0x75, 0x52, 0x77, 0x4a, 0xde, 0xfb, 0xff, 0x5e, 0xf8,
	0x25, 0x01, 0xe0, 0x5a, 0xd5, 0x89, 0xd2, 0x12, 0x25, 0x0d, 0xdc, 0x7e, 0x32, 0xe5, 0x2d, 0x36,
	0xb6, 0x4a, 0x6a, 0xb9, 0x4c, 0xb9, 0xe4, 0x32, 0xf5, 0x61, 0x65, 0x5f, 0x52, 0x64, 0x06, 0x53,
	0x6c, 0x98, 0x5b, 0xbf, 0x46, 0xa2, 0x33, 0x18, 0x17, 0xfd, 0x9c, 0xbd, 0x5a, 0x66, 0x90, 0x1e,
	0x42, 0xf8, 0x54, 0x76, 0x96, 0x1d, 0x91, 0x53, 0x12, 0x6f, 0xcd, 0xc3, 0x37, 0x57, 0x44, 0x11,
	0x80, 0x43, 0x8c, 0x92, 0xc2, 0xb0, 0x0d, 0xcc, 0x31, 0x84, 0x45, 0x5f, 0x18, 0xbe, 0x21, 0x3e,
	0x81, 0x91, 0x8f, 0xf3, 0xff, 0xf3, 0xfc, 0x83, 0x38, 0xe0, 0xd1, 0x39, 0x24, 0x30, 0x5e, 0x88,
	0x52, 0xf7, 0x37, 0x65, 0xd7, 0xd1, 0xfd, 0xc4, 0xdf, 0xee, 0xc7, 0x70, 0x72, 0xf0, 0xdb, 0x58,
	0xf9, 0x5c, 0x00, 0xdc, 0xca, 0x77, 0x61, 0x50, 0xb3, 0x72, 0x39, 0x1c, 0xd8, 0xfd, 0x6e, 0x14,
	0x86, 0x67, 0x84, 0x4e, 0x61, 0x67, 0xa1, 0x56, 0xec, 0x7a, 0x34, 0x3c, 0x38, 0x26, 0xf4, 0x1c,
	0x82, 0x59, 0xfb, 0xdc, 0xfe, 0x05, 0xf7, 0xd6, 0x8a, 0x3c, 0x26, 0x19, 0xc9, 0xaf, 0x61, 0xbb,
	0xe8, 0x67, 0x4c, 0xd4, 0x0d, 0xbd, 0x84, 0xc0, 0xc9, 0x0c, 0x35, 0x68, 0xe2, 0xdf, 0xfc, 0xae,
	0x15, 0xf7, 0x0a, 0x1f, 0x50, 0xdb, 0x1a, 0x33, 0x52, 0x8d, 0xfc, 0x1f, 0x5c, 0x7d, 0x06, 0x00,
	0x00, 0xff, 0xff, 0x66, 0x80, 0x21, 0x1c, 0xc4, 0x01, 0x00, 0x00,
}