krabka_protocol/opt/rustwide/workdir/generated/
ShareGroupDescribeResponse.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    primitives::{
7        fixed::{get_i16, get_i32, put_i16, put_i32},
8        string_bytes::{
9            compact_nullable_string_len, compact_string_len, nullable_string_len,
10            put_compact_nullable_string, put_compact_string, put_nullable_string, put_string,
11            string_len,
12        },
13        string_bytes_borrowed::{
14            get_compact_nullable_string_borrowed, get_compact_string_borrowed,
15            get_nullable_string_borrowed, get_string_borrowed,
16        },
17    },
18    tagged_fields::{WriteTaggedFields, read_tagged_fields, tagged_fields_len},
19};
20pub const API_KEY: i16 = 77;
21pub const MIN_VERSION: i16 = 1;
22pub const MAX_VERSION: i16 = 1;
23pub const FLEXIBLE_MIN: i16 = 0;
24#[inline]
25#[must_use]
26pub fn is_flexible(version: i16) -> bool {
27    version >= FLEXIBLE_MIN
28}
29#[derive(Debug, Clone, PartialEq, Eq, Default)]
30pub struct ShareGroupDescribeResponse<'a> {
31    pub throttle_time_ms: i32,
32    pub groups: Vec<DescribedGroup<'a>>,
33    pub unknown_tagged_fields: UnknownTaggedFields,
34}
35impl ShareGroupDescribeResponse<'_> {
36    /// # Panics
37    ///
38    /// Panics if a records field contains an invalid encoded record batch.
39    #[must_use]
40    pub fn to_owned(
41        &self,
42    ) -> crate::owned::share_group_describe_response::ShareGroupDescribeResponse {
43        crate::owned::share_group_describe_response::ShareGroupDescribeResponse {
44            throttle_time_ms: (self.throttle_time_ms),
45            groups: (self.groups).iter().map(DescribedGroup::to_owned).collect(),
46            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
47        }
48    }
49}
50impl Encode for ShareGroupDescribeResponse<'_> {
51    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
52        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
53            return Err(ProtocolError::UnsupportedVersion {
54                api_key: API_KEY,
55                version,
56            });
57        }
58        let flex = is_flexible(version);
59        if version >= 0 {
60            put_i32(buf, self.throttle_time_ms);
61        }
62        if version >= 0 {
63            {
64                crate::primitives::array::put_array_len(buf, (self.groups).len(), flex);
65                for it in &self.groups {
66                    it.encode(buf, version)?;
67                }
68            };
69        }
70        if flex {
71            let tagged = WriteTaggedFields::new();
72            tagged.write(buf, &self.unknown_tagged_fields);
73        }
74        Ok(())
75    }
76    fn encoded_len(&self, version: i16) -> usize {
77        let flex = is_flexible(version);
78        let mut n: usize = 0;
79        if version >= 0 {
80            n += 4;
81        }
82        if version >= 0 {
83            n += {
84                let prefix =
85                    crate::primitives::array::array_len_prefix_len((self.groups).len(), flex);
86                let body: usize = (self.groups).iter().map(|it| it.encoded_len(version)).sum();
87                prefix + body
88            };
89        }
90        if flex {
91            let known_pairs: Vec<(u32, usize)> = Vec::new();
92            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
93        }
94        n
95    }
96}
97impl<'de> DecodeBorrow<'de> for ShareGroupDescribeResponse<'de> {
98    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
99        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
100            return Err(ProtocolError::UnsupportedVersion {
101                api_key: API_KEY,
102                version,
103            });
104        }
105        let flex = is_flexible(version);
106        let mut out = Self::default();
107        if version >= 0 {
108            out.throttle_time_ms = get_i32(buf)?;
109        }
110        if version >= 0 {
111            out.groups = {
112                let n = crate::primitives::array::get_array_len(buf, flex)?;
113                let mut v = Vec::with_capacity(n);
114                for _ in 0..n {
115                    v.push(DescribedGroup::decode_borrow(buf, version)?);
116                }
117                v
118            };
119        }
120        if flex {
121            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
122        }
123        Ok(out)
124    }
125}
126#[cfg(test)]
127impl ShareGroupDescribeResponse<'_> {
128    #[must_use]
129    pub fn populated(version: i16) -> Self {
130        let mut m = Self::default();
131        if version >= 0 {
132            m.throttle_time_ms = 1i32;
133        }
134        if version >= 0 {
135            m.groups = vec![DescribedGroup::populated(version)];
136        }
137        m
138    }
139}
140#[derive(Debug, Clone, PartialEq, Eq)]
141pub struct DescribedGroup<'a> {
142    pub error_code: i16,
143    pub error_message: Option<&'a str>,
144    pub group_id: &'a str,
145    pub group_state: &'a str,
146    pub group_epoch: i32,
147    pub assignment_epoch: i32,
148    pub assignor_name: &'a str,
149    pub members: Vec<Member<'a>>,
150    pub authorized_operations: i32,
151    pub unknown_tagged_fields: UnknownTaggedFields,
152}
153impl Default for DescribedGroup<'_> {
154    fn default() -> Self {
155        Self {
156            error_code: 0i16,
157            error_message: None,
158            group_id: "",
159            group_state: "",
160            group_epoch: 0i32,
161            assignment_epoch: 0i32,
162            assignor_name: "",
163            members: Vec::new(),
164            authorized_operations: -2_147_483_648i32,
165            unknown_tagged_fields: UnknownTaggedFields::default(),
166        }
167    }
168}
169impl<'a> DescribedGroup<'a> {
170    /// # Panics
171    ///
172    /// Panics if a records field contains an invalid encoded record batch.
173    #[must_use]
174    pub fn to_owned(&self) -> crate::owned::share_group_describe_response::DescribedGroup {
175        crate::owned::share_group_describe_response::DescribedGroup {
176            error_code: (self.error_code),
177            error_message: (self.error_message).map(std::string::ToString::to_string),
178            group_id: (self.group_id).to_string(),
179            group_state: (self.group_state).to_string(),
180            group_epoch: (self.group_epoch),
181            assignment_epoch: (self.assignment_epoch),
182            assignor_name: (self.assignor_name).to_string(),
183            members: (self.members).iter().map(Member::to_owned).collect(),
184            authorized_operations: (self.authorized_operations),
185            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
186        }
187    }
188    fn encode_field_0<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
189        if version >= 0 {
190            put_i16(buf, self.error_code);
191        }
192    }
193    fn encode_field_1<B: BufMut>(&self, buf: &mut B, version: i16, flex: bool) {
194        if version >= 0 {
195            if flex {
196                let () = put_compact_nullable_string(buf, self.error_message);
197            } else {
198                let () = put_nullable_string(buf, self.error_message);
199            }
200        }
201    }
202    fn encode_field_2<B: BufMut>(&self, buf: &mut B, version: i16, flex: bool) {
203        if version >= 0 {
204            if flex {
205                let () = put_compact_string(buf, self.group_id);
206            } else {
207                let () = put_string(buf, self.group_id);
208            }
209        }
210    }
211    fn encode_field_3<B: BufMut>(&self, buf: &mut B, version: i16, flex: bool) {
212        if version >= 0 {
213            if flex {
214                let () = put_compact_string(buf, self.group_state);
215            } else {
216                let () = put_string(buf, self.group_state);
217            }
218        }
219    }
220    fn encode_field_4<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
221        if version >= 0 {
222            put_i32(buf, self.group_epoch);
223        }
224    }
225    fn encode_field_5<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
226        if version >= 0 {
227            put_i32(buf, self.assignment_epoch);
228        }
229    }
230    fn encode_field_6<B: BufMut>(&self, buf: &mut B, version: i16, flex: bool) {
231        if version >= 0 {
232            if flex {
233                let () = put_compact_string(buf, self.assignor_name);
234            } else {
235                let () = put_string(buf, self.assignor_name);
236            }
237        }
238    }
239    fn encode_field_7<B: BufMut>(
240        &self,
241        buf: &mut B,
242        version: i16,
243        flex: bool,
244    ) -> Result<(), ProtocolError> {
245        if version >= 0 {
246            {
247                crate::primitives::array::put_array_len(buf, (self.members).len(), flex);
248                for it in &self.members {
249                    it.encode(buf, version)?;
250                }
251            };
252        }
253        Ok(())
254    }
255    fn encode_field_8<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
256        if version >= 0 {
257            put_i32(buf, self.authorized_operations);
258        }
259    }
260    fn encode_tagged_fields<B: BufMut>(&self, buf: &mut B, _version: i16, flex: bool) {
261        if flex {
262            let tagged = WriteTaggedFields::new();
263            tagged.write(buf, &self.unknown_tagged_fields);
264        }
265    }
266    fn decode_field_0(
267        out: &mut Self,
268        buf: &mut &'a [u8],
269        version: i16,
270        _flex: bool,
271    ) -> Result<(), ProtocolError> {
272        if version >= 0 {
273            out.error_code = get_i16(buf)?;
274        }
275        Ok(())
276    }
277    fn decode_field_1(
278        out: &mut Self,
279        buf: &mut &'a [u8],
280        version: i16,
281        flex: bool,
282    ) -> Result<(), ProtocolError> {
283        if version >= 0 {
284            out.error_message = if flex {
285                get_compact_nullable_string_borrowed(buf)?
286            } else {
287                get_nullable_string_borrowed(buf)?
288            };
289        }
290        Ok(())
291    }
292    fn decode_field_2(
293        out: &mut Self,
294        buf: &mut &'a [u8],
295        version: i16,
296        flex: bool,
297    ) -> Result<(), ProtocolError> {
298        if version >= 0 {
299            out.group_id = if flex {
300                get_compact_string_borrowed(buf)?
301            } else {
302                get_string_borrowed(buf)?
303            };
304        }
305        Ok(())
306    }
307    fn decode_field_3(
308        out: &mut Self,
309        buf: &mut &'a [u8],
310        version: i16,
311        flex: bool,
312    ) -> Result<(), ProtocolError> {
313        if version >= 0 {
314            out.group_state = if flex {
315                get_compact_string_borrowed(buf)?
316            } else {
317                get_string_borrowed(buf)?
318            };
319        }
320        Ok(())
321    }
322    fn decode_field_4(
323        out: &mut Self,
324        buf: &mut &'a [u8],
325        version: i16,
326        _flex: bool,
327    ) -> Result<(), ProtocolError> {
328        if version >= 0 {
329            out.group_epoch = get_i32(buf)?;
330        }
331        Ok(())
332    }
333    fn decode_field_5(
334        out: &mut Self,
335        buf: &mut &'a [u8],
336        version: i16,
337        _flex: bool,
338    ) -> Result<(), ProtocolError> {
339        if version >= 0 {
340            out.assignment_epoch = get_i32(buf)?;
341        }
342        Ok(())
343    }
344    fn decode_field_6(
345        out: &mut Self,
346        buf: &mut &'a [u8],
347        version: i16,
348        flex: bool,
349    ) -> Result<(), ProtocolError> {
350        if version >= 0 {
351            out.assignor_name = if flex {
352                get_compact_string_borrowed(buf)?
353            } else {
354                get_string_borrowed(buf)?
355            };
356        }
357        Ok(())
358    }
359    fn decode_field_7(
360        out: &mut Self,
361        buf: &mut &'a [u8],
362        version: i16,
363        flex: bool,
364    ) -> Result<(), ProtocolError> {
365        if version >= 0 {
366            out.members = {
367                let n = crate::primitives::array::get_array_len(buf, flex)?;
368                let mut v = Vec::with_capacity(n);
369                for _ in 0..n {
370                    v.push(Member::decode_borrow(buf, version)?);
371                }
372                v
373            };
374        }
375        Ok(())
376    }
377    fn decode_field_8(
378        out: &mut Self,
379        buf: &mut &'a [u8],
380        version: i16,
381        _flex: bool,
382    ) -> Result<(), ProtocolError> {
383        if version >= 0 {
384            out.authorized_operations = get_i32(buf)?;
385        }
386        Ok(())
387    }
388    fn decode_tagged_fields(
389        out: &mut Self,
390        buf: &mut &'a [u8],
391        _version: i16,
392        flex: bool,
393    ) -> Result<(), ProtocolError> {
394        if flex {
395            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
396        }
397        Ok(())
398    }
399}
400impl Encode for DescribedGroup<'_> {
401    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
402        let flex = version >= 0;
403        self.encode_field_0(buf, version, flex);
404        self.encode_field_1(buf, version, flex);
405        self.encode_field_2(buf, version, flex);
406        self.encode_field_3(buf, version, flex);
407        self.encode_field_4(buf, version, flex);
408        self.encode_field_5(buf, version, flex);
409        self.encode_field_6(buf, version, flex);
410        self.encode_field_7(buf, version, flex)?;
411        self.encode_field_8(buf, version, flex);
412        self.encode_tagged_fields(buf, version, flex);
413        Ok(())
414    }
415    fn encoded_len(&self, version: i16) -> usize {
416        let flex = version >= 0;
417        let mut n: usize = 0;
418        if version >= 0 {
419            n += 2;
420        }
421        if version >= 0 {
422            n += if flex {
423                compact_nullable_string_len(self.error_message)
424            } else {
425                nullable_string_len(self.error_message)
426            };
427        }
428        if version >= 0 {
429            n += if flex {
430                compact_string_len(self.group_id)
431            } else {
432                string_len(self.group_id)
433            };
434        }
435        if version >= 0 {
436            n += if flex {
437                compact_string_len(self.group_state)
438            } else {
439                string_len(self.group_state)
440            };
441        }
442        if version >= 0 {
443            n += 4;
444        }
445        if version >= 0 {
446            n += 4;
447        }
448        if version >= 0 {
449            n += if flex {
450                compact_string_len(self.assignor_name)
451            } else {
452                string_len(self.assignor_name)
453            };
454        }
455        if version >= 0 {
456            n += {
457                let prefix =
458                    crate::primitives::array::array_len_prefix_len((self.members).len(), flex);
459                let body: usize = (self.members)
460                    .iter()
461                    .map(|it| it.encoded_len(version))
462                    .sum();
463                prefix + body
464            };
465        }
466        if version >= 0 {
467            n += 4;
468        }
469        if flex {
470            let known_pairs: Vec<(u32, usize)> = Vec::new();
471            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
472        }
473        n
474    }
475}
476impl<'de> DecodeBorrow<'de> for DescribedGroup<'de> {
477    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
478        let flex = version >= 0;
479        let mut out = Self::default();
480        Self::decode_field_0(&mut out, buf, version, flex)?;
481        Self::decode_field_1(&mut out, buf, version, flex)?;
482        Self::decode_field_2(&mut out, buf, version, flex)?;
483        Self::decode_field_3(&mut out, buf, version, flex)?;
484        Self::decode_field_4(&mut out, buf, version, flex)?;
485        Self::decode_field_5(&mut out, buf, version, flex)?;
486        Self::decode_field_6(&mut out, buf, version, flex)?;
487        Self::decode_field_7(&mut out, buf, version, flex)?;
488        Self::decode_field_8(&mut out, buf, version, flex)?;
489        Self::decode_tagged_fields(&mut out, buf, version, flex)?;
490        Ok(out)
491    }
492}
493#[cfg(test)]
494impl DescribedGroup<'_> {
495    #[must_use]
496    pub fn populated(version: i16) -> Self {
497        let mut m = Self::default();
498        if version >= 0 {
499            m.error_code = 1i16;
500        }
501        if version >= 0 {
502            m.error_message = Some("x");
503        }
504        if version >= 0 {
505            m.group_id = "x";
506        }
507        if version >= 0 {
508            m.group_state = "x";
509        }
510        if version >= 0 {
511            m.group_epoch = 1i32;
512        }
513        if version >= 0 {
514            m.assignment_epoch = 1i32;
515        }
516        if version >= 0 {
517            m.assignor_name = "x";
518        }
519        if version >= 0 {
520            m.members = vec![Member::populated(version)];
521        }
522        if version >= 0 {
523            m.authorized_operations = 1i32;
524        }
525        m
526    }
527}
528#[derive(Debug, Clone, PartialEq, Eq, Default)]
529pub struct Member<'a> {
530    pub member_id: &'a str,
531    pub rack_id: Option<&'a str>,
532    pub member_epoch: i32,
533    pub client_id: &'a str,
534    pub client_host: &'a str,
535    pub subscribed_topic_names: Vec<&'a str>,
536    pub assignment: super::common::share_group_describe_response::assignment::Assignment<'a>,
537    pub unknown_tagged_fields: UnknownTaggedFields,
538}
539impl Member<'_> {
540    /// # Panics
541    ///
542    /// Panics if a records field contains an invalid encoded record batch.
543    #[must_use]
544    pub fn to_owned(&self) -> crate::owned::share_group_describe_response::Member {
545        crate::owned::share_group_describe_response::Member {
546            member_id: (self.member_id).to_string(),
547            rack_id: (self.rack_id).map(std::string::ToString::to_string),
548            member_epoch: (self.member_epoch),
549            client_id: (self.client_id).to_string(),
550            client_host: (self.client_host).to_string(),
551            subscribed_topic_names: (self.subscribed_topic_names)
552                .iter()
553                .map(std::string::ToString::to_string)
554                .collect(),
555            assignment: (self.assignment).to_owned(),
556            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
557        }
558    }
559}
560impl Encode for Member<'_> {
561    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
562        let flex = version >= 0;
563        if version >= 0 {
564            if flex {
565                let () = put_compact_string(buf, self.member_id);
566            } else {
567                let () = put_string(buf, self.member_id);
568            }
569        }
570        if version >= 0 {
571            if flex {
572                let () = put_compact_nullable_string(buf, self.rack_id);
573            } else {
574                let () = put_nullable_string(buf, self.rack_id);
575            }
576        }
577        if version >= 0 {
578            put_i32(buf, self.member_epoch);
579        }
580        if version >= 0 {
581            if flex {
582                let () = put_compact_string(buf, self.client_id);
583            } else {
584                let () = put_string(buf, self.client_id);
585            }
586        }
587        if version >= 0 {
588            if flex {
589                let () = put_compact_string(buf, self.client_host);
590            } else {
591                let () = put_string(buf, self.client_host);
592            }
593        }
594        if version >= 0 {
595            {
596                crate::primitives::array::put_array_len(
597                    buf,
598                    (self.subscribed_topic_names).len(),
599                    flex,
600                );
601                for it in &self.subscribed_topic_names {
602                    if flex {
603                        let () = put_compact_string(buf, it);
604                    } else {
605                        let () = put_string(buf, it);
606                    }
607                }
608            };
609        }
610        if version >= 0 {
611            self.assignment.encode(buf, version)?;
612        }
613        if flex {
614            let tagged = WriteTaggedFields::new();
615            tagged.write(buf, &self.unknown_tagged_fields);
616        }
617        Ok(())
618    }
619    fn encoded_len(&self, version: i16) -> usize {
620        let flex = version >= 0;
621        let mut n: usize = 0;
622        if version >= 0 {
623            n += if flex {
624                compact_string_len(self.member_id)
625            } else {
626                string_len(self.member_id)
627            };
628        }
629        if version >= 0 {
630            n += if flex {
631                compact_nullable_string_len(self.rack_id)
632            } else {
633                nullable_string_len(self.rack_id)
634            };
635        }
636        if version >= 0 {
637            n += 4;
638        }
639        if version >= 0 {
640            n += if flex {
641                compact_string_len(self.client_id)
642            } else {
643                string_len(self.client_id)
644            };
645        }
646        if version >= 0 {
647            n += if flex {
648                compact_string_len(self.client_host)
649            } else {
650                string_len(self.client_host)
651            };
652        }
653        if version >= 0 {
654            n += {
655                let prefix = crate::primitives::array::array_len_prefix_len(
656                    (self.subscribed_topic_names).len(),
657                    flex,
658                );
659                let body: usize = (self.subscribed_topic_names)
660                    .iter()
661                    .map(|it| {
662                        if flex {
663                            compact_string_len(it)
664                        } else {
665                            string_len(it)
666                        }
667                    })
668                    .sum();
669                prefix + body
670            };
671        }
672        if version >= 0 {
673            n += self.assignment.encoded_len(version);
674        }
675        if flex {
676            let known_pairs: Vec<(u32, usize)> = Vec::new();
677            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
678        }
679        n
680    }
681}
682impl<'de> DecodeBorrow<'de> for Member<'de> {
683    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
684        let flex = version >= 0;
685        let mut out = Self::default();
686        if version >= 0 {
687            out.member_id = if flex {
688                get_compact_string_borrowed(buf)?
689            } else {
690                get_string_borrowed(buf)?
691            };
692        }
693        if version >= 0 {
694            out.rack_id = if flex {
695                get_compact_nullable_string_borrowed(buf)?
696            } else {
697                get_nullable_string_borrowed(buf)?
698            };
699        }
700        if version >= 0 {
701            out.member_epoch = get_i32(buf)?;
702        }
703        if version >= 0 {
704            out.client_id = if flex {
705                get_compact_string_borrowed(buf)?
706            } else {
707                get_string_borrowed(buf)?
708            };
709        }
710        if version >= 0 {
711            out.client_host = if flex {
712                get_compact_string_borrowed(buf)?
713            } else {
714                get_string_borrowed(buf)?
715            };
716        }
717        if version >= 0 {
718            out.subscribed_topic_names = {
719                let n = crate::primitives::array::get_array_len(buf, flex)?;
720                let mut v = Vec::with_capacity(n);
721                for _ in 0..n {
722                    v.push(if flex {
723                        get_compact_string_borrowed(buf)?
724                    } else {
725                        get_string_borrowed(buf)?
726                    });
727                }
728                v
729            };
730        }
731        if version >= 0 {
732            out.assignment = super::common::share_group_describe_response::assignment::Assignment::decode_borrow(buf, version)?;
733        }
734        if flex {
735            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
736        }
737        Ok(out)
738    }
739}
740#[cfg(test)]
741impl Member<'_> {
742    #[must_use]
743    pub fn populated(version: i16) -> Self {
744        let mut m = Self::default();
745        if version >= 0 {
746            m.member_id = "x";
747        }
748        if version >= 0 {
749            m.rack_id = Some("x");
750        }
751        if version >= 0 {
752            m.member_epoch = 1i32;
753        }
754        if version >= 0 {
755            m.client_id = "x";
756        }
757        if version >= 0 {
758            m.client_host = "x";
759        }
760        if version >= 0 {
761            m.subscribed_topic_names = vec!["x"];
762        }
763        if version >= 0 {
764            m.assignment =
765                super::common::share_group_describe_response::assignment::Assignment::populated(
766                    version,
767                );
768        }
769        m
770    }
771}
krabka_protocol/opt/rustwide/workdir/generated/ShareGroupDescribeResponse.borrowed.rs

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