github.com/inazumav/sing-box@v0.0.0-20230926072359-ab51429a14f1/transport/v2raygrpc/stream_grpc.pb.go (about)

     1  package v2raygrpc
     2  
     3  import (
     4  	context "context"
     5  
     6  	grpc "google.golang.org/grpc"
     7  	codes "google.golang.org/grpc/codes"
     8  	status "google.golang.org/grpc/status"
     9  )
    10  
    11  // This is a compile-time assertion to ensure that this generated file
    12  // is compatible with the grpc package it is being compiled against.
    13  // Requires gRPC-Go v1.32.0 or later.
    14  const _ = grpc.SupportPackageIsVersion7
    15  
    16  // GunServiceClient is the client API for GunService 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.
    19  type GunServiceClient interface {
    20  	Tun(ctx context.Context, opts ...grpc.CallOption) (GunService_TunClient, error)
    21  }
    22  
    23  type gunServiceClient struct {
    24  	cc grpc.ClientConnInterface
    25  }
    26  
    27  func NewGunServiceClient(cc grpc.ClientConnInterface) GunServiceClient {
    28  	return &gunServiceClient{cc}
    29  }
    30  
    31  func (c *gunServiceClient) Tun(ctx context.Context, opts ...grpc.CallOption) (GunService_TunClient, error) {
    32  	stream, err := c.cc.NewStream(ctx, &GunService_ServiceDesc.Streams[0], "/transport.v2raygrpc.GunService/Tun", opts...)
    33  	if err != nil {
    34  		return nil, err
    35  	}
    36  	x := &gunServiceTunClient{stream}
    37  	return x, nil
    38  }
    39  
    40  type GunService_TunClient interface {
    41  	Send(*Hunk) error
    42  	Recv() (*Hunk, error)
    43  	grpc.ClientStream
    44  }
    45  
    46  type gunServiceTunClient struct {
    47  	grpc.ClientStream
    48  }
    49  
    50  func (x *gunServiceTunClient) Send(m *Hunk) error {
    51  	return x.ClientStream.SendMsg(m)
    52  }
    53  
    54  func (x *gunServiceTunClient) Recv() (*Hunk, error) {
    55  	m := new(Hunk)
    56  	if err := x.ClientStream.RecvMsg(m); err != nil {
    57  		return nil, err
    58  	}
    59  	return m, nil
    60  }
    61  
    62  // GunServiceServer is the server API for GunService service.
    63  // All implementations must embed UnimplementedGunServiceServer
    64  // for forward compatibility
    65  type GunServiceServer interface {
    66  	Tun(GunService_TunServer) error
    67  	mustEmbedUnimplementedGunServiceServer()
    68  }
    69  
    70  // UnimplementedGunServiceServer must be embedded to have forward compatible implementations.
    71  type UnimplementedGunServiceServer struct{}
    72  
    73  func (UnimplementedGunServiceServer) Tun(GunService_TunServer) error {
    74  	return status.Errorf(codes.Unimplemented, "method Tun not implemented")
    75  }
    76  func (UnimplementedGunServiceServer) mustEmbedUnimplementedGunServiceServer() {}
    77  
    78  // UnsafeGunServiceServer may be embedded to opt out of forward compatibility for this service.
    79  // Use of this interface is not recommended, as added methods to GunServiceServer will
    80  // result in compilation errors.
    81  type UnsafeGunServiceServer interface {
    82  	mustEmbedUnimplementedGunServiceServer()
    83  }
    84  
    85  func RegisterGunServiceServer(s grpc.ServiceRegistrar, srv GunServiceServer) {
    86  	s.RegisterService(&GunService_ServiceDesc, srv)
    87  }
    88  
    89  func _GunService_Tun_Handler(srv interface{}, stream grpc.ServerStream) error {
    90  	return srv.(GunServiceServer).Tun(&gunServiceTunServer{stream})
    91  }
    92  
    93  type GunService_TunServer interface {
    94  	Send(*Hunk) error
    95  	Recv() (*Hunk, error)
    96  	grpc.ServerStream
    97  }
    98  
    99  type gunServiceTunServer struct {
   100  	grpc.ServerStream
   101  }
   102  
   103  func (x *gunServiceTunServer) Send(m *Hunk) error {
   104  	return x.ServerStream.SendMsg(m)
   105  }
   106  
   107  func (x *gunServiceTunServer) Recv() (*Hunk, error) {
   108  	m := new(Hunk)
   109  	if err := x.ServerStream.RecvMsg(m); err != nil {
   110  		return nil, err
   111  	}
   112  	return m, nil
   113  }
   114  
   115  // GunService_ServiceDesc is the grpc.ServiceDesc for GunService service.
   116  // It's only intended for direct use with grpc.RegisterService,
   117  // and not to be introspected or modified (even as a copy)
   118  var GunService_ServiceDesc = grpc.ServiceDesc{
   119  	ServiceName: "transport.v2raygrpc.GunService",
   120  	HandlerType: (*GunServiceServer)(nil),
   121  	Methods:     []grpc.MethodDesc{},
   122  	Streams: []grpc.StreamDesc{
   123  		{
   124  			StreamName:    "Tun",
   125  			Handler:       _GunService_Tun_Handler,
   126  			ServerStreams: true,
   127  			ClientStreams: true,
   128  		},
   129  	},
   130  	Metadata: "transport/v2raygrpc/stream.proto",
   131  }