alice.pds.demo.boltless.dev
This repository has no description
1// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
2// versions:
3// - protoc-gen-go-grpc v1.6.2
4// - protoc (unknown)
5// source: gitmirror/v1/gitmirror.proto
6
7package gitmirrorv1
8
9import (
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.64.0 or later.
19const _ = grpc.SupportPackageIsVersion9
20
21const (
22 GitMirrorService_CommitLog_FullMethodName = "/gitmirror.v1.GitMirrorService/CommitLog"
23 GitMirrorService_GetBlob_FullMethodName = "/gitmirror.v1.GitMirrorService/GetBlob"
24 GitMirrorService_Diff_FullMethodName = "/gitmirror.v1.GitMirrorService/Diff"
25 GitMirrorService_Interdiff_FullMethodName = "/gitmirror.v1.GitMirrorService/Interdiff"
26 GitMirrorService_MergeCheck_FullMethodName = "/gitmirror.v1.GitMirrorService/MergeCheck"
27 GitMirrorService_ResolveRev_FullMethodName = "/gitmirror.v1.GitMirrorService/ResolveRev"
28)
29
30// GitMirrorServiceClient is the client API for GitMirrorService service.
31//
32// 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.
33type GitMirrorServiceClient interface {
34 CommitLog(ctx context.Context, in *CommitLogRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[CommitLogResponse], error)
35 GetBlob(ctx context.Context, in *GetBlobRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[BlobChunk], error)
36 Diff(ctx context.Context, in *DiffRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[FileDiff], error)
37 Interdiff(ctx context.Context, in *InterdiffRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[FileDiff], error)
38 MergeCheck(ctx context.Context, in *MergeCheckRequest, opts ...grpc.CallOption) (*MergeCheckResponse, error)
39 ResolveRev(ctx context.Context, in *ResolveRevRequest, opts ...grpc.CallOption) (*ResolveRevResponse, error)
40}
41
42type gitMirrorServiceClient struct {
43 cc grpc.ClientConnInterface
44}
45
46func NewGitMirrorServiceClient(cc grpc.ClientConnInterface) GitMirrorServiceClient {
47 return &gitMirrorServiceClient{cc}
48}
49
50func (c *gitMirrorServiceClient) CommitLog(ctx context.Context, in *CommitLogRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[CommitLogResponse], error) {
51 cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
52 stream, err := c.cc.NewStream(ctx, &GitMirrorService_ServiceDesc.Streams[0], GitMirrorService_CommitLog_FullMethodName, cOpts...)
53 if err != nil {
54 return nil, err
55 }
56 x := &grpc.GenericClientStream[CommitLogRequest, CommitLogResponse]{ClientStream: stream}
57 if err := x.ClientStream.SendMsg(in); err != nil {
58 return nil, err
59 }
60 if err := x.ClientStream.CloseSend(); err != nil {
61 return nil, err
62 }
63 return x, nil
64}
65
66// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
67type GitMirrorService_CommitLogClient = grpc.ServerStreamingClient[CommitLogResponse]
68
69func (c *gitMirrorServiceClient) GetBlob(ctx context.Context, in *GetBlobRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[BlobChunk], error) {
70 cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
71 stream, err := c.cc.NewStream(ctx, &GitMirrorService_ServiceDesc.Streams[1], GitMirrorService_GetBlob_FullMethodName, cOpts...)
72 if err != nil {
73 return nil, err
74 }
75 x := &grpc.GenericClientStream[GetBlobRequest, BlobChunk]{ClientStream: stream}
76 if err := x.ClientStream.SendMsg(in); err != nil {
77 return nil, err
78 }
79 if err := x.ClientStream.CloseSend(); err != nil {
80 return nil, err
81 }
82 return x, nil
83}
84
85// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
86type GitMirrorService_GetBlobClient = grpc.ServerStreamingClient[BlobChunk]
87
88func (c *gitMirrorServiceClient) Diff(ctx context.Context, in *DiffRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[FileDiff], error) {
89 cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
90 stream, err := c.cc.NewStream(ctx, &GitMirrorService_ServiceDesc.Streams[2], GitMirrorService_Diff_FullMethodName, cOpts...)
91 if err != nil {
92 return nil, err
93 }
94 x := &grpc.GenericClientStream[DiffRequest, FileDiff]{ClientStream: stream}
95 if err := x.ClientStream.SendMsg(in); err != nil {
96 return nil, err
97 }
98 if err := x.ClientStream.CloseSend(); err != nil {
99 return nil, err
100 }
101 return x, nil
102}
103
104// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
105type GitMirrorService_DiffClient = grpc.ServerStreamingClient[FileDiff]
106
107func (c *gitMirrorServiceClient) Interdiff(ctx context.Context, in *InterdiffRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[FileDiff], error) {
108 cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
109 stream, err := c.cc.NewStream(ctx, &GitMirrorService_ServiceDesc.Streams[3], GitMirrorService_Interdiff_FullMethodName, cOpts...)
110 if err != nil {
111 return nil, err
112 }
113 x := &grpc.GenericClientStream[InterdiffRequest, FileDiff]{ClientStream: stream}
114 if err := x.ClientStream.SendMsg(in); err != nil {
115 return nil, err
116 }
117 if err := x.ClientStream.CloseSend(); err != nil {
118 return nil, err
119 }
120 return x, nil
121}
122
123// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
124type GitMirrorService_InterdiffClient = grpc.ServerStreamingClient[FileDiff]
125
126func (c *gitMirrorServiceClient) MergeCheck(ctx context.Context, in *MergeCheckRequest, opts ...grpc.CallOption) (*MergeCheckResponse, error) {
127 cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
128 out := new(MergeCheckResponse)
129 err := c.cc.Invoke(ctx, GitMirrorService_MergeCheck_FullMethodName, in, out, cOpts...)
130 if err != nil {
131 return nil, err
132 }
133 return out, nil
134}
135
136func (c *gitMirrorServiceClient) ResolveRev(ctx context.Context, in *ResolveRevRequest, opts ...grpc.CallOption) (*ResolveRevResponse, error) {
137 cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
138 out := new(ResolveRevResponse)
139 err := c.cc.Invoke(ctx, GitMirrorService_ResolveRev_FullMethodName, in, out, cOpts...)
140 if err != nil {
141 return nil, err
142 }
143 return out, nil
144}
145
146// GitMirrorServiceServer is the server API for GitMirrorService service.
147// All implementations must embed UnimplementedGitMirrorServiceServer
148// for forward compatibility.
149type GitMirrorServiceServer interface {
150 CommitLog(*CommitLogRequest, grpc.ServerStreamingServer[CommitLogResponse]) error
151 GetBlob(*GetBlobRequest, grpc.ServerStreamingServer[BlobChunk]) error
152 Diff(*DiffRequest, grpc.ServerStreamingServer[FileDiff]) error
153 Interdiff(*InterdiffRequest, grpc.ServerStreamingServer[FileDiff]) error
154 MergeCheck(context.Context, *MergeCheckRequest) (*MergeCheckResponse, error)
155 ResolveRev(context.Context, *ResolveRevRequest) (*ResolveRevResponse, error)
156 mustEmbedUnimplementedGitMirrorServiceServer()
157}
158
159// UnimplementedGitMirrorServiceServer must be embedded to have
160// forward compatible implementations.
161//
162// NOTE: this should be embedded by value instead of pointer to avoid a nil
163// pointer dereference when methods are called.
164type UnimplementedGitMirrorServiceServer struct{}
165
166func (UnimplementedGitMirrorServiceServer) CommitLog(*CommitLogRequest, grpc.ServerStreamingServer[CommitLogResponse]) error {
167 return status.Error(codes.Unimplemented, "method CommitLog not implemented")
168}
169func (UnimplementedGitMirrorServiceServer) GetBlob(*GetBlobRequest, grpc.ServerStreamingServer[BlobChunk]) error {
170 return status.Error(codes.Unimplemented, "method GetBlob not implemented")
171}
172func (UnimplementedGitMirrorServiceServer) Diff(*DiffRequest, grpc.ServerStreamingServer[FileDiff]) error {
173 return status.Error(codes.Unimplemented, "method Diff not implemented")
174}
175func (UnimplementedGitMirrorServiceServer) Interdiff(*InterdiffRequest, grpc.ServerStreamingServer[FileDiff]) error {
176 return status.Error(codes.Unimplemented, "method Interdiff not implemented")
177}
178func (UnimplementedGitMirrorServiceServer) MergeCheck(context.Context, *MergeCheckRequest) (*MergeCheckResponse, error) {
179 return nil, status.Error(codes.Unimplemented, "method MergeCheck not implemented")
180}
181func (UnimplementedGitMirrorServiceServer) ResolveRev(context.Context, *ResolveRevRequest) (*ResolveRevResponse, error) {
182 return nil, status.Error(codes.Unimplemented, "method ResolveRev not implemented")
183}
184func (UnimplementedGitMirrorServiceServer) mustEmbedUnimplementedGitMirrorServiceServer() {}
185func (UnimplementedGitMirrorServiceServer) testEmbeddedByValue() {}
186
187// UnsafeGitMirrorServiceServer may be embedded to opt out of forward compatibility for this service.
188// Use of this interface is not recommended, as added methods to GitMirrorServiceServer will
189// result in compilation errors.
190type UnsafeGitMirrorServiceServer interface {
191 mustEmbedUnimplementedGitMirrorServiceServer()
192}
193
194func RegisterGitMirrorServiceServer(s grpc.ServiceRegistrar, srv GitMirrorServiceServer) {
195 // If the following call panics, it indicates UnimplementedGitMirrorServiceServer was
196 // embedded by pointer and is nil. This will cause panics if an
197 // unimplemented method is ever invoked, so we test this at initialization
198 // time to prevent it from happening at runtime later due to I/O.
199 if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
200 t.testEmbeddedByValue()
201 }
202 s.RegisterService(&GitMirrorService_ServiceDesc, srv)
203}
204
205func _GitMirrorService_CommitLog_Handler(srv interface{}, stream grpc.ServerStream) error {
206 m := new(CommitLogRequest)
207 if err := stream.RecvMsg(m); err != nil {
208 return err
209 }
210 return srv.(GitMirrorServiceServer).CommitLog(m, &grpc.GenericServerStream[CommitLogRequest, CommitLogResponse]{ServerStream: stream})
211}
212
213// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
214type GitMirrorService_CommitLogServer = grpc.ServerStreamingServer[CommitLogResponse]
215
216func _GitMirrorService_GetBlob_Handler(srv interface{}, stream grpc.ServerStream) error {
217 m := new(GetBlobRequest)
218 if err := stream.RecvMsg(m); err != nil {
219 return err
220 }
221 return srv.(GitMirrorServiceServer).GetBlob(m, &grpc.GenericServerStream[GetBlobRequest, BlobChunk]{ServerStream: stream})
222}
223
224// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
225type GitMirrorService_GetBlobServer = grpc.ServerStreamingServer[BlobChunk]
226
227func _GitMirrorService_Diff_Handler(srv interface{}, stream grpc.ServerStream) error {
228 m := new(DiffRequest)
229 if err := stream.RecvMsg(m); err != nil {
230 return err
231 }
232 return srv.(GitMirrorServiceServer).Diff(m, &grpc.GenericServerStream[DiffRequest, FileDiff]{ServerStream: stream})
233}
234
235// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
236type GitMirrorService_DiffServer = grpc.ServerStreamingServer[FileDiff]
237
238func _GitMirrorService_Interdiff_Handler(srv interface{}, stream grpc.ServerStream) error {
239 m := new(InterdiffRequest)
240 if err := stream.RecvMsg(m); err != nil {
241 return err
242 }
243 return srv.(GitMirrorServiceServer).Interdiff(m, &grpc.GenericServerStream[InterdiffRequest, FileDiff]{ServerStream: stream})
244}
245
246// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
247type GitMirrorService_InterdiffServer = grpc.ServerStreamingServer[FileDiff]
248
249func _GitMirrorService_MergeCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
250 in := new(MergeCheckRequest)
251 if err := dec(in); err != nil {
252 return nil, err
253 }
254 if interceptor == nil {
255 return srv.(GitMirrorServiceServer).MergeCheck(ctx, in)
256 }
257 info := &grpc.UnaryServerInfo{
258 Server: srv,
259 FullMethod: GitMirrorService_MergeCheck_FullMethodName,
260 }
261 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
262 return srv.(GitMirrorServiceServer).MergeCheck(ctx, req.(*MergeCheckRequest))
263 }
264 return interceptor(ctx, in, info, handler)
265}
266
267func _GitMirrorService_ResolveRev_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
268 in := new(ResolveRevRequest)
269 if err := dec(in); err != nil {
270 return nil, err
271 }
272 if interceptor == nil {
273 return srv.(GitMirrorServiceServer).ResolveRev(ctx, in)
274 }
275 info := &grpc.UnaryServerInfo{
276 Server: srv,
277 FullMethod: GitMirrorService_ResolveRev_FullMethodName,
278 }
279 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
280 return srv.(GitMirrorServiceServer).ResolveRev(ctx, req.(*ResolveRevRequest))
281 }
282 return interceptor(ctx, in, info, handler)
283}
284
285// GitMirrorService_ServiceDesc is the grpc.ServiceDesc for GitMirrorService service.
286// It's only intended for direct use with grpc.RegisterService,
287// and not to be introspected or modified (even as a copy)
288var GitMirrorService_ServiceDesc = grpc.ServiceDesc{
289 ServiceName: "gitmirror.v1.GitMirrorService",
290 HandlerType: (*GitMirrorServiceServer)(nil),
291 Methods: []grpc.MethodDesc{
292 {
293 MethodName: "MergeCheck",
294 Handler: _GitMirrorService_MergeCheck_Handler,
295 },
296 {
297 MethodName: "ResolveRev",
298 Handler: _GitMirrorService_ResolveRev_Handler,
299 },
300 },
301 Streams: []grpc.StreamDesc{
302 {
303 StreamName: "CommitLog",
304 Handler: _GitMirrorService_CommitLog_Handler,
305 ServerStreams: true,
306 },
307 {
308 StreamName: "GetBlob",
309 Handler: _GitMirrorService_GetBlob_Handler,
310 ServerStreams: true,
311 },
312 {
313 StreamName: "Diff",
314 Handler: _GitMirrorService_Diff_Handler,
315 ServerStreams: true,
316 },
317 {
318 StreamName: "Interdiff",
319 Handler: _GitMirrorService_Interdiff_Handler,
320 ServerStreams: true,
321 },
322 },
323 Metadata: "gitmirror/v1/gitmirror.proto",
324}