1// Code generated by protoc-gen-go. DO NOT EDIT.
2// source: grpc_testing/test.proto
3
4package grpc_testing
5
6import (
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.
17var _ = proto.Marshal
18var _ = fmt.Errorf
19var _ = 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.
25const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
26
27type SimpleRequest struct {
28	Id                   int32    `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
29	XXX_NoUnkeyedLiteral struct{} `json:"-"`
30	XXX_unrecognized     []byte   `json:"-"`
31	XXX_sizecache        int32    `json:"-"`
32}
33
34func (m *SimpleRequest) Reset()         { *m = SimpleRequest{} }
35func (m *SimpleRequest) String() string { return proto.CompactTextString(m) }
36func (*SimpleRequest) ProtoMessage()    {}
37func (*SimpleRequest) Descriptor() ([]byte, []int) {
38	return fileDescriptor_e1cda82041fed8bf, []int{0}
39}
40
41func (m *SimpleRequest) XXX_Unmarshal(b []byte) error {
42	return xxx_messageInfo_SimpleRequest.Unmarshal(m, b)
43}
44func (m *SimpleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
45	return xxx_messageInfo_SimpleRequest.Marshal(b, m, deterministic)
46}
47func (m *SimpleRequest) XXX_Merge(src proto.Message) {
48	xxx_messageInfo_SimpleRequest.Merge(m, src)
49}
50func (m *SimpleRequest) XXX_Size() int {
51	return xxx_messageInfo_SimpleRequest.Size(m)
52}
53func (m *SimpleRequest) XXX_DiscardUnknown() {
54	xxx_messageInfo_SimpleRequest.DiscardUnknown(m)
55}
56
57var xxx_messageInfo_SimpleRequest proto.InternalMessageInfo
58
59func (m *SimpleRequest) GetId() int32 {
60	if m != nil {
61		return m.Id
62	}
63	return 0
64}
65
66type SimpleResponse struct {
67	Id                   int32    `protobuf:"varint,3,opt,name=id,proto3" json:"id,omitempty"`
68	XXX_NoUnkeyedLiteral struct{} `json:"-"`
69	XXX_unrecognized     []byte   `json:"-"`
70	XXX_sizecache        int32    `json:"-"`
71}
72
73func (m *SimpleResponse) Reset()         { *m = SimpleResponse{} }
74func (m *SimpleResponse) String() string { return proto.CompactTextString(m) }
75func (*SimpleResponse) ProtoMessage()    {}
76func (*SimpleResponse) Descriptor() ([]byte, []int) {
77	return fileDescriptor_e1cda82041fed8bf, []int{1}
78}
79
80func (m *SimpleResponse) XXX_Unmarshal(b []byte) error {
81	return xxx_messageInfo_SimpleResponse.Unmarshal(m, b)
82}
83func (m *SimpleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
84	return xxx_messageInfo_SimpleResponse.Marshal(b, m, deterministic)
85}
86func (m *SimpleResponse) XXX_Merge(src proto.Message) {
87	xxx_messageInfo_SimpleResponse.Merge(m, src)
88}
89func (m *SimpleResponse) XXX_Size() int {
90	return xxx_messageInfo_SimpleResponse.Size(m)
91}
92func (m *SimpleResponse) XXX_DiscardUnknown() {
93	xxx_messageInfo_SimpleResponse.DiscardUnknown(m)
94}
95
96var xxx_messageInfo_SimpleResponse proto.InternalMessageInfo
97
98func (m *SimpleResponse) GetId() int32 {
99	if m != nil {
100		return m.Id
101	}
102	return 0
103}
104
105func init() {
106	proto.RegisterType((*SimpleRequest)(nil), "grpc.testing.SimpleRequest")
107	proto.RegisterType((*SimpleResponse)(nil), "grpc.testing.SimpleResponse")
108}
109
110func init() { proto.RegisterFile("grpc_testing/test.proto", fileDescriptor_e1cda82041fed8bf) }
111
112var fileDescriptor_e1cda82041fed8bf = []byte{
113	// 202 bytes of a gzipped FileDescriptorProto
114	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x4f, 0x2f, 0x2a, 0x48,
115	0x8e, 0x2f, 0x49, 0x2d, 0x2e, 0xc9, 0xcc, 0x4b, 0xd7, 0x07, 0xd1, 0x7a, 0x05, 0x45, 0xf9, 0x25,
116	0xf9, 0x42, 0x3c, 0x20, 0x09, 0x3d, 0xa8, 0x84, 0x92, 0x3c, 0x17, 0x6f, 0x70, 0x66, 0x6e, 0x41,
117	0x4e, 0x6a, 0x50, 0x6a, 0x61, 0x69, 0x6a, 0x71, 0x89, 0x10, 0x1f, 0x17, 0x53, 0x66, 0x8a, 0x04,
118	0x93, 0x02, 0xa3, 0x06, 0x6b, 0x10, 0x53, 0x66, 0x8a, 0x92, 0x02, 0x17, 0x1f, 0x4c, 0x41, 0x71,
119	0x41, 0x7e, 0x5e, 0x71, 0x2a, 0x54, 0x05, 0x33, 0x4c, 0x85, 0xd1, 0x09, 0x26, 0x2e, 0xee, 0x90,
120	0xd4, 0xe2, 0x92, 0xe0, 0xd4, 0xa2, 0xb2, 0xcc, 0xe4, 0x54, 0x21, 0x37, 0x2e, 0xce, 0xd0, 0xbc,
121	0xc4, 0xa2, 0x4a, 0xe7, 0xc4, 0x9c, 0x1c, 0x21, 0x69, 0x3d, 0x64, 0xeb, 0xf4, 0x50, 0xec, 0x92,
122	0x92, 0xc1, 0x2e, 0x09, 0xb5, 0xc7, 0x9f, 0x8b, 0xcf, 0xad, 0x34, 0x27, 0xc7, 0xa5, 0xb4, 0x20,
123	0x27, 0xb5, 0x82, 0x42, 0xc3, 0x34, 0x18, 0x0d, 0x18, 0x85, 0xfc, 0xb9, 0x04, 0x9c, 0x73, 0x32,
124	0x53, 0xf3, 0x4a, 0x82, 0x4b, 0x8a, 0x52, 0x13, 0x73, 0x29, 0x36, 0x12, 0x64, 0x20, 0xc8, 0xd3,
125	0xa9, 0x45, 0x54, 0x31, 0xd0, 0x80, 0x31, 0x89, 0x0d, 0x1c, 0x45, 0xc6, 0x80, 0x00, 0x00, 0x00,
126	0xff, 0xff, 0x4c, 0x43, 0x27, 0x67, 0xbd, 0x01, 0x00, 0x00,
127}
128
129// Reference imports to suppress errors if they are not otherwise used.
130var _ context.Context
131var _ grpc.ClientConnInterface
132
133// This is a compile-time assertion to ensure that this generated file
134// is compatible with the grpc package it is being compiled against.
135const _ = grpc.SupportPackageIsVersion6
136
137// TestServiceClient is the client API for TestService service.
138//
139// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
140type TestServiceClient interface {
141	// One request followed by one response.
142	// The server returns the client id as-is.
143	UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error)
144	// A sequence of requests with each request served by the server immediately.
145	// As one request could lead to multiple responses, this interface
146	// demonstrates the idea of full duplexing.
147	FullDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_FullDuplexCallClient, error)
148	// Client stream
149	ClientStreamCall(ctx context.Context, opts ...grpc.CallOption) (TestService_ClientStreamCallClient, error)
150	// Server stream
151	ServerStreamCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (TestService_ServerStreamCallClient, error)
152}
153
154type testServiceClient struct {
155	cc grpc.ClientConnInterface
156}
157
158func NewTestServiceClient(cc grpc.ClientConnInterface) TestServiceClient {
159	return &testServiceClient{cc}
160}
161
162func (c *testServiceClient) UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) {
163	out := new(SimpleResponse)
164	err := c.cc.Invoke(ctx, "/grpc.testing.TestService/UnaryCall", in, out, opts...)
165	if err != nil {
166		return nil, err
167	}
168	return out, nil
169}
170
171func (c *testServiceClient) FullDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_FullDuplexCallClient, error) {
172	stream, err := c.cc.NewStream(ctx, &_TestService_serviceDesc.Streams[0], "/grpc.testing.TestService/FullDuplexCall", opts...)
173	if err != nil {
174		return nil, err
175	}
176	x := &testServiceFullDuplexCallClient{stream}
177	return x, nil
178}
179
180type TestService_FullDuplexCallClient interface {
181	Send(*SimpleRequest) error
182	Recv() (*SimpleResponse, error)
183	grpc.ClientStream
184}
185
186type testServiceFullDuplexCallClient struct {
187	grpc.ClientStream
188}
189
190func (x *testServiceFullDuplexCallClient) Send(m *SimpleRequest) error {
191	return x.ClientStream.SendMsg(m)
192}
193
194func (x *testServiceFullDuplexCallClient) Recv() (*SimpleResponse, error) {
195	m := new(SimpleResponse)
196	if err := x.ClientStream.RecvMsg(m); err != nil {
197		return nil, err
198	}
199	return m, nil
200}
201
202func (c *testServiceClient) ClientStreamCall(ctx context.Context, opts ...grpc.CallOption) (TestService_ClientStreamCallClient, error) {
203	stream, err := c.cc.NewStream(ctx, &_TestService_serviceDesc.Streams[1], "/grpc.testing.TestService/ClientStreamCall", opts...)
204	if err != nil {
205		return nil, err
206	}
207	x := &testServiceClientStreamCallClient{stream}
208	return x, nil
209}
210
211type TestService_ClientStreamCallClient interface {
212	Send(*SimpleRequest) error
213	CloseAndRecv() (*SimpleResponse, error)
214	grpc.ClientStream
215}
216
217type testServiceClientStreamCallClient struct {
218	grpc.ClientStream
219}
220
221func (x *testServiceClientStreamCallClient) Send(m *SimpleRequest) error {
222	return x.ClientStream.SendMsg(m)
223}
224
225func (x *testServiceClientStreamCallClient) CloseAndRecv() (*SimpleResponse, error) {
226	if err := x.ClientStream.CloseSend(); err != nil {
227		return nil, err
228	}
229	m := new(SimpleResponse)
230	if err := x.ClientStream.RecvMsg(m); err != nil {
231		return nil, err
232	}
233	return m, nil
234}
235
236func (c *testServiceClient) ServerStreamCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (TestService_ServerStreamCallClient, error) {
237	stream, err := c.cc.NewStream(ctx, &_TestService_serviceDesc.Streams[2], "/grpc.testing.TestService/ServerStreamCall", opts...)
238	if err != nil {
239		return nil, err
240	}
241	x := &testServiceServerStreamCallClient{stream}
242	if err := x.ClientStream.SendMsg(in); err != nil {
243		return nil, err
244	}
245	if err := x.ClientStream.CloseSend(); err != nil {
246		return nil, err
247	}
248	return x, nil
249}
250
251type TestService_ServerStreamCallClient interface {
252	Recv() (*SimpleResponse, error)
253	grpc.ClientStream
254}
255
256type testServiceServerStreamCallClient struct {
257	grpc.ClientStream
258}
259
260func (x *testServiceServerStreamCallClient) Recv() (*SimpleResponse, error) {
261	m := new(SimpleResponse)
262	if err := x.ClientStream.RecvMsg(m); err != nil {
263		return nil, err
264	}
265	return m, nil
266}
267
268// TestServiceServer is the server API for TestService service.
269type TestServiceServer interface {
270	// One request followed by one response.
271	// The server returns the client id as-is.
272	UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error)
273	// A sequence of requests with each request served by the server immediately.
274	// As one request could lead to multiple responses, this interface
275	// demonstrates the idea of full duplexing.
276	FullDuplexCall(TestService_FullDuplexCallServer) error
277	// Client stream
278	ClientStreamCall(TestService_ClientStreamCallServer) error
279	// Server stream
280	ServerStreamCall(*SimpleRequest, TestService_ServerStreamCallServer) error
281}
282
283// UnimplementedTestServiceServer can be embedded to have forward compatible implementations.
284type UnimplementedTestServiceServer struct {
285}
286
287func (*UnimplementedTestServiceServer) UnaryCall(ctx context.Context, req *SimpleRequest) (*SimpleResponse, error) {
288	return nil, status.Errorf(codes.Unimplemented, "method UnaryCall not implemented")
289}
290func (*UnimplementedTestServiceServer) FullDuplexCall(srv TestService_FullDuplexCallServer) error {
291	return status.Errorf(codes.Unimplemented, "method FullDuplexCall not implemented")
292}
293func (*UnimplementedTestServiceServer) ClientStreamCall(srv TestService_ClientStreamCallServer) error {
294	return status.Errorf(codes.Unimplemented, "method ClientStreamCall not implemented")
295}
296func (*UnimplementedTestServiceServer) ServerStreamCall(req *SimpleRequest, srv TestService_ServerStreamCallServer) error {
297	return status.Errorf(codes.Unimplemented, "method ServerStreamCall not implemented")
298}
299
300func RegisterTestServiceServer(s *grpc.Server, srv TestServiceServer) {
301	s.RegisterService(&_TestService_serviceDesc, srv)
302}
303
304func _TestService_UnaryCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
305	in := new(SimpleRequest)
306	if err := dec(in); err != nil {
307		return nil, err
308	}
309	if interceptor == nil {
310		return srv.(TestServiceServer).UnaryCall(ctx, in)
311	}
312	info := &grpc.UnaryServerInfo{
313		Server:     srv,
314		FullMethod: "/grpc.testing.TestService/UnaryCall",
315	}
316	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
317		return srv.(TestServiceServer).UnaryCall(ctx, req.(*SimpleRequest))
318	}
319	return interceptor(ctx, in, info, handler)
320}
321
322func _TestService_FullDuplexCall_Handler(srv interface{}, stream grpc.ServerStream) error {
323	return srv.(TestServiceServer).FullDuplexCall(&testServiceFullDuplexCallServer{stream})
324}
325
326type TestService_FullDuplexCallServer interface {
327	Send(*SimpleResponse) error
328	Recv() (*SimpleRequest, error)
329	grpc.ServerStream
330}
331
332type testServiceFullDuplexCallServer struct {
333	grpc.ServerStream
334}
335
336func (x *testServiceFullDuplexCallServer) Send(m *SimpleResponse) error {
337	return x.ServerStream.SendMsg(m)
338}
339
340func (x *testServiceFullDuplexCallServer) Recv() (*SimpleRequest, error) {
341	m := new(SimpleRequest)
342	if err := x.ServerStream.RecvMsg(m); err != nil {
343		return nil, err
344	}
345	return m, nil
346}
347
348func _TestService_ClientStreamCall_Handler(srv interface{}, stream grpc.ServerStream) error {
349	return srv.(TestServiceServer).ClientStreamCall(&testServiceClientStreamCallServer{stream})
350}
351
352type TestService_ClientStreamCallServer interface {
353	SendAndClose(*SimpleResponse) error
354	Recv() (*SimpleRequest, error)
355	grpc.ServerStream
356}
357
358type testServiceClientStreamCallServer struct {
359	grpc.ServerStream
360}
361
362func (x *testServiceClientStreamCallServer) SendAndClose(m *SimpleResponse) error {
363	return x.ServerStream.SendMsg(m)
364}
365
366func (x *testServiceClientStreamCallServer) Recv() (*SimpleRequest, error) {
367	m := new(SimpleRequest)
368	if err := x.ServerStream.RecvMsg(m); err != nil {
369		return nil, err
370	}
371	return m, nil
372}
373
374func _TestService_ServerStreamCall_Handler(srv interface{}, stream grpc.ServerStream) error {
375	m := new(SimpleRequest)
376	if err := stream.RecvMsg(m); err != nil {
377		return err
378	}
379	return srv.(TestServiceServer).ServerStreamCall(m, &testServiceServerStreamCallServer{stream})
380}
381
382type TestService_ServerStreamCallServer interface {
383	Send(*SimpleResponse) error
384	grpc.ServerStream
385}
386
387type testServiceServerStreamCallServer struct {
388	grpc.ServerStream
389}
390
391func (x *testServiceServerStreamCallServer) Send(m *SimpleResponse) error {
392	return x.ServerStream.SendMsg(m)
393}
394
395var _TestService_serviceDesc = grpc.ServiceDesc{
396	ServiceName: "grpc.testing.TestService",
397	HandlerType: (*TestServiceServer)(nil),
398	Methods: []grpc.MethodDesc{
399		{
400			MethodName: "UnaryCall",
401			Handler:    _TestService_UnaryCall_Handler,
402		},
403	},
404	Streams: []grpc.StreamDesc{
405		{
406			StreamName:    "FullDuplexCall",
407			Handler:       _TestService_FullDuplexCall_Handler,
408			ServerStreams: true,
409			ClientStreams: true,
410		},
411		{
412			StreamName:    "ClientStreamCall",
413			Handler:       _TestService_ClientStreamCall_Handler,
414			ClientStreams: true,
415		},
416		{
417			StreamName:    "ServerStreamCall",
418			Handler:       _TestService_ServerStreamCall_Handler,
419			ServerStreams: true,
420		},
421	},
422	Metadata: "grpc_testing/test.proto",
423}
424