krabka_protocol/opt/rustwide/workdir/generated/
ConsumerGroupDescribeResponse.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::consumer_group_describe_response,
7    primitives::{
8        array::{array_len_prefix_len, get_array_len, put_array_len},
9        fixed::{get_i8, get_i16, get_i32, put_i8, put_i16, put_i32},
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    },
20    tagged_fields::{WriteTaggedFields, read_tagged_fields, tagged_fields_len},
21};
22pub const API_KEY: i16 = 69;
23pub const MIN_VERSION: i16 = 0;
24pub const MAX_VERSION: i16 = 1;
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, Default)]
32pub struct ConsumerGroupDescribeResponse<'a> {
33    pub throttle_time_ms: i32,
34    pub groups: Vec<DescribedGroup<'a>>,
35    pub unknown_tagged_fields: UnknownTaggedFields,
36}
37impl ConsumerGroupDescribeResponse<'_> {
38    #[must_use]
39    pub fn to_owned(&self) -> consumer_group_describe_response::ConsumerGroupDescribeResponse {
40        consumer_group_describe_response::ConsumerGroupDescribeResponse {
41            throttle_time_ms: (self.throttle_time_ms),
42            groups: (self.groups).iter().map(DescribedGroup::to_owned).collect(),
43            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
44        }
45    }
46}
47impl Encode for ConsumerGroupDescribeResponse<'_> {
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            put_i32(buf, self.throttle_time_ms);
58        }
59        if version >= 0 {
60            {
61                put_array_len(buf, (self.groups).len(), flex)?;
62                for it in &self.groups {
63                    it.encode(buf, version)?;
64                }
65            }
66        }
67        if flex {
68            let tagged = WriteTaggedFields::new();
69            tagged.write(buf, &self.unknown_tagged_fields)?;
70        }
71        Ok(())
72    }
73    fn encoded_len(&self, version: i16) -> usize {
74        let flex = is_flexible(version);
75        let mut n: usize = 0;
76        if version >= 0 {
77            n += 4;
78        }
79        if version >= 0 {
80            n += {
81                let prefix = array_len_prefix_len((self.groups).len(), flex);
82                let body: usize = (self.groups).iter().map(|it| it.encoded_len(version)).sum();
83                prefix + body
84            };
85        }
86        if flex {
87            let known_pairs: Vec<(u32, usize)> = Vec::new();
88            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
89        }
90        n
91    }
92}
93impl<'de> DecodeBorrow<'de> for ConsumerGroupDescribeResponse<'de> {
94    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
95        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
96            return Err(ProtocolError::UnsupportedVersion {
97                api_key: API_KEY,
98                version,
99            });
100        }
101        let flex = is_flexible(version);
102        let mut out = Self::default();
103        if version >= 0 {
104            out.throttle_time_ms = get_i32(buf)?;
105        }
106        if version >= 0 {
107            out.groups = {
108                let n = get_array_len(buf, flex)?;
109                let mut v = Vec::with_capacity(n);
110                for _ in 0..n {
111                    v.push(DescribedGroup::decode_borrow(buf, version)?);
112                }
113                v
114            };
115        }
116        if flex {
117            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
118        }
119        Ok(out)
120    }
121}
122#[cfg(test)]
123impl ConsumerGroupDescribeResponse<'_> {
124    #[must_use]
125    pub fn populated(version: i16) -> Self {
126        let mut m = Self::default();
127        if version >= 0 {
128            m.throttle_time_ms = 1i32;
129        }
130        if version >= 0 {
131            m.groups = vec![DescribedGroup::populated(version)];
132        }
133        m
134    }
135}
136#[derive(Debug, Clone, PartialEq, Eq)]
137pub struct DescribedGroup<'a> {
138    pub error_code: i16,
139    pub error_message: Option<&'a str>,
140    pub group_id: &'a str,
141    pub group_state: &'a str,
142    pub group_epoch: i32,
143    pub assignment_epoch: i32,
144    pub assignor_name: &'a str,
145    pub members: Vec<Member<'a>>,
146    pub authorized_operations: i32,
147    pub unknown_tagged_fields: UnknownTaggedFields,
148}
149impl Default for DescribedGroup<'_> {
150    fn default() -> Self {
151        Self {
152            error_code: 0i16,
153            error_message: None,
154            group_id: "",
155            group_state: "",
156            group_epoch: 0i32,
157            assignment_epoch: 0i32,
158            assignor_name: "",
159            members: Vec::new(),
160            authorized_operations: -2_147_483_648i32,
161            unknown_tagged_fields: UnknownTaggedFields::default(),
162        }
163    }
164}
165impl<'a> DescribedGroup<'a> {
166    #[must_use]
167    pub fn to_owned(&self) -> consumer_group_describe_response::DescribedGroup {
168        consumer_group_describe_response::DescribedGroup {
169            error_code: (self.error_code),
170            error_message: (self.error_message).map(str::to_owned),
171            group_id: (self.group_id).to_owned(),
172            group_state: (self.group_state).to_owned(),
173            group_epoch: (self.group_epoch),
174            assignment_epoch: (self.assignment_epoch),
175            assignor_name: (self.assignor_name).to_owned(),
176            members: (self.members).iter().map(Member::to_owned).collect(),
177            authorized_operations: (self.authorized_operations),
178            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
179        }
180    }
181    fn encode_field_0<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
182        if version >= 0 {
183            put_i16(buf, self.error_code);
184        }
185    }
186    fn encode_field_1<B: BufMut>(
187        &self,
188        buf: &mut B,
189        version: i16,
190        flex: bool,
191    ) -> Result<(), ProtocolError> {
192        if version >= 0 {
193            if flex {
194                put_compact_nullable_string(buf, self.error_message)?;
195            } else {
196                put_nullable_string(buf, self.error_message)?;
197            }
198        }
199        Ok(())
200    }
201    fn encode_field_2<B: BufMut>(
202        &self,
203        buf: &mut B,
204        version: i16,
205        flex: bool,
206    ) -> Result<(), ProtocolError> {
207        if version >= 0 {
208            if flex {
209                put_compact_string(buf, self.group_id)?;
210            } else {
211                put_string(buf, self.group_id)?;
212            }
213        }
214        Ok(())
215    }
216    fn encode_field_3<B: BufMut>(
217        &self,
218        buf: &mut B,
219        version: i16,
220        flex: bool,
221    ) -> Result<(), ProtocolError> {
222        if version >= 0 {
223            if flex {
224                put_compact_string(buf, self.group_state)?;
225            } else {
226                put_string(buf, self.group_state)?;
227            }
228        }
229        Ok(())
230    }
231    fn encode_field_4<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
232        if version >= 0 {
233            put_i32(buf, self.group_epoch);
234        }
235    }
236    fn encode_field_5<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
237        if version >= 0 {
238            put_i32(buf, self.assignment_epoch);
239        }
240    }
241    fn encode_field_6<B: BufMut>(
242        &self,
243        buf: &mut B,
244        version: i16,
245        flex: bool,
246    ) -> Result<(), ProtocolError> {
247        if version >= 0 {
248            if flex {
249                put_compact_string(buf, self.assignor_name)?;
250            } else {
251                put_string(buf, self.assignor_name)?;
252            }
253        }
254        Ok(())
255    }
256    fn encode_field_7<B: BufMut>(
257        &self,
258        buf: &mut B,
259        version: i16,
260        flex: bool,
261    ) -> Result<(), ProtocolError> {
262        if version >= 0 {
263            {
264                put_array_len(buf, (self.members).len(), flex)?;
265                for it in &self.members {
266                    it.encode(buf, version)?;
267                }
268            }
269        }
270        Ok(())
271    }
272    fn encode_field_8<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
273        if version >= 0 {
274            put_i32(buf, self.authorized_operations);
275        }
276    }
277    fn encode_tagged_fields<B: BufMut>(
278        &self,
279        buf: &mut B,
280        _version: i16,
281        flex: bool,
282    ) -> Result<(), ProtocolError> {
283        if flex {
284            let tagged = WriteTaggedFields::new();
285            tagged.write(buf, &self.unknown_tagged_fields)?;
286        }
287        Ok(())
288    }
289    fn decode_field_0(
290        out: &mut Self,
291        buf: &mut &'a [u8],
292        version: i16,
293        _flex: bool,
294    ) -> Result<(), ProtocolError> {
295        if version >= 0 {
296            out.error_code = get_i16(buf)?;
297        }
298        Ok(())
299    }
300    fn decode_field_1(
301        out: &mut Self,
302        buf: &mut &'a [u8],
303        version: i16,
304        flex: bool,
305    ) -> Result<(), ProtocolError> {
306        if version >= 0 {
307            out.error_message = if flex {
308                get_compact_nullable_string_borrowed(buf)?
309            } else {
310                get_nullable_string_borrowed(buf)?
311            };
312        }
313        Ok(())
314    }
315    fn decode_field_2(
316        out: &mut Self,
317        buf: &mut &'a [u8],
318        version: i16,
319        flex: bool,
320    ) -> Result<(), ProtocolError> {
321        if version >= 0 {
322            out.group_id = if flex {
323                get_compact_string_borrowed(buf)?
324            } else {
325                get_string_borrowed(buf)?
326            };
327        }
328        Ok(())
329    }
330    fn decode_field_3(
331        out: &mut Self,
332        buf: &mut &'a [u8],
333        version: i16,
334        flex: bool,
335    ) -> Result<(), ProtocolError> {
336        if version >= 0 {
337            out.group_state = if flex {
338                get_compact_string_borrowed(buf)?
339            } else {
340                get_string_borrowed(buf)?
341            };
342        }
343        Ok(())
344    }
345    fn decode_field_4(
346        out: &mut Self,
347        buf: &mut &'a [u8],
348        version: i16,
349        _flex: bool,
350    ) -> Result<(), ProtocolError> {
351        if version >= 0 {
352            out.group_epoch = get_i32(buf)?;
353        }
354        Ok(())
355    }
356    fn decode_field_5(
357        out: &mut Self,
358        buf: &mut &'a [u8],
359        version: i16,
360        _flex: bool,
361    ) -> Result<(), ProtocolError> {
362        if version >= 0 {
363            out.assignment_epoch = get_i32(buf)?;
364        }
365        Ok(())
366    }
367    fn decode_field_6(
368        out: &mut Self,
369        buf: &mut &'a [u8],
370        version: i16,
371        flex: bool,
372    ) -> Result<(), ProtocolError> {
373        if version >= 0 {
374            out.assignor_name = if flex {
375                get_compact_string_borrowed(buf)?
376            } else {
377                get_string_borrowed(buf)?
378            };
379        }
380        Ok(())
381    }
382    fn decode_field_7(
383        out: &mut Self,
384        buf: &mut &'a [u8],
385        version: i16,
386        flex: bool,
387    ) -> Result<(), ProtocolError> {
388        if version >= 0 {
389            out.members = {
390                let n = get_array_len(buf, flex)?;
391                let mut v = Vec::with_capacity(n);
392                for _ in 0..n {
393                    v.push(Member::decode_borrow(buf, version)?);
394                }
395                v
396            };
397        }
398        Ok(())
399    }
400    fn decode_field_8(
401        out: &mut Self,
402        buf: &mut &'a [u8],
403        version: i16,
404        _flex: bool,
405    ) -> Result<(), ProtocolError> {
406        if version >= 0 {
407            out.authorized_operations = get_i32(buf)?;
408        }
409        Ok(())
410    }
411    fn decode_tagged_fields(
412        out: &mut Self,
413        buf: &mut &'a [u8],
414        _version: i16,
415        flex: bool,
416    ) -> Result<(), ProtocolError> {
417        if flex {
418            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
419        }
420        Ok(())
421    }
422}
423impl Encode for DescribedGroup<'_> {
424    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
425        let flex = version >= 0;
426        self.encode_field_0(buf, version, flex);
427        self.encode_field_1(buf, version, flex)?;
428        self.encode_field_2(buf, version, flex)?;
429        self.encode_field_3(buf, version, flex)?;
430        self.encode_field_4(buf, version, flex);
431        self.encode_field_5(buf, version, flex);
432        self.encode_field_6(buf, version, flex)?;
433        self.encode_field_7(buf, version, flex)?;
434        self.encode_field_8(buf, version, flex);
435        self.encode_tagged_fields(buf, version, flex)?;
436        Ok(())
437    }
438    fn encoded_len(&self, version: i16) -> usize {
439        let flex = version >= 0;
440        let mut n: usize = 0;
441        if version >= 0 {
442            n += 2;
443        }
444        if version >= 0 {
445            n += if flex {
446                compact_nullable_string_len(self.error_message)
447            } else {
448                nullable_string_len(self.error_message)
449            };
450        }
451        if version >= 0 {
452            n += if flex {
453                compact_string_len(self.group_id)
454            } else {
455                string_len(self.group_id)
456            };
457        }
458        if version >= 0 {
459            n += if flex {
460                compact_string_len(self.group_state)
461            } else {
462                string_len(self.group_state)
463            };
464        }
465        if version >= 0 {
466            n += 4;
467        }
468        if version >= 0 {
469            n += 4;
470        }
471        if version >= 0 {
472            n += if flex {
473                compact_string_len(self.assignor_name)
474            } else {
475                string_len(self.assignor_name)
476            };
477        }
478        if version >= 0 {
479            n += {
480                let prefix = array_len_prefix_len((self.members).len(), flex);
481                let body: usize = (self.members)
482                    .iter()
483                    .map(|it| it.encoded_len(version))
484                    .sum();
485                prefix + body
486            };
487        }
488        if version >= 0 {
489            n += 4;
490        }
491        if flex {
492            let known_pairs: Vec<(u32, usize)> = Vec::new();
493            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
494        }
495        n
496    }
497}
498impl<'de> DecodeBorrow<'de> for DescribedGroup<'de> {
499    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
500        let flex = version >= 0;
501        let mut out = Self::default();
502        Self::decode_field_0(&mut out, buf, version, flex)?;
503        Self::decode_field_1(&mut out, buf, version, flex)?;
504        Self::decode_field_2(&mut out, buf, version, flex)?;
505        Self::decode_field_3(&mut out, buf, version, flex)?;
506        Self::decode_field_4(&mut out, buf, version, flex)?;
507        Self::decode_field_5(&mut out, buf, version, flex)?;
508        Self::decode_field_6(&mut out, buf, version, flex)?;
509        Self::decode_field_7(&mut out, buf, version, flex)?;
510        Self::decode_field_8(&mut out, buf, version, flex)?;
511        Self::decode_tagged_fields(&mut out, buf, version, flex)?;
512        Ok(out)
513    }
514}
515#[cfg(test)]
516impl DescribedGroup<'_> {
517    #[must_use]
518    pub fn populated(version: i16) -> Self {
519        let mut m = Self::default();
520        if version >= 0 {
521            m.error_code = 1i16;
522        }
523        if version >= 0 {
524            m.error_message = Some("x");
525        }
526        if version >= 0 {
527            m.group_id = "x";
528        }
529        if version >= 0 {
530            m.group_state = "x";
531        }
532        if version >= 0 {
533            m.group_epoch = 1i32;
534        }
535        if version >= 0 {
536            m.assignment_epoch = 1i32;
537        }
538        if version >= 0 {
539            m.assignor_name = "x";
540        }
541        if version >= 0 {
542            m.members = vec![Member::populated(version)];
543        }
544        if version >= 0 {
545            m.authorized_operations = 1i32;
546        }
547        m
548    }
549}
550#[derive(Debug, Clone, PartialEq, Eq)]
551pub struct Member<'a> {
552    pub member_id: &'a str,
553    pub instance_id: Option<&'a str>,
554    pub rack_id: Option<&'a str>,
555    pub member_epoch: i32,
556    pub client_id: &'a str,
557    pub client_host: &'a str,
558    pub subscribed_topic_names: Vec<&'a str>,
559    pub subscribed_topic_regex: Option<&'a str>,
560    pub assignment: super::common::consumer_group_describe_response::assignment::Assignment<'a>,
561    pub target_assignment:
562        super::common::consumer_group_describe_response::assignment::Assignment<'a>,
563    pub member_type: i8,
564    pub unknown_tagged_fields: UnknownTaggedFields,
565}
566impl<'a> Default for Member<'a> {
567    fn default() -> Self {
568        Self {
569            member_id: "",
570            instance_id: None,
571            rack_id: None,
572            member_epoch: 0i32,
573            client_id: "",
574            client_host: "",
575            subscribed_topic_names: Vec::new(),
576            subscribed_topic_regex: None,
577            assignment: <super::common::consumer_group_describe_response::assignment::Assignment<'a>>::default(),
578            target_assignment: <super::common::consumer_group_describe_response::assignment::Assignment<'a>>::default(),
579            member_type: -1i8,
580            unknown_tagged_fields: UnknownTaggedFields::default(),
581        }
582    }
583}
584impl<'a> Member<'a> {
585    #[must_use]
586    pub fn to_owned(&self) -> consumer_group_describe_response::Member {
587        consumer_group_describe_response::Member {
588            member_id: (self.member_id).to_owned(),
589            instance_id: (self.instance_id).map(str::to_owned),
590            rack_id: (self.rack_id).map(str::to_owned),
591            member_epoch: (self.member_epoch),
592            client_id: (self.client_id).to_owned(),
593            client_host: (self.client_host).to_owned(),
594            subscribed_topic_names: (self.subscribed_topic_names)
595                .iter()
596                .map(|&s| s.to_owned())
597                .collect(),
598            subscribed_topic_regex: (self.subscribed_topic_regex).map(str::to_owned),
599            assignment: (self.assignment).to_owned(),
600            target_assignment: (self.target_assignment).to_owned(),
601            member_type: (self.member_type),
602            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
603        }
604    }
605    fn encode_field_0<B: BufMut>(
606        &self,
607        buf: &mut B,
608        version: i16,
609        flex: bool,
610    ) -> Result<(), ProtocolError> {
611        if version >= 0 {
612            if flex {
613                put_compact_string(buf, self.member_id)?;
614            } else {
615                put_string(buf, self.member_id)?;
616            }
617        }
618        Ok(())
619    }
620    fn encode_field_1<B: BufMut>(
621        &self,
622        buf: &mut B,
623        version: i16,
624        flex: bool,
625    ) -> Result<(), ProtocolError> {
626        if version >= 0 {
627            if flex {
628                put_compact_nullable_string(buf, self.instance_id)?;
629            } else {
630                put_nullable_string(buf, self.instance_id)?;
631            }
632        }
633        Ok(())
634    }
635    fn encode_field_2<B: BufMut>(
636        &self,
637        buf: &mut B,
638        version: i16,
639        flex: bool,
640    ) -> Result<(), ProtocolError> {
641        if version >= 0 {
642            if flex {
643                put_compact_nullable_string(buf, self.rack_id)?;
644            } else {
645                put_nullable_string(buf, self.rack_id)?;
646            }
647        }
648        Ok(())
649    }
650    fn encode_field_3<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
651        if version >= 0 {
652            put_i32(buf, self.member_epoch);
653        }
654    }
655    fn encode_field_4<B: BufMut>(
656        &self,
657        buf: &mut B,
658        version: i16,
659        flex: bool,
660    ) -> Result<(), ProtocolError> {
661        if version >= 0 {
662            if flex {
663                put_compact_string(buf, self.client_id)?;
664            } else {
665                put_string(buf, self.client_id)?;
666            }
667        }
668        Ok(())
669    }
670    fn encode_field_5<B: BufMut>(
671        &self,
672        buf: &mut B,
673        version: i16,
674        flex: bool,
675    ) -> Result<(), ProtocolError> {
676        if version >= 0 {
677            if flex {
678                put_compact_string(buf, self.client_host)?;
679            } else {
680                put_string(buf, self.client_host)?;
681            }
682        }
683        Ok(())
684    }
685    fn encode_field_6<B: BufMut>(
686        &self,
687        buf: &mut B,
688        version: i16,
689        flex: bool,
690    ) -> Result<(), ProtocolError> {
691        if version >= 0 {
692            {
693                put_array_len(buf, (self.subscribed_topic_names).len(), flex)?;
694                for it in &self.subscribed_topic_names {
695                    if flex {
696                        put_compact_string(buf, it)?;
697                    } else {
698                        put_string(buf, it)?;
699                    }
700                }
701            }
702        }
703        Ok(())
704    }
705    fn encode_field_7<B: BufMut>(
706        &self,
707        buf: &mut B,
708        version: i16,
709        flex: bool,
710    ) -> Result<(), ProtocolError> {
711        if version >= 0 {
712            if flex {
713                put_compact_nullable_string(buf, self.subscribed_topic_regex)?;
714            } else {
715                put_nullable_string(buf, self.subscribed_topic_regex)?;
716            }
717        }
718        Ok(())
719    }
720    fn encode_field_8<B: BufMut>(
721        &self,
722        buf: &mut B,
723        version: i16,
724        _flex: bool,
725    ) -> Result<(), ProtocolError> {
726        if version >= 0 {
727            self.assignment.encode(buf, version)?;
728        }
729        Ok(())
730    }
731    fn encode_field_9<B: BufMut>(
732        &self,
733        buf: &mut B,
734        version: i16,
735        _flex: bool,
736    ) -> Result<(), ProtocolError> {
737        if version >= 0 {
738            self.target_assignment.encode(buf, version)?;
739        }
740        Ok(())
741    }
742    fn encode_field_10<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
743        if version >= 1 {
744            put_i8(buf, self.member_type);
745        }
746    }
747    fn encode_tagged_fields<B: BufMut>(
748        &self,
749        buf: &mut B,
750        _version: i16,
751        flex: bool,
752    ) -> Result<(), ProtocolError> {
753        if flex {
754            let tagged = WriteTaggedFields::new();
755            tagged.write(buf, &self.unknown_tagged_fields)?;
756        }
757        Ok(())
758    }
759    fn decode_field_0(
760        out: &mut Self,
761        buf: &mut &'a [u8],
762        version: i16,
763        flex: bool,
764    ) -> Result<(), ProtocolError> {
765        if version >= 0 {
766            out.member_id = if flex {
767                get_compact_string_borrowed(buf)?
768            } else {
769                get_string_borrowed(buf)?
770            };
771        }
772        Ok(())
773    }
774    fn decode_field_1(
775        out: &mut Self,
776        buf: &mut &'a [u8],
777        version: i16,
778        flex: bool,
779    ) -> Result<(), ProtocolError> {
780        if version >= 0 {
781            out.instance_id = if flex {
782                get_compact_nullable_string_borrowed(buf)?
783            } else {
784                get_nullable_string_borrowed(buf)?
785            };
786        }
787        Ok(())
788    }
789    fn decode_field_2(
790        out: &mut Self,
791        buf: &mut &'a [u8],
792        version: i16,
793        flex: bool,
794    ) -> Result<(), ProtocolError> {
795        if version >= 0 {
796            out.rack_id = if flex {
797                get_compact_nullable_string_borrowed(buf)?
798            } else {
799                get_nullable_string_borrowed(buf)?
800            };
801        }
802        Ok(())
803    }
804    fn decode_field_3(
805        out: &mut Self,
806        buf: &mut &'a [u8],
807        version: i16,
808        _flex: bool,
809    ) -> Result<(), ProtocolError> {
810        if version >= 0 {
811            out.member_epoch = get_i32(buf)?;
812        }
813        Ok(())
814    }
815    fn decode_field_4(
816        out: &mut Self,
817        buf: &mut &'a [u8],
818        version: i16,
819        flex: bool,
820    ) -> Result<(), ProtocolError> {
821        if version >= 0 {
822            out.client_id = if flex {
823                get_compact_string_borrowed(buf)?
824            } else {
825                get_string_borrowed(buf)?
826            };
827        }
828        Ok(())
829    }
830    fn decode_field_5(
831        out: &mut Self,
832        buf: &mut &'a [u8],
833        version: i16,
834        flex: bool,
835    ) -> Result<(), ProtocolError> {
836        if version >= 0 {
837            out.client_host = if flex {
838                get_compact_string_borrowed(buf)?
839            } else {
840                get_string_borrowed(buf)?
841            };
842        }
843        Ok(())
844    }
845    fn decode_field_6(
846        out: &mut Self,
847        buf: &mut &'a [u8],
848        version: i16,
849        flex: bool,
850    ) -> Result<(), ProtocolError> {
851        if version >= 0 {
852            out.subscribed_topic_names = {
853                let n = get_array_len(buf, flex)?;
854                let mut v = Vec::with_capacity(n);
855                for _ in 0..n {
856                    v.push(if flex {
857                        get_compact_string_borrowed(buf)?
858                    } else {
859                        get_string_borrowed(buf)?
860                    });
861                }
862                v
863            };
864        }
865        Ok(())
866    }
867    fn decode_field_7(
868        out: &mut Self,
869        buf: &mut &'a [u8],
870        version: i16,
871        flex: bool,
872    ) -> Result<(), ProtocolError> {
873        if version >= 0 {
874            out.subscribed_topic_regex = if flex {
875                get_compact_nullable_string_borrowed(buf)?
876            } else {
877                get_nullable_string_borrowed(buf)?
878            };
879        }
880        Ok(())
881    }
882    fn decode_field_8(
883        out: &mut Self,
884        buf: &mut &'a [u8],
885        version: i16,
886        _flex: bool,
887    ) -> Result<(), ProtocolError> {
888        if version >= 0 {
889            out.assignment = super::common::consumer_group_describe_response::assignment::Assignment::decode_borrow(buf, version)?;
890        }
891        Ok(())
892    }
893    fn decode_field_9(
894        out: &mut Self,
895        buf: &mut &'a [u8],
896        version: i16,
897        _flex: bool,
898    ) -> Result<(), ProtocolError> {
899        if version >= 0 {
900            out.target_assignment = super::common::consumer_group_describe_response::assignment::Assignment::decode_borrow(buf, version)?;
901        }
902        Ok(())
903    }
904    fn decode_field_10(
905        out: &mut Self,
906        buf: &mut &'a [u8],
907        version: i16,
908        _flex: bool,
909    ) -> Result<(), ProtocolError> {
910        if version >= 1 {
911            out.member_type = get_i8(buf)?;
912        }
913        Ok(())
914    }
915    fn decode_tagged_fields(
916        out: &mut Self,
917        buf: &mut &'a [u8],
918        _version: i16,
919        flex: bool,
920    ) -> Result<(), ProtocolError> {
921        if flex {
922            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
923        }
924        Ok(())
925    }
926}
927impl Encode for Member<'_> {
928    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
929        let flex = version >= 0;
930        self.encode_field_0(buf, version, flex)?;
931        self.encode_field_1(buf, version, flex)?;
932        self.encode_field_2(buf, version, flex)?;
933        self.encode_field_3(buf, version, flex);
934        self.encode_field_4(buf, version, flex)?;
935        self.encode_field_5(buf, version, flex)?;
936        self.encode_field_6(buf, version, flex)?;
937        self.encode_field_7(buf, version, flex)?;
938        self.encode_field_8(buf, version, flex)?;
939        self.encode_field_9(buf, version, flex)?;
940        self.encode_field_10(buf, version, flex);
941        self.encode_tagged_fields(buf, version, flex)?;
942        Ok(())
943    }
944    fn encoded_len(&self, version: i16) -> usize {
945        let flex = version >= 0;
946        let mut n: usize = 0;
947        if version >= 0 {
948            n += if flex {
949                compact_string_len(self.member_id)
950            } else {
951                string_len(self.member_id)
952            };
953        }
954        if version >= 0 {
955            n += if flex {
956                compact_nullable_string_len(self.instance_id)
957            } else {
958                nullable_string_len(self.instance_id)
959            };
960        }
961        if version >= 0 {
962            n += if flex {
963                compact_nullable_string_len(self.rack_id)
964            } else {
965                nullable_string_len(self.rack_id)
966            };
967        }
968        if version >= 0 {
969            n += 4;
970        }
971        if version >= 0 {
972            n += if flex {
973                compact_string_len(self.client_id)
974            } else {
975                string_len(self.client_id)
976            };
977        }
978        if version >= 0 {
979            n += if flex {
980                compact_string_len(self.client_host)
981            } else {
982                string_len(self.client_host)
983            };
984        }
985        if version >= 0 {
986            n += {
987                let prefix = array_len_prefix_len((self.subscribed_topic_names).len(), flex);
988                let body: usize = (self.subscribed_topic_names)
989                    .iter()
990                    .map(|it| {
991                        if flex {
992                            compact_string_len(it)
993                        } else {
994                            string_len(it)
995                        }
996                    })
997                    .sum();
998                prefix + body
999            };
1000        }
1001        if version >= 0 {
1002            n += if flex {
1003                compact_nullable_string_len(self.subscribed_topic_regex)
1004            } else {
1005                nullable_string_len(self.subscribed_topic_regex)
1006            };
1007        }
1008        if version >= 0 {
1009            n += self.assignment.encoded_len(version);
1010        }
1011        if version >= 0 {
1012            n += self.target_assignment.encoded_len(version);
1013        }
1014        if version >= 1 {
1015            n += 1;
1016        }
1017        if flex {
1018            let known_pairs: Vec<(u32, usize)> = Vec::new();
1019            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
1020        }
1021        n
1022    }
1023}
1024impl<'de> DecodeBorrow<'de> for Member<'de> {
1025    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
1026        let flex = version >= 0;
1027        let mut out = Self::default();
1028        Self::decode_field_0(&mut out, buf, version, flex)?;
1029        Self::decode_field_1(&mut out, buf, version, flex)?;
1030        Self::decode_field_2(&mut out, buf, version, flex)?;
1031        Self::decode_field_3(&mut out, buf, version, flex)?;
1032        Self::decode_field_4(&mut out, buf, version, flex)?;
1033        Self::decode_field_5(&mut out, buf, version, flex)?;
1034        Self::decode_field_6(&mut out, buf, version, flex)?;
1035        Self::decode_field_7(&mut out, buf, version, flex)?;
1036        Self::decode_field_8(&mut out, buf, version, flex)?;
1037        Self::decode_field_9(&mut out, buf, version, flex)?;
1038        Self::decode_field_10(&mut out, buf, version, flex)?;
1039        Self::decode_tagged_fields(&mut out, buf, version, flex)?;
1040        Ok(out)
1041    }
1042}
1043#[cfg(test)]
1044impl Member<'_> {
1045    #[must_use]
1046    pub fn populated(version: i16) -> Self {
1047        let mut m = Self::default();
1048        if version >= 0 {
1049            m.member_id = "x";
1050        }
1051        if version >= 0 {
1052            m.instance_id = Some("x");
1053        }
1054        if version >= 0 {
1055            m.rack_id = Some("x");
1056        }
1057        if version >= 0 {
1058            m.member_epoch = 1i32;
1059        }
1060        if version >= 0 {
1061            m.client_id = "x";
1062        }
1063        if version >= 0 {
1064            m.client_host = "x";
1065        }
1066        if version >= 0 {
1067            m.subscribed_topic_names = vec!["x"];
1068        }
1069        if version >= 0 {
1070            m.subscribed_topic_regex = Some("x");
1071        }
1072        if version >= 0 {
1073            m.assignment =
1074                super::common::consumer_group_describe_response::assignment::Assignment::populated(
1075                    version,
1076                );
1077        }
1078        if version >= 0 {
1079            m.target_assignment =
1080                super::common::consumer_group_describe_response::assignment::Assignment::populated(
1081                    version,
1082                );
1083        }
1084        if version >= 1 {
1085            m.member_type = 1i8;
1086        }
1087        m
1088    }
1089}
krabka_protocol/opt/rustwide/workdir/generated/ConsumerGroupDescribeResponse.borrowed.rs

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