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 54var routeGuideGetFeatureStreamDesc = &grpc.StreamDesc{ 55 StreamName: "GetFeature", 56} 57 58func (c *routeGuideClient) GetFeature(ctx context.Context, in *Point, opts ...grpc.CallOption) (*Feature, error) { 59 out := new(Feature) 60 err := c.cc.Invoke(ctx, "/routeguide.RouteGuide/GetFeature", in, out, opts...) 61 if err != nil { 62 return nil, err 63 } 64 return out, nil 65} 66 67var routeGuideListFeaturesStreamDesc = &grpc.StreamDesc{ 68 StreamName: "ListFeatures", 69 ServerStreams: true, 70} 71 72func (c *routeGuideClient) ListFeatures(ctx context.Context, in *Rectangle, opts ...grpc.CallOption) (RouteGuide_ListFeaturesClient, error) { 73 stream, err := c.cc.NewStream(ctx, routeGuideListFeaturesStreamDesc, "/routeguide.RouteGuide/ListFeatures", opts...) 74 if err != nil { 75 return nil, err 76 } 77 x := &routeGuideListFeaturesClient{stream} 78 if err := x.ClientStream.SendMsg(in); err != nil { 79 return nil, err 80 } 81 if err := x.ClientStream.CloseSend(); err != nil { 82 return nil, err 83 } 84 return x, nil 85} 86 87type RouteGuide_ListFeaturesClient interface { 88 Recv() (*Feature, error) 89 grpc.ClientStream 90} 91 92type routeGuideListFeaturesClient struct { 93 grpc.ClientStream 94} 95 96func (x *routeGuideListFeaturesClient) Recv() (*Feature, error) { 97 m := new(Feature) 98 if err := x.ClientStream.RecvMsg(m); err != nil { 99 return nil, err 100 } 101 return m, nil 102} 103 104var routeGuideRecordRouteStreamDesc = &grpc.StreamDesc{ 105 StreamName: "RecordRoute", 106 ClientStreams: true, 107} 108 109func (c *routeGuideClient) RecordRoute(ctx context.Context, opts ...grpc.CallOption) (RouteGuide_RecordRouteClient, error) { 110 stream, err := c.cc.NewStream(ctx, routeGuideRecordRouteStreamDesc, "/routeguide.RouteGuide/RecordRoute", opts...) 111 if err != nil { 112 return nil, err 113 } 114 x := &routeGuideRecordRouteClient{stream} 115 return x, nil 116} 117 118type RouteGuide_RecordRouteClient interface { 119 Send(*Point) error 120 CloseAndRecv() (*RouteSummary, error) 121 grpc.ClientStream 122} 123 124type routeGuideRecordRouteClient struct { 125 grpc.ClientStream 126} 127 128func (x *routeGuideRecordRouteClient) Send(m *Point) error { 129 return x.ClientStream.SendMsg(m) 130} 131 132func (x *routeGuideRecordRouteClient) CloseAndRecv() (*RouteSummary, error) { 133 if err := x.ClientStream.CloseSend(); err != nil { 134 return nil, err 135 } 136 m := new(RouteSummary) 137 if err := x.ClientStream.RecvMsg(m); err != nil { 138 return nil, err 139 } 140 return m, nil 141} 142 143var routeGuideRouteChatStreamDesc = &grpc.StreamDesc{ 144 StreamName: "RouteChat", 145 ServerStreams: true, 146 ClientStreams: true, 147} 148 149func (c *routeGuideClient) RouteChat(ctx context.Context, opts ...grpc.CallOption) (RouteGuide_RouteChatClient, error) { 150 stream, err := c.cc.NewStream(ctx, routeGuideRouteChatStreamDesc, "/routeguide.RouteGuide/RouteChat", opts...) 151 if err != nil { 152 return nil, err 153 } 154 x := &routeGuideRouteChatClient{stream} 155 return x, nil 156} 157 158type RouteGuide_RouteChatClient interface { 159 Send(*RouteNote) error 160 Recv() (*RouteNote, error) 161 grpc.ClientStream 162} 163 164type routeGuideRouteChatClient struct { 165 grpc.ClientStream 166} 167 168func (x *routeGuideRouteChatClient) Send(m *RouteNote) error { 169 return x.ClientStream.SendMsg(m) 170} 171 172func (x *routeGuideRouteChatClient) Recv() (*RouteNote, error) { 173 m := new(RouteNote) 174 if err := x.ClientStream.RecvMsg(m); err != nil { 175 return nil, err 176 } 177 return m, nil 178} 179 180// RouteGuideService is the service API for RouteGuide service. 181// Fields should be assigned to their respective handler implementations only before 182// RegisterRouteGuideService is called. Any unassigned fields will result in the 183// handler for that method returning an Unimplemented error. 184type RouteGuideService struct { 185 // A simple RPC. 186 // 187 // Obtains the feature at a given position. 188 // 189 // A feature with an empty name is returned if there's no feature at the given 190 // position. 191 GetFeature func(context.Context, *Point) (*Feature, error) 192 // A server-to-client streaming RPC. 193 // 194 // Obtains the Features available within the given Rectangle. Results are 195 // streamed rather than returned at once (e.g. in a response message with a 196 // repeated field), as the rectangle may cover a large area and contain a 197 // huge number of features. 198 ListFeatures func(*Rectangle, RouteGuide_ListFeaturesServer) error 199 // A client-to-server streaming RPC. 200 // 201 // Accepts a stream of Points on a route being traversed, returning a 202 // RouteSummary when traversal is completed. 203 RecordRoute func(RouteGuide_RecordRouteServer) error 204 // A Bidirectional streaming RPC. 205 // 206 // Accepts a stream of RouteNotes sent while a route is being traversed, 207 // while receiving other RouteNotes (e.g. from other users). 208 RouteChat func(RouteGuide_RouteChatServer) error 209} 210 211func (s *RouteGuideService) getFeature(_ interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 212 if s.GetFeature == nil { 213 return nil, status.Errorf(codes.Unimplemented, "method GetFeature not implemented") 214 } 215 in := new(Point) 216 if err := dec(in); err != nil { 217 return nil, err 218 } 219 if interceptor == nil { 220 return s.GetFeature(ctx, in) 221 } 222 info := &grpc.UnaryServerInfo{ 223 Server: s, 224 FullMethod: "/routeguide.RouteGuide/GetFeature", 225 } 226 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 227 return s.GetFeature(ctx, req.(*Point)) 228 } 229 return interceptor(ctx, in, info, handler) 230} 231func (s *RouteGuideService) listFeatures(_ interface{}, stream grpc.ServerStream) error { 232 if s.ListFeatures == nil { 233 return status.Errorf(codes.Unimplemented, "method ListFeatures not implemented") 234 } 235 m := new(Rectangle) 236 if err := stream.RecvMsg(m); err != nil { 237 return err 238 } 239 return s.ListFeatures(m, &routeGuideListFeaturesServer{stream}) 240} 241func (s *RouteGuideService) recordRoute(_ interface{}, stream grpc.ServerStream) error { 242 if s.RecordRoute == nil { 243 return status.Errorf(codes.Unimplemented, "method RecordRoute not implemented") 244 } 245 return s.RecordRoute(&routeGuideRecordRouteServer{stream}) 246} 247func (s *RouteGuideService) routeChat(_ interface{}, stream grpc.ServerStream) error { 248 if s.RouteChat == nil { 249 return status.Errorf(codes.Unimplemented, "method RouteChat not implemented") 250 } 251 return s.RouteChat(&routeGuideRouteChatServer{stream}) 252} 253 254type RouteGuide_ListFeaturesServer interface { 255 Send(*Feature) error 256 grpc.ServerStream 257} 258 259type routeGuideListFeaturesServer struct { 260 grpc.ServerStream 261} 262 263func (x *routeGuideListFeaturesServer) Send(m *Feature) error { 264 return x.ServerStream.SendMsg(m) 265} 266 267type RouteGuide_RecordRouteServer interface { 268 SendAndClose(*RouteSummary) error 269 Recv() (*Point, error) 270 grpc.ServerStream 271} 272 273type routeGuideRecordRouteServer struct { 274 grpc.ServerStream 275} 276 277func (x *routeGuideRecordRouteServer) SendAndClose(m *RouteSummary) error { 278 return x.ServerStream.SendMsg(m) 279} 280 281func (x *routeGuideRecordRouteServer) Recv() (*Point, error) { 282 m := new(Point) 283 if err := x.ServerStream.RecvMsg(m); err != nil { 284 return nil, err 285 } 286 return m, nil 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 311// RegisterRouteGuideService registers a service implementation with a gRPC server. 312func RegisterRouteGuideService(s grpc.ServiceRegistrar, srv *RouteGuideService) { 313 sd := grpc.ServiceDesc{ 314 ServiceName: "routeguide.RouteGuide", 315 Methods: []grpc.MethodDesc{ 316 { 317 MethodName: "GetFeature", 318 Handler: srv.getFeature, 319 }, 320 }, 321 Streams: []grpc.StreamDesc{ 322 { 323 StreamName: "ListFeatures", 324 Handler: srv.listFeatures, 325 ServerStreams: true, 326 }, 327 { 328 StreamName: "RecordRoute", 329 Handler: srv.recordRoute, 330 ClientStreams: true, 331 }, 332 { 333 StreamName: "RouteChat", 334 Handler: srv.routeChat, 335 ServerStreams: true, 336 ClientStreams: true, 337 }, 338 }, 339 Metadata: "examples/route_guide/routeguide/route_guide.proto", 340 } 341 342 s.RegisterService(&sd, nil) 343} 344 345// NewRouteGuideService creates a new RouteGuideService containing the 346// implemented methods of the RouteGuide service in s. Any unimplemented 347// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client. 348// This includes situations where the method handler is misspelled or has the wrong 349// signature. For this reason, this function should be used with great care and 350// is not recommended to be used by most users. 351func NewRouteGuideService(s interface{}) *RouteGuideService { 352 ns := &RouteGuideService{} 353 if h, ok := s.(interface { 354 GetFeature(context.Context, *Point) (*Feature, error) 355 }); ok { 356 ns.GetFeature = h.GetFeature 357 } 358 if h, ok := s.(interface { 359 ListFeatures(*Rectangle, RouteGuide_ListFeaturesServer) error 360 }); ok { 361 ns.ListFeatures = h.ListFeatures 362 } 363 if h, ok := s.(interface { 364 RecordRoute(RouteGuide_RecordRouteServer) error 365 }); ok { 366 ns.RecordRoute = h.RecordRoute 367 } 368 if h, ok := s.(interface { 369 RouteChat(RouteGuide_RouteChatServer) error 370 }); ok { 371 ns.RouteChat = h.RouteChat 372 } 373 return ns 374} 375 376// UnstableRouteGuideService is the service API for RouteGuide service. 377// New methods may be added to this interface if they are added to the service 378// definition, which is not a backward-compatible change. For this reason, 379// use of this type is not recommended. 380type UnstableRouteGuideService interface { 381 // A simple RPC. 382 // 383 // Obtains the feature at a given position. 384 // 385 // A feature with an empty name is returned if there's no feature at the given 386 // position. 387 GetFeature(context.Context, *Point) (*Feature, error) 388 // A server-to-client streaming RPC. 389 // 390 // Obtains the Features available within the given Rectangle. Results are 391 // streamed rather than returned at once (e.g. in a response message with a 392 // repeated field), as the rectangle may cover a large area and contain a 393 // huge number of features. 394 ListFeatures(*Rectangle, RouteGuide_ListFeaturesServer) error 395 // A client-to-server streaming RPC. 396 // 397 // Accepts a stream of Points on a route being traversed, returning a 398 // RouteSummary when traversal is completed. 399 RecordRoute(RouteGuide_RecordRouteServer) error 400 // A Bidirectional streaming RPC. 401 // 402 // Accepts a stream of RouteNotes sent while a route is being traversed, 403 // while receiving other RouteNotes (e.g. from other users). 404 RouteChat(RouteGuide_RouteChatServer) error 405} 406