kacrab_protocol/generated/
list_groups_request.rs

1//! Generated from ListGroupsRequest.json - DO NOT EDIT
2#![allow(
3    missing_docs,
4    clippy::all,
5    clippy::pedantic,
6    clippy::nursery,
7    clippy::arithmetic_side_effects,
8    reason = "Generated protocol modules mirror Kafka's schema shape and intentionally trade \
9              hand-written lint style for reproducible wire-code output."
10)]
11use bytes::{Bytes, BytesMut};
12
13use crate::*;
14
15#[derive(Debug, Clone, PartialEq)]
16pub struct ListGroupsRequestData {
17    /// The states of the groups we want to list. If empty, all groups are returned with their
18    /// state.
19    pub states_filter: Vec<KafkaString>,
20    /// The types of the groups we want to list. If empty, all groups are returned with their type.
21    pub types_filter: Vec<KafkaString>,
22    pub _unknown_tagged_fields: Vec<RawTaggedField>,
23}
24impl Default for ListGroupsRequestData {
25    fn default() -> Self {
26        Self {
27            states_filter: Vec::new(),
28            types_filter: Vec::new(),
29            _unknown_tagged_fields: Vec::new(),
30        }
31    }
32}
33impl ListGroupsRequestData {
34    pub fn with_states_filter(mut self, value: Vec<KafkaString>) -> Self {
35        self.states_filter = value;
36        self
37    }
38    pub fn with_types_filter(mut self, value: Vec<KafkaString>) -> Self {
39        self.types_filter = value;
40        self
41    }
42    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
43        if version < 0 || version > 5 {
44            return Err(UnsupportedVersion::new(16, version).into());
45        }
46        let mut states_filter = Vec::new();
47        let mut types_filter = Vec::new();
48        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
49        if version >= 4 {
50            states_filter = {
51                let len = read_compact_array_length(buf)?;
52                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
53                for _ in 0..len {
54                    arr.push(read_compact_string(buf)?);
55                }
56                arr
57            };
58        }
59        if version >= 5 {
60            types_filter = {
61                let len = read_compact_array_length(buf)?;
62                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
63                for _ in 0..len {
64                    arr.push(read_compact_string(buf)?);
65                }
66                arr
67            };
68        }
69        if version >= 3 {
70            let tagged_fields = read_tagged_fields(buf)?;
71            for field in &tagged_fields {
72                match field.tag {
73                    _ => {
74                        _unknown_tagged_fields.push(field.clone());
75                    },
76                }
77            }
78        }
79        Ok(Self {
80            states_filter,
81            types_filter,
82            _unknown_tagged_fields,
83        })
84    }
85    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
86        if version < 0 || version > 5 {
87            return Err(UnsupportedVersion::new(16, version).into());
88        }
89        if version >= 4 {
90            write_compact_array_length(buf, self.states_filter.len() as i32);
91            for el in &self.states_filter {
92                write_compact_string(buf, el)?;
93            }
94        } else if self.states_filter != Vec::new() {
95            return Err(UnsupportedFieldVersion::new(16, "states_filter", version).into());
96        }
97        if version >= 5 {
98            write_compact_array_length(buf, self.types_filter.len() as i32);
99            for el in &self.types_filter {
100                write_compact_string(buf, el)?;
101            }
102        } else if self.types_filter != Vec::new() {
103            return Err(UnsupportedFieldVersion::new(16, "types_filter", version).into());
104        }
105        if version >= 3 {
106            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
107            all_tags.sort_by_key(|f| f.tag);
108            write_tagged_fields(buf, &all_tags)?;
109        }
110        Ok(())
111    }
112    pub fn encoded_len(&self, version: i16) -> Result<usize> {
113        if version < 0 || version > 5 {
114            return Err(UnsupportedVersion::new(16, version).into());
115        }
116        let mut len: usize = 0;
117        if version >= 4 {
118            len += compact_array_length_len(self.states_filter.len() as i32);
119            for el in &self.states_filter {
120                len += compact_string_len(el)?;
121            }
122        } else if self.states_filter != Vec::new() {
123            return Err(UnsupportedFieldVersion::new(16, "states_filter", version).into());
124        }
125        if version >= 5 {
126            len += compact_array_length_len(self.types_filter.len() as i32);
127            for el in &self.types_filter {
128                len += compact_string_len(el)?;
129            }
130        } else if self.types_filter != Vec::new() {
131            return Err(UnsupportedFieldVersion::new(16, "types_filter", version).into());
132        }
133        if version >= 3 {
134            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
135            all_tags.sort_by_key(|f| f.tag);
136            len += tagged_fields_len(&all_tags)?;
137        }
138        Ok(len)
139    }
140}
kacrab_protocol/generated/list_groups_request.rs

kacrab_protocol/generated/
list_groups_request.rs
