Source file src/github.com/grpc-ecosystem/grpc-gateway/v2/examples/internal/proto/examplepb/flow_combination_grpc.pb.go

Documentation: github.com/grpc-ecosystem/grpc-gateway/v2/examples/internal/proto/examplepb

     1  // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
     2  // versions:
     3  // - protoc-gen-go-grpc v1.2.0
     4  // - protoc             (unknown)
     5  // source: examples/internal/proto/examplepb/flow_combination.proto
     6  
     7  package examplepb
     8  
     9  import (
    10  	context "context"
    11  	grpc "google.golang.org/grpc"
    12  	codes "google.golang.org/grpc/codes"
    13  	status "google.golang.org/grpc/status"
    14  )
    15  
    16  // This is a compile-time assertion to ensure that this generated file
    17  // is compatible with the grpc package it is being compiled against.
    18  // Requires gRPC-Go v1.32.0 or later.
    19  const _ = grpc.SupportPackageIsVersion7
    20  
    21  // FlowCombinationClient is the client API for FlowCombination service.
    22  //
    23  // 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.
    24  type FlowCombinationClient interface {
    25  	RpcEmptyRpc(ctx context.Context, in *EmptyProto, opts ...grpc.CallOption) (*EmptyProto, error)
    26  	RpcEmptyStream(ctx context.Context, in *EmptyProto, opts ...grpc.CallOption) (FlowCombination_RpcEmptyStreamClient, error)
    27  	StreamEmptyRpc(ctx context.Context, opts ...grpc.CallOption) (FlowCombination_StreamEmptyRpcClient, error)
    28  	StreamEmptyStream(ctx context.Context, opts ...grpc.CallOption) (FlowCombination_StreamEmptyStreamClient, error)
    29  	RpcBodyRpc(ctx context.Context, in *NonEmptyProto, opts ...grpc.CallOption) (*EmptyProto, error)
    30  	RpcPathSingleNestedRpc(ctx context.Context, in *SingleNestedProto, opts ...grpc.CallOption) (*EmptyProto, error)
    31  	RpcPathNestedRpc(ctx context.Context, in *NestedProto, opts ...grpc.CallOption) (*EmptyProto, error)
    32  	RpcBodyStream(ctx context.Context, in *NonEmptyProto, opts ...grpc.CallOption) (FlowCombination_RpcBodyStreamClient, error)
    33  	RpcPathSingleNestedStream(ctx context.Context, in *SingleNestedProto, opts ...grpc.CallOption) (FlowCombination_RpcPathSingleNestedStreamClient, error)
    34  	RpcPathNestedStream(ctx context.Context, in *NestedProto, opts ...grpc.CallOption) (FlowCombination_RpcPathNestedStreamClient, error)
    35  }
    36  
    37  type flowCombinationClient struct {
    38  	cc grpc.ClientConnInterface
    39  }
    40  
    41  func NewFlowCombinationClient(cc grpc.ClientConnInterface) FlowCombinationClient {
    42  	return &flowCombinationClient{cc}
    43  }
    44  
    45  func (c *flowCombinationClient) RpcEmptyRpc(ctx context.Context, in *EmptyProto, opts ...grpc.CallOption) (*EmptyProto, error) {
    46  	out := new(EmptyProto)
    47  	err := c.cc.Invoke(ctx, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcEmptyRpc", in, out, opts...)
    48  	if err != nil {
    49  		return nil, err
    50  	}
    51  	return out, nil
    52  }
    53  
    54  func (c *flowCombinationClient) RpcEmptyStream(ctx context.Context, in *EmptyProto, opts ...grpc.CallOption) (FlowCombination_RpcEmptyStreamClient, error) {
    55  	stream, err := c.cc.NewStream(ctx, &FlowCombination_ServiceDesc.Streams[0], "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcEmptyStream", opts...)
    56  	if err != nil {
    57  		return nil, err
    58  	}
    59  	x := &flowCombinationRpcEmptyStreamClient{stream}
    60  	if err := x.ClientStream.SendMsg(in); err != nil {
    61  		return nil, err
    62  	}
    63  	if err := x.ClientStream.CloseSend(); err != nil {
    64  		return nil, err
    65  	}
    66  	return x, nil
    67  }
    68  
    69  type FlowCombination_RpcEmptyStreamClient interface {
    70  	Recv() (*EmptyProto, error)
    71  	grpc.ClientStream
    72  }
    73  
    74  type flowCombinationRpcEmptyStreamClient struct {
    75  	grpc.ClientStream
    76  }
    77  
    78  func (x *flowCombinationRpcEmptyStreamClient) Recv() (*EmptyProto, error) {
    79  	m := new(EmptyProto)
    80  	if err := x.ClientStream.RecvMsg(m); err != nil {
    81  		return nil, err
    82  	}
    83  	return m, nil
    84  }
    85  
    86  func (c *flowCombinationClient) StreamEmptyRpc(ctx context.Context, opts ...grpc.CallOption) (FlowCombination_StreamEmptyRpcClient, error) {
    87  	stream, err := c.cc.NewStream(ctx, &FlowCombination_ServiceDesc.Streams[1], "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/StreamEmptyRpc", opts...)
    88  	if err != nil {
    89  		return nil, err
    90  	}
    91  	x := &flowCombinationStreamEmptyRpcClient{stream}
    92  	return x, nil
    93  }
    94  
    95  type FlowCombination_StreamEmptyRpcClient interface {
    96  	Send(*EmptyProto) error
    97  	CloseAndRecv() (*EmptyProto, error)
    98  	grpc.ClientStream
    99  }
   100  
   101  type flowCombinationStreamEmptyRpcClient struct {
   102  	grpc.ClientStream
   103  }
   104  
   105  func (x *flowCombinationStreamEmptyRpcClient) Send(m *EmptyProto) error {
   106  	return x.ClientStream.SendMsg(m)
   107  }
   108  
   109  func (x *flowCombinationStreamEmptyRpcClient) CloseAndRecv() (*EmptyProto, error) {
   110  	if err := x.ClientStream.CloseSend(); err != nil {
   111  		return nil, err
   112  	}
   113  	m := new(EmptyProto)
   114  	if err := x.ClientStream.RecvMsg(m); err != nil {
   115  		return nil, err
   116  	}
   117  	return m, nil
   118  }
   119  
   120  func (c *flowCombinationClient) StreamEmptyStream(ctx context.Context, opts ...grpc.CallOption) (FlowCombination_StreamEmptyStreamClient, error) {
   121  	stream, err := c.cc.NewStream(ctx, &FlowCombination_ServiceDesc.Streams[2], "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/StreamEmptyStream", opts...)
   122  	if err != nil {
   123  		return nil, err
   124  	}
   125  	x := &flowCombinationStreamEmptyStreamClient{stream}
   126  	return x, nil
   127  }
   128  
   129  type FlowCombination_StreamEmptyStreamClient interface {
   130  	Send(*EmptyProto) error
   131  	Recv() (*EmptyProto, error)
   132  	grpc.ClientStream
   133  }
   134  
   135  type flowCombinationStreamEmptyStreamClient struct {
   136  	grpc.ClientStream
   137  }
   138  
   139  func (x *flowCombinationStreamEmptyStreamClient) Send(m *EmptyProto) error {
   140  	return x.ClientStream.SendMsg(m)
   141  }
   142  
   143  func (x *flowCombinationStreamEmptyStreamClient) Recv() (*EmptyProto, error) {
   144  	m := new(EmptyProto)
   145  	if err := x.ClientStream.RecvMsg(m); err != nil {
   146  		return nil, err
   147  	}
   148  	return m, nil
   149  }
   150  
   151  func (c *flowCombinationClient) RpcBodyRpc(ctx context.Context, in *NonEmptyProto, opts ...grpc.CallOption) (*EmptyProto, error) {
   152  	out := new(EmptyProto)
   153  	err := c.cc.Invoke(ctx, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyRpc", in, out, opts...)
   154  	if err != nil {
   155  		return nil, err
   156  	}
   157  	return out, nil
   158  }
   159  
   160  func (c *flowCombinationClient) RpcPathSingleNestedRpc(ctx context.Context, in *SingleNestedProto, opts ...grpc.CallOption) (*EmptyProto, error) {
   161  	out := new(EmptyProto)
   162  	err := c.cc.Invoke(ctx, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathSingleNestedRpc", in, out, opts...)
   163  	if err != nil {
   164  		return nil, err
   165  	}
   166  	return out, nil
   167  }
   168  
   169  func (c *flowCombinationClient) RpcPathNestedRpc(ctx context.Context, in *NestedProto, opts ...grpc.CallOption) (*EmptyProto, error) {
   170  	out := new(EmptyProto)
   171  	err := c.cc.Invoke(ctx, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathNestedRpc", in, out, opts...)
   172  	if err != nil {
   173  		return nil, err
   174  	}
   175  	return out, nil
   176  }
   177  
   178  func (c *flowCombinationClient) RpcBodyStream(ctx context.Context, in *NonEmptyProto, opts ...grpc.CallOption) (FlowCombination_RpcBodyStreamClient, error) {
   179  	stream, err := c.cc.NewStream(ctx, &FlowCombination_ServiceDesc.Streams[3], "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyStream", opts...)
   180  	if err != nil {
   181  		return nil, err
   182  	}
   183  	x := &flowCombinationRpcBodyStreamClient{stream}
   184  	if err := x.ClientStream.SendMsg(in); err != nil {
   185  		return nil, err
   186  	}
   187  	if err := x.ClientStream.CloseSend(); err != nil {
   188  		return nil, err
   189  	}
   190  	return x, nil
   191  }
   192  
   193  type FlowCombination_RpcBodyStreamClient interface {
   194  	Recv() (*EmptyProto, error)
   195  	grpc.ClientStream
   196  }
   197  
   198  type flowCombinationRpcBodyStreamClient struct {
   199  	grpc.ClientStream
   200  }
   201  
   202  func (x *flowCombinationRpcBodyStreamClient) Recv() (*EmptyProto, error) {
   203  	m := new(EmptyProto)
   204  	if err := x.ClientStream.RecvMsg(m); err != nil {
   205  		return nil, err
   206  	}
   207  	return m, nil
   208  }
   209  
   210  func (c *flowCombinationClient) RpcPathSingleNestedStream(ctx context.Context, in *SingleNestedProto, opts ...grpc.CallOption) (FlowCombination_RpcPathSingleNestedStreamClient, error) {
   211  	stream, err := c.cc.NewStream(ctx, &FlowCombination_ServiceDesc.Streams[4], "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathSingleNestedStream", opts...)
   212  	if err != nil {
   213  		return nil, err
   214  	}
   215  	x := &flowCombinationRpcPathSingleNestedStreamClient{stream}
   216  	if err := x.ClientStream.SendMsg(in); err != nil {
   217  		return nil, err
   218  	}
   219  	if err := x.ClientStream.CloseSend(); err != nil {
   220  		return nil, err
   221  	}
   222  	return x, nil
   223  }
   224  
   225  type FlowCombination_RpcPathSingleNestedStreamClient interface {
   226  	Recv() (*EmptyProto, error)
   227  	grpc.ClientStream
   228  }
   229  
   230  type flowCombinationRpcPathSingleNestedStreamClient struct {
   231  	grpc.ClientStream
   232  }
   233  
   234  func (x *flowCombinationRpcPathSingleNestedStreamClient) Recv() (*EmptyProto, error) {
   235  	m := new(EmptyProto)
   236  	if err := x.ClientStream.RecvMsg(m); err != nil {
   237  		return nil, err
   238  	}
   239  	return m, nil
   240  }
   241  
   242  func (c *flowCombinationClient) RpcPathNestedStream(ctx context.Context, in *NestedProto, opts ...grpc.CallOption) (FlowCombination_RpcPathNestedStreamClient, error) {
   243  	stream, err := c.cc.NewStream(ctx, &FlowCombination_ServiceDesc.Streams[5], "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathNestedStream", opts...)
   244  	if err != nil {
   245  		return nil, err
   246  	}
   247  	x := &flowCombinationRpcPathNestedStreamClient{stream}
   248  	if err := x.ClientStream.SendMsg(in); err != nil {
   249  		return nil, err
   250  	}
   251  	if err := x.ClientStream.CloseSend(); err != nil {
   252  		return nil, err
   253  	}
   254  	return x, nil
   255  }
   256  
   257  type FlowCombination_RpcPathNestedStreamClient interface {
   258  	Recv() (*EmptyProto, error)
   259  	grpc.ClientStream
   260  }
   261  
   262  type flowCombinationRpcPathNestedStreamClient struct {
   263  	grpc.ClientStream
   264  }
   265  
   266  func (x *flowCombinationRpcPathNestedStreamClient) Recv() (*EmptyProto, error) {
   267  	m := new(EmptyProto)
   268  	if err := x.ClientStream.RecvMsg(m); err != nil {
   269  		return nil, err
   270  	}
   271  	return m, nil
   272  }
   273  
   274  // FlowCombinationServer is the server API for FlowCombination service.
   275  // All implementations should embed UnimplementedFlowCombinationServer
   276  // for forward compatibility
   277  type FlowCombinationServer interface {
   278  	RpcEmptyRpc(context.Context, *EmptyProto) (*EmptyProto, error)
   279  	RpcEmptyStream(*EmptyProto, FlowCombination_RpcEmptyStreamServer) error
   280  	StreamEmptyRpc(FlowCombination_StreamEmptyRpcServer) error
   281  	StreamEmptyStream(FlowCombination_StreamEmptyStreamServer) error
   282  	RpcBodyRpc(context.Context, *NonEmptyProto) (*EmptyProto, error)
   283  	RpcPathSingleNestedRpc(context.Context, *SingleNestedProto) (*EmptyProto, error)
   284  	RpcPathNestedRpc(context.Context, *NestedProto) (*EmptyProto, error)
   285  	RpcBodyStream(*NonEmptyProto, FlowCombination_RpcBodyStreamServer) error
   286  	RpcPathSingleNestedStream(*SingleNestedProto, FlowCombination_RpcPathSingleNestedStreamServer) error
   287  	RpcPathNestedStream(*NestedProto, FlowCombination_RpcPathNestedStreamServer) error
   288  }
   289  
   290  // UnimplementedFlowCombinationServer should be embedded to have forward compatible implementations.
   291  type UnimplementedFlowCombinationServer struct {
   292  }
   293  
   294  func (UnimplementedFlowCombinationServer) RpcEmptyRpc(context.Context, *EmptyProto) (*EmptyProto, error) {
   295  	return nil, status.Errorf(codes.Unimplemented, "method RpcEmptyRpc not implemented")
   296  }
   297  func (UnimplementedFlowCombinationServer) RpcEmptyStream(*EmptyProto, FlowCombination_RpcEmptyStreamServer) error {
   298  	return status.Errorf(codes.Unimplemented, "method RpcEmptyStream not implemented")
   299  }
   300  func (UnimplementedFlowCombinationServer) StreamEmptyRpc(FlowCombination_StreamEmptyRpcServer) error {
   301  	return status.Errorf(codes.Unimplemented, "method StreamEmptyRpc not implemented")
   302  }
   303  func (UnimplementedFlowCombinationServer) StreamEmptyStream(FlowCombination_StreamEmptyStreamServer) error {
   304  	return status.Errorf(codes.Unimplemented, "method StreamEmptyStream not implemented")
   305  }
   306  func (UnimplementedFlowCombinationServer) RpcBodyRpc(context.Context, *NonEmptyProto) (*EmptyProto, error) {
   307  	return nil, status.Errorf(codes.Unimplemented, "method RpcBodyRpc not implemented")
   308  }
   309  func (UnimplementedFlowCombinationServer) RpcPathSingleNestedRpc(context.Context, *SingleNestedProto) (*EmptyProto, error) {
   310  	return nil, status.Errorf(codes.Unimplemented, "method RpcPathSingleNestedRpc not implemented")
   311  }
   312  func (UnimplementedFlowCombinationServer) RpcPathNestedRpc(context.Context, *NestedProto) (*EmptyProto, error) {
   313  	return nil, status.Errorf(codes.Unimplemented, "method RpcPathNestedRpc not implemented")
   314  }
   315  func (UnimplementedFlowCombinationServer) RpcBodyStream(*NonEmptyProto, FlowCombination_RpcBodyStreamServer) error {
   316  	return status.Errorf(codes.Unimplemented, "method RpcBodyStream not implemented")
   317  }
   318  func (UnimplementedFlowCombinationServer) RpcPathSingleNestedStream(*SingleNestedProto, FlowCombination_RpcPathSingleNestedStreamServer) error {
   319  	return status.Errorf(codes.Unimplemented, "method RpcPathSingleNestedStream not implemented")
   320  }
   321  func (UnimplementedFlowCombinationServer) RpcPathNestedStream(*NestedProto, FlowCombination_RpcPathNestedStreamServer) error {
   322  	return status.Errorf(codes.Unimplemented, "method RpcPathNestedStream not implemented")
   323  }
   324  
   325  // UnsafeFlowCombinationServer may be embedded to opt out of forward compatibility for this service.
   326  // Use of this interface is not recommended, as added methods to FlowCombinationServer will
   327  // result in compilation errors.
   328  type UnsafeFlowCombinationServer interface {
   329  	mustEmbedUnimplementedFlowCombinationServer()
   330  }
   331  
   332  func RegisterFlowCombinationServer(s grpc.ServiceRegistrar, srv FlowCombinationServer) {
   333  	s.RegisterService(&FlowCombination_ServiceDesc, srv)
   334  }
   335  
   336  func _FlowCombination_RpcEmptyRpc_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   337  	in := new(EmptyProto)
   338  	if err := dec(in); err != nil {
   339  		return nil, err
   340  	}
   341  	if interceptor == nil {
   342  		return srv.(FlowCombinationServer).RpcEmptyRpc(ctx, in)
   343  	}
   344  	info := &grpc.UnaryServerInfo{
   345  		Server:     srv,
   346  		FullMethod: "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcEmptyRpc",
   347  	}
   348  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   349  		return srv.(FlowCombinationServer).RpcEmptyRpc(ctx, req.(*EmptyProto))
   350  	}
   351  	return interceptor(ctx, in, info, handler)
   352  }
   353  
   354  func _FlowCombination_RpcEmptyStream_Handler(srv interface{}, stream grpc.ServerStream) error {
   355  	m := new(EmptyProto)
   356  	if err := stream.RecvMsg(m); err != nil {
   357  		return err
   358  	}
   359  	return srv.(FlowCombinationServer).RpcEmptyStream(m, &flowCombinationRpcEmptyStreamServer{stream})
   360  }
   361  
   362  type FlowCombination_RpcEmptyStreamServer interface {
   363  	Send(*EmptyProto) error
   364  	grpc.ServerStream
   365  }
   366  
   367  type flowCombinationRpcEmptyStreamServer struct {
   368  	grpc.ServerStream
   369  }
   370  
   371  func (x *flowCombinationRpcEmptyStreamServer) Send(m *EmptyProto) error {
   372  	return x.ServerStream.SendMsg(m)
   373  }
   374  
   375  func _FlowCombination_StreamEmptyRpc_Handler(srv interface{}, stream grpc.ServerStream) error {
   376  	return srv.(FlowCombinationServer).StreamEmptyRpc(&flowCombinationStreamEmptyRpcServer{stream})
   377  }
   378  
   379  type FlowCombination_StreamEmptyRpcServer interface {
   380  	SendAndClose(*EmptyProto) error
   381  	Recv() (*EmptyProto, error)
   382  	grpc.ServerStream
   383  }
   384  
   385  type flowCombinationStreamEmptyRpcServer struct {
   386  	grpc.ServerStream
   387  }
   388  
   389  func (x *flowCombinationStreamEmptyRpcServer) SendAndClose(m *EmptyProto) error {
   390  	return x.ServerStream.SendMsg(m)
   391  }
   392  
   393  func (x *flowCombinationStreamEmptyRpcServer) Recv() (*EmptyProto, error) {
   394  	m := new(EmptyProto)
   395  	if err := x.ServerStream.RecvMsg(m); err != nil {
   396  		return nil, err
   397  	}
   398  	return m, nil
   399  }
   400  
   401  func _FlowCombination_StreamEmptyStream_Handler(srv interface{}, stream grpc.ServerStream) error {
   402  	return srv.(FlowCombinationServer).StreamEmptyStream(&flowCombinationStreamEmptyStreamServer{stream})
   403  }
   404  
   405  type FlowCombination_StreamEmptyStreamServer interface {
   406  	Send(*EmptyProto) error
   407  	Recv() (*EmptyProto, error)
   408  	grpc.ServerStream
   409  }
   410  
   411  type flowCombinationStreamEmptyStreamServer struct {
   412  	grpc.ServerStream
   413  }
   414  
   415  func (x *flowCombinationStreamEmptyStreamServer) Send(m *EmptyProto) error {
   416  	return x.ServerStream.SendMsg(m)
   417  }
   418  
   419  func (x *flowCombinationStreamEmptyStreamServer) Recv() (*EmptyProto, error) {
   420  	m := new(EmptyProto)
   421  	if err := x.ServerStream.RecvMsg(m); err != nil {
   422  		return nil, err
   423  	}
   424  	return m, nil
   425  }
   426  
   427  func _FlowCombination_RpcBodyRpc_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   428  	in := new(NonEmptyProto)
   429  	if err := dec(in); err != nil {
   430  		return nil, err
   431  	}
   432  	if interceptor == nil {
   433  		return srv.(FlowCombinationServer).RpcBodyRpc(ctx, in)
   434  	}
   435  	info := &grpc.UnaryServerInfo{
   436  		Server:     srv,
   437  		FullMethod: "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyRpc",
   438  	}
   439  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   440  		return srv.(FlowCombinationServer).RpcBodyRpc(ctx, req.(*NonEmptyProto))
   441  	}
   442  	return interceptor(ctx, in, info, handler)
   443  }
   444  
   445  func _FlowCombination_RpcPathSingleNestedRpc_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   446  	in := new(SingleNestedProto)
   447  	if err := dec(in); err != nil {
   448  		return nil, err
   449  	}
   450  	if interceptor == nil {
   451  		return srv.(FlowCombinationServer).RpcPathSingleNestedRpc(ctx, in)
   452  	}
   453  	info := &grpc.UnaryServerInfo{
   454  		Server:     srv,
   455  		FullMethod: "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathSingleNestedRpc",
   456  	}
   457  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   458  		return srv.(FlowCombinationServer).RpcPathSingleNestedRpc(ctx, req.(*SingleNestedProto))
   459  	}
   460  	return interceptor(ctx, in, info, handler)
   461  }
   462  
   463  func _FlowCombination_RpcPathNestedRpc_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   464  	in := new(NestedProto)
   465  	if err := dec(in); err != nil {
   466  		return nil, err
   467  	}
   468  	if interceptor == nil {
   469  		return srv.(FlowCombinationServer).RpcPathNestedRpc(ctx, in)
   470  	}
   471  	info := &grpc.UnaryServerInfo{
   472  		Server:     srv,
   473  		FullMethod: "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathNestedRpc",
   474  	}
   475  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   476  		return srv.(FlowCombinationServer).RpcPathNestedRpc(ctx, req.(*NestedProto))
   477  	}
   478  	return interceptor(ctx, in, info, handler)
   479  }
   480  
   481  func _FlowCombination_RpcBodyStream_Handler(srv interface{}, stream grpc.ServerStream) error {
   482  	m := new(NonEmptyProto)
   483  	if err := stream.RecvMsg(m); err != nil {
   484  		return err
   485  	}
   486  	return srv.(FlowCombinationServer).RpcBodyStream(m, &flowCombinationRpcBodyStreamServer{stream})
   487  }
   488  
   489  type FlowCombination_RpcBodyStreamServer interface {
   490  	Send(*EmptyProto) error
   491  	grpc.ServerStream
   492  }
   493  
   494  type flowCombinationRpcBodyStreamServer struct {
   495  	grpc.ServerStream
   496  }
   497  
   498  func (x *flowCombinationRpcBodyStreamServer) Send(m *EmptyProto) error {
   499  	return x.ServerStream.SendMsg(m)
   500  }
   501  
   502  func _FlowCombination_RpcPathSingleNestedStream_Handler(srv interface{}, stream grpc.ServerStream) error {
   503  	m := new(SingleNestedProto)
   504  	if err := stream.RecvMsg(m); err != nil {
   505  		return err
   506  	}
   507  	return srv.(FlowCombinationServer).RpcPathSingleNestedStream(m, &flowCombinationRpcPathSingleNestedStreamServer{stream})
   508  }
   509  
   510  type FlowCombination_RpcPathSingleNestedStreamServer interface {
   511  	Send(*EmptyProto) error
   512  	grpc.ServerStream
   513  }
   514  
   515  type flowCombinationRpcPathSingleNestedStreamServer struct {
   516  	grpc.ServerStream
   517  }
   518  
   519  func (x *flowCombinationRpcPathSingleNestedStreamServer) Send(m *EmptyProto) error {
   520  	return x.ServerStream.SendMsg(m)
   521  }
   522  
   523  func _FlowCombination_RpcPathNestedStream_Handler(srv interface{}, stream grpc.ServerStream) error {
   524  	m := new(NestedProto)
   525  	if err := stream.RecvMsg(m); err != nil {
   526  		return err
   527  	}
   528  	return srv.(FlowCombinationServer).RpcPathNestedStream(m, &flowCombinationRpcPathNestedStreamServer{stream})
   529  }
   530  
   531  type FlowCombination_RpcPathNestedStreamServer interface {
   532  	Send(*EmptyProto) error
   533  	grpc.ServerStream
   534  }
   535  
   536  type flowCombinationRpcPathNestedStreamServer struct {
   537  	grpc.ServerStream
   538  }
   539  
   540  func (x *flowCombinationRpcPathNestedStreamServer) Send(m *EmptyProto) error {
   541  	return x.ServerStream.SendMsg(m)
   542  }
   543  
   544  // FlowCombination_ServiceDesc is the grpc.ServiceDesc for FlowCombination service.
   545  // It's only intended for direct use with grpc.RegisterService,
   546  // and not to be introspected or modified (even as a copy)
   547  var FlowCombination_ServiceDesc = grpc.ServiceDesc{
   548  	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.FlowCombination",
   549  	HandlerType: (*FlowCombinationServer)(nil),
   550  	Methods: []grpc.MethodDesc{
   551  		{
   552  			MethodName: "RpcEmptyRpc",
   553  			Handler:    _FlowCombination_RpcEmptyRpc_Handler,
   554  		},
   555  		{
   556  			MethodName: "RpcBodyRpc",
   557  			Handler:    _FlowCombination_RpcBodyRpc_Handler,
   558  		},
   559  		{
   560  			MethodName: "RpcPathSingleNestedRpc",
   561  			Handler:    _FlowCombination_RpcPathSingleNestedRpc_Handler,
   562  		},
   563  		{
   564  			MethodName: "RpcPathNestedRpc",
   565  			Handler:    _FlowCombination_RpcPathNestedRpc_Handler,
   566  		},
   567  	},
   568  	Streams: []grpc.StreamDesc{
   569  		{
   570  			StreamName:    "RpcEmptyStream",
   571  			Handler:       _FlowCombination_RpcEmptyStream_Handler,
   572  			ServerStreams: true,
   573  		},
   574  		{
   575  			StreamName:    "StreamEmptyRpc",
   576  			Handler:       _FlowCombination_StreamEmptyRpc_Handler,
   577  			ClientStreams: true,
   578  		},
   579  		{
   580  			StreamName:    "StreamEmptyStream",
   581  			Handler:       _FlowCombination_StreamEmptyStream_Handler,
   582  			ServerStreams: true,
   583  			ClientStreams: true,
   584  		},
   585  		{
   586  			StreamName:    "RpcBodyStream",
   587  			Handler:       _FlowCombination_RpcBodyStream_Handler,
   588  			ServerStreams: true,
   589  		},
   590  		{
   591  			StreamName:    "RpcPathSingleNestedStream",
   592  			Handler:       _FlowCombination_RpcPathSingleNestedStream_Handler,
   593  			ServerStreams: true,
   594  		},
   595  		{
   596  			StreamName:    "RpcPathNestedStream",
   597  			Handler:       _FlowCombination_RpcPathNestedStream_Handler,
   598  			ServerStreams: true,
   599  		},
   600  	},
   601  	Metadata: "examples/internal/proto/examplepb/flow_combination.proto",
   602  }
   603  

View as plain text