kacrab_protocol/generated/
describe_groups_response.rs

1//! Generated from DescribeGroupsResponse.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 DescribeGroupsResponseData {
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    /// Each described group.
21    pub groups: Vec<DescribedGroup>,
22    pub _unknown_tagged_fields: Vec<RawTaggedField>,
23}
24impl Default for DescribeGroupsResponseData {
25    fn default() -> Self {
26        Self {
27            throttle_time_ms: 0_i32,
28            groups: Vec::new(),
29            _unknown_tagged_fields: Vec::new(),
30        }
31    }
32}
33impl DescribeGroupsResponseData {
34    pub fn with_throttle_time_ms(mut self, value: i32) -> Self {
35        self.throttle_time_ms = value;
36        self
37    }
38    pub fn with_groups(mut self, value: Vec<DescribedGroup>) -> Self {
39        self.groups = value;
40        self
41    }
42    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
43        if version < 0 || version > 6 {
44            return Err(UnsupportedVersion::new(15, version).into());
45        }
46        let mut throttle_time_ms = 0_i32;
47        let groups;
48        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
49        if version >= 1 {
50            throttle_time_ms = read_i32(buf)?;
51        }
52        if version >= 5 {
53            groups = {
54                let len = read_compact_array_length(buf)?;
55                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
56                for _ in 0..len {
57                    arr.push(DescribedGroup::read(buf, version)?);
58                }
59                arr
60            };
61        } else {
62            groups = {
63                let len = read_array_length(buf)?;
64                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
65                for _ in 0..len {
66                    arr.push(DescribedGroup::read(buf, version)?);
67                }
68                arr
69            };
70        }
71        if version >= 5 {
72            let tagged_fields = read_tagged_fields(buf)?;
73            for field in &tagged_fields {
74                match field.tag {
75                    _ => {
76                        _unknown_tagged_fields.push(field.clone());
77                    },
78                }
79            }
80        }
81        Ok(Self {
82            throttle_time_ms,
83            groups,
84            _unknown_tagged_fields,
85        })
86    }
87    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
88        if version < 0 || version > 6 {
89            return Err(UnsupportedVersion::new(15, version).into());
90        }
91        if version >= 1 {
92            write_i32(buf, self.throttle_time_ms);
93        } else if self.throttle_time_ms != 0_i32 {
94            return Err(UnsupportedFieldVersion::new(15, "throttle_time_ms", version).into());
95        }
96        if version >= 5 {
97            write_compact_array_length(buf, self.groups.len() as i32);
98            for el in &self.groups {
99                el.write(buf, version)?;
100            }
101        } else {
102            write_array_length(buf, self.groups.len() as i32);
103            for el in &self.groups {
104                el.write(buf, version)?;
105            }
106        }
107        if version >= 5 {
108            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
109            all_tags.sort_by_key(|f| f.tag);
110            write_tagged_fields(buf, &all_tags)?;
111        }
112        Ok(())
113    }
114    pub fn encoded_len(&self, version: i16) -> Result<usize> {
115        if version < 0 || version > 6 {
116            return Err(UnsupportedVersion::new(15, version).into());
117        }
118        let mut len: usize = 0;
119        if version >= 1 {
120            len += 4;
121        } else if self.throttle_time_ms != 0_i32 {
122            return Err(UnsupportedFieldVersion::new(15, "throttle_time_ms", version).into());
123        }
124        if version >= 5 {
125            len += compact_array_length_len(self.groups.len() as i32);
126            for el in &self.groups {
127                len += el.encoded_len(version)?;
128            }
129        } else {
130            len += array_length_len();
131            for el in &self.groups {
132                len += el.encoded_len(version)?;
133            }
134        }
135        if version >= 5 {
136            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
137            all_tags.sort_by_key(|f| f.tag);
138            len += tagged_fields_len(&all_tags)?;
139        }
140        Ok(len)
141    }
142}
143#[derive(Debug, Clone, PartialEq)]
144pub struct DescribedGroup {
145    /// The describe error, or 0 if there was no error.
146    pub error_code: i16,
147    /// The describe error message, or null if there was no error.
148    pub error_message: Option<KafkaString>,
149    /// The group ID string.
150    pub group_id: KafkaString,
151    /// The group state string, or the empty string.
152    pub group_state: KafkaString,
153    /// The group protocol type, or the empty string.
154    pub protocol_type: KafkaString,
155    /// The group protocol data, or the empty string.
156    pub protocol_data: KafkaString,
157    /// The group members.
158    pub members: Vec<DescribedGroupMember>,
159    /// 32-bit bitfield to represent authorized operations for this group.
160    pub authorized_operations: i32,
161    pub _unknown_tagged_fields: Vec<RawTaggedField>,
162}
163impl Default for DescribedGroup {
164    fn default() -> Self {
165        Self {
166            error_code: 0_i16,
167            error_message: None,
168            group_id: KafkaString::default(),
169            group_state: KafkaString::default(),
170            protocol_type: KafkaString::default(),
171            protocol_data: KafkaString::default(),
172            members: Vec::new(),
173            authorized_operations: i32::MIN,
174            _unknown_tagged_fields: Vec::new(),
175        }
176    }
177}
178impl DescribedGroup {
179    pub fn with_error_code(mut self, value: i16) -> Self {
180        self.error_code = value;
181        self
182    }
183    pub fn with_error_message(mut self, value: Option<KafkaString>) -> Self {
184        self.error_message = value;
185        self
186    }
187    pub fn with_group_id(mut self, value: KafkaString) -> Self {
188        self.group_id = value;
189        self
190    }
191    pub fn with_group_state(mut self, value: KafkaString) -> Self {
192        self.group_state = value;
193        self
194    }
195    pub fn with_protocol_type(mut self, value: KafkaString) -> Self {
196        self.protocol_type = value;
197        self
198    }
199    pub fn with_protocol_data(mut self, value: KafkaString) -> Self {
200        self.protocol_data = value;
201        self
202    }
203    pub fn with_members(mut self, value: Vec<DescribedGroupMember>) -> Self {
204        self.members = value;
205        self
206    }
207    pub fn with_authorized_operations(mut self, value: i32) -> Self {
208        self.authorized_operations = value;
209        self
210    }
211    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
212        let error_code;
213        let mut error_message = None;
214        let group_id;
215        let group_state;
216        let protocol_type;
217        let protocol_data;
218        let members;
219        let mut authorized_operations = i32::MIN;
220        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
221        error_code = read_i16(buf)?;
222        if version >= 6 {
223            error_message = read_compact_nullable_string(buf)?;
224        }
225        if version >= 5 {
226            group_id = read_compact_string(buf)?;
227        } else {
228            group_id = read_string(buf)?;
229        }
230        if version >= 5 {
231            group_state = read_compact_string(buf)?;
232        } else {
233            group_state = read_string(buf)?;
234        }
235        if version >= 5 {
236            protocol_type = read_compact_string(buf)?;
237        } else {
238            protocol_type = read_string(buf)?;
239        }
240        if version >= 5 {
241            protocol_data = read_compact_string(buf)?;
242        } else {
243            protocol_data = read_string(buf)?;
244        }
245        if version >= 5 {
246            members = {
247                let len = read_compact_array_length(buf)?;
248                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
249                for _ in 0..len {
250                    arr.push(DescribedGroupMember::read(buf, version)?);
251                }
252                arr
253            };
254        } else {
255            members = {
256                let len = read_array_length(buf)?;
257                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
258                for _ in 0..len {
259                    arr.push(DescribedGroupMember::read(buf, version)?);
260                }
261                arr
262            };
263        }
264        if version >= 3 {
265            authorized_operations = read_i32(buf)?;
266        }
267        if version >= 5 {
268            let tagged_fields = read_tagged_fields(buf)?;
269            for field in &tagged_fields {
270                match field.tag {
271                    _ => {
272                        _unknown_tagged_fields.push(field.clone());
273                    },
274                }
275            }
276        }
277        Ok(Self {
278            error_code,
279            error_message,
280            group_id,
281            group_state,
282            protocol_type,
283            protocol_data,
284            members,
285            authorized_operations,
286            _unknown_tagged_fields,
287        })
288    }
289    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
290        write_i16(buf, self.error_code);
291        if version >= 6 {
292            write_compact_nullable_string(buf, self.error_message.as_ref())?;
293        } else if self.error_message != None {
294            return Err(UnsupportedFieldVersion::new(15, "error_message", version).into());
295        }
296        if version >= 5 {
297            write_compact_string(buf, &self.group_id)?;
298        } else {
299            write_string(buf, &self.group_id)?;
300        }
301        if version >= 5 {
302            write_compact_string(buf, &self.group_state)?;
303        } else {
304            write_string(buf, &self.group_state)?;
305        }
306        if version >= 5 {
307            write_compact_string(buf, &self.protocol_type)?;
308        } else {
309            write_string(buf, &self.protocol_type)?;
310        }
311        if version >= 5 {
312            write_compact_string(buf, &self.protocol_data)?;
313        } else {
314            write_string(buf, &self.protocol_data)?;
315        }
316        if version >= 5 {
317            write_compact_array_length(buf, self.members.len() as i32);
318            for el in &self.members {
319                el.write(buf, version)?;
320            }
321        } else {
322            write_array_length(buf, self.members.len() as i32);
323            for el in &self.members {
324                el.write(buf, version)?;
325            }
326        }
327        if version >= 3 {
328            write_i32(buf, self.authorized_operations);
329        } else if self.authorized_operations != i32::MIN {
330            return Err(UnsupportedFieldVersion::new(15, "authorized_operations", version).into());
331        }
332        if version >= 5 {
333            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
334            all_tags.sort_by_key(|f| f.tag);
335            write_tagged_fields(buf, &all_tags)?;
336        }
337        Ok(())
338    }
339    pub fn encoded_len(&self, version: i16) -> Result<usize> {
340        let mut len: usize = 0;
341        len += 2;
342        if version >= 6 {
343            len += compact_nullable_string_len(self.error_message.as_ref())?;
344        } else if self.error_message != None {
345            return Err(UnsupportedFieldVersion::new(15, "error_message", version).into());
346        }
347        if version >= 5 {
348            len += compact_string_len(&self.group_id)?;
349        } else {
350            len += string_len(&self.group_id)?;
351        }
352        if version >= 5 {
353            len += compact_string_len(&self.group_state)?;
354        } else {
355            len += string_len(&self.group_state)?;
356        }
357        if version >= 5 {
358            len += compact_string_len(&self.protocol_type)?;
359        } else {
360            len += string_len(&self.protocol_type)?;
361        }
362        if version >= 5 {
363            len += compact_string_len(&self.protocol_data)?;
364        } else {
365            len += string_len(&self.protocol_data)?;
366        }
367        if version >= 5 {
368            len += compact_array_length_len(self.members.len() as i32);
369            for el in &self.members {
370                len += el.encoded_len(version)?;
371            }
372        } else {
373            len += array_length_len();
374            for el in &self.members {
375                len += el.encoded_len(version)?;
376            }
377        }
378        if version >= 3 {
379            len += 4;
380        } else if self.authorized_operations != i32::MIN {
381            return Err(UnsupportedFieldVersion::new(15, "authorized_operations", version).into());
382        }
383        if version >= 5 {
384            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
385            all_tags.sort_by_key(|f| f.tag);
386            len += tagged_fields_len(&all_tags)?;
387        }
388        Ok(len)
389    }
390}
391#[derive(Debug, Clone, PartialEq)]
392pub struct DescribedGroupMember {
393    /// The member id.
394    pub member_id: KafkaString,
395    /// The unique identifier of the consumer instance provided by end user.
396    pub group_instance_id: Option<KafkaString>,
397    /// The client ID used in the member's latest join group request.
398    pub client_id: KafkaString,
399    /// The client host.
400    pub client_host: KafkaString,
401    /// The metadata corresponding to the current group protocol in use.
402    pub member_metadata: Bytes,
403    /// The current assignment provided by the group leader.
404    pub member_assignment: Bytes,
405    pub _unknown_tagged_fields: Vec<RawTaggedField>,
406}
407impl Default for DescribedGroupMember {
408    fn default() -> Self {
409        Self {
410            member_id: KafkaString::default(),
411            group_instance_id: None,
412            client_id: KafkaString::default(),
413            client_host: KafkaString::default(),
414            member_metadata: Bytes::new(),
415            member_assignment: Bytes::new(),
416            _unknown_tagged_fields: Vec::new(),
417        }
418    }
419}
420impl DescribedGroupMember {
421    pub fn with_member_id(mut self, value: KafkaString) -> Self {
422        self.member_id = value;
423        self
424    }
425    pub fn with_group_instance_id(mut self, value: Option<KafkaString>) -> Self {
426        self.group_instance_id = value;
427        self
428    }
429    pub fn with_client_id(mut self, value: KafkaString) -> Self {
430        self.client_id = value;
431        self
432    }
433    pub fn with_client_host(mut self, value: KafkaString) -> Self {
434        self.client_host = value;
435        self
436    }
437    pub fn with_member_metadata(mut self, value: Bytes) -> Self {
438        self.member_metadata = value;
439        self
440    }
441    pub fn with_member_assignment(mut self, value: Bytes) -> Self {
442        self.member_assignment = value;
443        self
444    }
445    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
446        let member_id;
447        let mut group_instance_id = None;
448        let client_id;
449        let client_host;
450        let member_metadata;
451        let member_assignment;
452        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
453        if version >= 5 {
454            member_id = read_compact_string(buf)?;
455        } else {
456            member_id = read_string(buf)?;
457        }
458        if version >= 4 {
459            if version >= 5 {
460                group_instance_id = read_compact_nullable_string(buf)?;
461            } else {
462                group_instance_id = read_nullable_string(buf)?;
463            }
464        }
465        if version >= 5 {
466            client_id = read_compact_string(buf)?;
467        } else {
468            client_id = read_string(buf)?;
469        }
470        if version >= 5 {
471            client_host = read_compact_string(buf)?;
472        } else {
473            client_host = read_string(buf)?;
474        }
475        if version >= 5 {
476            member_metadata = read_compact_bytes(buf)?;
477        } else {
478            member_metadata = read_bytes(buf)?;
479        }
480        if version >= 5 {
481            member_assignment = read_compact_bytes(buf)?;
482        } else {
483            member_assignment = read_bytes(buf)?;
484        }
485        if version >= 5 {
486            let tagged_fields = read_tagged_fields(buf)?;
487            for field in &tagged_fields {
488                match field.tag {
489                    _ => {
490                        _unknown_tagged_fields.push(field.clone());
491                    },
492                }
493            }
494        }
495        Ok(Self {
496            member_id,
497            group_instance_id,
498            client_id,
499            client_host,
500            member_metadata,
501            member_assignment,
502            _unknown_tagged_fields,
503        })
504    }
505    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
506        if version >= 5 {
507            write_compact_string(buf, &self.member_id)?;
508        } else {
509            write_string(buf, &self.member_id)?;
510        }
511        if version >= 4 {
512            if version >= 5 {
513                write_compact_nullable_string(buf, self.group_instance_id.as_ref())?;
514            } else {
515                write_nullable_string(buf, self.group_instance_id.as_ref())?;
516            }
517        } else if self.group_instance_id != None {
518            return Err(UnsupportedFieldVersion::new(15, "group_instance_id", version).into());
519        }
520        if version >= 5 {
521            write_compact_string(buf, &self.client_id)?;
522        } else {
523            write_string(buf, &self.client_id)?;
524        }
525        if version >= 5 {
526            write_compact_string(buf, &self.client_host)?;
527        } else {
528            write_string(buf, &self.client_host)?;
529        }
530        if version >= 5 {
531            write_compact_bytes(buf, &self.member_metadata)?;
532        } else {
533            write_bytes(buf, &self.member_metadata)?;
534        }
535        if version >= 5 {
536            write_compact_bytes(buf, &self.member_assignment)?;
537        } else {
538            write_bytes(buf, &self.member_assignment)?;
539        }
540        if version >= 5 {
541            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
542            all_tags.sort_by_key(|f| f.tag);
543            write_tagged_fields(buf, &all_tags)?;
544        }
545        Ok(())
546    }
547    pub fn encoded_len(&self, version: i16) -> Result<usize> {
548        let mut len: usize = 0;
549        if version >= 5 {
550            len += compact_string_len(&self.member_id)?;
551        } else {
552            len += string_len(&self.member_id)?;
553        }
554        if version >= 4 {
555            if version >= 5 {
556                len += compact_nullable_string_len(self.group_instance_id.as_ref())?;
557            } else {
558                len += nullable_string_len(self.group_instance_id.as_ref())?;
559            }
560        } else if self.group_instance_id != None {
561            return Err(UnsupportedFieldVersion::new(15, "group_instance_id", version).into());
562        }
563        if version >= 5 {
564            len += compact_string_len(&self.client_id)?;
565        } else {
566            len += string_len(&self.client_id)?;
567        }
568        if version >= 5 {
569            len += compact_string_len(&self.client_host)?;
570        } else {
571            len += string_len(&self.client_host)?;
572        }
573        if version >= 5 {
574            len += compact_bytes_len(&self.member_metadata)?;
575        } else {
576            len += bytes_len(&self.member_metadata)?;
577        }
578        if version >= 5 {
579            len += compact_bytes_len(&self.member_assignment)?;
580        } else {
581            len += bytes_len(&self.member_assignment)?;
582        }
583        if version >= 5 {
584            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
585            all_tags.sort_by_key(|f| f.tag);
586            len += tagged_fields_len(&all_tags)?;
587        }
588        Ok(len)
589    }
590}
kacrab_protocol/generated/describe_groups_response.rs

kacrab_protocol/generated/
describe_groups_response.rs
