krabka_protocol/opt/rustwide/workdir/generated/
ShareAcknowledgeRequest.borrowed.rs

1// AUTO-GENERATED by krabka-protocol-codegen against a9ce3221537b8653448750697915607dc7936cf3. Do not edit.
2use bytes::BufMut;
3
4use crate::{
5    DecodeBorrow, Encode, ProtocolError, UnknownTaggedFields,
6    owned::share_acknowledge_request,
7    primitives::{
8        array::{array_len_prefix_len, get_array_len, put_array_len},
9        fixed::{get_bool, get_i8, get_i32, get_i64, put_bool, put_i8, put_i32, put_i64},
10        string_bytes::{
11            compact_nullable_string_len, nullable_string_len, put_compact_nullable_string,
12            put_nullable_string,
13        },
14        string_bytes_borrowed::{
15            get_compact_nullable_string_borrowed, get_nullable_string_borrowed,
16        },
17        uuid::{Uuid, get_uuid, put_uuid},
18    },
19    tagged_fields::{WriteTaggedFields, read_tagged_fields, tagged_fields_len},
20};
21pub const API_KEY: i16 = 79;
22pub const MIN_VERSION: i16 = 1;
23pub const MAX_VERSION: i16 = 2;
24pub const LATEST_STABLE_VERSION: i16 = 2;
25pub const FLEXIBLE_MIN: i16 = 0;
26#[inline]
27#[must_use]
28pub fn is_flexible(version: i16) -> bool {
29    version >= FLEXIBLE_MIN
30}
31#[derive(Debug, Clone, PartialEq, Eq)]
32pub struct ShareAcknowledgeRequest<'a> {
33    pub group_id: Option<&'a str>,
34    pub member_id: Option<&'a str>,
35    pub share_session_epoch: i32,
36    pub is_renew_ack: bool,
37    pub topics: Vec<AcknowledgeTopic>,
38    pub unknown_tagged_fields: UnknownTaggedFields,
39}
40impl Default for ShareAcknowledgeRequest<'_> {
41    fn default() -> Self {
42        Self {
43            group_id: None,
44            member_id: Some(""),
45            share_session_epoch: 0i32,
46            is_renew_ack: false,
47            topics: Vec::new(),
48            unknown_tagged_fields: UnknownTaggedFields::default(),
49        }
50    }
51}
52impl ShareAcknowledgeRequest<'_> {
53    #[must_use]
54    pub fn to_owned(&self) -> share_acknowledge_request::ShareAcknowledgeRequest {
55        share_acknowledge_request::ShareAcknowledgeRequest {
56            group_id: (self.group_id).map(str::to_owned),
57            member_id: (self.member_id).map(str::to_owned),
58            share_session_epoch: (self.share_session_epoch),
59            is_renew_ack: (self.is_renew_ack),
60            topics: (self.topics)
61                .iter()
62                .map(AcknowledgeTopic::to_owned)
63                .collect(),
64            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
65        }
66    }
67}
68impl Encode for ShareAcknowledgeRequest<'_> {
69    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
70        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
71            return Err(ProtocolError::UnsupportedVersion {
72                api_key: API_KEY,
73                version,
74            });
75        }
76        let flex = is_flexible(version);
77        if version >= 0 {
78            if flex {
79                put_compact_nullable_string(buf, self.group_id)?;
80            } else {
81                put_nullable_string(buf, self.group_id)?;
82            }
83        }
84        if version >= 0 {
85            if flex {
86                put_compact_nullable_string(buf, self.member_id)?;
87            } else {
88                put_nullable_string(buf, self.member_id)?;
89            }
90        }
91        if version >= 0 {
92            put_i32(buf, self.share_session_epoch);
93        }
94        if version >= 2 {
95            put_bool(buf, self.is_renew_ack);
96        }
97        if version >= 0 {
98            {
99                put_array_len(buf, (self.topics).len(), flex)?;
100                for it in &self.topics {
101                    it.encode(buf, version)?;
102                }
103            }
104        }
105        if flex {
106            let tagged = WriteTaggedFields::new();
107            tagged.write(buf, &self.unknown_tagged_fields)?;
108        }
109        Ok(())
110    }
111    fn encoded_len(&self, version: i16) -> usize {
112        let flex = is_flexible(version);
113        let mut n: usize = 0;
114        if version >= 0 {
115            n += if flex {
116                compact_nullable_string_len(self.group_id)
117            } else {
118                nullable_string_len(self.group_id)
119            };
120        }
121        if version >= 0 {
122            n += if flex {
123                compact_nullable_string_len(self.member_id)
124            } else {
125                nullable_string_len(self.member_id)
126            };
127        }
128        if version >= 0 {
129            n += 4;
130        }
131        if version >= 2 {
132            n += 1;
133        }
134        if version >= 0 {
135            n += {
136                let prefix = array_len_prefix_len((self.topics).len(), flex);
137                let body: usize = (self.topics).iter().map(|it| it.encoded_len(version)).sum();
138                prefix + body
139            };
140        }
141        if flex {
142            let known_pairs: Vec<(u32, usize)> = Vec::new();
143            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
144        }
145        n
146    }
147}
148impl<'de> DecodeBorrow<'de> for ShareAcknowledgeRequest<'de> {
149    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
150        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
151            return Err(ProtocolError::UnsupportedVersion {
152                api_key: API_KEY,
153                version,
154            });
155        }
156        let flex = is_flexible(version);
157        let mut out = Self::default();
158        if version >= 0 {
159            out.group_id = if flex {
160                get_compact_nullable_string_borrowed(buf)?
161            } else {
162                get_nullable_string_borrowed(buf)?
163            };
164        }
165        if version >= 0 {
166            out.member_id = if flex {
167                get_compact_nullable_string_borrowed(buf)?
168            } else {
169                get_nullable_string_borrowed(buf)?
170            };
171        }
172        if version >= 0 {
173            out.share_session_epoch = get_i32(buf)?;
174        }
175        if version >= 2 {
176            out.is_renew_ack = get_bool(buf)?;
177        }
178        if version >= 0 {
179            out.topics = {
180                let n = get_array_len(buf, flex)?;
181                let mut v = Vec::with_capacity(n);
182                for _ in 0..n {
183                    v.push(AcknowledgeTopic::decode_borrow(buf, version)?);
184                }
185                v
186            };
187        }
188        if flex {
189            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
190        }
191        Ok(out)
192    }
193}
194#[cfg(test)]
195impl ShareAcknowledgeRequest<'_> {
196    #[must_use]
197    pub fn populated(version: i16) -> Self {
198        let mut m = Self::default();
199        if version >= 0 {
200            m.group_id = Some("x");
201        }
202        if version >= 0 {
203            m.member_id = Some("x");
204        }
205        if version >= 0 {
206            m.share_session_epoch = 1i32;
207        }
208        if version >= 2 {
209            m.is_renew_ack = true;
210        }
211        if version >= 0 {
212            m.topics = vec![AcknowledgeTopic::populated(version)];
213        }
214        m
215    }
216}
217#[derive(Debug, Clone, PartialEq, Eq, Default)]
218pub struct AcknowledgeTopic {
219    pub topic_id: Uuid,
220    pub partitions: Vec<AcknowledgePartition>,
221    pub unknown_tagged_fields: UnknownTaggedFields,
222}
223impl AcknowledgeTopic {
224    #[must_use]
225    pub fn to_owned(&self) -> share_acknowledge_request::AcknowledgeTopic {
226        share_acknowledge_request::AcknowledgeTopic {
227            topic_id: (self.topic_id),
228            partitions: (self.partitions)
229                .iter()
230                .map(AcknowledgePartition::to_owned)
231                .collect(),
232            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
233        }
234    }
235}
236impl Encode for AcknowledgeTopic {
237    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
238        let flex = version >= 0;
239        if version >= 0 {
240            put_uuid(buf, self.topic_id);
241        }
242        if version >= 0 {
243            {
244                put_array_len(buf, (self.partitions).len(), flex)?;
245                for it in &self.partitions {
246                    it.encode(buf, version)?;
247                }
248            }
249        }
250        if flex {
251            let tagged = WriteTaggedFields::new();
252            tagged.write(buf, &self.unknown_tagged_fields)?;
253        }
254        Ok(())
255    }
256    fn encoded_len(&self, version: i16) -> usize {
257        let flex = version >= 0;
258        let mut n: usize = 0;
259        if version >= 0 {
260            n += 16;
261        }
262        if version >= 0 {
263            n += {
264                let prefix = array_len_prefix_len((self.partitions).len(), flex);
265                let body: usize = (self.partitions)
266                    .iter()
267                    .map(|it| it.encoded_len(version))
268                    .sum();
269                prefix + body
270            };
271        }
272        if flex {
273            let known_pairs: Vec<(u32, usize)> = Vec::new();
274            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
275        }
276        n
277    }
278}
279impl<'de> DecodeBorrow<'de> for AcknowledgeTopic {
280    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
281        let flex = version >= 0;
282        let mut out = Self::default();
283        if version >= 0 {
284            out.topic_id = get_uuid(buf)?;
285        }
286        if version >= 0 {
287            out.partitions = {
288                let n = get_array_len(buf, flex)?;
289                let mut v = Vec::with_capacity(n);
290                for _ in 0..n {
291                    v.push(AcknowledgePartition::decode_borrow(buf, version)?);
292                }
293                v
294            };
295        }
296        if flex {
297            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
298        }
299        Ok(out)
300    }
301}
302#[cfg(test)]
303impl AcknowledgeTopic {
304    #[must_use]
305    pub fn populated(version: i16) -> Self {
306        let mut m = Self::default();
307        if version >= 0 {
308            m.topic_id = Uuid([1u8; 16]);
309        }
310        if version >= 0 {
311            m.partitions = vec![AcknowledgePartition::populated(version)];
312        }
313        m
314    }
315}
316#[derive(Debug, Clone, PartialEq, Eq, Default)]
317pub struct AcknowledgePartition {
318    pub partition_index: i32,
319    pub acknowledgement_batches: Vec<AcknowledgementBatch>,
320    pub unknown_tagged_fields: UnknownTaggedFields,
321}
322impl AcknowledgePartition {
323    #[must_use]
324    pub fn to_owned(&self) -> share_acknowledge_request::AcknowledgePartition {
325        share_acknowledge_request::AcknowledgePartition {
326            partition_index: (self.partition_index),
327            acknowledgement_batches: (self.acknowledgement_batches)
328                .iter()
329                .map(AcknowledgementBatch::to_owned)
330                .collect(),
331            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
332        }
333    }
334}
335impl Encode for AcknowledgePartition {
336    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
337        let flex = version >= 0;
338        if version >= 0 {
339            put_i32(buf, self.partition_index);
340        }
341        if version >= 0 {
342            {
343                put_array_len(buf, (self.acknowledgement_batches).len(), flex)?;
344                for it in &self.acknowledgement_batches {
345                    it.encode(buf, version)?;
346                }
347            }
348        }
349        if flex {
350            let tagged = WriteTaggedFields::new();
351            tagged.write(buf, &self.unknown_tagged_fields)?;
352        }
353        Ok(())
354    }
355    fn encoded_len(&self, version: i16) -> usize {
356        let flex = version >= 0;
357        let mut n: usize = 0;
358        if version >= 0 {
359            n += 4;
360        }
361        if version >= 0 {
362            n += {
363                let prefix = array_len_prefix_len((self.acknowledgement_batches).len(), flex);
364                let body: usize = (self.acknowledgement_batches)
365                    .iter()
366                    .map(|it| it.encoded_len(version))
367                    .sum();
368                prefix + body
369            };
370        }
371        if flex {
372            let known_pairs: Vec<(u32, usize)> = Vec::new();
373            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
374        }
375        n
376    }
377}
378impl<'de> DecodeBorrow<'de> for AcknowledgePartition {
379    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
380        let flex = version >= 0;
381        let mut out = Self::default();
382        if version >= 0 {
383            out.partition_index = get_i32(buf)?;
384        }
385        if version >= 0 {
386            out.acknowledgement_batches = {
387                let n = get_array_len(buf, flex)?;
388                let mut v = Vec::with_capacity(n);
389                for _ in 0..n {
390                    v.push(AcknowledgementBatch::decode_borrow(buf, version)?);
391                }
392                v
393            };
394        }
395        if flex {
396            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
397        }
398        Ok(out)
399    }
400}
401#[cfg(test)]
402impl AcknowledgePartition {
403    #[must_use]
404    pub fn populated(version: i16) -> Self {
405        let mut m = Self::default();
406        if version >= 0 {
407            m.partition_index = 1i32;
408        }
409        if version >= 0 {
410            m.acknowledgement_batches = vec![AcknowledgementBatch::populated(version)];
411        }
412        m
413    }
414}
415#[derive(Debug, Clone, PartialEq, Eq, Default)]
416pub struct AcknowledgementBatch {
417    pub first_offset: i64,
418    pub last_offset: i64,
419    pub acknowledge_types: Vec<i8>,
420    pub unknown_tagged_fields: UnknownTaggedFields,
421}
422impl AcknowledgementBatch {
423    #[must_use]
424    pub fn to_owned(&self) -> share_acknowledge_request::AcknowledgementBatch {
425        share_acknowledge_request::AcknowledgementBatch {
426            first_offset: (self.first_offset),
427            last_offset: (self.last_offset),
428            acknowledge_types: (self.acknowledge_types).clone(),
429            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
430        }
431    }
432}
433impl Encode for AcknowledgementBatch {
434    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
435        let flex = version >= 0;
436        if version >= 0 {
437            put_i64(buf, self.first_offset);
438        }
439        if version >= 0 {
440            put_i64(buf, self.last_offset);
441        }
442        if version >= 0 {
443            {
444                put_array_len(buf, (self.acknowledge_types).len(), flex)?;
445                for it in &self.acknowledge_types {
446                    put_i8(buf, *it);
447                }
448            }
449        }
450        if flex {
451            let tagged = WriteTaggedFields::new();
452            tagged.write(buf, &self.unknown_tagged_fields)?;
453        }
454        Ok(())
455    }
456    fn encoded_len(&self, version: i16) -> usize {
457        let flex = version >= 0;
458        let mut n: usize = 0;
459        if version >= 0 {
460            n += 8;
461        }
462        if version >= 0 {
463            n += 8;
464        }
465        if version >= 0 {
466            n += {
467                let prefix = array_len_prefix_len((self.acknowledge_types).len(), flex);
468                let body: usize = (self.acknowledge_types).iter().map(|_| 1).sum();
469                prefix + body
470            };
471        }
472        if flex {
473            let known_pairs: Vec<(u32, usize)> = Vec::new();
474            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
475        }
476        n
477    }
478}
479impl<'de> DecodeBorrow<'de> for AcknowledgementBatch {
480    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
481        let flex = version >= 0;
482        let mut out = Self::default();
483        if version >= 0 {
484            out.first_offset = get_i64(buf)?;
485        }
486        if version >= 0 {
487            out.last_offset = get_i64(buf)?;
488        }
489        if version >= 0 {
490            out.acknowledge_types = {
491                let n = get_array_len(buf, flex)?;
492                let mut v = Vec::with_capacity(n);
493                for _ in 0..n {
494                    v.push(get_i8(buf)?);
495                }
496                v
497            };
498        }
499        if flex {
500            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
501        }
502        Ok(out)
503    }
504}
505#[cfg(test)]
506impl AcknowledgementBatch {
507    #[must_use]
508    pub fn populated(version: i16) -> Self {
509        let mut m = Self::default();
510        if version >= 0 {
511            m.first_offset = 1i64;
512        }
513        if version >= 0 {
514            m.last_offset = 1i64;
515        }
516        if version >= 0 {
517            m.acknowledge_types = vec![1i8];
518        }
519        m
520    }
521}
krabka_protocol/opt/rustwide/workdir/generated/ShareAcknowledgeRequest.borrowed.rs

krabka_protocol/opt/rustwide/workdir/generated/
ShareAcknowledgeRequest.borrowed.rs
