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    owned::share_group_describe_response,
7    primitives::{
8        array::{array_len_prefix_len, get_array_len, put_array_len},
9        fixed::{get_i16, get_i32, 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 = 77;
23pub const MIN_VERSION: i16 = 1;
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 ShareGroupDescribeResponse<'a> {
33    pub throttle_time_ms: i32,
34    pub groups: Vec<DescribedGroup<'a>>,
35    pub unknown_tagged_fields: UnknownTaggedFields,
36}
37impl ShareGroupDescribeResponse<'_> {
38    #[must_use]
39    pub fn to_owned(&self) -> share_group_describe_response::ShareGroupDescribeResponse {
40        share_group_describe_response::ShareGroupDescribeResponse {
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 ShareGroupDescribeResponse<'_> {
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 ShareGroupDescribeResponse<'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 ShareGroupDescribeResponse<'_> {
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) -> share_group_describe_response::DescribedGroup {
168        share_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, Default)]
551pub struct Member<'a> {
552    pub member_id: &'a str,
553    pub rack_id: Option<&'a str>,
554    pub member_epoch: i32,
555    pub client_id: &'a str,
556    pub client_host: &'a str,
557    pub subscribed_topic_names: Vec<&'a str>,
558    pub assignment: super::common::share_group_describe_response::assignment::Assignment<'a>,
559    pub unknown_tagged_fields: UnknownTaggedFields,
560}
561impl Member<'_> {
562    #[must_use]
563    pub fn to_owned(&self) -> share_group_describe_response::Member {
564        share_group_describe_response::Member {
565            member_id: (self.member_id).to_owned(),
566            rack_id: (self.rack_id).map(str::to_owned),
567            member_epoch: (self.member_epoch),
568            client_id: (self.client_id).to_owned(),
569            client_host: (self.client_host).to_owned(),
570            subscribed_topic_names: (self.subscribed_topic_names)
571                .iter()
572                .map(|&s| s.to_owned())
573                .collect(),
574            assignment: (self.assignment).to_owned(),
575            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
576        }
577    }
578}
579impl Encode for Member<'_> {
580    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
581        let flex = version >= 0;
582        if version >= 0 {
583            if flex {
584                put_compact_string(buf, self.member_id)?;
585            } else {
586                put_string(buf, self.member_id)?;
587            }
588        }
589        if version >= 0 {
590            if flex {
591                put_compact_nullable_string(buf, self.rack_id)?;
592            } else {
593                put_nullable_string(buf, self.rack_id)?;
594            }
595        }
596        if version >= 0 {
597            put_i32(buf, self.member_epoch);
598        }
599        if version >= 0 {
600            if flex {
601                put_compact_string(buf, self.client_id)?;
602            } else {
603                put_string(buf, self.client_id)?;
604            }
605        }
606        if version >= 0 {
607            if flex {
608                put_compact_string(buf, self.client_host)?;
609            } else {
610                put_string(buf, self.client_host)?;
611            }
612        }
613        if version >= 0 {
614            {
615                put_array_len(buf, (self.subscribed_topic_names).len(), flex)?;
616                for it in &self.subscribed_topic_names {
617                    if flex {
618                        put_compact_string(buf, it)?;
619                    } else {
620                        put_string(buf, it)?;
621                    }
622                }
623            }
624        }
625        if version >= 0 {
626            self.assignment.encode(buf, version)?;
627        }
628        if flex {
629            let tagged = WriteTaggedFields::new();
630            tagged.write(buf, &self.unknown_tagged_fields)?;
631        }
632        Ok(())
633    }
634    fn encoded_len(&self, version: i16) -> usize {
635        let flex = version >= 0;
636        let mut n: usize = 0;
637        if version >= 0 {
638            n += if flex {
639                compact_string_len(self.member_id)
640            } else {
641                string_len(self.member_id)
642            };
643        }
644        if version >= 0 {
645            n += if flex {
646                compact_nullable_string_len(self.rack_id)
647            } else {
648                nullable_string_len(self.rack_id)
649            };
650        }
651        if version >= 0 {
652            n += 4;
653        }
654        if version >= 0 {
655            n += if flex {
656                compact_string_len(self.client_id)
657            } else {
658                string_len(self.client_id)
659            };
660        }
661        if version >= 0 {
662            n += if flex {
663                compact_string_len(self.client_host)
664            } else {
665                string_len(self.client_host)
666            };
667        }
668        if version >= 0 {
669            n += {
670                let prefix = array_len_prefix_len((self.subscribed_topic_names).len(), flex);
671                let body: usize = (self.subscribed_topic_names)
672                    .iter()
673                    .map(|it| {
674                        if flex {
675                            compact_string_len(it)
676                        } else {
677                            string_len(it)
678                        }
679                    })
680                    .sum();
681                prefix + body
682            };
683        }
684        if version >= 0 {
685            n += self.assignment.encoded_len(version);
686        }
687        if flex {
688            let known_pairs: Vec<(u32, usize)> = Vec::new();
689            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
690        }
691        n
692    }
693}
694impl<'de> DecodeBorrow<'de> for Member<'de> {
695    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
696        let flex = version >= 0;
697        let mut out = Self::default();
698        if version >= 0 {
699            out.member_id = if flex {
700                get_compact_string_borrowed(buf)?
701            } else {
702                get_string_borrowed(buf)?
703            };
704        }
705        if version >= 0 {
706            out.rack_id = if flex {
707                get_compact_nullable_string_borrowed(buf)?
708            } else {
709                get_nullable_string_borrowed(buf)?
710            };
711        }
712        if version >= 0 {
713            out.member_epoch = get_i32(buf)?;
714        }
715        if version >= 0 {
716            out.client_id = if flex {
717                get_compact_string_borrowed(buf)?
718            } else {
719                get_string_borrowed(buf)?
720            };
721        }
722        if version >= 0 {
723            out.client_host = if flex {
724                get_compact_string_borrowed(buf)?
725            } else {
726                get_string_borrowed(buf)?
727            };
728        }
729        if version >= 0 {
730            out.subscribed_topic_names = {
731                let n = get_array_len(buf, flex)?;
732                let mut v = Vec::with_capacity(n);
733                for _ in 0..n {
734                    v.push(if flex {
735                        get_compact_string_borrowed(buf)?
736                    } else {
737                        get_string_borrowed(buf)?
738                    });
739                }
740                v
741            };
742        }
743        if version >= 0 {
744            out.assignment = super::common::share_group_describe_response::assignment::Assignment::decode_borrow(buf, version)?;
745        }
746        if flex {
747            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
748        }
749        Ok(out)
750    }
751}
752#[cfg(test)]
753impl Member<'_> {
754    #[must_use]
755    pub fn populated(version: i16) -> Self {
756        let mut m = Self::default();
757        if version >= 0 {
758            m.member_id = "x";
759        }
760        if version >= 0 {
761            m.rack_id = Some("x");
762        }
763        if version >= 0 {
764            m.member_epoch = 1i32;
765        }
766        if version >= 0 {
767            m.client_id = "x";
768        }
769        if version >= 0 {
770            m.client_host = "x";
771        }
772        if version >= 0 {
773            m.subscribed_topic_names = vec!["x"];
774        }
775        if version >= 0 {
776            m.assignment =
777                super::common::share_group_describe_response::assignment::Assignment::populated(
778                    version,
779                );
780        }
781        m
782    }
783}
krabka_protocol/opt/rustwide/workdir/generated/ShareGroupDescribeResponse.borrowed.rs

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