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

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