kacrab_protocol/generated/
list_groups_response.rs

1//! Generated from ListGroupsResponse.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 ListGroupsResponseData {
17    /// The duration in milliseconds for which the request was throttled due to a quota violation,
18    /// or zero if the request did not violate any quota.
19    pub throttle_time_ms: i32,
20    /// The error code, or 0 if there was no error.
21    pub error_code: i16,
22    /// Each group in the response.
23    pub groups: Vec<ListedGroup>,
24    pub _unknown_tagged_fields: Vec<RawTaggedField>,
25}
26impl Default for ListGroupsResponseData {
27    fn default() -> Self {
28        Self {
29            throttle_time_ms: 0_i32,
30            error_code: 0_i16,
31            groups: Vec::new(),
32            _unknown_tagged_fields: Vec::new(),
33        }
34    }
35}
36impl ListGroupsResponseData {
37    pub fn with_throttle_time_ms(mut self, value: i32) -> Self {
38        self.throttle_time_ms = value;
39        self
40    }
41    pub fn with_error_code(mut self, value: i16) -> Self {
42        self.error_code = value;
43        self
44    }
45    pub fn with_groups(mut self, value: Vec<ListedGroup>) -> Self {
46        self.groups = value;
47        self
48    }
49    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
50        if version < 0 || version > 5 {
51            return Err(UnsupportedVersion::new(16, version).into());
52        }
53        let mut throttle_time_ms = 0_i32;
54        let error_code;
55        let groups;
56        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
57        if version >= 1 {
58            throttle_time_ms = read_i32(buf)?;
59        }
60        error_code = read_i16(buf)?;
61        if version >= 3 {
62            groups = {
63                let len = read_compact_array_length(buf)?;
64                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
65                for _ in 0..len {
66                    arr.push(ListedGroup::read(buf, version)?);
67                }
68                arr
69            };
70        } else {
71            groups = {
72                let len = read_array_length(buf)?;
73                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
74                for _ in 0..len {
75                    arr.push(ListedGroup::read(buf, version)?);
76                }
77                arr
78            };
79        }
80        if version >= 3 {
81            let tagged_fields = read_tagged_fields(buf)?;
82            for field in &tagged_fields {
83                match field.tag {
84                    _ => {
85                        _unknown_tagged_fields.push(field.clone());
86                    },
87                }
88            }
89        }
90        Ok(Self {
91            throttle_time_ms,
92            error_code,
93            groups,
94            _unknown_tagged_fields,
95        })
96    }
97    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
98        if version < 0 || version > 5 {
99            return Err(UnsupportedVersion::new(16, version).into());
100        }
101        if version >= 1 {
102            write_i32(buf, self.throttle_time_ms);
103        } else if self.throttle_time_ms != 0_i32 {
104            return Err(UnsupportedFieldVersion::new(16, "throttle_time_ms", version).into());
105        }
106        write_i16(buf, self.error_code);
107        if version >= 3 {
108            write_compact_array_length(buf, self.groups.len() as i32);
109            for el in &self.groups {
110                el.write(buf, version)?;
111            }
112        } else {
113            write_array_length(buf, self.groups.len() as i32);
114            for el in &self.groups {
115                el.write(buf, version)?;
116            }
117        }
118        if version >= 3 {
119            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
120            all_tags.sort_by_key(|f| f.tag);
121            write_tagged_fields(buf, &all_tags)?;
122        }
123        Ok(())
124    }
125    pub fn encoded_len(&self, version: i16) -> Result<usize> {
126        if version < 0 || version > 5 {
127            return Err(UnsupportedVersion::new(16, version).into());
128        }
129        let mut len: usize = 0;
130        if version >= 1 {
131            len += 4;
132        } else if self.throttle_time_ms != 0_i32 {
133            return Err(UnsupportedFieldVersion::new(16, "throttle_time_ms", version).into());
134        }
135        len += 2;
136        if version >= 3 {
137            len += compact_array_length_len(self.groups.len() as i32);
138            for el in &self.groups {
139                len += el.encoded_len(version)?;
140            }
141        } else {
142            len += array_length_len();
143            for el in &self.groups {
144                len += el.encoded_len(version)?;
145            }
146        }
147        if version >= 3 {
148            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
149            all_tags.sort_by_key(|f| f.tag);
150            len += tagged_fields_len(&all_tags)?;
151        }
152        Ok(len)
153    }
154}
155#[derive(Debug, Clone, PartialEq)]
156pub struct ListedGroup {
157    /// The group ID.
158    pub group_id: KafkaString,
159    /// The group protocol type.
160    pub protocol_type: KafkaString,
161    /// The group state name.
162    pub group_state: KafkaString,
163    /// The group type name.
164    pub group_type: KafkaString,
165    pub _unknown_tagged_fields: Vec<RawTaggedField>,
166}
167impl Default for ListedGroup {
168    fn default() -> Self {
169        Self {
170            group_id: KafkaString::default(),
171            protocol_type: KafkaString::default(),
172            group_state: KafkaString::default(),
173            group_type: KafkaString::default(),
174            _unknown_tagged_fields: Vec::new(),
175        }
176    }
177}
178impl ListedGroup {
179    pub fn with_group_id(mut self, value: KafkaString) -> Self {
180        self.group_id = value;
181        self
182    }
183    pub fn with_protocol_type(mut self, value: KafkaString) -> Self {
184        self.protocol_type = value;
185        self
186    }
187    pub fn with_group_state(mut self, value: KafkaString) -> Self {
188        self.group_state = value;
189        self
190    }
191    pub fn with_group_type(mut self, value: KafkaString) -> Self {
192        self.group_type = value;
193        self
194    }
195    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
196        let group_id;
197        let protocol_type;
198        let mut group_state = KafkaString::default();
199        let mut group_type = KafkaString::default();
200        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
201        if version >= 3 {
202            group_id = read_compact_string(buf)?;
203        } else {
204            group_id = read_string(buf)?;
205        }
206        if version >= 3 {
207            protocol_type = read_compact_string(buf)?;
208        } else {
209            protocol_type = read_string(buf)?;
210        }
211        if version >= 4 {
212            group_state = read_compact_string(buf)?;
213        }
214        if version >= 5 {
215            group_type = read_compact_string(buf)?;
216        }
217        if version >= 3 {
218            let tagged_fields = read_tagged_fields(buf)?;
219            for field in &tagged_fields {
220                match field.tag {
221                    _ => {
222                        _unknown_tagged_fields.push(field.clone());
223                    },
224                }
225            }
226        }
227        Ok(Self {
228            group_id,
229            protocol_type,
230            group_state,
231            group_type,
232            _unknown_tagged_fields,
233        })
234    }
235    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
236        if version >= 3 {
237            write_compact_string(buf, &self.group_id)?;
238        } else {
239            write_string(buf, &self.group_id)?;
240        }
241        if version >= 3 {
242            write_compact_string(buf, &self.protocol_type)?;
243        } else {
244            write_string(buf, &self.protocol_type)?;
245        }
246        if version >= 4 {
247            write_compact_string(buf, &self.group_state)?;
248        } else if self.group_state != KafkaString::default() {
249            return Err(UnsupportedFieldVersion::new(16, "group_state", version).into());
250        }
251        if version >= 5 {
252            write_compact_string(buf, &self.group_type)?;
253        } else if self.group_type != KafkaString::default() {
254            return Err(UnsupportedFieldVersion::new(16, "group_type", version).into());
255        }
256        if version >= 3 {
257            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
258            all_tags.sort_by_key(|f| f.tag);
259            write_tagged_fields(buf, &all_tags)?;
260        }
261        Ok(())
262    }
263    pub fn encoded_len(&self, version: i16) -> Result<usize> {
264        let mut len: usize = 0;
265        if version >= 3 {
266            len += compact_string_len(&self.group_id)?;
267        } else {
268            len += string_len(&self.group_id)?;
269        }
270        if version >= 3 {
271            len += compact_string_len(&self.protocol_type)?;
272        } else {
273            len += string_len(&self.protocol_type)?;
274        }
275        if version >= 4 {
276            len += compact_string_len(&self.group_state)?;
277        } else if self.group_state != KafkaString::default() {
278            return Err(UnsupportedFieldVersion::new(16, "group_state", version).into());
279        }
280        if version >= 5 {
281            len += compact_string_len(&self.group_type)?;
282        } else if self.group_type != KafkaString::default() {
283            return Err(UnsupportedFieldVersion::new(16, "group_type", version).into());
284        }
285        if version >= 3 {
286            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
287            all_tags.sort_by_key(|f| f.tag);
288            len += tagged_fields_len(&all_tags)?;
289        }
290        Ok(len)
291    }
292}
kacrab_protocol/generated/list_groups_response.rs

kacrab_protocol/generated/
list_groups_response.rs
