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

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