1// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
2
3package routeguide
4
5import (
6	context "context"
7	grpc "google.golang.org/grpc"
8	codes "google.golang.org/grpc/codes"
9	status "google.golang.org/grpc/status"
10)
11
12// This is a compile-time assertion to ensure that this generated file
13// is compatible with the grpc package it is being compiled against.
14const _ = grpc.SupportPackageIsVersion7
15
16// RouteGuideClient is the client API for RouteGuide service.
17//
18// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
19type RouteGuideClient interface {
20	// A simple RPC.
21	//
22	// Obtains the feature at a given position.
23	//
24	// A feature with an empty name is returned if there's no feature at the given
25	// position.
26	GetFeature(ctx context.Context, in *Point, opts ...grpc.CallOption) (*Feature, error)
27	// A server-to-client streaming RPC.
28	//
29	// Obtains the Features available within the given Rectangle.  Results are
30	// streamed rather than returned at once (e.g. in a response message with a
31	// repeated field), as the rectangle may cover a large area and contain a
32	// huge number of features.
33	ListFeatures(ctx context.Context, in *Rectangle, opts ...grpc.CallOption) (RouteGuide_ListFeaturesClient, error)
34	// A client-to-server streaming RPC.
35	//
36	// Accepts a stream of Points on a route being traversed, returning a
37	// RouteSummary when traversal is completed.
38	RecordRoute(ctx context.Context, opts ...grpc.CallOption) (RouteGuide_RecordRouteClient, error)
39	// A Bidirectional streaming RPC.
40	//
41	// Accepts a stream of RouteNotes sent while a route is being traversed,
42	// while receiving other RouteNotes (e.g. from other users).
43	RouteChat(ctx context.Context, opts ...grpc.CallOption) (RouteGuide_RouteChatClient, error)
44}
45
46type routeGuideClient struct {
47	cc grpc.ClientConnInterface
48}
49
50func NewRouteGuideClient(cc grpc.ClientConnInterface) RouteGuideClient {
51	return &routeGuideClient{cc}
52}
53
54func (c *routeGuideClient) GetFeature(ctx context.Context, in *Point, opts ...grpc.CallOption) (*Feature, error) {
55	out := new(Feature)
56	err := c.cc.Invoke(ctx, "/routeguide.RouteGuide/GetFeature", in, out, opts...)
57	if err != nil {
58		return nil, err
59	}
60	return out, nil
61}
62
63func (c *routeGuideClient) ListFeatures(ctx context.Context, in *Rectangle, opts ...grpc.CallOption) (RouteGuide_ListFeaturesClient, error) {
64	stream, err := c.cc.NewStream(ctx, &_RouteGuide_serviceDesc.Streams[0], "/routeguide.RouteGuide/ListFeatures", opts...)
65	if err != nil {
66		return nil, err
67	}
68	x := &routeGuideListFeaturesClient{stream}
69	if err := x.ClientStream.SendMsg(in); err != nil {
70		return nil, err
71	}
72	if err := x.ClientStream.CloseSend(); err != nil {
73		return nil, err
74	}
75	return x, nil
76}
77
78type RouteGuide_ListFeaturesClient interface {
79	Recv() (*Feature, error)
80	grpc.ClientStream
81}
82
83type routeGuideListFeaturesClient struct {
84	grpc.ClientStream
85}
86
87func (x *routeGuideListFeaturesClient) Recv() (*Feature, error) {
88	m := new(Feature)
89	if err := x.ClientStream.RecvMsg(m); err != nil {
90		return nil, err
91	}
92	return m, nil
93}
94
95func (c *routeGuideClient) RecordRoute(ctx context.Context, opts ...grpc.CallOption) (RouteGuide_RecordRouteClient, error) {
96	stream, err := c.cc.NewStream(ctx, &_RouteGuide_serviceDesc.Streams[1], "/routeguide.RouteGuide/RecordRoute", opts...)
97	if err != nil {
98		return nil, err
99	}
100	x := &routeGuideRecordRouteClient{stream}
101	return x, nil
102}
103
104type RouteGuide_RecordRouteClient interface {
105	Send(*Point) error
106	CloseAndRecv() (*RouteSummary, error)
107	grpc.ClientStream
108}
109
110type routeGuideRecordRouteClient struct {
111	grpc.ClientStream
112}
113
114func (x *routeGuideRecordRouteClient) Send(m *Point) error {
115	return x.ClientStream.SendMsg(m)
116}
117
118func (x *routeGuideRecordRouteClient) CloseAndRecv() (*RouteSummary, error) {
119	if err := x.ClientStream.CloseSend(); err != nil {
120		return nil, err
121	}
122	m := new(RouteSummary)
123	if err := x.ClientStream.RecvMsg(m); err != nil {
124		return nil, err
125	}
126	return m, nil
127}
128
129func (c *routeGuideClient) RouteChat(ctx context.Context, opts ...grpc.CallOption) (RouteGuide_RouteChatClient, error) {
130	stream, err := c.cc.NewStream(ctx, &_RouteGuide_serviceDesc.Streams[2], "/routeguide.RouteGuide/RouteChat", opts...)
131	if err != nil {
132		return nil, err
133	}
134	x := &routeGuideRouteChatClient{stream}
135	return x, nil
136}
137
138type RouteGuide_RouteChatClient interface {
139	Send(*RouteNote) error
140	Recv() (*RouteNote, error)
141	grpc.ClientStream
142}
143
144type routeGuideRouteChatClient struct {
145	grpc.ClientStream
146}
147
148func (x *routeGuideRouteChatClient) Send(m *RouteNote) error {
149	return x.ClientStream.SendMsg(m)
150}
151
152func (x *routeGuideRouteChatClient) Recv() (*RouteNote, error) {
153	m := new(RouteNote)
154	if err := x.ClientStream.RecvMsg(m); err != nil {
155		return nil, err
156	}
157	return m, nil
158}
159
160// RouteGuideServer is the server API for RouteGuide service.
161// All implementations must embed UnimplementedRouteGuideServer
162// for forward compatibility
163type RouteGuideServer interface {
164	// A simple RPC.
165	//
166	// Obtains the feature at a given position.
167	//
168	// A feature with an empty name is returned if there's no feature at the given
169	// position.
170	GetFeature(context.Context, *Point) (*Feature, error)
171	// A server-to-client streaming RPC.
172	//
173	// Obtains the Features available within the given Rectangle.  Results are
174	// streamed rather than returned at once (e.g. in a response message with a
175	// repeated field), as the rectangle may cover a large area and contain a
176	// huge number of features.
177	ListFeatures(*Rectangle, RouteGuide_ListFeaturesServer) error
178	// A client-to-server streaming RPC.
179	//
180	// Accepts a stream of Points on a route being traversed, returning a
181	// RouteSummary when traversal is completed.
182	RecordRoute(RouteGuide_RecordRouteServer) error
183	// A Bidirectional streaming RPC.
184	//
185	// Accepts a stream of RouteNotes sent while a route is being traversed,
186	// while receiving other RouteNotes (e.g. from other users).
187	RouteChat(RouteGuide_RouteChatServer) error
188	mustEmbedUnimplementedRouteGuideServer()
189}
190
191// UnimplementedRouteGuideServer must be embedded to have forward compatible implementations.
192type UnimplementedRouteGuideServer struct {
193}
194
195func (UnimplementedRouteGuideServer) GetFeature(context.Context, *Point) (*Feature, error) {
196	return nil, status.Errorf(codes.Unimplemented, "method GetFeature not implemented")
197}
198func (UnimplementedRouteGuideServer) ListFeatures(*Rectangle, RouteGuide_ListFeaturesServer) error {
199	return status.Errorf(codes.Unimplemented, "method ListFeatures not implemented")
200}
201func (UnimplementedRouteGuideServer) RecordRoute(RouteGuide_RecordRouteServer) error {
202	return status.Errorf(codes.Unimplemented, "method RecordRoute not implemented")
203}
204func (UnimplementedRouteGuideServer) RouteChat(RouteGuide_RouteChatServer) error {
205	return status.Errorf(codes.Unimplemented, "method RouteChat not implemented")
206}
207func (UnimplementedRouteGuideServer) mustEmbedUnimplementedRouteGuideServer() {}
208
209// UnsafeRouteGuideServer may be embedded to opt out of forward compatibility for this service.
210// Use of this interface is not recommended, as added methods to RouteGuideServer will
211// result in compilation errors.
212type UnsafeRouteGuideServer interface {
213	mustEmbedUnimplementedRouteGuideServer()
214}
215
216func RegisterRouteGuideServer(s grpc.ServiceRegistrar, srv RouteGuideServer) {
217	s.RegisterService(&_RouteGuide_serviceDesc, srv)
218}
219
220func _RouteGuide_GetFeature_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
221	in := new(Point)
222	if err := dec(in); err != nil {
223		return nil, err
224	}
225	if interceptor == nil {
226		return srv.(RouteGuideServer).GetFeature(ctx, in)
227	}
228	info := &grpc.UnaryServerInfo{
229		Server:     srv,
230		FullMethod: "/routeguide.RouteGuide/GetFeature",
231	}
232	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
233		return srv.(RouteGuideServer).GetFeature(ctx, req.(*Point))
234	}
235	return interceptor(ctx, in, info, handler)
236}
237
238func _RouteGuide_ListFeatures_Handler(srv interface{}, stream grpc.ServerStream) error {
239	m := new(Rectangle)
240	if err := stream.RecvMsg(m); err != nil {
241		return err
242	}
243	return srv.(RouteGuideServer).ListFeatures(m, &routeGuideListFeaturesServer{stream})
244}
245
246type RouteGuide_ListFeaturesServer interface {
247	Send(*Feature) error
248	grpc.ServerStream
249}
250
251type routeGuideListFeaturesServer struct {
252	grpc.ServerStream
253}
254
255func (x *routeGuideListFeaturesServer) Send(m *Feature) error {
256	return x.ServerStream.SendMsg(m)
257}
258
259func _RouteGuide_RecordRoute_Handler(srv interface{}, stream grpc.ServerStream) error {
260	return srv.(RouteGuideServer).RecordRoute(&routeGuideRecordRouteServer{stream})
261}
262
263type RouteGuide_RecordRouteServer interface {
264	SendAndClose(*RouteSummary) error
265	Recv() (*Point, error)
266	grpc.ServerStream
267}
268
269type routeGuideRecordRouteServer struct {
270	grpc.ServerStream
271}
272
273func (x *routeGuideRecordRouteServer) SendAndClose(m *RouteSummary) error {
274	return x.ServerStream.SendMsg(m)
275}
276
277func (x *routeGuideRecordRouteServer) Recv() (*Point, error) {
278	m := new(Point)
279	if err := x.ServerStream.RecvMsg(m); err != nil {
280		return nil, err
281	}
282	return m, nil
283}
284
285func _RouteGuide_RouteChat_Handler(srv interface{}, stream grpc.ServerStream) error {
286	return srv.(RouteGuideServer).RouteChat(&routeGuideRouteChatServer{stream})
287}
288
289type RouteGuide_RouteChatServer interface {
290	Send(*RouteNote) error
291	Recv() (*RouteNote, error)
292	grpc.ServerStream
293}
294
295type routeGuideRouteChatServer struct {
296	grpc.ServerStream
297}
298
299func (x *routeGuideRouteChatServer) Send(m *RouteNote) error {
300	return x.ServerStream.SendMsg(m)
301}
302
303func (x *routeGuideRouteChatServer) Recv() (*RouteNote, error) {
304	m := new(RouteNote)
305	if err := x.ServerStream.RecvMsg(m); err != nil {
306		return nil, err
307	}
308	return m, nil
309}
310
311var _RouteGuide_serviceDesc = grpc.ServiceDesc{
312	ServiceName: "routeguide.RouteGuide",
313	HandlerType: (*RouteGuideServer)(nil),
314	Methods: []grpc.MethodDesc{
315		{
316			MethodName: "GetFeature",
317			Handler:    _RouteGuide_GetFeature_Handler,
318		},
319	},
320	Streams: []grpc.StreamDesc{
321		{
322			StreamName:    "ListFeatures",
323			Handler:       _RouteGuide_ListFeatures_Handler,
324			ServerStreams: true,
325		},
326		{
327			StreamName:    "RecordRoute",
328			Handler:       _RouteGuide_RecordRoute_Handler,
329			ClientStreams: true,
330		},
331		{
332			StreamName:    "RouteChat",
333			Handler:       _RouteGuide_RouteChat_Handler,
334			ServerStreams: true,
335			ClientStreams: true,
336		},
337	},
338	Metadata: "examples/route_guide/routeguide/route_guide.proto",
339}
340