1#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4pub struct Timestamp {
5 #[prost(int64, tag = "1")]
7 pub seconds: i64,
8 #[prost(int32, tag = "2")]
10 pub nanos: i32,
11}
12#[derive(Clone, PartialEq, ::prost::Message)]
14pub struct CreateParams {
15 #[prost(string, tag = "1")]
17 pub table: ::prost::alloc::string::String,
18}
19#[derive(Clone, PartialEq, ::prost::Message)]
21pub struct CreateQuery {
22 #[prost(string, tag = "1")]
24 pub pluck: ::prost::alloc::string::String,
25 #[prost(string, tag = "2")]
27 pub durability: ::prost::alloc::string::String,
28}
29#[derive(Clone, PartialEq, ::prost::Message)]
31pub struct Items {
32 #[prost(int32, tag = "1")]
33 pub tombstone: i32,
34 #[prost(string, tag = "2")]
35 pub status: ::prost::alloc::string::String,
36 #[prost(string, optional, tag = "3")]
37 pub previous_status: ::core::option::Option<::prost::alloc::string::String>,
38 #[prost(int32, tag = "4")]
39 pub version: i32,
40 #[prost(string, optional, tag = "5")]
41 pub created_date: ::core::option::Option<::prost::alloc::string::String>,
42 #[prost(string, optional, tag = "6")]
43 pub created_time: ::core::option::Option<::prost::alloc::string::String>,
44 #[prost(string, optional, tag = "7")]
45 pub updated_date: ::core::option::Option<::prost::alloc::string::String>,
46 #[prost(string, optional, tag = "8")]
47 pub updated_time: ::core::option::Option<::prost::alloc::string::String>,
48 #[prost(string, optional, tag = "9")]
49 pub organization_id: ::core::option::Option<::prost::alloc::string::String>,
50 #[prost(string, optional, tag = "10")]
51 pub created_by: ::core::option::Option<::prost::alloc::string::String>,
52 #[prost(string, optional, tag = "11")]
53 pub updated_by: ::core::option::Option<::prost::alloc::string::String>,
54 #[prost(string, optional, tag = "12")]
55 pub deleted_by: ::core::option::Option<::prost::alloc::string::String>,
56 #[prost(string, optional, tag = "13")]
57 pub requested_by: ::core::option::Option<::prost::alloc::string::String>,
58 #[prost(string, repeated, tag = "14")]
59 pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
60 #[prost(int32, tag = "15")]
61 pub id: i32,
62 #[prost(string, tag = "16")]
63 pub name: ::prost::alloc::string::String,
64 #[prost(string, optional, tag = "17")]
65 pub description: ::core::option::Option<::prost::alloc::string::String>,
66}
67#[derive(Clone, PartialEq, ::prost::Message)]
69pub struct Packets {
70 #[prost(int32, optional, tag = "1")]
71 pub tombstone: ::core::option::Option<i32>,
72 #[prost(string, optional, tag = "2")]
73 pub status: ::core::option::Option<::prost::alloc::string::String>,
74 #[prost(string, optional, tag = "3")]
75 pub previous_status: ::core::option::Option<::prost::alloc::string::String>,
76 #[prost(int32, optional, tag = "4")]
77 pub version: ::core::option::Option<i32>,
78 #[prost(string, optional, tag = "5")]
79 pub created_date: ::core::option::Option<::prost::alloc::string::String>,
80 #[prost(string, optional, tag = "6")]
81 pub created_time: ::core::option::Option<::prost::alloc::string::String>,
82 #[prost(string, optional, tag = "7")]
83 pub updated_date: ::core::option::Option<::prost::alloc::string::String>,
84 #[prost(string, optional, tag = "8")]
85 pub updated_time: ::core::option::Option<::prost::alloc::string::String>,
86 #[prost(string, optional, tag = "9")]
87 pub organization_id: ::core::option::Option<::prost::alloc::string::String>,
88 #[prost(string, optional, tag = "10")]
89 pub created_by: ::core::option::Option<::prost::alloc::string::String>,
90 #[prost(string, optional, tag = "11")]
91 pub updated_by: ::core::option::Option<::prost::alloc::string::String>,
92 #[prost(string, optional, tag = "12")]
93 pub deleted_by: ::core::option::Option<::prost::alloc::string::String>,
94 #[prost(string, optional, tag = "13")]
95 pub requested_by: ::core::option::Option<::prost::alloc::string::String>,
96 #[prost(string, repeated, tag = "14")]
97 pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
98 #[prost(string, tag = "15")]
99 pub id: ::prost::alloc::string::String,
100 #[prost(string, tag = "16")]
101 pub timestamp: ::prost::alloc::string::String,
102 #[prost(string, optional, tag = "17")]
103 pub hypertable_timestamp: ::core::option::Option<::prost::alloc::string::String>,
104 #[prost(string, optional, tag = "18")]
105 pub interface_name: ::core::option::Option<::prost::alloc::string::String>,
106 #[prost(string, optional, tag = "19")]
107 pub device_id: ::core::option::Option<::prost::alloc::string::String>,
108 #[prost(string, optional, tag = "20")]
109 pub source_mac: ::core::option::Option<::prost::alloc::string::String>,
110 #[prost(string, optional, tag = "21")]
111 pub destination_mac: ::core::option::Option<::prost::alloc::string::String>,
112 #[prost(string, optional, tag = "22")]
113 pub ether_type: ::core::option::Option<::prost::alloc::string::String>,
114 #[prost(string, optional, tag = "23")]
115 pub protocol: ::core::option::Option<::prost::alloc::string::String>,
116 #[prost(int32, optional, tag = "24")]
117 pub total_length: ::core::option::Option<i32>,
118 #[prost(string, optional, tag = "25")]
119 pub source_ip: ::core::option::Option<::prost::alloc::string::String>,
120 #[prost(string, optional, tag = "26")]
121 pub destination_ip: ::core::option::Option<::prost::alloc::string::String>,
122 #[prost(int32, optional, tag = "27")]
123 pub source_port: ::core::option::Option<i32>,
124 #[prost(int32, optional, tag = "28")]
125 pub destination_port: ::core::option::Option<i32>,
126 #[prost(int32, optional, tag = "29")]
127 pub tcp_header_length: ::core::option::Option<i32>,
128 #[prost(int64, optional, tag = "30")]
129 pub tcp_sequence_number: ::core::option::Option<i64>,
130 #[prost(int64, optional, tag = "31")]
131 pub tcp_acknowledgment_number: ::core::option::Option<i64>,
132 #[prost(int32, optional, tag = "32")]
133 pub tcp_data_offset: ::core::option::Option<i32>,
134 #[prost(int32, optional, tag = "33")]
135 pub tcp_flags: ::core::option::Option<i32>,
136 #[prost(int32, optional, tag = "34")]
137 pub tcp_window_size: ::core::option::Option<i32>,
138 #[prost(int32, optional, tag = "35")]
139 pub tcp_urgent_pointer: ::core::option::Option<i32>,
140 #[prost(int32, optional, tag = "36")]
141 pub icmp_type: ::core::option::Option<i32>,
142 #[prost(int32, optional, tag = "37")]
143 pub icmp_code: ::core::option::Option<i32>,
144}
145#[derive(Clone, PartialEq, ::prost::Message)]
147pub struct Connections {
148 #[prost(int32, optional, tag = "1")]
149 pub tombstone: ::core::option::Option<i32>,
150 #[prost(string, optional, tag = "2")]
151 pub status: ::core::option::Option<::prost::alloc::string::String>,
152 #[prost(string, optional, tag = "3")]
153 pub previous_status: ::core::option::Option<::prost::alloc::string::String>,
154 #[prost(int32, optional, tag = "4")]
155 pub version: ::core::option::Option<i32>,
156 #[prost(string, optional, tag = "5")]
157 pub created_date: ::core::option::Option<::prost::alloc::string::String>,
158 #[prost(string, optional, tag = "6")]
159 pub created_time: ::core::option::Option<::prost::alloc::string::String>,
160 #[prost(string, optional, tag = "7")]
161 pub updated_date: ::core::option::Option<::prost::alloc::string::String>,
162 #[prost(string, optional, tag = "8")]
163 pub updated_time: ::core::option::Option<::prost::alloc::string::String>,
164 #[prost(string, optional, tag = "9")]
165 pub organization_id: ::core::option::Option<::prost::alloc::string::String>,
166 #[prost(string, optional, tag = "10")]
167 pub created_by: ::core::option::Option<::prost::alloc::string::String>,
168 #[prost(string, optional, tag = "11")]
169 pub updated_by: ::core::option::Option<::prost::alloc::string::String>,
170 #[prost(string, optional, tag = "12")]
171 pub deleted_by: ::core::option::Option<::prost::alloc::string::String>,
172 #[prost(string, optional, tag = "13")]
173 pub requested_by: ::core::option::Option<::prost::alloc::string::String>,
174 #[prost(string, repeated, tag = "14")]
175 pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
176 #[prost(string, tag = "15")]
177 pub id: ::prost::alloc::string::String,
178 #[prost(string, tag = "16")]
179 pub timestamp: ::prost::alloc::string::String,
180 #[prost(string, optional, tag = "17")]
181 pub interface_name: ::core::option::Option<::prost::alloc::string::String>,
182 #[prost(string, optional, tag = "18")]
183 pub hypertable_timestamp: ::core::option::Option<::prost::alloc::string::String>,
184 #[prost(int32, optional, tag = "19")]
185 pub total_packet: ::core::option::Option<i32>,
186 #[prost(int32, optional, tag = "20")]
187 pub total_byte: ::core::option::Option<i32>,
188 #[prost(string, optional, tag = "21")]
189 pub device_id: ::core::option::Option<::prost::alloc::string::String>,
190 #[prost(string, optional, tag = "22")]
191 pub protocol: ::core::option::Option<::prost::alloc::string::String>,
192 #[prost(string, optional, tag = "23")]
193 pub source_ip: ::core::option::Option<::prost::alloc::string::String>,
194 #[prost(string, optional, tag = "24")]
195 pub destination_ip: ::core::option::Option<::prost::alloc::string::String>,
196 #[prost(string, optional, tag = "25")]
197 pub remote_ip: ::core::option::Option<::prost::alloc::string::String>,
198 #[prost(int32, optional, tag = "26")]
199 pub source_port: ::core::option::Option<i32>,
200 #[prost(int32, optional, tag = "27")]
201 pub destination_port: ::core::option::Option<i32>,
202}
203#[derive(Clone, PartialEq, ::prost::Message)]
205pub struct CrdtMessages {
206 #[prost(string, optional, tag = "1")]
207 pub database: ::core::option::Option<::prost::alloc::string::String>,
208 #[prost(string, tag = "2")]
209 pub dataset: ::prost::alloc::string::String,
210 #[prost(string, tag = "3")]
211 pub group_id: ::prost::alloc::string::String,
212 #[prost(string, tag = "4")]
213 pub timestamp: ::prost::alloc::string::String,
214 #[prost(string, tag = "5")]
215 pub row: ::prost::alloc::string::String,
216 #[prost(string, tag = "6")]
217 pub column: ::prost::alloc::string::String,
218 #[prost(string, tag = "7")]
219 pub client_id: ::prost::alloc::string::String,
220 #[prost(string, tag = "8")]
221 pub value: ::prost::alloc::string::String,
222 #[prost(string, tag = "9")]
223 pub operation: ::prost::alloc::string::String,
224 #[prost(string, optional, tag = "10")]
225 pub hypertable_timestamp: ::core::option::Option<::prost::alloc::string::String>,
226}
227#[derive(Clone, PartialEq, ::prost::Message)]
229pub struct CrdtMerkles {
230 #[prost(string, tag = "1")]
231 pub group_id: ::prost::alloc::string::String,
232 #[prost(string, tag = "2")]
233 pub timestamp: ::prost::alloc::string::String,
234 #[prost(string, tag = "3")]
235 pub merkle: ::prost::alloc::string::String,
236}
237#[derive(Clone, PartialEq, ::prost::Message)]
239pub struct SyncEndpoints {
240 #[prost(string, tag = "1")]
241 pub id: ::prost::alloc::string::String,
242 #[prost(string, tag = "2")]
243 pub name: ::prost::alloc::string::String,
244 #[prost(string, tag = "3")]
245 pub url: ::prost::alloc::string::String,
246 #[prost(string, tag = "4")]
247 pub group_id: ::prost::alloc::string::String,
248 #[prost(string, tag = "5")]
249 pub username: ::prost::alloc::string::String,
250 #[prost(string, tag = "6")]
251 pub password: ::prost::alloc::string::String,
252 #[prost(string, tag = "7")]
253 pub status: ::prost::alloc::string::String,
254}
255#[derive(Clone, PartialEq, ::prost::Message)]
257pub struct Queues {
258 #[prost(string, tag = "1")]
259 pub id: ::prost::alloc::string::String,
260 #[prost(string, tag = "2")]
261 pub name: ::prost::alloc::string::String,
262 #[prost(int32, tag = "3")]
263 pub size: i32,
264 #[prost(int32, tag = "4")]
265 pub count: i32,
266}
267#[derive(Clone, PartialEq, ::prost::Message)]
269pub struct QueueItems {
270 #[prost(string, tag = "1")]
271 pub id: ::prost::alloc::string::String,
272 #[prost(int32, tag = "2")]
273 pub order: i32,
274 #[prost(string, tag = "3")]
275 pub queue_id: ::prost::alloc::string::String,
276 #[prost(string, tag = "4")]
277 pub value: ::prost::alloc::string::String,
278}
279#[derive(Clone, PartialEq, ::prost::Message)]
281pub struct Transactions {
282 #[prost(string, tag = "1")]
283 pub id: ::prost::alloc::string::String,
284 #[prost(string, tag = "2")]
285 pub timestamp: ::prost::alloc::string::String,
286 #[prost(string, tag = "3")]
287 pub status: ::prost::alloc::string::String,
288 #[prost(int64, tag = "4")]
289 pub expiry: i64,
290}
291#[derive(Clone, PartialEq, ::prost::Message)]
293pub struct CreateItemsRequest {
294 #[prost(message, optional, tag = "1")]
295 pub items: ::core::option::Option<Items>,
296 #[prost(message, optional, tag = "2")]
297 pub params: ::core::option::Option<CreateParams>,
298 #[prost(message, optional, tag = "3")]
299 pub query: ::core::option::Option<CreateQuery>,
300 #[prost(string, tag = "4")]
302 pub entity_prefix: ::prost::alloc::string::String,
303}
304#[derive(Clone, PartialEq, ::prost::Message)]
306pub struct CreateItemsResponse {
307 #[prost(bool, tag = "1")]
308 pub success: bool,
309 #[prost(int32, tag = "2")]
310 pub count: i32,
311 #[prost(string, tag = "3")]
312 pub message: ::prost::alloc::string::String,
313 #[prost(message, optional, tag = "4")]
314 pub data: ::core::option::Option<Items>,
315}
316#[derive(Clone, PartialEq, ::prost::Message)]
318pub struct GetItemsRequest {
319 #[prost(string, tag = "1")]
320 pub id: ::prost::alloc::string::String,
321}
322#[derive(Clone, PartialEq, ::prost::Message)]
324pub struct GetItemsResponse {
325 #[prost(bool, tag = "1")]
326 pub success: bool,
327 #[prost(string, tag = "2")]
328 pub message: ::prost::alloc::string::String,
329 #[prost(message, optional, tag = "3")]
330 pub data: ::core::option::Option<Items>,
331}
332#[derive(Clone, PartialEq, ::prost::Message)]
334pub struct UpdateItemsRequest {
335 #[prost(message, optional, tag = "1")]
336 pub items: ::core::option::Option<Items>,
337}
338#[derive(Clone, PartialEq, ::prost::Message)]
340pub struct UpdateItemsResponse {
341 #[prost(bool, tag = "1")]
342 pub success: bool,
343 #[prost(string, tag = "2")]
344 pub message: ::prost::alloc::string::String,
345 #[prost(message, optional, tag = "3")]
346 pub data: ::core::option::Option<Items>,
347}
348#[derive(Clone, PartialEq, ::prost::Message)]
350pub struct DeleteItemsRequest {
351 #[prost(string, tag = "1")]
352 pub id: ::prost::alloc::string::String,
353}
354#[derive(Clone, PartialEq, ::prost::Message)]
356pub struct DeleteItemsResponse {
357 #[prost(bool, tag = "1")]
358 pub success: bool,
359 #[prost(string, tag = "2")]
360 pub message: ::prost::alloc::string::String,
361}
362#[derive(Clone, PartialEq, ::prost::Message)]
364pub struct CreatePacketsRequest {
365 #[prost(message, optional, tag = "1")]
366 pub packets: ::core::option::Option<Packets>,
367 #[prost(message, optional, tag = "2")]
368 pub params: ::core::option::Option<CreateParams>,
369 #[prost(message, optional, tag = "3")]
370 pub query: ::core::option::Option<CreateQuery>,
371 #[prost(string, tag = "4")]
373 pub entity_prefix: ::prost::alloc::string::String,
374}
375#[derive(Clone, PartialEq, ::prost::Message)]
377pub struct CreatePacketsResponse {
378 #[prost(bool, tag = "1")]
379 pub success: bool,
380 #[prost(int32, tag = "2")]
381 pub count: i32,
382 #[prost(string, tag = "3")]
383 pub message: ::prost::alloc::string::String,
384 #[prost(message, optional, tag = "4")]
385 pub data: ::core::option::Option<Packets>,
386}
387#[derive(Clone, PartialEq, ::prost::Message)]
389pub struct GetPacketsRequest {
390 #[prost(string, tag = "1")]
391 pub id: ::prost::alloc::string::String,
392}
393#[derive(Clone, PartialEq, ::prost::Message)]
395pub struct GetPacketsResponse {
396 #[prost(bool, tag = "1")]
397 pub success: bool,
398 #[prost(string, tag = "2")]
399 pub message: ::prost::alloc::string::String,
400 #[prost(message, optional, tag = "3")]
401 pub data: ::core::option::Option<Packets>,
402}
403#[derive(Clone, PartialEq, ::prost::Message)]
405pub struct UpdatePacketsRequest {
406 #[prost(message, optional, tag = "1")]
407 pub packets: ::core::option::Option<Packets>,
408}
409#[derive(Clone, PartialEq, ::prost::Message)]
411pub struct UpdatePacketsResponse {
412 #[prost(bool, tag = "1")]
413 pub success: bool,
414 #[prost(string, tag = "2")]
415 pub message: ::prost::alloc::string::String,
416 #[prost(message, optional, tag = "3")]
417 pub data: ::core::option::Option<Packets>,
418}
419#[derive(Clone, PartialEq, ::prost::Message)]
421pub struct DeletePacketsRequest {
422 #[prost(string, tag = "1")]
423 pub id: ::prost::alloc::string::String,
424}
425#[derive(Clone, PartialEq, ::prost::Message)]
427pub struct DeletePacketsResponse {
428 #[prost(bool, tag = "1")]
429 pub success: bool,
430 #[prost(string, tag = "2")]
431 pub message: ::prost::alloc::string::String,
432}
433#[derive(Clone, PartialEq, ::prost::Message)]
435pub struct CreateConnectionsRequest {
436 #[prost(message, optional, tag = "1")]
437 pub connections: ::core::option::Option<Connections>,
438 #[prost(message, optional, tag = "2")]
439 pub params: ::core::option::Option<CreateParams>,
440 #[prost(message, optional, tag = "3")]
441 pub query: ::core::option::Option<CreateQuery>,
442 #[prost(string, tag = "4")]
444 pub entity_prefix: ::prost::alloc::string::String,
445}
446#[derive(Clone, PartialEq, ::prost::Message)]
448pub struct CreateConnectionsResponse {
449 #[prost(bool, tag = "1")]
450 pub success: bool,
451 #[prost(int32, tag = "2")]
452 pub count: i32,
453 #[prost(string, tag = "3")]
454 pub message: ::prost::alloc::string::String,
455 #[prost(message, optional, tag = "4")]
456 pub data: ::core::option::Option<Connections>,
457}
458#[derive(Clone, PartialEq, ::prost::Message)]
460pub struct GetConnectionsRequest {
461 #[prost(string, tag = "1")]
462 pub id: ::prost::alloc::string::String,
463}
464#[derive(Clone, PartialEq, ::prost::Message)]
466pub struct GetConnectionsResponse {
467 #[prost(bool, tag = "1")]
468 pub success: bool,
469 #[prost(string, tag = "2")]
470 pub message: ::prost::alloc::string::String,
471 #[prost(message, optional, tag = "3")]
472 pub data: ::core::option::Option<Connections>,
473}
474#[derive(Clone, PartialEq, ::prost::Message)]
476pub struct UpdateConnectionsRequest {
477 #[prost(message, optional, tag = "1")]
478 pub connections: ::core::option::Option<Connections>,
479}
480#[derive(Clone, PartialEq, ::prost::Message)]
482pub struct UpdateConnectionsResponse {
483 #[prost(bool, tag = "1")]
484 pub success: bool,
485 #[prost(string, tag = "2")]
486 pub message: ::prost::alloc::string::String,
487 #[prost(message, optional, tag = "3")]
488 pub data: ::core::option::Option<Connections>,
489}
490#[derive(Clone, PartialEq, ::prost::Message)]
492pub struct DeleteConnectionsRequest {
493 #[prost(string, tag = "1")]
494 pub id: ::prost::alloc::string::String,
495}
496#[derive(Clone, PartialEq, ::prost::Message)]
498pub struct DeleteConnectionsResponse {
499 #[prost(bool, tag = "1")]
500 pub success: bool,
501 #[prost(string, tag = "2")]
502 pub message: ::prost::alloc::string::String,
503}
504#[derive(Clone, PartialEq, ::prost::Message)]
506pub struct CreateCrdtMessagesRequest {
507 #[prost(message, optional, tag = "1")]
508 pub crdt_messages: ::core::option::Option<CrdtMessages>,
509 #[prost(message, optional, tag = "2")]
510 pub params: ::core::option::Option<CreateParams>,
511 #[prost(message, optional, tag = "3")]
512 pub query: ::core::option::Option<CreateQuery>,
513 #[prost(string, tag = "4")]
515 pub entity_prefix: ::prost::alloc::string::String,
516}
517#[derive(Clone, PartialEq, ::prost::Message)]
519pub struct CreateCrdtMessagesResponse {
520 #[prost(bool, tag = "1")]
521 pub success: bool,
522 #[prost(int32, tag = "2")]
523 pub count: i32,
524 #[prost(string, tag = "3")]
525 pub message: ::prost::alloc::string::String,
526 #[prost(message, optional, tag = "4")]
527 pub data: ::core::option::Option<CrdtMessages>,
528}
529#[derive(Clone, PartialEq, ::prost::Message)]
531pub struct GetCrdtMessagesRequest {
532 #[prost(string, tag = "1")]
533 pub id: ::prost::alloc::string::String,
534}
535#[derive(Clone, PartialEq, ::prost::Message)]
537pub struct GetCrdtMessagesResponse {
538 #[prost(bool, tag = "1")]
539 pub success: bool,
540 #[prost(string, tag = "2")]
541 pub message: ::prost::alloc::string::String,
542 #[prost(message, optional, tag = "3")]
543 pub data: ::core::option::Option<CrdtMessages>,
544}
545#[derive(Clone, PartialEq, ::prost::Message)]
547pub struct UpdateCrdtMessagesRequest {
548 #[prost(message, optional, tag = "1")]
549 pub crdt_messages: ::core::option::Option<CrdtMessages>,
550}
551#[derive(Clone, PartialEq, ::prost::Message)]
553pub struct UpdateCrdtMessagesResponse {
554 #[prost(bool, tag = "1")]
555 pub success: bool,
556 #[prost(string, tag = "2")]
557 pub message: ::prost::alloc::string::String,
558 #[prost(message, optional, tag = "3")]
559 pub data: ::core::option::Option<CrdtMessages>,
560}
561#[derive(Clone, PartialEq, ::prost::Message)]
563pub struct DeleteCrdtMessagesRequest {
564 #[prost(string, tag = "1")]
565 pub id: ::prost::alloc::string::String,
566}
567#[derive(Clone, PartialEq, ::prost::Message)]
569pub struct DeleteCrdtMessagesResponse {
570 #[prost(bool, tag = "1")]
571 pub success: bool,
572 #[prost(string, tag = "2")]
573 pub message: ::prost::alloc::string::String,
574}
575#[derive(Clone, PartialEq, ::prost::Message)]
577pub struct CreateCrdtMerklesRequest {
578 #[prost(message, optional, tag = "1")]
579 pub crdt_merkles: ::core::option::Option<CrdtMerkles>,
580 #[prost(message, optional, tag = "2")]
581 pub params: ::core::option::Option<CreateParams>,
582 #[prost(message, optional, tag = "3")]
583 pub query: ::core::option::Option<CreateQuery>,
584 #[prost(string, tag = "4")]
586 pub entity_prefix: ::prost::alloc::string::String,
587}
588#[derive(Clone, PartialEq, ::prost::Message)]
590pub struct CreateCrdtMerklesResponse {
591 #[prost(bool, tag = "1")]
592 pub success: bool,
593 #[prost(int32, tag = "2")]
594 pub count: i32,
595 #[prost(string, tag = "3")]
596 pub message: ::prost::alloc::string::String,
597 #[prost(message, optional, tag = "4")]
598 pub data: ::core::option::Option<CrdtMerkles>,
599}
600#[derive(Clone, PartialEq, ::prost::Message)]
602pub struct GetCrdtMerklesRequest {
603 #[prost(string, tag = "1")]
604 pub id: ::prost::alloc::string::String,
605}
606#[derive(Clone, PartialEq, ::prost::Message)]
608pub struct GetCrdtMerklesResponse {
609 #[prost(bool, tag = "1")]
610 pub success: bool,
611 #[prost(string, tag = "2")]
612 pub message: ::prost::alloc::string::String,
613 #[prost(message, optional, tag = "3")]
614 pub data: ::core::option::Option<CrdtMerkles>,
615}
616#[derive(Clone, PartialEq, ::prost::Message)]
618pub struct UpdateCrdtMerklesRequest {
619 #[prost(message, optional, tag = "1")]
620 pub crdt_merkles: ::core::option::Option<CrdtMerkles>,
621}
622#[derive(Clone, PartialEq, ::prost::Message)]
624pub struct UpdateCrdtMerklesResponse {
625 #[prost(bool, tag = "1")]
626 pub success: bool,
627 #[prost(string, tag = "2")]
628 pub message: ::prost::alloc::string::String,
629 #[prost(message, optional, tag = "3")]
630 pub data: ::core::option::Option<CrdtMerkles>,
631}
632#[derive(Clone, PartialEq, ::prost::Message)]
634pub struct DeleteCrdtMerklesRequest {
635 #[prost(string, tag = "1")]
636 pub id: ::prost::alloc::string::String,
637}
638#[derive(Clone, PartialEq, ::prost::Message)]
640pub struct DeleteCrdtMerklesResponse {
641 #[prost(bool, tag = "1")]
642 pub success: bool,
643 #[prost(string, tag = "2")]
644 pub message: ::prost::alloc::string::String,
645}
646#[derive(Clone, PartialEq, ::prost::Message)]
648pub struct CreateSyncEndpointsRequest {
649 #[prost(message, optional, tag = "1")]
650 pub sync_endpoints: ::core::option::Option<SyncEndpoints>,
651 #[prost(message, optional, tag = "2")]
652 pub params: ::core::option::Option<CreateParams>,
653 #[prost(message, optional, tag = "3")]
654 pub query: ::core::option::Option<CreateQuery>,
655 #[prost(string, tag = "4")]
657 pub entity_prefix: ::prost::alloc::string::String,
658}
659#[derive(Clone, PartialEq, ::prost::Message)]
661pub struct CreateSyncEndpointsResponse {
662 #[prost(bool, tag = "1")]
663 pub success: bool,
664 #[prost(int32, tag = "2")]
665 pub count: i32,
666 #[prost(string, tag = "3")]
667 pub message: ::prost::alloc::string::String,
668 #[prost(message, optional, tag = "4")]
669 pub data: ::core::option::Option<SyncEndpoints>,
670}
671#[derive(Clone, PartialEq, ::prost::Message)]
673pub struct GetSyncEndpointsRequest {
674 #[prost(string, tag = "1")]
675 pub id: ::prost::alloc::string::String,
676}
677#[derive(Clone, PartialEq, ::prost::Message)]
679pub struct GetSyncEndpointsResponse {
680 #[prost(bool, tag = "1")]
681 pub success: bool,
682 #[prost(string, tag = "2")]
683 pub message: ::prost::alloc::string::String,
684 #[prost(message, optional, tag = "3")]
685 pub data: ::core::option::Option<SyncEndpoints>,
686}
687#[derive(Clone, PartialEq, ::prost::Message)]
689pub struct UpdateSyncEndpointsRequest {
690 #[prost(message, optional, tag = "1")]
691 pub sync_endpoints: ::core::option::Option<SyncEndpoints>,
692}
693#[derive(Clone, PartialEq, ::prost::Message)]
695pub struct UpdateSyncEndpointsResponse {
696 #[prost(bool, tag = "1")]
697 pub success: bool,
698 #[prost(string, tag = "2")]
699 pub message: ::prost::alloc::string::String,
700 #[prost(message, optional, tag = "3")]
701 pub data: ::core::option::Option<SyncEndpoints>,
702}
703#[derive(Clone, PartialEq, ::prost::Message)]
705pub struct DeleteSyncEndpointsRequest {
706 #[prost(string, tag = "1")]
707 pub id: ::prost::alloc::string::String,
708}
709#[derive(Clone, PartialEq, ::prost::Message)]
711pub struct DeleteSyncEndpointsResponse {
712 #[prost(bool, tag = "1")]
713 pub success: bool,
714 #[prost(string, tag = "2")]
715 pub message: ::prost::alloc::string::String,
716}
717#[derive(Clone, PartialEq, ::prost::Message)]
719pub struct CreateQueuesRequest {
720 #[prost(message, optional, tag = "1")]
721 pub queues: ::core::option::Option<Queues>,
722 #[prost(message, optional, tag = "2")]
723 pub params: ::core::option::Option<CreateParams>,
724 #[prost(message, optional, tag = "3")]
725 pub query: ::core::option::Option<CreateQuery>,
726 #[prost(string, tag = "4")]
728 pub entity_prefix: ::prost::alloc::string::String,
729}
730#[derive(Clone, PartialEq, ::prost::Message)]
732pub struct CreateQueuesResponse {
733 #[prost(bool, tag = "1")]
734 pub success: bool,
735 #[prost(int32, tag = "2")]
736 pub count: i32,
737 #[prost(string, tag = "3")]
738 pub message: ::prost::alloc::string::String,
739 #[prost(message, optional, tag = "4")]
740 pub data: ::core::option::Option<Queues>,
741}
742#[derive(Clone, PartialEq, ::prost::Message)]
744pub struct GetQueuesRequest {
745 #[prost(string, tag = "1")]
746 pub id: ::prost::alloc::string::String,
747}
748#[derive(Clone, PartialEq, ::prost::Message)]
750pub struct GetQueuesResponse {
751 #[prost(bool, tag = "1")]
752 pub success: bool,
753 #[prost(string, tag = "2")]
754 pub message: ::prost::alloc::string::String,
755 #[prost(message, optional, tag = "3")]
756 pub data: ::core::option::Option<Queues>,
757}
758#[derive(Clone, PartialEq, ::prost::Message)]
760pub struct UpdateQueuesRequest {
761 #[prost(message, optional, tag = "1")]
762 pub queues: ::core::option::Option<Queues>,
763}
764#[derive(Clone, PartialEq, ::prost::Message)]
766pub struct UpdateQueuesResponse {
767 #[prost(bool, tag = "1")]
768 pub success: bool,
769 #[prost(string, tag = "2")]
770 pub message: ::prost::alloc::string::String,
771 #[prost(message, optional, tag = "3")]
772 pub data: ::core::option::Option<Queues>,
773}
774#[derive(Clone, PartialEq, ::prost::Message)]
776pub struct DeleteQueuesRequest {
777 #[prost(string, tag = "1")]
778 pub id: ::prost::alloc::string::String,
779}
780#[derive(Clone, PartialEq, ::prost::Message)]
782pub struct DeleteQueuesResponse {
783 #[prost(bool, tag = "1")]
784 pub success: bool,
785 #[prost(string, tag = "2")]
786 pub message: ::prost::alloc::string::String,
787}
788#[derive(Clone, PartialEq, ::prost::Message)]
790pub struct CreateQueueItemsRequest {
791 #[prost(message, optional, tag = "1")]
792 pub queue_items: ::core::option::Option<QueueItems>,
793 #[prost(message, optional, tag = "2")]
794 pub params: ::core::option::Option<CreateParams>,
795 #[prost(message, optional, tag = "3")]
796 pub query: ::core::option::Option<CreateQuery>,
797 #[prost(string, tag = "4")]
799 pub entity_prefix: ::prost::alloc::string::String,
800}
801#[derive(Clone, PartialEq, ::prost::Message)]
803pub struct CreateQueueItemsResponse {
804 #[prost(bool, tag = "1")]
805 pub success: bool,
806 #[prost(int32, tag = "2")]
807 pub count: i32,
808 #[prost(string, tag = "3")]
809 pub message: ::prost::alloc::string::String,
810 #[prost(message, optional, tag = "4")]
811 pub data: ::core::option::Option<QueueItems>,
812}
813#[derive(Clone, PartialEq, ::prost::Message)]
815pub struct GetQueueItemsRequest {
816 #[prost(string, tag = "1")]
817 pub id: ::prost::alloc::string::String,
818}
819#[derive(Clone, PartialEq, ::prost::Message)]
821pub struct GetQueueItemsResponse {
822 #[prost(bool, tag = "1")]
823 pub success: bool,
824 #[prost(string, tag = "2")]
825 pub message: ::prost::alloc::string::String,
826 #[prost(message, optional, tag = "3")]
827 pub data: ::core::option::Option<QueueItems>,
828}
829#[derive(Clone, PartialEq, ::prost::Message)]
831pub struct UpdateQueueItemsRequest {
832 #[prost(message, optional, tag = "1")]
833 pub queue_items: ::core::option::Option<QueueItems>,
834}
835#[derive(Clone, PartialEq, ::prost::Message)]
837pub struct UpdateQueueItemsResponse {
838 #[prost(bool, tag = "1")]
839 pub success: bool,
840 #[prost(string, tag = "2")]
841 pub message: ::prost::alloc::string::String,
842 #[prost(message, optional, tag = "3")]
843 pub data: ::core::option::Option<QueueItems>,
844}
845#[derive(Clone, PartialEq, ::prost::Message)]
847pub struct DeleteQueueItemsRequest {
848 #[prost(string, tag = "1")]
849 pub id: ::prost::alloc::string::String,
850}
851#[derive(Clone, PartialEq, ::prost::Message)]
853pub struct DeleteQueueItemsResponse {
854 #[prost(bool, tag = "1")]
855 pub success: bool,
856 #[prost(string, tag = "2")]
857 pub message: ::prost::alloc::string::String,
858}
859#[derive(Clone, PartialEq, ::prost::Message)]
861pub struct CreateTransactionsRequest {
862 #[prost(message, optional, tag = "1")]
863 pub transactions: ::core::option::Option<Transactions>,
864 #[prost(message, optional, tag = "2")]
865 pub params: ::core::option::Option<CreateParams>,
866 #[prost(message, optional, tag = "3")]
867 pub query: ::core::option::Option<CreateQuery>,
868 #[prost(string, tag = "4")]
870 pub entity_prefix: ::prost::alloc::string::String,
871}
872#[derive(Clone, PartialEq, ::prost::Message)]
874pub struct CreateTransactionsResponse {
875 #[prost(bool, tag = "1")]
876 pub success: bool,
877 #[prost(int32, tag = "2")]
878 pub count: i32,
879 #[prost(string, tag = "3")]
880 pub message: ::prost::alloc::string::String,
881 #[prost(message, optional, tag = "4")]
882 pub data: ::core::option::Option<Transactions>,
883}
884#[derive(Clone, PartialEq, ::prost::Message)]
886pub struct GetTransactionsRequest {
887 #[prost(string, tag = "1")]
888 pub id: ::prost::alloc::string::String,
889}
890#[derive(Clone, PartialEq, ::prost::Message)]
892pub struct GetTransactionsResponse {
893 #[prost(bool, tag = "1")]
894 pub success: bool,
895 #[prost(string, tag = "2")]
896 pub message: ::prost::alloc::string::String,
897 #[prost(message, optional, tag = "3")]
898 pub data: ::core::option::Option<Transactions>,
899}
900#[derive(Clone, PartialEq, ::prost::Message)]
902pub struct UpdateTransactionsRequest {
903 #[prost(message, optional, tag = "1")]
904 pub transactions: ::core::option::Option<Transactions>,
905}
906#[derive(Clone, PartialEq, ::prost::Message)]
908pub struct UpdateTransactionsResponse {
909 #[prost(bool, tag = "1")]
910 pub success: bool,
911 #[prost(string, tag = "2")]
912 pub message: ::prost::alloc::string::String,
913 #[prost(message, optional, tag = "3")]
914 pub data: ::core::option::Option<Transactions>,
915}
916#[derive(Clone, PartialEq, ::prost::Message)]
918pub struct DeleteTransactionsRequest {
919 #[prost(string, tag = "1")]
920 pub id: ::prost::alloc::string::String,
921}
922#[derive(Clone, PartialEq, ::prost::Message)]
924pub struct DeleteTransactionsResponse {
925 #[prost(bool, tag = "1")]
926 pub success: bool,
927 #[prost(string, tag = "2")]
928 pub message: ::prost::alloc::string::String,
929}
930pub mod store_service_client {
932 #![allow(
933 unused_variables,
934 dead_code,
935 missing_docs,
936 clippy::wildcard_imports,
937 clippy::let_unit_value,
938 )]
939 use tonic::codegen::*;
940 use tonic::codegen::http::Uri;
941 #[derive(Debug, Clone)]
943 pub struct StoreServiceClient<T> {
944 inner: tonic::client::Grpc<T>,
945 }
946 impl StoreServiceClient<tonic::transport::Channel> {
947 pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
949 where
950 D: TryInto<tonic::transport::Endpoint>,
951 D::Error: Into<StdError>,
952 {
953 let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
954 Ok(Self::new(conn))
955 }
956 }
957 impl<T> StoreServiceClient<T>
958 where
959 T: tonic::client::GrpcService<tonic::body::BoxBody>,
960 T::Error: Into<StdError>,
961 T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
962 <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
963 {
964 pub fn new(inner: T) -> Self {
965 let inner = tonic::client::Grpc::new(inner);
966 Self { inner }
967 }
968 pub fn with_origin(inner: T, origin: Uri) -> Self {
969 let inner = tonic::client::Grpc::with_origin(inner, origin);
970 Self { inner }
971 }
972 pub fn with_interceptor<F>(
973 inner: T,
974 interceptor: F,
975 ) -> StoreServiceClient<InterceptedService<T, F>>
976 where
977 F: tonic::service::Interceptor,
978 T::ResponseBody: Default,
979 T: tonic::codegen::Service<
980 http::Request<tonic::body::BoxBody>,
981 Response = http::Response<
982 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
983 >,
984 >,
985 <T as tonic::codegen::Service<
986 http::Request<tonic::body::BoxBody>,
987 >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
988 {
989 StoreServiceClient::new(InterceptedService::new(inner, interceptor))
990 }
991 #[must_use]
996 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
997 self.inner = self.inner.send_compressed(encoding);
998 self
999 }
1000 #[must_use]
1002 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1003 self.inner = self.inner.accept_compressed(encoding);
1004 self
1005 }
1006 #[must_use]
1010 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1011 self.inner = self.inner.max_decoding_message_size(limit);
1012 self
1013 }
1014 #[must_use]
1018 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1019 self.inner = self.inner.max_encoding_message_size(limit);
1020 self
1021 }
1022 pub async fn create_items(
1024 &mut self,
1025 request: impl tonic::IntoRequest<super::CreateItemsRequest>,
1026 ) -> std::result::Result<
1027 tonic::Response<super::CreateItemsResponse>,
1028 tonic::Status,
1029 > {
1030 self.inner
1031 .ready()
1032 .await
1033 .map_err(|e| {
1034 tonic::Status::unknown(
1035 format!("Service was not ready: {}", e.into()),
1036 )
1037 })?;
1038 let codec = tonic::codec::ProstCodec::default();
1039 let path = http::uri::PathAndQuery::from_static(
1040 "/store.StoreService/CreateItems",
1041 );
1042 let mut req = request.into_request();
1043 req.extensions_mut()
1044 .insert(GrpcMethod::new("store.StoreService", "CreateItems"));
1045 self.inner.unary(req, path, codec).await
1046 }
1047 pub async fn get_items(
1049 &mut self,
1050 request: impl tonic::IntoRequest<super::GetItemsRequest>,
1051 ) -> std::result::Result<
1052 tonic::Response<super::GetItemsResponse>,
1053 tonic::Status,
1054 > {
1055 self.inner
1056 .ready()
1057 .await
1058 .map_err(|e| {
1059 tonic::Status::unknown(
1060 format!("Service was not ready: {}", e.into()),
1061 )
1062 })?;
1063 let codec = tonic::codec::ProstCodec::default();
1064 let path = http::uri::PathAndQuery::from_static(
1065 "/store.StoreService/GetItems",
1066 );
1067 let mut req = request.into_request();
1068 req.extensions_mut()
1069 .insert(GrpcMethod::new("store.StoreService", "GetItems"));
1070 self.inner.unary(req, path, codec).await
1071 }
1072 pub async fn update_items(
1074 &mut self,
1075 request: impl tonic::IntoRequest<super::UpdateItemsRequest>,
1076 ) -> std::result::Result<
1077 tonic::Response<super::UpdateItemsResponse>,
1078 tonic::Status,
1079 > {
1080 self.inner
1081 .ready()
1082 .await
1083 .map_err(|e| {
1084 tonic::Status::unknown(
1085 format!("Service was not ready: {}", e.into()),
1086 )
1087 })?;
1088 let codec = tonic::codec::ProstCodec::default();
1089 let path = http::uri::PathAndQuery::from_static(
1090 "/store.StoreService/UpdateItems",
1091 );
1092 let mut req = request.into_request();
1093 req.extensions_mut()
1094 .insert(GrpcMethod::new("store.StoreService", "UpdateItems"));
1095 self.inner.unary(req, path, codec).await
1096 }
1097 pub async fn delete_items(
1099 &mut self,
1100 request: impl tonic::IntoRequest<super::DeleteItemsRequest>,
1101 ) -> std::result::Result<
1102 tonic::Response<super::DeleteItemsResponse>,
1103 tonic::Status,
1104 > {
1105 self.inner
1106 .ready()
1107 .await
1108 .map_err(|e| {
1109 tonic::Status::unknown(
1110 format!("Service was not ready: {}", e.into()),
1111 )
1112 })?;
1113 let codec = tonic::codec::ProstCodec::default();
1114 let path = http::uri::PathAndQuery::from_static(
1115 "/store.StoreService/DeleteItems",
1116 );
1117 let mut req = request.into_request();
1118 req.extensions_mut()
1119 .insert(GrpcMethod::new("store.StoreService", "DeleteItems"));
1120 self.inner.unary(req, path, codec).await
1121 }
1122 pub async fn create_packets(
1124 &mut self,
1125 request: impl tonic::IntoRequest<super::CreatePacketsRequest>,
1126 ) -> std::result::Result<
1127 tonic::Response<super::CreatePacketsResponse>,
1128 tonic::Status,
1129 > {
1130 self.inner
1131 .ready()
1132 .await
1133 .map_err(|e| {
1134 tonic::Status::unknown(
1135 format!("Service was not ready: {}", e.into()),
1136 )
1137 })?;
1138 let codec = tonic::codec::ProstCodec::default();
1139 let path = http::uri::PathAndQuery::from_static(
1140 "/store.StoreService/CreatePackets",
1141 );
1142 let mut req = request.into_request();
1143 req.extensions_mut()
1144 .insert(GrpcMethod::new("store.StoreService", "CreatePackets"));
1145 self.inner.unary(req, path, codec).await
1146 }
1147 pub async fn get_packets(
1149 &mut self,
1150 request: impl tonic::IntoRequest<super::GetPacketsRequest>,
1151 ) -> std::result::Result<
1152 tonic::Response<super::GetPacketsResponse>,
1153 tonic::Status,
1154 > {
1155 self.inner
1156 .ready()
1157 .await
1158 .map_err(|e| {
1159 tonic::Status::unknown(
1160 format!("Service was not ready: {}", e.into()),
1161 )
1162 })?;
1163 let codec = tonic::codec::ProstCodec::default();
1164 let path = http::uri::PathAndQuery::from_static(
1165 "/store.StoreService/GetPackets",
1166 );
1167 let mut req = request.into_request();
1168 req.extensions_mut()
1169 .insert(GrpcMethod::new("store.StoreService", "GetPackets"));
1170 self.inner.unary(req, path, codec).await
1171 }
1172 pub async fn update_packets(
1174 &mut self,
1175 request: impl tonic::IntoRequest<super::UpdatePacketsRequest>,
1176 ) -> std::result::Result<
1177 tonic::Response<super::UpdatePacketsResponse>,
1178 tonic::Status,
1179 > {
1180 self.inner
1181 .ready()
1182 .await
1183 .map_err(|e| {
1184 tonic::Status::unknown(
1185 format!("Service was not ready: {}", e.into()),
1186 )
1187 })?;
1188 let codec = tonic::codec::ProstCodec::default();
1189 let path = http::uri::PathAndQuery::from_static(
1190 "/store.StoreService/UpdatePackets",
1191 );
1192 let mut req = request.into_request();
1193 req.extensions_mut()
1194 .insert(GrpcMethod::new("store.StoreService", "UpdatePackets"));
1195 self.inner.unary(req, path, codec).await
1196 }
1197 pub async fn delete_packets(
1199 &mut self,
1200 request: impl tonic::IntoRequest<super::DeletePacketsRequest>,
1201 ) -> std::result::Result<
1202 tonic::Response<super::DeletePacketsResponse>,
1203 tonic::Status,
1204 > {
1205 self.inner
1206 .ready()
1207 .await
1208 .map_err(|e| {
1209 tonic::Status::unknown(
1210 format!("Service was not ready: {}", e.into()),
1211 )
1212 })?;
1213 let codec = tonic::codec::ProstCodec::default();
1214 let path = http::uri::PathAndQuery::from_static(
1215 "/store.StoreService/DeletePackets",
1216 );
1217 let mut req = request.into_request();
1218 req.extensions_mut()
1219 .insert(GrpcMethod::new("store.StoreService", "DeletePackets"));
1220 self.inner.unary(req, path, codec).await
1221 }
1222 pub async fn create_connections(
1224 &mut self,
1225 request: impl tonic::IntoRequest<super::CreateConnectionsRequest>,
1226 ) -> std::result::Result<
1227 tonic::Response<super::CreateConnectionsResponse>,
1228 tonic::Status,
1229 > {
1230 self.inner
1231 .ready()
1232 .await
1233 .map_err(|e| {
1234 tonic::Status::unknown(
1235 format!("Service was not ready: {}", e.into()),
1236 )
1237 })?;
1238 let codec = tonic::codec::ProstCodec::default();
1239 let path = http::uri::PathAndQuery::from_static(
1240 "/store.StoreService/CreateConnections",
1241 );
1242 let mut req = request.into_request();
1243 req.extensions_mut()
1244 .insert(GrpcMethod::new("store.StoreService", "CreateConnections"));
1245 self.inner.unary(req, path, codec).await
1246 }
1247 pub async fn get_connections(
1249 &mut self,
1250 request: impl tonic::IntoRequest<super::GetConnectionsRequest>,
1251 ) -> std::result::Result<
1252 tonic::Response<super::GetConnectionsResponse>,
1253 tonic::Status,
1254 > {
1255 self.inner
1256 .ready()
1257 .await
1258 .map_err(|e| {
1259 tonic::Status::unknown(
1260 format!("Service was not ready: {}", e.into()),
1261 )
1262 })?;
1263 let codec = tonic::codec::ProstCodec::default();
1264 let path = http::uri::PathAndQuery::from_static(
1265 "/store.StoreService/GetConnections",
1266 );
1267 let mut req = request.into_request();
1268 req.extensions_mut()
1269 .insert(GrpcMethod::new("store.StoreService", "GetConnections"));
1270 self.inner.unary(req, path, codec).await
1271 }
1272 pub async fn update_connections(
1274 &mut self,
1275 request: impl tonic::IntoRequest<super::UpdateConnectionsRequest>,
1276 ) -> std::result::Result<
1277 tonic::Response<super::UpdateConnectionsResponse>,
1278 tonic::Status,
1279 > {
1280 self.inner
1281 .ready()
1282 .await
1283 .map_err(|e| {
1284 tonic::Status::unknown(
1285 format!("Service was not ready: {}", e.into()),
1286 )
1287 })?;
1288 let codec = tonic::codec::ProstCodec::default();
1289 let path = http::uri::PathAndQuery::from_static(
1290 "/store.StoreService/UpdateConnections",
1291 );
1292 let mut req = request.into_request();
1293 req.extensions_mut()
1294 .insert(GrpcMethod::new("store.StoreService", "UpdateConnections"));
1295 self.inner.unary(req, path, codec).await
1296 }
1297 pub async fn delete_connections(
1299 &mut self,
1300 request: impl tonic::IntoRequest<super::DeleteConnectionsRequest>,
1301 ) -> std::result::Result<
1302 tonic::Response<super::DeleteConnectionsResponse>,
1303 tonic::Status,
1304 > {
1305 self.inner
1306 .ready()
1307 .await
1308 .map_err(|e| {
1309 tonic::Status::unknown(
1310 format!("Service was not ready: {}", e.into()),
1311 )
1312 })?;
1313 let codec = tonic::codec::ProstCodec::default();
1314 let path = http::uri::PathAndQuery::from_static(
1315 "/store.StoreService/DeleteConnections",
1316 );
1317 let mut req = request.into_request();
1318 req.extensions_mut()
1319 .insert(GrpcMethod::new("store.StoreService", "DeleteConnections"));
1320 self.inner.unary(req, path, codec).await
1321 }
1322 pub async fn create_crdt_messages(
1324 &mut self,
1325 request: impl tonic::IntoRequest<super::CreateCrdtMessagesRequest>,
1326 ) -> std::result::Result<
1327 tonic::Response<super::CreateCrdtMessagesResponse>,
1328 tonic::Status,
1329 > {
1330 self.inner
1331 .ready()
1332 .await
1333 .map_err(|e| {
1334 tonic::Status::unknown(
1335 format!("Service was not ready: {}", e.into()),
1336 )
1337 })?;
1338 let codec = tonic::codec::ProstCodec::default();
1339 let path = http::uri::PathAndQuery::from_static(
1340 "/store.StoreService/CreateCrdtMessages",
1341 );
1342 let mut req = request.into_request();
1343 req.extensions_mut()
1344 .insert(GrpcMethod::new("store.StoreService", "CreateCrdtMessages"));
1345 self.inner.unary(req, path, codec).await
1346 }
1347 pub async fn get_crdt_messages(
1349 &mut self,
1350 request: impl tonic::IntoRequest<super::GetCrdtMessagesRequest>,
1351 ) -> std::result::Result<
1352 tonic::Response<super::GetCrdtMessagesResponse>,
1353 tonic::Status,
1354 > {
1355 self.inner
1356 .ready()
1357 .await
1358 .map_err(|e| {
1359 tonic::Status::unknown(
1360 format!("Service was not ready: {}", e.into()),
1361 )
1362 })?;
1363 let codec = tonic::codec::ProstCodec::default();
1364 let path = http::uri::PathAndQuery::from_static(
1365 "/store.StoreService/GetCrdtMessages",
1366 );
1367 let mut req = request.into_request();
1368 req.extensions_mut()
1369 .insert(GrpcMethod::new("store.StoreService", "GetCrdtMessages"));
1370 self.inner.unary(req, path, codec).await
1371 }
1372 pub async fn update_crdt_messages(
1374 &mut self,
1375 request: impl tonic::IntoRequest<super::UpdateCrdtMessagesRequest>,
1376 ) -> std::result::Result<
1377 tonic::Response<super::UpdateCrdtMessagesResponse>,
1378 tonic::Status,
1379 > {
1380 self.inner
1381 .ready()
1382 .await
1383 .map_err(|e| {
1384 tonic::Status::unknown(
1385 format!("Service was not ready: {}", e.into()),
1386 )
1387 })?;
1388 let codec = tonic::codec::ProstCodec::default();
1389 let path = http::uri::PathAndQuery::from_static(
1390 "/store.StoreService/UpdateCrdtMessages",
1391 );
1392 let mut req = request.into_request();
1393 req.extensions_mut()
1394 .insert(GrpcMethod::new("store.StoreService", "UpdateCrdtMessages"));
1395 self.inner.unary(req, path, codec).await
1396 }
1397 pub async fn delete_crdt_messages(
1399 &mut self,
1400 request: impl tonic::IntoRequest<super::DeleteCrdtMessagesRequest>,
1401 ) -> std::result::Result<
1402 tonic::Response<super::DeleteCrdtMessagesResponse>,
1403 tonic::Status,
1404 > {
1405 self.inner
1406 .ready()
1407 .await
1408 .map_err(|e| {
1409 tonic::Status::unknown(
1410 format!("Service was not ready: {}", e.into()),
1411 )
1412 })?;
1413 let codec = tonic::codec::ProstCodec::default();
1414 let path = http::uri::PathAndQuery::from_static(
1415 "/store.StoreService/DeleteCrdtMessages",
1416 );
1417 let mut req = request.into_request();
1418 req.extensions_mut()
1419 .insert(GrpcMethod::new("store.StoreService", "DeleteCrdtMessages"));
1420 self.inner.unary(req, path, codec).await
1421 }
1422 pub async fn create_crdt_merkles(
1424 &mut self,
1425 request: impl tonic::IntoRequest<super::CreateCrdtMerklesRequest>,
1426 ) -> std::result::Result<
1427 tonic::Response<super::CreateCrdtMerklesResponse>,
1428 tonic::Status,
1429 > {
1430 self.inner
1431 .ready()
1432 .await
1433 .map_err(|e| {
1434 tonic::Status::unknown(
1435 format!("Service was not ready: {}", e.into()),
1436 )
1437 })?;
1438 let codec = tonic::codec::ProstCodec::default();
1439 let path = http::uri::PathAndQuery::from_static(
1440 "/store.StoreService/CreateCrdtMerkles",
1441 );
1442 let mut req = request.into_request();
1443 req.extensions_mut()
1444 .insert(GrpcMethod::new("store.StoreService", "CreateCrdtMerkles"));
1445 self.inner.unary(req, path, codec).await
1446 }
1447 pub async fn get_crdt_merkles(
1449 &mut self,
1450 request: impl tonic::IntoRequest<super::GetCrdtMerklesRequest>,
1451 ) -> std::result::Result<
1452 tonic::Response<super::GetCrdtMerklesResponse>,
1453 tonic::Status,
1454 > {
1455 self.inner
1456 .ready()
1457 .await
1458 .map_err(|e| {
1459 tonic::Status::unknown(
1460 format!("Service was not ready: {}", e.into()),
1461 )
1462 })?;
1463 let codec = tonic::codec::ProstCodec::default();
1464 let path = http::uri::PathAndQuery::from_static(
1465 "/store.StoreService/GetCrdtMerkles",
1466 );
1467 let mut req = request.into_request();
1468 req.extensions_mut()
1469 .insert(GrpcMethod::new("store.StoreService", "GetCrdtMerkles"));
1470 self.inner.unary(req, path, codec).await
1471 }
1472 pub async fn update_crdt_merkles(
1474 &mut self,
1475 request: impl tonic::IntoRequest<super::UpdateCrdtMerklesRequest>,
1476 ) -> std::result::Result<
1477 tonic::Response<super::UpdateCrdtMerklesResponse>,
1478 tonic::Status,
1479 > {
1480 self.inner
1481 .ready()
1482 .await
1483 .map_err(|e| {
1484 tonic::Status::unknown(
1485 format!("Service was not ready: {}", e.into()),
1486 )
1487 })?;
1488 let codec = tonic::codec::ProstCodec::default();
1489 let path = http::uri::PathAndQuery::from_static(
1490 "/store.StoreService/UpdateCrdtMerkles",
1491 );
1492 let mut req = request.into_request();
1493 req.extensions_mut()
1494 .insert(GrpcMethod::new("store.StoreService", "UpdateCrdtMerkles"));
1495 self.inner.unary(req, path, codec).await
1496 }
1497 pub async fn delete_crdt_merkles(
1499 &mut self,
1500 request: impl tonic::IntoRequest<super::DeleteCrdtMerklesRequest>,
1501 ) -> std::result::Result<
1502 tonic::Response<super::DeleteCrdtMerklesResponse>,
1503 tonic::Status,
1504 > {
1505 self.inner
1506 .ready()
1507 .await
1508 .map_err(|e| {
1509 tonic::Status::unknown(
1510 format!("Service was not ready: {}", e.into()),
1511 )
1512 })?;
1513 let codec = tonic::codec::ProstCodec::default();
1514 let path = http::uri::PathAndQuery::from_static(
1515 "/store.StoreService/DeleteCrdtMerkles",
1516 );
1517 let mut req = request.into_request();
1518 req.extensions_mut()
1519 .insert(GrpcMethod::new("store.StoreService", "DeleteCrdtMerkles"));
1520 self.inner.unary(req, path, codec).await
1521 }
1522 pub async fn create_sync_endpoints(
1524 &mut self,
1525 request: impl tonic::IntoRequest<super::CreateSyncEndpointsRequest>,
1526 ) -> std::result::Result<
1527 tonic::Response<super::CreateSyncEndpointsResponse>,
1528 tonic::Status,
1529 > {
1530 self.inner
1531 .ready()
1532 .await
1533 .map_err(|e| {
1534 tonic::Status::unknown(
1535 format!("Service was not ready: {}", e.into()),
1536 )
1537 })?;
1538 let codec = tonic::codec::ProstCodec::default();
1539 let path = http::uri::PathAndQuery::from_static(
1540 "/store.StoreService/CreateSyncEndpoints",
1541 );
1542 let mut req = request.into_request();
1543 req.extensions_mut()
1544 .insert(GrpcMethod::new("store.StoreService", "CreateSyncEndpoints"));
1545 self.inner.unary(req, path, codec).await
1546 }
1547 pub async fn get_sync_endpoints(
1549 &mut self,
1550 request: impl tonic::IntoRequest<super::GetSyncEndpointsRequest>,
1551 ) -> std::result::Result<
1552 tonic::Response<super::GetSyncEndpointsResponse>,
1553 tonic::Status,
1554 > {
1555 self.inner
1556 .ready()
1557 .await
1558 .map_err(|e| {
1559 tonic::Status::unknown(
1560 format!("Service was not ready: {}", e.into()),
1561 )
1562 })?;
1563 let codec = tonic::codec::ProstCodec::default();
1564 let path = http::uri::PathAndQuery::from_static(
1565 "/store.StoreService/GetSyncEndpoints",
1566 );
1567 let mut req = request.into_request();
1568 req.extensions_mut()
1569 .insert(GrpcMethod::new("store.StoreService", "GetSyncEndpoints"));
1570 self.inner.unary(req, path, codec).await
1571 }
1572 pub async fn update_sync_endpoints(
1574 &mut self,
1575 request: impl tonic::IntoRequest<super::UpdateSyncEndpointsRequest>,
1576 ) -> std::result::Result<
1577 tonic::Response<super::UpdateSyncEndpointsResponse>,
1578 tonic::Status,
1579 > {
1580 self.inner
1581 .ready()
1582 .await
1583 .map_err(|e| {
1584 tonic::Status::unknown(
1585 format!("Service was not ready: {}", e.into()),
1586 )
1587 })?;
1588 let codec = tonic::codec::ProstCodec::default();
1589 let path = http::uri::PathAndQuery::from_static(
1590 "/store.StoreService/UpdateSyncEndpoints",
1591 );
1592 let mut req = request.into_request();
1593 req.extensions_mut()
1594 .insert(GrpcMethod::new("store.StoreService", "UpdateSyncEndpoints"));
1595 self.inner.unary(req, path, codec).await
1596 }
1597 pub async fn delete_sync_endpoints(
1599 &mut self,
1600 request: impl tonic::IntoRequest<super::DeleteSyncEndpointsRequest>,
1601 ) -> std::result::Result<
1602 tonic::Response<super::DeleteSyncEndpointsResponse>,
1603 tonic::Status,
1604 > {
1605 self.inner
1606 .ready()
1607 .await
1608 .map_err(|e| {
1609 tonic::Status::unknown(
1610 format!("Service was not ready: {}", e.into()),
1611 )
1612 })?;
1613 let codec = tonic::codec::ProstCodec::default();
1614 let path = http::uri::PathAndQuery::from_static(
1615 "/store.StoreService/DeleteSyncEndpoints",
1616 );
1617 let mut req = request.into_request();
1618 req.extensions_mut()
1619 .insert(GrpcMethod::new("store.StoreService", "DeleteSyncEndpoints"));
1620 self.inner.unary(req, path, codec).await
1621 }
1622 pub async fn create_queues(
1624 &mut self,
1625 request: impl tonic::IntoRequest<super::CreateQueuesRequest>,
1626 ) -> std::result::Result<
1627 tonic::Response<super::CreateQueuesResponse>,
1628 tonic::Status,
1629 > {
1630 self.inner
1631 .ready()
1632 .await
1633 .map_err(|e| {
1634 tonic::Status::unknown(
1635 format!("Service was not ready: {}", e.into()),
1636 )
1637 })?;
1638 let codec = tonic::codec::ProstCodec::default();
1639 let path = http::uri::PathAndQuery::from_static(
1640 "/store.StoreService/CreateQueues",
1641 );
1642 let mut req = request.into_request();
1643 req.extensions_mut()
1644 .insert(GrpcMethod::new("store.StoreService", "CreateQueues"));
1645 self.inner.unary(req, path, codec).await
1646 }
1647 pub async fn get_queues(
1649 &mut self,
1650 request: impl tonic::IntoRequest<super::GetQueuesRequest>,
1651 ) -> std::result::Result<
1652 tonic::Response<super::GetQueuesResponse>,
1653 tonic::Status,
1654 > {
1655 self.inner
1656 .ready()
1657 .await
1658 .map_err(|e| {
1659 tonic::Status::unknown(
1660 format!("Service was not ready: {}", e.into()),
1661 )
1662 })?;
1663 let codec = tonic::codec::ProstCodec::default();
1664 let path = http::uri::PathAndQuery::from_static(
1665 "/store.StoreService/GetQueues",
1666 );
1667 let mut req = request.into_request();
1668 req.extensions_mut()
1669 .insert(GrpcMethod::new("store.StoreService", "GetQueues"));
1670 self.inner.unary(req, path, codec).await
1671 }
1672 pub async fn update_queues(
1674 &mut self,
1675 request: impl tonic::IntoRequest<super::UpdateQueuesRequest>,
1676 ) -> std::result::Result<
1677 tonic::Response<super::UpdateQueuesResponse>,
1678 tonic::Status,
1679 > {
1680 self.inner
1681 .ready()
1682 .await
1683 .map_err(|e| {
1684 tonic::Status::unknown(
1685 format!("Service was not ready: {}", e.into()),
1686 )
1687 })?;
1688 let codec = tonic::codec::ProstCodec::default();
1689 let path = http::uri::PathAndQuery::from_static(
1690 "/store.StoreService/UpdateQueues",
1691 );
1692 let mut req = request.into_request();
1693 req.extensions_mut()
1694 .insert(GrpcMethod::new("store.StoreService", "UpdateQueues"));
1695 self.inner.unary(req, path, codec).await
1696 }
1697 pub async fn delete_queues(
1699 &mut self,
1700 request: impl tonic::IntoRequest<super::DeleteQueuesRequest>,
1701 ) -> std::result::Result<
1702 tonic::Response<super::DeleteQueuesResponse>,
1703 tonic::Status,
1704 > {
1705 self.inner
1706 .ready()
1707 .await
1708 .map_err(|e| {
1709 tonic::Status::unknown(
1710 format!("Service was not ready: {}", e.into()),
1711 )
1712 })?;
1713 let codec = tonic::codec::ProstCodec::default();
1714 let path = http::uri::PathAndQuery::from_static(
1715 "/store.StoreService/DeleteQueues",
1716 );
1717 let mut req = request.into_request();
1718 req.extensions_mut()
1719 .insert(GrpcMethod::new("store.StoreService", "DeleteQueues"));
1720 self.inner.unary(req, path, codec).await
1721 }
1722 pub async fn create_queue_items(
1724 &mut self,
1725 request: impl tonic::IntoRequest<super::CreateQueueItemsRequest>,
1726 ) -> std::result::Result<
1727 tonic::Response<super::CreateQueueItemsResponse>,
1728 tonic::Status,
1729 > {
1730 self.inner
1731 .ready()
1732 .await
1733 .map_err(|e| {
1734 tonic::Status::unknown(
1735 format!("Service was not ready: {}", e.into()),
1736 )
1737 })?;
1738 let codec = tonic::codec::ProstCodec::default();
1739 let path = http::uri::PathAndQuery::from_static(
1740 "/store.StoreService/CreateQueueItems",
1741 );
1742 let mut req = request.into_request();
1743 req.extensions_mut()
1744 .insert(GrpcMethod::new("store.StoreService", "CreateQueueItems"));
1745 self.inner.unary(req, path, codec).await
1746 }
1747 pub async fn get_queue_items(
1749 &mut self,
1750 request: impl tonic::IntoRequest<super::GetQueueItemsRequest>,
1751 ) -> std::result::Result<
1752 tonic::Response<super::GetQueueItemsResponse>,
1753 tonic::Status,
1754 > {
1755 self.inner
1756 .ready()
1757 .await
1758 .map_err(|e| {
1759 tonic::Status::unknown(
1760 format!("Service was not ready: {}", e.into()),
1761 )
1762 })?;
1763 let codec = tonic::codec::ProstCodec::default();
1764 let path = http::uri::PathAndQuery::from_static(
1765 "/store.StoreService/GetQueueItems",
1766 );
1767 let mut req = request.into_request();
1768 req.extensions_mut()
1769 .insert(GrpcMethod::new("store.StoreService", "GetQueueItems"));
1770 self.inner.unary(req, path, codec).await
1771 }
1772 pub async fn update_queue_items(
1774 &mut self,
1775 request: impl tonic::IntoRequest<super::UpdateQueueItemsRequest>,
1776 ) -> std::result::Result<
1777 tonic::Response<super::UpdateQueueItemsResponse>,
1778 tonic::Status,
1779 > {
1780 self.inner
1781 .ready()
1782 .await
1783 .map_err(|e| {
1784 tonic::Status::unknown(
1785 format!("Service was not ready: {}", e.into()),
1786 )
1787 })?;
1788 let codec = tonic::codec::ProstCodec::default();
1789 let path = http::uri::PathAndQuery::from_static(
1790 "/store.StoreService/UpdateQueueItems",
1791 );
1792 let mut req = request.into_request();
1793 req.extensions_mut()
1794 .insert(GrpcMethod::new("store.StoreService", "UpdateQueueItems"));
1795 self.inner.unary(req, path, codec).await
1796 }
1797 pub async fn delete_queue_items(
1799 &mut self,
1800 request: impl tonic::IntoRequest<super::DeleteQueueItemsRequest>,
1801 ) -> std::result::Result<
1802 tonic::Response<super::DeleteQueueItemsResponse>,
1803 tonic::Status,
1804 > {
1805 self.inner
1806 .ready()
1807 .await
1808 .map_err(|e| {
1809 tonic::Status::unknown(
1810 format!("Service was not ready: {}", e.into()),
1811 )
1812 })?;
1813 let codec = tonic::codec::ProstCodec::default();
1814 let path = http::uri::PathAndQuery::from_static(
1815 "/store.StoreService/DeleteQueueItems",
1816 );
1817 let mut req = request.into_request();
1818 req.extensions_mut()
1819 .insert(GrpcMethod::new("store.StoreService", "DeleteQueueItems"));
1820 self.inner.unary(req, path, codec).await
1821 }
1822 pub async fn create_transactions(
1824 &mut self,
1825 request: impl tonic::IntoRequest<super::CreateTransactionsRequest>,
1826 ) -> std::result::Result<
1827 tonic::Response<super::CreateTransactionsResponse>,
1828 tonic::Status,
1829 > {
1830 self.inner
1831 .ready()
1832 .await
1833 .map_err(|e| {
1834 tonic::Status::unknown(
1835 format!("Service was not ready: {}", e.into()),
1836 )
1837 })?;
1838 let codec = tonic::codec::ProstCodec::default();
1839 let path = http::uri::PathAndQuery::from_static(
1840 "/store.StoreService/CreateTransactions",
1841 );
1842 let mut req = request.into_request();
1843 req.extensions_mut()
1844 .insert(GrpcMethod::new("store.StoreService", "CreateTransactions"));
1845 self.inner.unary(req, path, codec).await
1846 }
1847 pub async fn get_transactions(
1849 &mut self,
1850 request: impl tonic::IntoRequest<super::GetTransactionsRequest>,
1851 ) -> std::result::Result<
1852 tonic::Response<super::GetTransactionsResponse>,
1853 tonic::Status,
1854 > {
1855 self.inner
1856 .ready()
1857 .await
1858 .map_err(|e| {
1859 tonic::Status::unknown(
1860 format!("Service was not ready: {}", e.into()),
1861 )
1862 })?;
1863 let codec = tonic::codec::ProstCodec::default();
1864 let path = http::uri::PathAndQuery::from_static(
1865 "/store.StoreService/GetTransactions",
1866 );
1867 let mut req = request.into_request();
1868 req.extensions_mut()
1869 .insert(GrpcMethod::new("store.StoreService", "GetTransactions"));
1870 self.inner.unary(req, path, codec).await
1871 }
1872 pub async fn update_transactions(
1874 &mut self,
1875 request: impl tonic::IntoRequest<super::UpdateTransactionsRequest>,
1876 ) -> std::result::Result<
1877 tonic::Response<super::UpdateTransactionsResponse>,
1878 tonic::Status,
1879 > {
1880 self.inner
1881 .ready()
1882 .await
1883 .map_err(|e| {
1884 tonic::Status::unknown(
1885 format!("Service was not ready: {}", e.into()),
1886 )
1887 })?;
1888 let codec = tonic::codec::ProstCodec::default();
1889 let path = http::uri::PathAndQuery::from_static(
1890 "/store.StoreService/UpdateTransactions",
1891 );
1892 let mut req = request.into_request();
1893 req.extensions_mut()
1894 .insert(GrpcMethod::new("store.StoreService", "UpdateTransactions"));
1895 self.inner.unary(req, path, codec).await
1896 }
1897 pub async fn delete_transactions(
1899 &mut self,
1900 request: impl tonic::IntoRequest<super::DeleteTransactionsRequest>,
1901 ) -> std::result::Result<
1902 tonic::Response<super::DeleteTransactionsResponse>,
1903 tonic::Status,
1904 > {
1905 self.inner
1906 .ready()
1907 .await
1908 .map_err(|e| {
1909 tonic::Status::unknown(
1910 format!("Service was not ready: {}", e.into()),
1911 )
1912 })?;
1913 let codec = tonic::codec::ProstCodec::default();
1914 let path = http::uri::PathAndQuery::from_static(
1915 "/store.StoreService/DeleteTransactions",
1916 );
1917 let mut req = request.into_request();
1918 req.extensions_mut()
1919 .insert(GrpcMethod::new("store.StoreService", "DeleteTransactions"));
1920 self.inner.unary(req, path, codec).await
1921 }
1922 }
1923}
1924pub mod store_service_server {
1926 #![allow(
1927 unused_variables,
1928 dead_code,
1929 missing_docs,
1930 clippy::wildcard_imports,
1931 clippy::let_unit_value,
1932 )]
1933 use tonic::codegen::*;
1934 #[async_trait]
1936 pub trait StoreService: std::marker::Send + std::marker::Sync + 'static {
1937 async fn create_items(
1939 &self,
1940 request: tonic::Request<super::CreateItemsRequest>,
1941 ) -> std::result::Result<
1942 tonic::Response<super::CreateItemsResponse>,
1943 tonic::Status,
1944 >;
1945 async fn get_items(
1947 &self,
1948 request: tonic::Request<super::GetItemsRequest>,
1949 ) -> std::result::Result<
1950 tonic::Response<super::GetItemsResponse>,
1951 tonic::Status,
1952 >;
1953 async fn update_items(
1955 &self,
1956 request: tonic::Request<super::UpdateItemsRequest>,
1957 ) -> std::result::Result<
1958 tonic::Response<super::UpdateItemsResponse>,
1959 tonic::Status,
1960 >;
1961 async fn delete_items(
1963 &self,
1964 request: tonic::Request<super::DeleteItemsRequest>,
1965 ) -> std::result::Result<
1966 tonic::Response<super::DeleteItemsResponse>,
1967 tonic::Status,
1968 >;
1969 async fn create_packets(
1971 &self,
1972 request: tonic::Request<super::CreatePacketsRequest>,
1973 ) -> std::result::Result<
1974 tonic::Response<super::CreatePacketsResponse>,
1975 tonic::Status,
1976 >;
1977 async fn get_packets(
1979 &self,
1980 request: tonic::Request<super::GetPacketsRequest>,
1981 ) -> std::result::Result<
1982 tonic::Response<super::GetPacketsResponse>,
1983 tonic::Status,
1984 >;
1985 async fn update_packets(
1987 &self,
1988 request: tonic::Request<super::UpdatePacketsRequest>,
1989 ) -> std::result::Result<
1990 tonic::Response<super::UpdatePacketsResponse>,
1991 tonic::Status,
1992 >;
1993 async fn delete_packets(
1995 &self,
1996 request: tonic::Request<super::DeletePacketsRequest>,
1997 ) -> std::result::Result<
1998 tonic::Response<super::DeletePacketsResponse>,
1999 tonic::Status,
2000 >;
2001 async fn create_connections(
2003 &self,
2004 request: tonic::Request<super::CreateConnectionsRequest>,
2005 ) -> std::result::Result<
2006 tonic::Response<super::CreateConnectionsResponse>,
2007 tonic::Status,
2008 >;
2009 async fn get_connections(
2011 &self,
2012 request: tonic::Request<super::GetConnectionsRequest>,
2013 ) -> std::result::Result<
2014 tonic::Response<super::GetConnectionsResponse>,
2015 tonic::Status,
2016 >;
2017 async fn update_connections(
2019 &self,
2020 request: tonic::Request<super::UpdateConnectionsRequest>,
2021 ) -> std::result::Result<
2022 tonic::Response<super::UpdateConnectionsResponse>,
2023 tonic::Status,
2024 >;
2025 async fn delete_connections(
2027 &self,
2028 request: tonic::Request<super::DeleteConnectionsRequest>,
2029 ) -> std::result::Result<
2030 tonic::Response<super::DeleteConnectionsResponse>,
2031 tonic::Status,
2032 >;
2033 async fn create_crdt_messages(
2035 &self,
2036 request: tonic::Request<super::CreateCrdtMessagesRequest>,
2037 ) -> std::result::Result<
2038 tonic::Response<super::CreateCrdtMessagesResponse>,
2039 tonic::Status,
2040 >;
2041 async fn get_crdt_messages(
2043 &self,
2044 request: tonic::Request<super::GetCrdtMessagesRequest>,
2045 ) -> std::result::Result<
2046 tonic::Response<super::GetCrdtMessagesResponse>,
2047 tonic::Status,
2048 >;
2049 async fn update_crdt_messages(
2051 &self,
2052 request: tonic::Request<super::UpdateCrdtMessagesRequest>,
2053 ) -> std::result::Result<
2054 tonic::Response<super::UpdateCrdtMessagesResponse>,
2055 tonic::Status,
2056 >;
2057 async fn delete_crdt_messages(
2059 &self,
2060 request: tonic::Request<super::DeleteCrdtMessagesRequest>,
2061 ) -> std::result::Result<
2062 tonic::Response<super::DeleteCrdtMessagesResponse>,
2063 tonic::Status,
2064 >;
2065 async fn create_crdt_merkles(
2067 &self,
2068 request: tonic::Request<super::CreateCrdtMerklesRequest>,
2069 ) -> std::result::Result<
2070 tonic::Response<super::CreateCrdtMerklesResponse>,
2071 tonic::Status,
2072 >;
2073 async fn get_crdt_merkles(
2075 &self,
2076 request: tonic::Request<super::GetCrdtMerklesRequest>,
2077 ) -> std::result::Result<
2078 tonic::Response<super::GetCrdtMerklesResponse>,
2079 tonic::Status,
2080 >;
2081 async fn update_crdt_merkles(
2083 &self,
2084 request: tonic::Request<super::UpdateCrdtMerklesRequest>,
2085 ) -> std::result::Result<
2086 tonic::Response<super::UpdateCrdtMerklesResponse>,
2087 tonic::Status,
2088 >;
2089 async fn delete_crdt_merkles(
2091 &self,
2092 request: tonic::Request<super::DeleteCrdtMerklesRequest>,
2093 ) -> std::result::Result<
2094 tonic::Response<super::DeleteCrdtMerklesResponse>,
2095 tonic::Status,
2096 >;
2097 async fn create_sync_endpoints(
2099 &self,
2100 request: tonic::Request<super::CreateSyncEndpointsRequest>,
2101 ) -> std::result::Result<
2102 tonic::Response<super::CreateSyncEndpointsResponse>,
2103 tonic::Status,
2104 >;
2105 async fn get_sync_endpoints(
2107 &self,
2108 request: tonic::Request<super::GetSyncEndpointsRequest>,
2109 ) -> std::result::Result<
2110 tonic::Response<super::GetSyncEndpointsResponse>,
2111 tonic::Status,
2112 >;
2113 async fn update_sync_endpoints(
2115 &self,
2116 request: tonic::Request<super::UpdateSyncEndpointsRequest>,
2117 ) -> std::result::Result<
2118 tonic::Response<super::UpdateSyncEndpointsResponse>,
2119 tonic::Status,
2120 >;
2121 async fn delete_sync_endpoints(
2123 &self,
2124 request: tonic::Request<super::DeleteSyncEndpointsRequest>,
2125 ) -> std::result::Result<
2126 tonic::Response<super::DeleteSyncEndpointsResponse>,
2127 tonic::Status,
2128 >;
2129 async fn create_queues(
2131 &self,
2132 request: tonic::Request<super::CreateQueuesRequest>,
2133 ) -> std::result::Result<
2134 tonic::Response<super::CreateQueuesResponse>,
2135 tonic::Status,
2136 >;
2137 async fn get_queues(
2139 &self,
2140 request: tonic::Request<super::GetQueuesRequest>,
2141 ) -> std::result::Result<
2142 tonic::Response<super::GetQueuesResponse>,
2143 tonic::Status,
2144 >;
2145 async fn update_queues(
2147 &self,
2148 request: tonic::Request<super::UpdateQueuesRequest>,
2149 ) -> std::result::Result<
2150 tonic::Response<super::UpdateQueuesResponse>,
2151 tonic::Status,
2152 >;
2153 async fn delete_queues(
2155 &self,
2156 request: tonic::Request<super::DeleteQueuesRequest>,
2157 ) -> std::result::Result<
2158 tonic::Response<super::DeleteQueuesResponse>,
2159 tonic::Status,
2160 >;
2161 async fn create_queue_items(
2163 &self,
2164 request: tonic::Request<super::CreateQueueItemsRequest>,
2165 ) -> std::result::Result<
2166 tonic::Response<super::CreateQueueItemsResponse>,
2167 tonic::Status,
2168 >;
2169 async fn get_queue_items(
2171 &self,
2172 request: tonic::Request<super::GetQueueItemsRequest>,
2173 ) -> std::result::Result<
2174 tonic::Response<super::GetQueueItemsResponse>,
2175 tonic::Status,
2176 >;
2177 async fn update_queue_items(
2179 &self,
2180 request: tonic::Request<super::UpdateQueueItemsRequest>,
2181 ) -> std::result::Result<
2182 tonic::Response<super::UpdateQueueItemsResponse>,
2183 tonic::Status,
2184 >;
2185 async fn delete_queue_items(
2187 &self,
2188 request: tonic::Request<super::DeleteQueueItemsRequest>,
2189 ) -> std::result::Result<
2190 tonic::Response<super::DeleteQueueItemsResponse>,
2191 tonic::Status,
2192 >;
2193 async fn create_transactions(
2195 &self,
2196 request: tonic::Request<super::CreateTransactionsRequest>,
2197 ) -> std::result::Result<
2198 tonic::Response<super::CreateTransactionsResponse>,
2199 tonic::Status,
2200 >;
2201 async fn get_transactions(
2203 &self,
2204 request: tonic::Request<super::GetTransactionsRequest>,
2205 ) -> std::result::Result<
2206 tonic::Response<super::GetTransactionsResponse>,
2207 tonic::Status,
2208 >;
2209 async fn update_transactions(
2211 &self,
2212 request: tonic::Request<super::UpdateTransactionsRequest>,
2213 ) -> std::result::Result<
2214 tonic::Response<super::UpdateTransactionsResponse>,
2215 tonic::Status,
2216 >;
2217 async fn delete_transactions(
2219 &self,
2220 request: tonic::Request<super::DeleteTransactionsRequest>,
2221 ) -> std::result::Result<
2222 tonic::Response<super::DeleteTransactionsResponse>,
2223 tonic::Status,
2224 >;
2225 }
2226 #[derive(Debug)]
2228 pub struct StoreServiceServer<T> {
2229 inner: Arc<T>,
2230 accept_compression_encodings: EnabledCompressionEncodings,
2231 send_compression_encodings: EnabledCompressionEncodings,
2232 max_decoding_message_size: Option<usize>,
2233 max_encoding_message_size: Option<usize>,
2234 }
2235 impl<T> StoreServiceServer<T> {
2236 pub fn new(inner: T) -> Self {
2237 Self::from_arc(Arc::new(inner))
2238 }
2239 pub fn from_arc(inner: Arc<T>) -> Self {
2240 Self {
2241 inner,
2242 accept_compression_encodings: Default::default(),
2243 send_compression_encodings: Default::default(),
2244 max_decoding_message_size: None,
2245 max_encoding_message_size: None,
2246 }
2247 }
2248 pub fn with_interceptor<F>(
2249 inner: T,
2250 interceptor: F,
2251 ) -> InterceptedService<Self, F>
2252 where
2253 F: tonic::service::Interceptor,
2254 {
2255 InterceptedService::new(Self::new(inner), interceptor)
2256 }
2257 #[must_use]
2259 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
2260 self.accept_compression_encodings.enable(encoding);
2261 self
2262 }
2263 #[must_use]
2265 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
2266 self.send_compression_encodings.enable(encoding);
2267 self
2268 }
2269 #[must_use]
2273 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
2274 self.max_decoding_message_size = Some(limit);
2275 self
2276 }
2277 #[must_use]
2281 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
2282 self.max_encoding_message_size = Some(limit);
2283 self
2284 }
2285 }
2286 impl<T, B> tonic::codegen::Service<http::Request<B>> for StoreServiceServer<T>
2287 where
2288 T: StoreService,
2289 B: Body + std::marker::Send + 'static,
2290 B::Error: Into<StdError> + std::marker::Send + 'static,
2291 {
2292 type Response = http::Response<tonic::body::BoxBody>;
2293 type Error = std::convert::Infallible;
2294 type Future = BoxFuture<Self::Response, Self::Error>;
2295 fn poll_ready(
2296 &mut self,
2297 _cx: &mut Context<'_>,
2298 ) -> Poll<std::result::Result<(), Self::Error>> {
2299 Poll::Ready(Ok(()))
2300 }
2301 fn call(&mut self, req: http::Request<B>) -> Self::Future {
2302 match req.uri().path() {
2303 "/store.StoreService/CreateItems" => {
2304 #[allow(non_camel_case_types)]
2305 struct CreateItemsSvc<T: StoreService>(pub Arc<T>);
2306 impl<
2307 T: StoreService,
2308 > tonic::server::UnaryService<super::CreateItemsRequest>
2309 for CreateItemsSvc<T> {
2310 type Response = super::CreateItemsResponse;
2311 type Future = BoxFuture<
2312 tonic::Response<Self::Response>,
2313 tonic::Status,
2314 >;
2315 fn call(
2316 &mut self,
2317 request: tonic::Request<super::CreateItemsRequest>,
2318 ) -> Self::Future {
2319 let inner = Arc::clone(&self.0);
2320 let fut = async move {
2321 <T as StoreService>::create_items(&inner, request).await
2322 };
2323 Box::pin(fut)
2324 }
2325 }
2326 let accept_compression_encodings = self.accept_compression_encodings;
2327 let send_compression_encodings = self.send_compression_encodings;
2328 let max_decoding_message_size = self.max_decoding_message_size;
2329 let max_encoding_message_size = self.max_encoding_message_size;
2330 let inner = self.inner.clone();
2331 let fut = async move {
2332 let method = CreateItemsSvc(inner);
2333 let codec = tonic::codec::ProstCodec::default();
2334 let mut grpc = tonic::server::Grpc::new(codec)
2335 .apply_compression_config(
2336 accept_compression_encodings,
2337 send_compression_encodings,
2338 )
2339 .apply_max_message_size_config(
2340 max_decoding_message_size,
2341 max_encoding_message_size,
2342 );
2343 let res = grpc.unary(method, req).await;
2344 Ok(res)
2345 };
2346 Box::pin(fut)
2347 }
2348 "/store.StoreService/GetItems" => {
2349 #[allow(non_camel_case_types)]
2350 struct GetItemsSvc<T: StoreService>(pub Arc<T>);
2351 impl<
2352 T: StoreService,
2353 > tonic::server::UnaryService<super::GetItemsRequest>
2354 for GetItemsSvc<T> {
2355 type Response = super::GetItemsResponse;
2356 type Future = BoxFuture<
2357 tonic::Response<Self::Response>,
2358 tonic::Status,
2359 >;
2360 fn call(
2361 &mut self,
2362 request: tonic::Request<super::GetItemsRequest>,
2363 ) -> Self::Future {
2364 let inner = Arc::clone(&self.0);
2365 let fut = async move {
2366 <T as StoreService>::get_items(&inner, request).await
2367 };
2368 Box::pin(fut)
2369 }
2370 }
2371 let accept_compression_encodings = self.accept_compression_encodings;
2372 let send_compression_encodings = self.send_compression_encodings;
2373 let max_decoding_message_size = self.max_decoding_message_size;
2374 let max_encoding_message_size = self.max_encoding_message_size;
2375 let inner = self.inner.clone();
2376 let fut = async move {
2377 let method = GetItemsSvc(inner);
2378 let codec = tonic::codec::ProstCodec::default();
2379 let mut grpc = tonic::server::Grpc::new(codec)
2380 .apply_compression_config(
2381 accept_compression_encodings,
2382 send_compression_encodings,
2383 )
2384 .apply_max_message_size_config(
2385 max_decoding_message_size,
2386 max_encoding_message_size,
2387 );
2388 let res = grpc.unary(method, req).await;
2389 Ok(res)
2390 };
2391 Box::pin(fut)
2392 }
2393 "/store.StoreService/UpdateItems" => {
2394 #[allow(non_camel_case_types)]
2395 struct UpdateItemsSvc<T: StoreService>(pub Arc<T>);
2396 impl<
2397 T: StoreService,
2398 > tonic::server::UnaryService<super::UpdateItemsRequest>
2399 for UpdateItemsSvc<T> {
2400 type Response = super::UpdateItemsResponse;
2401 type Future = BoxFuture<
2402 tonic::Response<Self::Response>,
2403 tonic::Status,
2404 >;
2405 fn call(
2406 &mut self,
2407 request: tonic::Request<super::UpdateItemsRequest>,
2408 ) -> Self::Future {
2409 let inner = Arc::clone(&self.0);
2410 let fut = async move {
2411 <T as StoreService>::update_items(&inner, request).await
2412 };
2413 Box::pin(fut)
2414 }
2415 }
2416 let accept_compression_encodings = self.accept_compression_encodings;
2417 let send_compression_encodings = self.send_compression_encodings;
2418 let max_decoding_message_size = self.max_decoding_message_size;
2419 let max_encoding_message_size = self.max_encoding_message_size;
2420 let inner = self.inner.clone();
2421 let fut = async move {
2422 let method = UpdateItemsSvc(inner);
2423 let codec = tonic::codec::ProstCodec::default();
2424 let mut grpc = tonic::server::Grpc::new(codec)
2425 .apply_compression_config(
2426 accept_compression_encodings,
2427 send_compression_encodings,
2428 )
2429 .apply_max_message_size_config(
2430 max_decoding_message_size,
2431 max_encoding_message_size,
2432 );
2433 let res = grpc.unary(method, req).await;
2434 Ok(res)
2435 };
2436 Box::pin(fut)
2437 }
2438 "/store.StoreService/DeleteItems" => {
2439 #[allow(non_camel_case_types)]
2440 struct DeleteItemsSvc<T: StoreService>(pub Arc<T>);
2441 impl<
2442 T: StoreService,
2443 > tonic::server::UnaryService<super::DeleteItemsRequest>
2444 for DeleteItemsSvc<T> {
2445 type Response = super::DeleteItemsResponse;
2446 type Future = BoxFuture<
2447 tonic::Response<Self::Response>,
2448 tonic::Status,
2449 >;
2450 fn call(
2451 &mut self,
2452 request: tonic::Request<super::DeleteItemsRequest>,
2453 ) -> Self::Future {
2454 let inner = Arc::clone(&self.0);
2455 let fut = async move {
2456 <T as StoreService>::delete_items(&inner, request).await
2457 };
2458 Box::pin(fut)
2459 }
2460 }
2461 let accept_compression_encodings = self.accept_compression_encodings;
2462 let send_compression_encodings = self.send_compression_encodings;
2463 let max_decoding_message_size = self.max_decoding_message_size;
2464 let max_encoding_message_size = self.max_encoding_message_size;
2465 let inner = self.inner.clone();
2466 let fut = async move {
2467 let method = DeleteItemsSvc(inner);
2468 let codec = tonic::codec::ProstCodec::default();
2469 let mut grpc = tonic::server::Grpc::new(codec)
2470 .apply_compression_config(
2471 accept_compression_encodings,
2472 send_compression_encodings,
2473 )
2474 .apply_max_message_size_config(
2475 max_decoding_message_size,
2476 max_encoding_message_size,
2477 );
2478 let res = grpc.unary(method, req).await;
2479 Ok(res)
2480 };
2481 Box::pin(fut)
2482 }
2483 "/store.StoreService/CreatePackets" => {
2484 #[allow(non_camel_case_types)]
2485 struct CreatePacketsSvc<T: StoreService>(pub Arc<T>);
2486 impl<
2487 T: StoreService,
2488 > tonic::server::UnaryService<super::CreatePacketsRequest>
2489 for CreatePacketsSvc<T> {
2490 type Response = super::CreatePacketsResponse;
2491 type Future = BoxFuture<
2492 tonic::Response<Self::Response>,
2493 tonic::Status,
2494 >;
2495 fn call(
2496 &mut self,
2497 request: tonic::Request<super::CreatePacketsRequest>,
2498 ) -> Self::Future {
2499 let inner = Arc::clone(&self.0);
2500 let fut = async move {
2501 <T as StoreService>::create_packets(&inner, request).await
2502 };
2503 Box::pin(fut)
2504 }
2505 }
2506 let accept_compression_encodings = self.accept_compression_encodings;
2507 let send_compression_encodings = self.send_compression_encodings;
2508 let max_decoding_message_size = self.max_decoding_message_size;
2509 let max_encoding_message_size = self.max_encoding_message_size;
2510 let inner = self.inner.clone();
2511 let fut = async move {
2512 let method = CreatePacketsSvc(inner);
2513 let codec = tonic::codec::ProstCodec::default();
2514 let mut grpc = tonic::server::Grpc::new(codec)
2515 .apply_compression_config(
2516 accept_compression_encodings,
2517 send_compression_encodings,
2518 )
2519 .apply_max_message_size_config(
2520 max_decoding_message_size,
2521 max_encoding_message_size,
2522 );
2523 let res = grpc.unary(method, req).await;
2524 Ok(res)
2525 };
2526 Box::pin(fut)
2527 }
2528 "/store.StoreService/GetPackets" => {
2529 #[allow(non_camel_case_types)]
2530 struct GetPacketsSvc<T: StoreService>(pub Arc<T>);
2531 impl<
2532 T: StoreService,
2533 > tonic::server::UnaryService<super::GetPacketsRequest>
2534 for GetPacketsSvc<T> {
2535 type Response = super::GetPacketsResponse;
2536 type Future = BoxFuture<
2537 tonic::Response<Self::Response>,
2538 tonic::Status,
2539 >;
2540 fn call(
2541 &mut self,
2542 request: tonic::Request<super::GetPacketsRequest>,
2543 ) -> Self::Future {
2544 let inner = Arc::clone(&self.0);
2545 let fut = async move {
2546 <T as StoreService>::get_packets(&inner, request).await
2547 };
2548 Box::pin(fut)
2549 }
2550 }
2551 let accept_compression_encodings = self.accept_compression_encodings;
2552 let send_compression_encodings = self.send_compression_encodings;
2553 let max_decoding_message_size = self.max_decoding_message_size;
2554 let max_encoding_message_size = self.max_encoding_message_size;
2555 let inner = self.inner.clone();
2556 let fut = async move {
2557 let method = GetPacketsSvc(inner);
2558 let codec = tonic::codec::ProstCodec::default();
2559 let mut grpc = tonic::server::Grpc::new(codec)
2560 .apply_compression_config(
2561 accept_compression_encodings,
2562 send_compression_encodings,
2563 )
2564 .apply_max_message_size_config(
2565 max_decoding_message_size,
2566 max_encoding_message_size,
2567 );
2568 let res = grpc.unary(method, req).await;
2569 Ok(res)
2570 };
2571 Box::pin(fut)
2572 }
2573 "/store.StoreService/UpdatePackets" => {
2574 #[allow(non_camel_case_types)]
2575 struct UpdatePacketsSvc<T: StoreService>(pub Arc<T>);
2576 impl<
2577 T: StoreService,
2578 > tonic::server::UnaryService<super::UpdatePacketsRequest>
2579 for UpdatePacketsSvc<T> {
2580 type Response = super::UpdatePacketsResponse;
2581 type Future = BoxFuture<
2582 tonic::Response<Self::Response>,
2583 tonic::Status,
2584 >;
2585 fn call(
2586 &mut self,
2587 request: tonic::Request<super::UpdatePacketsRequest>,
2588 ) -> Self::Future {
2589 let inner = Arc::clone(&self.0);
2590 let fut = async move {
2591 <T as StoreService>::update_packets(&inner, request).await
2592 };
2593 Box::pin(fut)
2594 }
2595 }
2596 let accept_compression_encodings = self.accept_compression_encodings;
2597 let send_compression_encodings = self.send_compression_encodings;
2598 let max_decoding_message_size = self.max_decoding_message_size;
2599 let max_encoding_message_size = self.max_encoding_message_size;
2600 let inner = self.inner.clone();
2601 let fut = async move {
2602 let method = UpdatePacketsSvc(inner);
2603 let codec = tonic::codec::ProstCodec::default();
2604 let mut grpc = tonic::server::Grpc::new(codec)
2605 .apply_compression_config(
2606 accept_compression_encodings,
2607 send_compression_encodings,
2608 )
2609 .apply_max_message_size_config(
2610 max_decoding_message_size,
2611 max_encoding_message_size,
2612 );
2613 let res = grpc.unary(method, req).await;
2614 Ok(res)
2615 };
2616 Box::pin(fut)
2617 }
2618 "/store.StoreService/DeletePackets" => {
2619 #[allow(non_camel_case_types)]
2620 struct DeletePacketsSvc<T: StoreService>(pub Arc<T>);
2621 impl<
2622 T: StoreService,
2623 > tonic::server::UnaryService<super::DeletePacketsRequest>
2624 for DeletePacketsSvc<T> {
2625 type Response = super::DeletePacketsResponse;
2626 type Future = BoxFuture<
2627 tonic::Response<Self::Response>,
2628 tonic::Status,
2629 >;
2630 fn call(
2631 &mut self,
2632 request: tonic::Request<super::DeletePacketsRequest>,
2633 ) -> Self::Future {
2634 let inner = Arc::clone(&self.0);
2635 let fut = async move {
2636 <T as StoreService>::delete_packets(&inner, request).await
2637 };
2638 Box::pin(fut)
2639 }
2640 }
2641 let accept_compression_encodings = self.accept_compression_encodings;
2642 let send_compression_encodings = self.send_compression_encodings;
2643 let max_decoding_message_size = self.max_decoding_message_size;
2644 let max_encoding_message_size = self.max_encoding_message_size;
2645 let inner = self.inner.clone();
2646 let fut = async move {
2647 let method = DeletePacketsSvc(inner);
2648 let codec = tonic::codec::ProstCodec::default();
2649 let mut grpc = tonic::server::Grpc::new(codec)
2650 .apply_compression_config(
2651 accept_compression_encodings,
2652 send_compression_encodings,
2653 )
2654 .apply_max_message_size_config(
2655 max_decoding_message_size,
2656 max_encoding_message_size,
2657 );
2658 let res = grpc.unary(method, req).await;
2659 Ok(res)
2660 };
2661 Box::pin(fut)
2662 }
2663 "/store.StoreService/CreateConnections" => {
2664 #[allow(non_camel_case_types)]
2665 struct CreateConnectionsSvc<T: StoreService>(pub Arc<T>);
2666 impl<
2667 T: StoreService,
2668 > tonic::server::UnaryService<super::CreateConnectionsRequest>
2669 for CreateConnectionsSvc<T> {
2670 type Response = super::CreateConnectionsResponse;
2671 type Future = BoxFuture<
2672 tonic::Response<Self::Response>,
2673 tonic::Status,
2674 >;
2675 fn call(
2676 &mut self,
2677 request: tonic::Request<super::CreateConnectionsRequest>,
2678 ) -> Self::Future {
2679 let inner = Arc::clone(&self.0);
2680 let fut = async move {
2681 <T as StoreService>::create_connections(&inner, request)
2682 .await
2683 };
2684 Box::pin(fut)
2685 }
2686 }
2687 let accept_compression_encodings = self.accept_compression_encodings;
2688 let send_compression_encodings = self.send_compression_encodings;
2689 let max_decoding_message_size = self.max_decoding_message_size;
2690 let max_encoding_message_size = self.max_encoding_message_size;
2691 let inner = self.inner.clone();
2692 let fut = async move {
2693 let method = CreateConnectionsSvc(inner);
2694 let codec = tonic::codec::ProstCodec::default();
2695 let mut grpc = tonic::server::Grpc::new(codec)
2696 .apply_compression_config(
2697 accept_compression_encodings,
2698 send_compression_encodings,
2699 )
2700 .apply_max_message_size_config(
2701 max_decoding_message_size,
2702 max_encoding_message_size,
2703 );
2704 let res = grpc.unary(method, req).await;
2705 Ok(res)
2706 };
2707 Box::pin(fut)
2708 }
2709 "/store.StoreService/GetConnections" => {
2710 #[allow(non_camel_case_types)]
2711 struct GetConnectionsSvc<T: StoreService>(pub Arc<T>);
2712 impl<
2713 T: StoreService,
2714 > tonic::server::UnaryService<super::GetConnectionsRequest>
2715 for GetConnectionsSvc<T> {
2716 type Response = super::GetConnectionsResponse;
2717 type Future = BoxFuture<
2718 tonic::Response<Self::Response>,
2719 tonic::Status,
2720 >;
2721 fn call(
2722 &mut self,
2723 request: tonic::Request<super::GetConnectionsRequest>,
2724 ) -> Self::Future {
2725 let inner = Arc::clone(&self.0);
2726 let fut = async move {
2727 <T as StoreService>::get_connections(&inner, request).await
2728 };
2729 Box::pin(fut)
2730 }
2731 }
2732 let accept_compression_encodings = self.accept_compression_encodings;
2733 let send_compression_encodings = self.send_compression_encodings;
2734 let max_decoding_message_size = self.max_decoding_message_size;
2735 let max_encoding_message_size = self.max_encoding_message_size;
2736 let inner = self.inner.clone();
2737 let fut = async move {
2738 let method = GetConnectionsSvc(inner);
2739 let codec = tonic::codec::ProstCodec::default();
2740 let mut grpc = tonic::server::Grpc::new(codec)
2741 .apply_compression_config(
2742 accept_compression_encodings,
2743 send_compression_encodings,
2744 )
2745 .apply_max_message_size_config(
2746 max_decoding_message_size,
2747 max_encoding_message_size,
2748 );
2749 let res = grpc.unary(method, req).await;
2750 Ok(res)
2751 };
2752 Box::pin(fut)
2753 }
2754 "/store.StoreService/UpdateConnections" => {
2755 #[allow(non_camel_case_types)]
2756 struct UpdateConnectionsSvc<T: StoreService>(pub Arc<T>);
2757 impl<
2758 T: StoreService,
2759 > tonic::server::UnaryService<super::UpdateConnectionsRequest>
2760 for UpdateConnectionsSvc<T> {
2761 type Response = super::UpdateConnectionsResponse;
2762 type Future = BoxFuture<
2763 tonic::Response<Self::Response>,
2764 tonic::Status,
2765 >;
2766 fn call(
2767 &mut self,
2768 request: tonic::Request<super::UpdateConnectionsRequest>,
2769 ) -> Self::Future {
2770 let inner = Arc::clone(&self.0);
2771 let fut = async move {
2772 <T as StoreService>::update_connections(&inner, request)
2773 .await
2774 };
2775 Box::pin(fut)
2776 }
2777 }
2778 let accept_compression_encodings = self.accept_compression_encodings;
2779 let send_compression_encodings = self.send_compression_encodings;
2780 let max_decoding_message_size = self.max_decoding_message_size;
2781 let max_encoding_message_size = self.max_encoding_message_size;
2782 let inner = self.inner.clone();
2783 let fut = async move {
2784 let method = UpdateConnectionsSvc(inner);
2785 let codec = tonic::codec::ProstCodec::default();
2786 let mut grpc = tonic::server::Grpc::new(codec)
2787 .apply_compression_config(
2788 accept_compression_encodings,
2789 send_compression_encodings,
2790 )
2791 .apply_max_message_size_config(
2792 max_decoding_message_size,
2793 max_encoding_message_size,
2794 );
2795 let res = grpc.unary(method, req).await;
2796 Ok(res)
2797 };
2798 Box::pin(fut)
2799 }
2800 "/store.StoreService/DeleteConnections" => {
2801 #[allow(non_camel_case_types)]
2802 struct DeleteConnectionsSvc<T: StoreService>(pub Arc<T>);
2803 impl<
2804 T: StoreService,
2805 > tonic::server::UnaryService<super::DeleteConnectionsRequest>
2806 for DeleteConnectionsSvc<T> {
2807 type Response = super::DeleteConnectionsResponse;
2808 type Future = BoxFuture<
2809 tonic::Response<Self::Response>,
2810 tonic::Status,
2811 >;
2812 fn call(
2813 &mut self,
2814 request: tonic::Request<super::DeleteConnectionsRequest>,
2815 ) -> Self::Future {
2816 let inner = Arc::clone(&self.0);
2817 let fut = async move {
2818 <T as StoreService>::delete_connections(&inner, request)
2819 .await
2820 };
2821 Box::pin(fut)
2822 }
2823 }
2824 let accept_compression_encodings = self.accept_compression_encodings;
2825 let send_compression_encodings = self.send_compression_encodings;
2826 let max_decoding_message_size = self.max_decoding_message_size;
2827 let max_encoding_message_size = self.max_encoding_message_size;
2828 let inner = self.inner.clone();
2829 let fut = async move {
2830 let method = DeleteConnectionsSvc(inner);
2831 let codec = tonic::codec::ProstCodec::default();
2832 let mut grpc = tonic::server::Grpc::new(codec)
2833 .apply_compression_config(
2834 accept_compression_encodings,
2835 send_compression_encodings,
2836 )
2837 .apply_max_message_size_config(
2838 max_decoding_message_size,
2839 max_encoding_message_size,
2840 );
2841 let res = grpc.unary(method, req).await;
2842 Ok(res)
2843 };
2844 Box::pin(fut)
2845 }
2846 "/store.StoreService/CreateCrdtMessages" => {
2847 #[allow(non_camel_case_types)]
2848 struct CreateCrdtMessagesSvc<T: StoreService>(pub Arc<T>);
2849 impl<
2850 T: StoreService,
2851 > tonic::server::UnaryService<super::CreateCrdtMessagesRequest>
2852 for CreateCrdtMessagesSvc<T> {
2853 type Response = super::CreateCrdtMessagesResponse;
2854 type Future = BoxFuture<
2855 tonic::Response<Self::Response>,
2856 tonic::Status,
2857 >;
2858 fn call(
2859 &mut self,
2860 request: tonic::Request<super::CreateCrdtMessagesRequest>,
2861 ) -> Self::Future {
2862 let inner = Arc::clone(&self.0);
2863 let fut = async move {
2864 <T as StoreService>::create_crdt_messages(&inner, request)
2865 .await
2866 };
2867 Box::pin(fut)
2868 }
2869 }
2870 let accept_compression_encodings = self.accept_compression_encodings;
2871 let send_compression_encodings = self.send_compression_encodings;
2872 let max_decoding_message_size = self.max_decoding_message_size;
2873 let max_encoding_message_size = self.max_encoding_message_size;
2874 let inner = self.inner.clone();
2875 let fut = async move {
2876 let method = CreateCrdtMessagesSvc(inner);
2877 let codec = tonic::codec::ProstCodec::default();
2878 let mut grpc = tonic::server::Grpc::new(codec)
2879 .apply_compression_config(
2880 accept_compression_encodings,
2881 send_compression_encodings,
2882 )
2883 .apply_max_message_size_config(
2884 max_decoding_message_size,
2885 max_encoding_message_size,
2886 );
2887 let res = grpc.unary(method, req).await;
2888 Ok(res)
2889 };
2890 Box::pin(fut)
2891 }
2892 "/store.StoreService/GetCrdtMessages" => {
2893 #[allow(non_camel_case_types)]
2894 struct GetCrdtMessagesSvc<T: StoreService>(pub Arc<T>);
2895 impl<
2896 T: StoreService,
2897 > tonic::server::UnaryService<super::GetCrdtMessagesRequest>
2898 for GetCrdtMessagesSvc<T> {
2899 type Response = super::GetCrdtMessagesResponse;
2900 type Future = BoxFuture<
2901 tonic::Response<Self::Response>,
2902 tonic::Status,
2903 >;
2904 fn call(
2905 &mut self,
2906 request: tonic::Request<super::GetCrdtMessagesRequest>,
2907 ) -> Self::Future {
2908 let inner = Arc::clone(&self.0);
2909 let fut = async move {
2910 <T as StoreService>::get_crdt_messages(&inner, request)
2911 .await
2912 };
2913 Box::pin(fut)
2914 }
2915 }
2916 let accept_compression_encodings = self.accept_compression_encodings;
2917 let send_compression_encodings = self.send_compression_encodings;
2918 let max_decoding_message_size = self.max_decoding_message_size;
2919 let max_encoding_message_size = self.max_encoding_message_size;
2920 let inner = self.inner.clone();
2921 let fut = async move {
2922 let method = GetCrdtMessagesSvc(inner);
2923 let codec = tonic::codec::ProstCodec::default();
2924 let mut grpc = tonic::server::Grpc::new(codec)
2925 .apply_compression_config(
2926 accept_compression_encodings,
2927 send_compression_encodings,
2928 )
2929 .apply_max_message_size_config(
2930 max_decoding_message_size,
2931 max_encoding_message_size,
2932 );
2933 let res = grpc.unary(method, req).await;
2934 Ok(res)
2935 };
2936 Box::pin(fut)
2937 }
2938 "/store.StoreService/UpdateCrdtMessages" => {
2939 #[allow(non_camel_case_types)]
2940 struct UpdateCrdtMessagesSvc<T: StoreService>(pub Arc<T>);
2941 impl<
2942 T: StoreService,
2943 > tonic::server::UnaryService<super::UpdateCrdtMessagesRequest>
2944 for UpdateCrdtMessagesSvc<T> {
2945 type Response = super::UpdateCrdtMessagesResponse;
2946 type Future = BoxFuture<
2947 tonic::Response<Self::Response>,
2948 tonic::Status,
2949 >;
2950 fn call(
2951 &mut self,
2952 request: tonic::Request<super::UpdateCrdtMessagesRequest>,
2953 ) -> Self::Future {
2954 let inner = Arc::clone(&self.0);
2955 let fut = async move {
2956 <T as StoreService>::update_crdt_messages(&inner, request)
2957 .await
2958 };
2959 Box::pin(fut)
2960 }
2961 }
2962 let accept_compression_encodings = self.accept_compression_encodings;
2963 let send_compression_encodings = self.send_compression_encodings;
2964 let max_decoding_message_size = self.max_decoding_message_size;
2965 let max_encoding_message_size = self.max_encoding_message_size;
2966 let inner = self.inner.clone();
2967 let fut = async move {
2968 let method = UpdateCrdtMessagesSvc(inner);
2969 let codec = tonic::codec::ProstCodec::default();
2970 let mut grpc = tonic::server::Grpc::new(codec)
2971 .apply_compression_config(
2972 accept_compression_encodings,
2973 send_compression_encodings,
2974 )
2975 .apply_max_message_size_config(
2976 max_decoding_message_size,
2977 max_encoding_message_size,
2978 );
2979 let res = grpc.unary(method, req).await;
2980 Ok(res)
2981 };
2982 Box::pin(fut)
2983 }
2984 "/store.StoreService/DeleteCrdtMessages" => {
2985 #[allow(non_camel_case_types)]
2986 struct DeleteCrdtMessagesSvc<T: StoreService>(pub Arc<T>);
2987 impl<
2988 T: StoreService,
2989 > tonic::server::UnaryService<super::DeleteCrdtMessagesRequest>
2990 for DeleteCrdtMessagesSvc<T> {
2991 type Response = super::DeleteCrdtMessagesResponse;
2992 type Future = BoxFuture<
2993 tonic::Response<Self::Response>,
2994 tonic::Status,
2995 >;
2996 fn call(
2997 &mut self,
2998 request: tonic::Request<super::DeleteCrdtMessagesRequest>,
2999 ) -> Self::Future {
3000 let inner = Arc::clone(&self.0);
3001 let fut = async move {
3002 <T as StoreService>::delete_crdt_messages(&inner, request)
3003 .await
3004 };
3005 Box::pin(fut)
3006 }
3007 }
3008 let accept_compression_encodings = self.accept_compression_encodings;
3009 let send_compression_encodings = self.send_compression_encodings;
3010 let max_decoding_message_size = self.max_decoding_message_size;
3011 let max_encoding_message_size = self.max_encoding_message_size;
3012 let inner = self.inner.clone();
3013 let fut = async move {
3014 let method = DeleteCrdtMessagesSvc(inner);
3015 let codec = tonic::codec::ProstCodec::default();
3016 let mut grpc = tonic::server::Grpc::new(codec)
3017 .apply_compression_config(
3018 accept_compression_encodings,
3019 send_compression_encodings,
3020 )
3021 .apply_max_message_size_config(
3022 max_decoding_message_size,
3023 max_encoding_message_size,
3024 );
3025 let res = grpc.unary(method, req).await;
3026 Ok(res)
3027 };
3028 Box::pin(fut)
3029 }
3030 "/store.StoreService/CreateCrdtMerkles" => {
3031 #[allow(non_camel_case_types)]
3032 struct CreateCrdtMerklesSvc<T: StoreService>(pub Arc<T>);
3033 impl<
3034 T: StoreService,
3035 > tonic::server::UnaryService<super::CreateCrdtMerklesRequest>
3036 for CreateCrdtMerklesSvc<T> {
3037 type Response = super::CreateCrdtMerklesResponse;
3038 type Future = BoxFuture<
3039 tonic::Response<Self::Response>,
3040 tonic::Status,
3041 >;
3042 fn call(
3043 &mut self,
3044 request: tonic::Request<super::CreateCrdtMerklesRequest>,
3045 ) -> Self::Future {
3046 let inner = Arc::clone(&self.0);
3047 let fut = async move {
3048 <T as StoreService>::create_crdt_merkles(&inner, request)
3049 .await
3050 };
3051 Box::pin(fut)
3052 }
3053 }
3054 let accept_compression_encodings = self.accept_compression_encodings;
3055 let send_compression_encodings = self.send_compression_encodings;
3056 let max_decoding_message_size = self.max_decoding_message_size;
3057 let max_encoding_message_size = self.max_encoding_message_size;
3058 let inner = self.inner.clone();
3059 let fut = async move {
3060 let method = CreateCrdtMerklesSvc(inner);
3061 let codec = tonic::codec::ProstCodec::default();
3062 let mut grpc = tonic::server::Grpc::new(codec)
3063 .apply_compression_config(
3064 accept_compression_encodings,
3065 send_compression_encodings,
3066 )
3067 .apply_max_message_size_config(
3068 max_decoding_message_size,
3069 max_encoding_message_size,
3070 );
3071 let res = grpc.unary(method, req).await;
3072 Ok(res)
3073 };
3074 Box::pin(fut)
3075 }
3076 "/store.StoreService/GetCrdtMerkles" => {
3077 #[allow(non_camel_case_types)]
3078 struct GetCrdtMerklesSvc<T: StoreService>(pub Arc<T>);
3079 impl<
3080 T: StoreService,
3081 > tonic::server::UnaryService<super::GetCrdtMerklesRequest>
3082 for GetCrdtMerklesSvc<T> {
3083 type Response = super::GetCrdtMerklesResponse;
3084 type Future = BoxFuture<
3085 tonic::Response<Self::Response>,
3086 tonic::Status,
3087 >;
3088 fn call(
3089 &mut self,
3090 request: tonic::Request<super::GetCrdtMerklesRequest>,
3091 ) -> Self::Future {
3092 let inner = Arc::clone(&self.0);
3093 let fut = async move {
3094 <T as StoreService>::get_crdt_merkles(&inner, request).await
3095 };
3096 Box::pin(fut)
3097 }
3098 }
3099 let accept_compression_encodings = self.accept_compression_encodings;
3100 let send_compression_encodings = self.send_compression_encodings;
3101 let max_decoding_message_size = self.max_decoding_message_size;
3102 let max_encoding_message_size = self.max_encoding_message_size;
3103 let inner = self.inner.clone();
3104 let fut = async move {
3105 let method = GetCrdtMerklesSvc(inner);
3106 let codec = tonic::codec::ProstCodec::default();
3107 let mut grpc = tonic::server::Grpc::new(codec)
3108 .apply_compression_config(
3109 accept_compression_encodings,
3110 send_compression_encodings,
3111 )
3112 .apply_max_message_size_config(
3113 max_decoding_message_size,
3114 max_encoding_message_size,
3115 );
3116 let res = grpc.unary(method, req).await;
3117 Ok(res)
3118 };
3119 Box::pin(fut)
3120 }
3121 "/store.StoreService/UpdateCrdtMerkles" => {
3122 #[allow(non_camel_case_types)]
3123 struct UpdateCrdtMerklesSvc<T: StoreService>(pub Arc<T>);
3124 impl<
3125 T: StoreService,
3126 > tonic::server::UnaryService<super::UpdateCrdtMerklesRequest>
3127 for UpdateCrdtMerklesSvc<T> {
3128 type Response = super::UpdateCrdtMerklesResponse;
3129 type Future = BoxFuture<
3130 tonic::Response<Self::Response>,
3131 tonic::Status,
3132 >;
3133 fn call(
3134 &mut self,
3135 request: tonic::Request<super::UpdateCrdtMerklesRequest>,
3136 ) -> Self::Future {
3137 let inner = Arc::clone(&self.0);
3138 let fut = async move {
3139 <T as StoreService>::update_crdt_merkles(&inner, request)
3140 .await
3141 };
3142 Box::pin(fut)
3143 }
3144 }
3145 let accept_compression_encodings = self.accept_compression_encodings;
3146 let send_compression_encodings = self.send_compression_encodings;
3147 let max_decoding_message_size = self.max_decoding_message_size;
3148 let max_encoding_message_size = self.max_encoding_message_size;
3149 let inner = self.inner.clone();
3150 let fut = async move {
3151 let method = UpdateCrdtMerklesSvc(inner);
3152 let codec = tonic::codec::ProstCodec::default();
3153 let mut grpc = tonic::server::Grpc::new(codec)
3154 .apply_compression_config(
3155 accept_compression_encodings,
3156 send_compression_encodings,
3157 )
3158 .apply_max_message_size_config(
3159 max_decoding_message_size,
3160 max_encoding_message_size,
3161 );
3162 let res = grpc.unary(method, req).await;
3163 Ok(res)
3164 };
3165 Box::pin(fut)
3166 }
3167 "/store.StoreService/DeleteCrdtMerkles" => {
3168 #[allow(non_camel_case_types)]
3169 struct DeleteCrdtMerklesSvc<T: StoreService>(pub Arc<T>);
3170 impl<
3171 T: StoreService,
3172 > tonic::server::UnaryService<super::DeleteCrdtMerklesRequest>
3173 for DeleteCrdtMerklesSvc<T> {
3174 type Response = super::DeleteCrdtMerklesResponse;
3175 type Future = BoxFuture<
3176 tonic::Response<Self::Response>,
3177 tonic::Status,
3178 >;
3179 fn call(
3180 &mut self,
3181 request: tonic::Request<super::DeleteCrdtMerklesRequest>,
3182 ) -> Self::Future {
3183 let inner = Arc::clone(&self.0);
3184 let fut = async move {
3185 <T as StoreService>::delete_crdt_merkles(&inner, request)
3186 .await
3187 };
3188 Box::pin(fut)
3189 }
3190 }
3191 let accept_compression_encodings = self.accept_compression_encodings;
3192 let send_compression_encodings = self.send_compression_encodings;
3193 let max_decoding_message_size = self.max_decoding_message_size;
3194 let max_encoding_message_size = self.max_encoding_message_size;
3195 let inner = self.inner.clone();
3196 let fut = async move {
3197 let method = DeleteCrdtMerklesSvc(inner);
3198 let codec = tonic::codec::ProstCodec::default();
3199 let mut grpc = tonic::server::Grpc::new(codec)
3200 .apply_compression_config(
3201 accept_compression_encodings,
3202 send_compression_encodings,
3203 )
3204 .apply_max_message_size_config(
3205 max_decoding_message_size,
3206 max_encoding_message_size,
3207 );
3208 let res = grpc.unary(method, req).await;
3209 Ok(res)
3210 };
3211 Box::pin(fut)
3212 }
3213 "/store.StoreService/CreateSyncEndpoints" => {
3214 #[allow(non_camel_case_types)]
3215 struct CreateSyncEndpointsSvc<T: StoreService>(pub Arc<T>);
3216 impl<
3217 T: StoreService,
3218 > tonic::server::UnaryService<super::CreateSyncEndpointsRequest>
3219 for CreateSyncEndpointsSvc<T> {
3220 type Response = super::CreateSyncEndpointsResponse;
3221 type Future = BoxFuture<
3222 tonic::Response<Self::Response>,
3223 tonic::Status,
3224 >;
3225 fn call(
3226 &mut self,
3227 request: tonic::Request<super::CreateSyncEndpointsRequest>,
3228 ) -> Self::Future {
3229 let inner = Arc::clone(&self.0);
3230 let fut = async move {
3231 <T as StoreService>::create_sync_endpoints(&inner, request)
3232 .await
3233 };
3234 Box::pin(fut)
3235 }
3236 }
3237 let accept_compression_encodings = self.accept_compression_encodings;
3238 let send_compression_encodings = self.send_compression_encodings;
3239 let max_decoding_message_size = self.max_decoding_message_size;
3240 let max_encoding_message_size = self.max_encoding_message_size;
3241 let inner = self.inner.clone();
3242 let fut = async move {
3243 let method = CreateSyncEndpointsSvc(inner);
3244 let codec = tonic::codec::ProstCodec::default();
3245 let mut grpc = tonic::server::Grpc::new(codec)
3246 .apply_compression_config(
3247 accept_compression_encodings,
3248 send_compression_encodings,
3249 )
3250 .apply_max_message_size_config(
3251 max_decoding_message_size,
3252 max_encoding_message_size,
3253 );
3254 let res = grpc.unary(method, req).await;
3255 Ok(res)
3256 };
3257 Box::pin(fut)
3258 }
3259 "/store.StoreService/GetSyncEndpoints" => {
3260 #[allow(non_camel_case_types)]
3261 struct GetSyncEndpointsSvc<T: StoreService>(pub Arc<T>);
3262 impl<
3263 T: StoreService,
3264 > tonic::server::UnaryService<super::GetSyncEndpointsRequest>
3265 for GetSyncEndpointsSvc<T> {
3266 type Response = super::GetSyncEndpointsResponse;
3267 type Future = BoxFuture<
3268 tonic::Response<Self::Response>,
3269 tonic::Status,
3270 >;
3271 fn call(
3272 &mut self,
3273 request: tonic::Request<super::GetSyncEndpointsRequest>,
3274 ) -> Self::Future {
3275 let inner = Arc::clone(&self.0);
3276 let fut = async move {
3277 <T as StoreService>::get_sync_endpoints(&inner, request)
3278 .await
3279 };
3280 Box::pin(fut)
3281 }
3282 }
3283 let accept_compression_encodings = self.accept_compression_encodings;
3284 let send_compression_encodings = self.send_compression_encodings;
3285 let max_decoding_message_size = self.max_decoding_message_size;
3286 let max_encoding_message_size = self.max_encoding_message_size;
3287 let inner = self.inner.clone();
3288 let fut = async move {
3289 let method = GetSyncEndpointsSvc(inner);
3290 let codec = tonic::codec::ProstCodec::default();
3291 let mut grpc = tonic::server::Grpc::new(codec)
3292 .apply_compression_config(
3293 accept_compression_encodings,
3294 send_compression_encodings,
3295 )
3296 .apply_max_message_size_config(
3297 max_decoding_message_size,
3298 max_encoding_message_size,
3299 );
3300 let res = grpc.unary(method, req).await;
3301 Ok(res)
3302 };
3303 Box::pin(fut)
3304 }
3305 "/store.StoreService/UpdateSyncEndpoints" => {
3306 #[allow(non_camel_case_types)]
3307 struct UpdateSyncEndpointsSvc<T: StoreService>(pub Arc<T>);
3308 impl<
3309 T: StoreService,
3310 > tonic::server::UnaryService<super::UpdateSyncEndpointsRequest>
3311 for UpdateSyncEndpointsSvc<T> {
3312 type Response = super::UpdateSyncEndpointsResponse;
3313 type Future = BoxFuture<
3314 tonic::Response<Self::Response>,
3315 tonic::Status,
3316 >;
3317 fn call(
3318 &mut self,
3319 request: tonic::Request<super::UpdateSyncEndpointsRequest>,
3320 ) -> Self::Future {
3321 let inner = Arc::clone(&self.0);
3322 let fut = async move {
3323 <T as StoreService>::update_sync_endpoints(&inner, request)
3324 .await
3325 };
3326 Box::pin(fut)
3327 }
3328 }
3329 let accept_compression_encodings = self.accept_compression_encodings;
3330 let send_compression_encodings = self.send_compression_encodings;
3331 let max_decoding_message_size = self.max_decoding_message_size;
3332 let max_encoding_message_size = self.max_encoding_message_size;
3333 let inner = self.inner.clone();
3334 let fut = async move {
3335 let method = UpdateSyncEndpointsSvc(inner);
3336 let codec = tonic::codec::ProstCodec::default();
3337 let mut grpc = tonic::server::Grpc::new(codec)
3338 .apply_compression_config(
3339 accept_compression_encodings,
3340 send_compression_encodings,
3341 )
3342 .apply_max_message_size_config(
3343 max_decoding_message_size,
3344 max_encoding_message_size,
3345 );
3346 let res = grpc.unary(method, req).await;
3347 Ok(res)
3348 };
3349 Box::pin(fut)
3350 }
3351 "/store.StoreService/DeleteSyncEndpoints" => {
3352 #[allow(non_camel_case_types)]
3353 struct DeleteSyncEndpointsSvc<T: StoreService>(pub Arc<T>);
3354 impl<
3355 T: StoreService,
3356 > tonic::server::UnaryService<super::DeleteSyncEndpointsRequest>
3357 for DeleteSyncEndpointsSvc<T> {
3358 type Response = super::DeleteSyncEndpointsResponse;
3359 type Future = BoxFuture<
3360 tonic::Response<Self::Response>,
3361 tonic::Status,
3362 >;
3363 fn call(
3364 &mut self,
3365 request: tonic::Request<super::DeleteSyncEndpointsRequest>,
3366 ) -> Self::Future {
3367 let inner = Arc::clone(&self.0);
3368 let fut = async move {
3369 <T as StoreService>::delete_sync_endpoints(&inner, request)
3370 .await
3371 };
3372 Box::pin(fut)
3373 }
3374 }
3375 let accept_compression_encodings = self.accept_compression_encodings;
3376 let send_compression_encodings = self.send_compression_encodings;
3377 let max_decoding_message_size = self.max_decoding_message_size;
3378 let max_encoding_message_size = self.max_encoding_message_size;
3379 let inner = self.inner.clone();
3380 let fut = async move {
3381 let method = DeleteSyncEndpointsSvc(inner);
3382 let codec = tonic::codec::ProstCodec::default();
3383 let mut grpc = tonic::server::Grpc::new(codec)
3384 .apply_compression_config(
3385 accept_compression_encodings,
3386 send_compression_encodings,
3387 )
3388 .apply_max_message_size_config(
3389 max_decoding_message_size,
3390 max_encoding_message_size,
3391 );
3392 let res = grpc.unary(method, req).await;
3393 Ok(res)
3394 };
3395 Box::pin(fut)
3396 }
3397 "/store.StoreService/CreateQueues" => {
3398 #[allow(non_camel_case_types)]
3399 struct CreateQueuesSvc<T: StoreService>(pub Arc<T>);
3400 impl<
3401 T: StoreService,
3402 > tonic::server::UnaryService<super::CreateQueuesRequest>
3403 for CreateQueuesSvc<T> {
3404 type Response = super::CreateQueuesResponse;
3405 type Future = BoxFuture<
3406 tonic::Response<Self::Response>,
3407 tonic::Status,
3408 >;
3409 fn call(
3410 &mut self,
3411 request: tonic::Request<super::CreateQueuesRequest>,
3412 ) -> Self::Future {
3413 let inner = Arc::clone(&self.0);
3414 let fut = async move {
3415 <T as StoreService>::create_queues(&inner, request).await
3416 };
3417 Box::pin(fut)
3418 }
3419 }
3420 let accept_compression_encodings = self.accept_compression_encodings;
3421 let send_compression_encodings = self.send_compression_encodings;
3422 let max_decoding_message_size = self.max_decoding_message_size;
3423 let max_encoding_message_size = self.max_encoding_message_size;
3424 let inner = self.inner.clone();
3425 let fut = async move {
3426 let method = CreateQueuesSvc(inner);
3427 let codec = tonic::codec::ProstCodec::default();
3428 let mut grpc = tonic::server::Grpc::new(codec)
3429 .apply_compression_config(
3430 accept_compression_encodings,
3431 send_compression_encodings,
3432 )
3433 .apply_max_message_size_config(
3434 max_decoding_message_size,
3435 max_encoding_message_size,
3436 );
3437 let res = grpc.unary(method, req).await;
3438 Ok(res)
3439 };
3440 Box::pin(fut)
3441 }
3442 "/store.StoreService/GetQueues" => {
3443 #[allow(non_camel_case_types)]
3444 struct GetQueuesSvc<T: StoreService>(pub Arc<T>);
3445 impl<
3446 T: StoreService,
3447 > tonic::server::UnaryService<super::GetQueuesRequest>
3448 for GetQueuesSvc<T> {
3449 type Response = super::GetQueuesResponse;
3450 type Future = BoxFuture<
3451 tonic::Response<Self::Response>,
3452 tonic::Status,
3453 >;
3454 fn call(
3455 &mut self,
3456 request: tonic::Request<super::GetQueuesRequest>,
3457 ) -> Self::Future {
3458 let inner = Arc::clone(&self.0);
3459 let fut = async move {
3460 <T as StoreService>::get_queues(&inner, request).await
3461 };
3462 Box::pin(fut)
3463 }
3464 }
3465 let accept_compression_encodings = self.accept_compression_encodings;
3466 let send_compression_encodings = self.send_compression_encodings;
3467 let max_decoding_message_size = self.max_decoding_message_size;
3468 let max_encoding_message_size = self.max_encoding_message_size;
3469 let inner = self.inner.clone();
3470 let fut = async move {
3471 let method = GetQueuesSvc(inner);
3472 let codec = tonic::codec::ProstCodec::default();
3473 let mut grpc = tonic::server::Grpc::new(codec)
3474 .apply_compression_config(
3475 accept_compression_encodings,
3476 send_compression_encodings,
3477 )
3478 .apply_max_message_size_config(
3479 max_decoding_message_size,
3480 max_encoding_message_size,
3481 );
3482 let res = grpc.unary(method, req).await;
3483 Ok(res)
3484 };
3485 Box::pin(fut)
3486 }
3487 "/store.StoreService/UpdateQueues" => {
3488 #[allow(non_camel_case_types)]
3489 struct UpdateQueuesSvc<T: StoreService>(pub Arc<T>);
3490 impl<
3491 T: StoreService,
3492 > tonic::server::UnaryService<super::UpdateQueuesRequest>
3493 for UpdateQueuesSvc<T> {
3494 type Response = super::UpdateQueuesResponse;
3495 type Future = BoxFuture<
3496 tonic::Response<Self::Response>,
3497 tonic::Status,
3498 >;
3499 fn call(
3500 &mut self,
3501 request: tonic::Request<super::UpdateQueuesRequest>,
3502 ) -> Self::Future {
3503 let inner = Arc::clone(&self.0);
3504 let fut = async move {
3505 <T as StoreService>::update_queues(&inner, request).await
3506 };
3507 Box::pin(fut)
3508 }
3509 }
3510 let accept_compression_encodings = self.accept_compression_encodings;
3511 let send_compression_encodings = self.send_compression_encodings;
3512 let max_decoding_message_size = self.max_decoding_message_size;
3513 let max_encoding_message_size = self.max_encoding_message_size;
3514 let inner = self.inner.clone();
3515 let fut = async move {
3516 let method = UpdateQueuesSvc(inner);
3517 let codec = tonic::codec::ProstCodec::default();
3518 let mut grpc = tonic::server::Grpc::new(codec)
3519 .apply_compression_config(
3520 accept_compression_encodings,
3521 send_compression_encodings,
3522 )
3523 .apply_max_message_size_config(
3524 max_decoding_message_size,
3525 max_encoding_message_size,
3526 );
3527 let res = grpc.unary(method, req).await;
3528 Ok(res)
3529 };
3530 Box::pin(fut)
3531 }
3532 "/store.StoreService/DeleteQueues" => {
3533 #[allow(non_camel_case_types)]
3534 struct DeleteQueuesSvc<T: StoreService>(pub Arc<T>);
3535 impl<
3536 T: StoreService,
3537 > tonic::server::UnaryService<super::DeleteQueuesRequest>
3538 for DeleteQueuesSvc<T> {
3539 type Response = super::DeleteQueuesResponse;
3540 type Future = BoxFuture<
3541 tonic::Response<Self::Response>,
3542 tonic::Status,
3543 >;
3544 fn call(
3545 &mut self,
3546 request: tonic::Request<super::DeleteQueuesRequest>,
3547 ) -> Self::Future {
3548 let inner = Arc::clone(&self.0);
3549 let fut = async move {
3550 <T as StoreService>::delete_queues(&inner, request).await
3551 };
3552 Box::pin(fut)
3553 }
3554 }
3555 let accept_compression_encodings = self.accept_compression_encodings;
3556 let send_compression_encodings = self.send_compression_encodings;
3557 let max_decoding_message_size = self.max_decoding_message_size;
3558 let max_encoding_message_size = self.max_encoding_message_size;
3559 let inner = self.inner.clone();
3560 let fut = async move {
3561 let method = DeleteQueuesSvc(inner);
3562 let codec = tonic::codec::ProstCodec::default();
3563 let mut grpc = tonic::server::Grpc::new(codec)
3564 .apply_compression_config(
3565 accept_compression_encodings,
3566 send_compression_encodings,
3567 )
3568 .apply_max_message_size_config(
3569 max_decoding_message_size,
3570 max_encoding_message_size,
3571 );
3572 let res = grpc.unary(method, req).await;
3573 Ok(res)
3574 };
3575 Box::pin(fut)
3576 }
3577 "/store.StoreService/CreateQueueItems" => {
3578 #[allow(non_camel_case_types)]
3579 struct CreateQueueItemsSvc<T: StoreService>(pub Arc<T>);
3580 impl<
3581 T: StoreService,
3582 > tonic::server::UnaryService<super::CreateQueueItemsRequest>
3583 for CreateQueueItemsSvc<T> {
3584 type Response = super::CreateQueueItemsResponse;
3585 type Future = BoxFuture<
3586 tonic::Response<Self::Response>,
3587 tonic::Status,
3588 >;
3589 fn call(
3590 &mut self,
3591 request: tonic::Request<super::CreateQueueItemsRequest>,
3592 ) -> Self::Future {
3593 let inner = Arc::clone(&self.0);
3594 let fut = async move {
3595 <T as StoreService>::create_queue_items(&inner, request)
3596 .await
3597 };
3598 Box::pin(fut)
3599 }
3600 }
3601 let accept_compression_encodings = self.accept_compression_encodings;
3602 let send_compression_encodings = self.send_compression_encodings;
3603 let max_decoding_message_size = self.max_decoding_message_size;
3604 let max_encoding_message_size = self.max_encoding_message_size;
3605 let inner = self.inner.clone();
3606 let fut = async move {
3607 let method = CreateQueueItemsSvc(inner);
3608 let codec = tonic::codec::ProstCodec::default();
3609 let mut grpc = tonic::server::Grpc::new(codec)
3610 .apply_compression_config(
3611 accept_compression_encodings,
3612 send_compression_encodings,
3613 )
3614 .apply_max_message_size_config(
3615 max_decoding_message_size,
3616 max_encoding_message_size,
3617 );
3618 let res = grpc.unary(method, req).await;
3619 Ok(res)
3620 };
3621 Box::pin(fut)
3622 }
3623 "/store.StoreService/GetQueueItems" => {
3624 #[allow(non_camel_case_types)]
3625 struct GetQueueItemsSvc<T: StoreService>(pub Arc<T>);
3626 impl<
3627 T: StoreService,
3628 > tonic::server::UnaryService<super::GetQueueItemsRequest>
3629 for GetQueueItemsSvc<T> {
3630 type Response = super::GetQueueItemsResponse;
3631 type Future = BoxFuture<
3632 tonic::Response<Self::Response>,
3633 tonic::Status,
3634 >;
3635 fn call(
3636 &mut self,
3637 request: tonic::Request<super::GetQueueItemsRequest>,
3638 ) -> Self::Future {
3639 let inner = Arc::clone(&self.0);
3640 let fut = async move {
3641 <T as StoreService>::get_queue_items(&inner, request).await
3642 };
3643 Box::pin(fut)
3644 }
3645 }
3646 let accept_compression_encodings = self.accept_compression_encodings;
3647 let send_compression_encodings = self.send_compression_encodings;
3648 let max_decoding_message_size = self.max_decoding_message_size;
3649 let max_encoding_message_size = self.max_encoding_message_size;
3650 let inner = self.inner.clone();
3651 let fut = async move {
3652 let method = GetQueueItemsSvc(inner);
3653 let codec = tonic::codec::ProstCodec::default();
3654 let mut grpc = tonic::server::Grpc::new(codec)
3655 .apply_compression_config(
3656 accept_compression_encodings,
3657 send_compression_encodings,
3658 )
3659 .apply_max_message_size_config(
3660 max_decoding_message_size,
3661 max_encoding_message_size,
3662 );
3663 let res = grpc.unary(method, req).await;
3664 Ok(res)
3665 };
3666 Box::pin(fut)
3667 }
3668 "/store.StoreService/UpdateQueueItems" => {
3669 #[allow(non_camel_case_types)]
3670 struct UpdateQueueItemsSvc<T: StoreService>(pub Arc<T>);
3671 impl<
3672 T: StoreService,
3673 > tonic::server::UnaryService<super::UpdateQueueItemsRequest>
3674 for UpdateQueueItemsSvc<T> {
3675 type Response = super::UpdateQueueItemsResponse;
3676 type Future = BoxFuture<
3677 tonic::Response<Self::Response>,
3678 tonic::Status,
3679 >;
3680 fn call(
3681 &mut self,
3682 request: tonic::Request<super::UpdateQueueItemsRequest>,
3683 ) -> Self::Future {
3684 let inner = Arc::clone(&self.0);
3685 let fut = async move {
3686 <T as StoreService>::update_queue_items(&inner, request)
3687 .await
3688 };
3689 Box::pin(fut)
3690 }
3691 }
3692 let accept_compression_encodings = self.accept_compression_encodings;
3693 let send_compression_encodings = self.send_compression_encodings;
3694 let max_decoding_message_size = self.max_decoding_message_size;
3695 let max_encoding_message_size = self.max_encoding_message_size;
3696 let inner = self.inner.clone();
3697 let fut = async move {
3698 let method = UpdateQueueItemsSvc(inner);
3699 let codec = tonic::codec::ProstCodec::default();
3700 let mut grpc = tonic::server::Grpc::new(codec)
3701 .apply_compression_config(
3702 accept_compression_encodings,
3703 send_compression_encodings,
3704 )
3705 .apply_max_message_size_config(
3706 max_decoding_message_size,
3707 max_encoding_message_size,
3708 );
3709 let res = grpc.unary(method, req).await;
3710 Ok(res)
3711 };
3712 Box::pin(fut)
3713 }
3714 "/store.StoreService/DeleteQueueItems" => {
3715 #[allow(non_camel_case_types)]
3716 struct DeleteQueueItemsSvc<T: StoreService>(pub Arc<T>);
3717 impl<
3718 T: StoreService,
3719 > tonic::server::UnaryService<super::DeleteQueueItemsRequest>
3720 for DeleteQueueItemsSvc<T> {
3721 type Response = super::DeleteQueueItemsResponse;
3722 type Future = BoxFuture<
3723 tonic::Response<Self::Response>,
3724 tonic::Status,
3725 >;
3726 fn call(
3727 &mut self,
3728 request: tonic::Request<super::DeleteQueueItemsRequest>,
3729 ) -> Self::Future {
3730 let inner = Arc::clone(&self.0);
3731 let fut = async move {
3732 <T as StoreService>::delete_queue_items(&inner, request)
3733 .await
3734 };
3735 Box::pin(fut)
3736 }
3737 }
3738 let accept_compression_encodings = self.accept_compression_encodings;
3739 let send_compression_encodings = self.send_compression_encodings;
3740 let max_decoding_message_size = self.max_decoding_message_size;
3741 let max_encoding_message_size = self.max_encoding_message_size;
3742 let inner = self.inner.clone();
3743 let fut = async move {
3744 let method = DeleteQueueItemsSvc(inner);
3745 let codec = tonic::codec::ProstCodec::default();
3746 let mut grpc = tonic::server::Grpc::new(codec)
3747 .apply_compression_config(
3748 accept_compression_encodings,
3749 send_compression_encodings,
3750 )
3751 .apply_max_message_size_config(
3752 max_decoding_message_size,
3753 max_encoding_message_size,
3754 );
3755 let res = grpc.unary(method, req).await;
3756 Ok(res)
3757 };
3758 Box::pin(fut)
3759 }
3760 "/store.StoreService/CreateTransactions" => {
3761 #[allow(non_camel_case_types)]
3762 struct CreateTransactionsSvc<T: StoreService>(pub Arc<T>);
3763 impl<
3764 T: StoreService,
3765 > tonic::server::UnaryService<super::CreateTransactionsRequest>
3766 for CreateTransactionsSvc<T> {
3767 type Response = super::CreateTransactionsResponse;
3768 type Future = BoxFuture<
3769 tonic::Response<Self::Response>,
3770 tonic::Status,
3771 >;
3772 fn call(
3773 &mut self,
3774 request: tonic::Request<super::CreateTransactionsRequest>,
3775 ) -> Self::Future {
3776 let inner = Arc::clone(&self.0);
3777 let fut = async move {
3778 <T as StoreService>::create_transactions(&inner, request)
3779 .await
3780 };
3781 Box::pin(fut)
3782 }
3783 }
3784 let accept_compression_encodings = self.accept_compression_encodings;
3785 let send_compression_encodings = self.send_compression_encodings;
3786 let max_decoding_message_size = self.max_decoding_message_size;
3787 let max_encoding_message_size = self.max_encoding_message_size;
3788 let inner = self.inner.clone();
3789 let fut = async move {
3790 let method = CreateTransactionsSvc(inner);
3791 let codec = tonic::codec::ProstCodec::default();
3792 let mut grpc = tonic::server::Grpc::new(codec)
3793 .apply_compression_config(
3794 accept_compression_encodings,
3795 send_compression_encodings,
3796 )
3797 .apply_max_message_size_config(
3798 max_decoding_message_size,
3799 max_encoding_message_size,
3800 );
3801 let res = grpc.unary(method, req).await;
3802 Ok(res)
3803 };
3804 Box::pin(fut)
3805 }
3806 "/store.StoreService/GetTransactions" => {
3807 #[allow(non_camel_case_types)]
3808 struct GetTransactionsSvc<T: StoreService>(pub Arc<T>);
3809 impl<
3810 T: StoreService,
3811 > tonic::server::UnaryService<super::GetTransactionsRequest>
3812 for GetTransactionsSvc<T> {
3813 type Response = super::GetTransactionsResponse;
3814 type Future = BoxFuture<
3815 tonic::Response<Self::Response>,
3816 tonic::Status,
3817 >;
3818 fn call(
3819 &mut self,
3820 request: tonic::Request<super::GetTransactionsRequest>,
3821 ) -> Self::Future {
3822 let inner = Arc::clone(&self.0);
3823 let fut = async move {
3824 <T as StoreService>::get_transactions(&inner, request).await
3825 };
3826 Box::pin(fut)
3827 }
3828 }
3829 let accept_compression_encodings = self.accept_compression_encodings;
3830 let send_compression_encodings = self.send_compression_encodings;
3831 let max_decoding_message_size = self.max_decoding_message_size;
3832 let max_encoding_message_size = self.max_encoding_message_size;
3833 let inner = self.inner.clone();
3834 let fut = async move {
3835 let method = GetTransactionsSvc(inner);
3836 let codec = tonic::codec::ProstCodec::default();
3837 let mut grpc = tonic::server::Grpc::new(codec)
3838 .apply_compression_config(
3839 accept_compression_encodings,
3840 send_compression_encodings,
3841 )
3842 .apply_max_message_size_config(
3843 max_decoding_message_size,
3844 max_encoding_message_size,
3845 );
3846 let res = grpc.unary(method, req).await;
3847 Ok(res)
3848 };
3849 Box::pin(fut)
3850 }
3851 "/store.StoreService/UpdateTransactions" => {
3852 #[allow(non_camel_case_types)]
3853 struct UpdateTransactionsSvc<T: StoreService>(pub Arc<T>);
3854 impl<
3855 T: StoreService,
3856 > tonic::server::UnaryService<super::UpdateTransactionsRequest>
3857 for UpdateTransactionsSvc<T> {
3858 type Response = super::UpdateTransactionsResponse;
3859 type Future = BoxFuture<
3860 tonic::Response<Self::Response>,
3861 tonic::Status,
3862 >;
3863 fn call(
3864 &mut self,
3865 request: tonic::Request<super::UpdateTransactionsRequest>,
3866 ) -> Self::Future {
3867 let inner = Arc::clone(&self.0);
3868 let fut = async move {
3869 <T as StoreService>::update_transactions(&inner, request)
3870 .await
3871 };
3872 Box::pin(fut)
3873 }
3874 }
3875 let accept_compression_encodings = self.accept_compression_encodings;
3876 let send_compression_encodings = self.send_compression_encodings;
3877 let max_decoding_message_size = self.max_decoding_message_size;
3878 let max_encoding_message_size = self.max_encoding_message_size;
3879 let inner = self.inner.clone();
3880 let fut = async move {
3881 let method = UpdateTransactionsSvc(inner);
3882 let codec = tonic::codec::ProstCodec::default();
3883 let mut grpc = tonic::server::Grpc::new(codec)
3884 .apply_compression_config(
3885 accept_compression_encodings,
3886 send_compression_encodings,
3887 )
3888 .apply_max_message_size_config(
3889 max_decoding_message_size,
3890 max_encoding_message_size,
3891 );
3892 let res = grpc.unary(method, req).await;
3893 Ok(res)
3894 };
3895 Box::pin(fut)
3896 }
3897 "/store.StoreService/DeleteTransactions" => {
3898 #[allow(non_camel_case_types)]
3899 struct DeleteTransactionsSvc<T: StoreService>(pub Arc<T>);
3900 impl<
3901 T: StoreService,
3902 > tonic::server::UnaryService<super::DeleteTransactionsRequest>
3903 for DeleteTransactionsSvc<T> {
3904 type Response = super::DeleteTransactionsResponse;
3905 type Future = BoxFuture<
3906 tonic::Response<Self::Response>,
3907 tonic::Status,
3908 >;
3909 fn call(
3910 &mut self,
3911 request: tonic::Request<super::DeleteTransactionsRequest>,
3912 ) -> Self::Future {
3913 let inner = Arc::clone(&self.0);
3914 let fut = async move {
3915 <T as StoreService>::delete_transactions(&inner, request)
3916 .await
3917 };
3918 Box::pin(fut)
3919 }
3920 }
3921 let accept_compression_encodings = self.accept_compression_encodings;
3922 let send_compression_encodings = self.send_compression_encodings;
3923 let max_decoding_message_size = self.max_decoding_message_size;
3924 let max_encoding_message_size = self.max_encoding_message_size;
3925 let inner = self.inner.clone();
3926 let fut = async move {
3927 let method = DeleteTransactionsSvc(inner);
3928 let codec = tonic::codec::ProstCodec::default();
3929 let mut grpc = tonic::server::Grpc::new(codec)
3930 .apply_compression_config(
3931 accept_compression_encodings,
3932 send_compression_encodings,
3933 )
3934 .apply_max_message_size_config(
3935 max_decoding_message_size,
3936 max_encoding_message_size,
3937 );
3938 let res = grpc.unary(method, req).await;
3939 Ok(res)
3940 };
3941 Box::pin(fut)
3942 }
3943 _ => {
3944 Box::pin(async move {
3945 let mut response = http::Response::new(empty_body());
3946 let headers = response.headers_mut();
3947 headers
3948 .insert(
3949 tonic::Status::GRPC_STATUS,
3950 (tonic::Code::Unimplemented as i32).into(),
3951 );
3952 headers
3953 .insert(
3954 http::header::CONTENT_TYPE,
3955 tonic::metadata::GRPC_CONTENT_TYPE,
3956 );
3957 Ok(response)
3958 })
3959 }
3960 }
3961 }
3962 }
3963 impl<T> Clone for StoreServiceServer<T> {
3964 fn clone(&self) -> Self {
3965 let inner = self.inner.clone();
3966 Self {
3967 inner,
3968 accept_compression_encodings: self.accept_compression_encodings,
3969 send_compression_encodings: self.send_compression_encodings,
3970 max_decoding_message_size: self.max_decoding_message_size,
3971 max_encoding_message_size: self.max_encoding_message_size,
3972 }
3973 }
3974 }
3975 pub const SERVICE_NAME: &str = "store.StoreService";
3977 impl<T> tonic::server::NamedService for StoreServiceServer<T> {
3978 const NAME: &'static str = SERVICE_NAME;
3979 }
3980}