/
IvanTimofeev
/
cranberry
GigaCode
beta
ОбзорЦентр заботыВойти

cranberry

Форк
0
Ветки: 1Коммиты: 95Теги: 19
cranberry
/pkg
/grpc
/
cranberry_grpc.pb.go 
331 строка · 13.4 Кб
1
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
2
// versions:
3
// - protoc-gen-go-grpc v1.5.1
4
// - protoc             v5.28.2
5
// source: api/cranberry.proto
6


7
package grpc
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.64.0 or later.
19
const _ = grpc.SupportPackageIsVersion9
20


21
const (
22
	GossipService_SendBlock_FullMethodName = "/GossipService/SendBlock"
23
)
24


25
// GossipServiceClient is the client API for GossipService service.
26
//
27
// 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.
28
type GossipServiceClient interface {
29
	SendBlock(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[SendBlockMessage, SendBlockMessage], error)
30
}
31


32
type gossipServiceClient struct {
33
	cc grpc.ClientConnInterface
34
}
35


36
func NewGossipServiceClient(cc grpc.ClientConnInterface) GossipServiceClient {
37
	return &gossipServiceClient{cc}
38
}
39


40
func (c *gossipServiceClient) SendBlock(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[SendBlockMessage, SendBlockMessage], error) {
41
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
42
	stream, err := c.cc.NewStream(ctx, &GossipService_ServiceDesc.Streams[0], GossipService_SendBlock_FullMethodName, cOpts...)
43
	if err != nil {
44
		return nil, err
45
	}
46
	x := &grpc.GenericClientStream[SendBlockMessage, SendBlockMessage]{ClientStream: stream}
47
	return x, nil
48
}
49


50
// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
51
type GossipService_SendBlockClient = grpc.BidiStreamingClient[SendBlockMessage, SendBlockMessage]
52


53
// GossipServiceServer is the server API for GossipService service.
54
// All implementations must embed UnimplementedGossipServiceServer
55
// for forward compatibility.
56
type GossipServiceServer interface {
57
	SendBlock(grpc.BidiStreamingServer[SendBlockMessage, SendBlockMessage]) error
58
	mustEmbedUnimplementedGossipServiceServer()
59
}
60


61
// UnimplementedGossipServiceServer must be embedded to have
62
// forward compatible implementations.
63
//
64
// NOTE: this should be embedded by value instead of pointer to avoid a nil
65
// pointer dereference when methods are called.
66
type UnimplementedGossipServiceServer struct{}
67


68
func (UnimplementedGossipServiceServer) SendBlock(grpc.BidiStreamingServer[SendBlockMessage, SendBlockMessage]) error {
69
	return status.Errorf(codes.Unimplemented, "method SendBlock not implemented")
70
}
71
func (UnimplementedGossipServiceServer) mustEmbedUnimplementedGossipServiceServer() {}
72
func (UnimplementedGossipServiceServer) testEmbeddedByValue()                       {}
73


74
// UnsafeGossipServiceServer may be embedded to opt out of forward compatibility for this service.
75
// Use of this interface is not recommended, as added methods to GossipServiceServer will
76
// result in compilation errors.
77
type UnsafeGossipServiceServer interface {
78
	mustEmbedUnimplementedGossipServiceServer()
79
}
80


81
func RegisterGossipServiceServer(s grpc.ServiceRegistrar, srv GossipServiceServer) {
82
	// If the following call pancis, it indicates UnimplementedGossipServiceServer was
83
	// embedded by pointer and is nil.  This will cause panics if an
84
	// unimplemented method is ever invoked, so we test this at initialization
85
	// time to prevent it from happening at runtime later due to I/O.
86
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
87
		t.testEmbeddedByValue()
88
	}
89
	s.RegisterService(&GossipService_ServiceDesc, srv)
90
}
91


92
func _GossipService_SendBlock_Handler(srv interface{}, stream grpc.ServerStream) error {
93
	return srv.(GossipServiceServer).SendBlock(&grpc.GenericServerStream[SendBlockMessage, SendBlockMessage]{ServerStream: stream})
94
}
95


96
// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
97
type GossipService_SendBlockServer = grpc.BidiStreamingServer[SendBlockMessage, SendBlockMessage]
98


99
// GossipService_ServiceDesc is the grpc.ServiceDesc for GossipService service.
100
// It's only intended for direct use with grpc.RegisterService,
101
// and not to be introspected or modified (even as a copy)
102
var GossipService_ServiceDesc = grpc.ServiceDesc{
103
	ServiceName: "GossipService",
104
	HandlerType: (*GossipServiceServer)(nil),
105
	Methods:     []grpc.MethodDesc{},
106
	Streams: []grpc.StreamDesc{
107
		{
108
			StreamName:    "SendBlock",
109
			Handler:       _GossipService_SendBlock_Handler,
110
			ServerStreams: true,
111
			ClientStreams: true,
112
		},
113
	},
114
	Metadata: "api/cranberry.proto",
115
}
116


117
const (
118
	CranberryService_SendTx_FullMethodName           = "/CranberryService/SendTx"
119
	CranberryService_GetBlockByHeight_FullMethodName = "/CranberryService/GetBlockByHeight"
120
	CranberryService_AddPeer_FullMethodName          = "/CranberryService/AddPeer"
121
	CranberryService_PropagateTx_FullMethodName      = "/CranberryService/PropagateTx"
122
)
123


124
// CranberryServiceClient is the client API for CranberryService service.
125
//
126
// 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.
127
type CranberryServiceClient interface {
128
	SendTx(ctx context.Context, in *SendTxRequest, opts ...grpc.CallOption) (*SendTxResponse, error)
129
	GetBlockByHeight(ctx context.Context, in *GetBlockByHeightRequest, opts ...grpc.CallOption) (*GetBlockByHeightResponse, error)
130
	AddPeer(ctx context.Context, in *AddPeerRequest, opts ...grpc.CallOption) (*AddPeerResponse, error)
131
	PropagateTx(ctx context.Context, in *PropagateTxRequest, opts ...grpc.CallOption) (*PropagateTxResponse, error)
132
}
133


134
type cranberryServiceClient struct {
135
	cc grpc.ClientConnInterface
136
}
137


138
func NewCranberryServiceClient(cc grpc.ClientConnInterface) CranberryServiceClient {
139
	return &cranberryServiceClient{cc}
140
}
141


142
func (c *cranberryServiceClient) SendTx(ctx context.Context, in *SendTxRequest, opts ...grpc.CallOption) (*SendTxResponse, error) {
143
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
144
	out := new(SendTxResponse)
145
	err := c.cc.Invoke(ctx, CranberryService_SendTx_FullMethodName, in, out, cOpts...)
146
	if err != nil {
147
		return nil, err
148
	}
149
	return out, nil
150
}
151


152
func (c *cranberryServiceClient) GetBlockByHeight(ctx context.Context, in *GetBlockByHeightRequest, opts ...grpc.CallOption) (*GetBlockByHeightResponse, error) {
153
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
154
	out := new(GetBlockByHeightResponse)
155
	err := c.cc.Invoke(ctx, CranberryService_GetBlockByHeight_FullMethodName, in, out, cOpts...)
156
	if err != nil {
157
		return nil, err
158
	}
159
	return out, nil
160
}
161


162
func (c *cranberryServiceClient) AddPeer(ctx context.Context, in *AddPeerRequest, opts ...grpc.CallOption) (*AddPeerResponse, error) {
163
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
164
	out := new(AddPeerResponse)
165
	err := c.cc.Invoke(ctx, CranberryService_AddPeer_FullMethodName, in, out, cOpts...)
166
	if err != nil {
167
		return nil, err
168
	}
169
	return out, nil
170
}
171


172
func (c *cranberryServiceClient) PropagateTx(ctx context.Context, in *PropagateTxRequest, opts ...grpc.CallOption) (*PropagateTxResponse, error) {
173
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
174
	out := new(PropagateTxResponse)
175
	err := c.cc.Invoke(ctx, CranberryService_PropagateTx_FullMethodName, in, out, cOpts...)
176
	if err != nil {
177
		return nil, err
178
	}
179
	return out, nil
180
}
181


182
// CranberryServiceServer is the server API for CranberryService service.
183
// All implementations must embed UnimplementedCranberryServiceServer
184
// for forward compatibility.
185
type CranberryServiceServer interface {
186
	SendTx(context.Context, *SendTxRequest) (*SendTxResponse, error)
187
	GetBlockByHeight(context.Context, *GetBlockByHeightRequest) (*GetBlockByHeightResponse, error)
188
	AddPeer(context.Context, *AddPeerRequest) (*AddPeerResponse, error)
189
	PropagateTx(context.Context, *PropagateTxRequest) (*PropagateTxResponse, error)
190
	mustEmbedUnimplementedCranberryServiceServer()
191
}
192


193
// UnimplementedCranberryServiceServer must be embedded to have
194
// forward compatible implementations.
195
//
196
// NOTE: this should be embedded by value instead of pointer to avoid a nil
197
// pointer dereference when methods are called.
198
type UnimplementedCranberryServiceServer struct{}
199


200
func (UnimplementedCranberryServiceServer) SendTx(context.Context, *SendTxRequest) (*SendTxResponse, error) {
201
	return nil, status.Errorf(codes.Unimplemented, "method SendTx not implemented")
202
}
203
func (UnimplementedCranberryServiceServer) GetBlockByHeight(context.Context, *GetBlockByHeightRequest) (*GetBlockByHeightResponse, error) {
204
	return nil, status.Errorf(codes.Unimplemented, "method GetBlockByHeight not implemented")
205
}
206
func (UnimplementedCranberryServiceServer) AddPeer(context.Context, *AddPeerRequest) (*AddPeerResponse, error) {
207
	return nil, status.Errorf(codes.Unimplemented, "method AddPeer not implemented")
208
}
209
func (UnimplementedCranberryServiceServer) PropagateTx(context.Context, *PropagateTxRequest) (*PropagateTxResponse, error) {
210
	return nil, status.Errorf(codes.Unimplemented, "method PropagateTx not implemented")
211
}
212
func (UnimplementedCranberryServiceServer) mustEmbedUnimplementedCranberryServiceServer() {}
213
func (UnimplementedCranberryServiceServer) testEmbeddedByValue()                          {}
214


215
// UnsafeCranberryServiceServer may be embedded to opt out of forward compatibility for this service.
216
// Use of this interface is not recommended, as added methods to CranberryServiceServer will
217
// result in compilation errors.
218
type UnsafeCranberryServiceServer interface {
219
	mustEmbedUnimplementedCranberryServiceServer()
220
}
221


222
func RegisterCranberryServiceServer(s grpc.ServiceRegistrar, srv CranberryServiceServer) {
223
	// If the following call pancis, it indicates UnimplementedCranberryServiceServer was
224
	// embedded by pointer and is nil.  This will cause panics if an
225
	// unimplemented method is ever invoked, so we test this at initialization
226
	// time to prevent it from happening at runtime later due to I/O.
227
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
228
		t.testEmbeddedByValue()
229
	}
230
	s.RegisterService(&CranberryService_ServiceDesc, srv)
231
}
232


233
func _CranberryService_SendTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
234
	in := new(SendTxRequest)
235
	if err := dec(in); err != nil {
236
		return nil, err
237
	}
238
	if interceptor == nil {
239
		return srv.(CranberryServiceServer).SendTx(ctx, in)
240
	}
241
	info := &grpc.UnaryServerInfo{
242
		Server:     srv,
243
		FullMethod: CranberryService_SendTx_FullMethodName,
244
	}
245
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
246
		return srv.(CranberryServiceServer).SendTx(ctx, req.(*SendTxRequest))
247
	}
248
	return interceptor(ctx, in, info, handler)
249
}
250


251
func _CranberryService_GetBlockByHeight_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
252
	in := new(GetBlockByHeightRequest)
253
	if err := dec(in); err != nil {
254
		return nil, err
255
	}
256
	if interceptor == nil {
257
		return srv.(CranberryServiceServer).GetBlockByHeight(ctx, in)
258
	}
259
	info := &grpc.UnaryServerInfo{
260
		Server:     srv,
261
		FullMethod: CranberryService_GetBlockByHeight_FullMethodName,
262
	}
263
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
264
		return srv.(CranberryServiceServer).GetBlockByHeight(ctx, req.(*GetBlockByHeightRequest))
265
	}
266
	return interceptor(ctx, in, info, handler)
267
}
268


269
func _CranberryService_AddPeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
270
	in := new(AddPeerRequest)
271
	if err := dec(in); err != nil {
272
		return nil, err
273
	}
274
	if interceptor == nil {
275
		return srv.(CranberryServiceServer).AddPeer(ctx, in)
276
	}
277
	info := &grpc.UnaryServerInfo{
278
		Server:     srv,
279
		FullMethod: CranberryService_AddPeer_FullMethodName,
280
	}
281
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
282
		return srv.(CranberryServiceServer).AddPeer(ctx, req.(*AddPeerRequest))
283
	}
284
	return interceptor(ctx, in, info, handler)
285
}
286


287
func _CranberryService_PropagateTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
288
	in := new(PropagateTxRequest)
289
	if err := dec(in); err != nil {
290
		return nil, err
291
	}
292
	if interceptor == nil {
293
		return srv.(CranberryServiceServer).PropagateTx(ctx, in)
294
	}
295
	info := &grpc.UnaryServerInfo{
296
		Server:     srv,
297
		FullMethod: CranberryService_PropagateTx_FullMethodName,
298
	}
299
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
300
		return srv.(CranberryServiceServer).PropagateTx(ctx, req.(*PropagateTxRequest))
301
	}
302
	return interceptor(ctx, in, info, handler)
303
}
304


305
// CranberryService_ServiceDesc is the grpc.ServiceDesc for CranberryService service.
306
// It's only intended for direct use with grpc.RegisterService,
307
// and not to be introspected or modified (even as a copy)
308
var CranberryService_ServiceDesc = grpc.ServiceDesc{
309
	ServiceName: "CranberryService",
310
	HandlerType: (*CranberryServiceServer)(nil),
311
	Methods: []grpc.MethodDesc{
312
		{
313
			MethodName: "SendTx",
314
			Handler:    _CranberryService_SendTx_Handler,
315
		},
316
		{
317
			MethodName: "GetBlockByHeight",
318
			Handler:    _CranberryService_GetBlockByHeight_Handler,
319
		},
320
		{
321
			MethodName: "AddPeer",
322
			Handler:    _CranberryService_AddPeer_Handler,
323
		},
324
		{
325
			MethodName: "PropagateTx",
326
			Handler:    _CranberryService_PropagateTx_Handler,
327
		},
328
	},
329
	Streams:  []grpc.StreamDesc{},
330
	Metadata: "api/cranberry.proto",
331
}
332

Использование cookies

Мы используем файлы cookie в соответствии с Политикой конфиденциальности и Политикой использования cookies.

Нажимая кнопку «Принимаю», Вы даете АО «СберТех» согласие на обработку Ваших персональных данных в целях совершенствования нашего веб-сайта и Сервиса GitVerse, а также повышения удобства их использования.

Запретить использование cookies Вы можете самостоятельно в настройках Вашего браузера.