kacrab_protocol/generated/
leave_group_response.rs

1//! Generated from LeaveGroupResponse.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 LeaveGroupResponseData {
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    /// List of leaving member responses.
23    pub members: Vec<MemberResponse>,
24    pub _unknown_tagged_fields: Vec<RawTaggedField>,
25}
26impl Default for LeaveGroupResponseData {
27    fn default() -> Self {
28        Self {
29            throttle_time_ms: 0_i32,
30            error_code: 0_i16,
31            members: Vec::new(),
32            _unknown_tagged_fields: Vec::new(),
33        }
34    }
35}
36impl LeaveGroupResponseData {
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_members(mut self, value: Vec<MemberResponse>) -> Self {
46        self.members = 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(13, version).into());
52        }
53        let mut throttle_time_ms = 0_i32;
54        let error_code;
55        let mut members = Vec::new();
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            if version >= 4 {
63                members = {
64                    let len = read_compact_array_length(buf)?;
65                    let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
66                    for _ in 0..len {
67                        arr.push(MemberResponse::read(buf, version)?);
68                    }
69                    arr
70                };
71            } else {
72                members = {
73                    let len = read_array_length(buf)?;
74                    let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
75                    for _ in 0..len {
76                        arr.push(MemberResponse::read(buf, version)?);
77                    }
78                    arr
79                };
80            }
81        }
82        if version >= 4 {
83            let tagged_fields = read_tagged_fields(buf)?;
84            for field in &tagged_fields {
85                match field.tag {
86                    _ => {
87                        _unknown_tagged_fields.push(field.clone());
88                    },
89                }
90            }
91        }
92        Ok(Self {
93            throttle_time_ms,
94            error_code,
95            members,
96            _unknown_tagged_fields,
97        })
98    }
99    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
100        if version < 0 || version > 5 {
101            return Err(UnsupportedVersion::new(13, version).into());
102        }
103        if version >= 1 {
104            write_i32(buf, self.throttle_time_ms);
105        } else if self.throttle_time_ms != 0_i32 {
106            return Err(UnsupportedFieldVersion::new(13, "throttle_time_ms", version).into());
107        }
108        write_i16(buf, self.error_code);
109        if version >= 3 {
110            if version >= 4 {
111                write_compact_array_length(buf, self.members.len() as i32);
112                for el in &self.members {
113                    el.write(buf, version)?;
114                }
115            } else {
116                write_array_length(buf, self.members.len() as i32);
117                for el in &self.members {
118                    el.write(buf, version)?;
119                }
120            }
121        } else if self.members != Vec::new() {
122            return Err(UnsupportedFieldVersion::new(13, "members", version).into());
123        }
124        if version >= 4 {
125            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
126            all_tags.sort_by_key(|f| f.tag);
127            write_tagged_fields(buf, &all_tags)?;
128        }
129        Ok(())
130    }
131    pub fn encoded_len(&self, version: i16) -> Result<usize> {
132        if version < 0 || version > 5 {
133            return Err(UnsupportedVersion::new(13, version).into());
134        }
135        let mut len: usize = 0;
136        if version >= 1 {
137            len += 4;
138        } else if self.throttle_time_ms != 0_i32 {
139            return Err(UnsupportedFieldVersion::new(13, "throttle_time_ms", version).into());
140        }
141        len += 2;
142        if version >= 3 {
143            if version >= 4 {
144                len += compact_array_length_len(self.members.len() as i32);
145                for el in &self.members {
146                    len += el.encoded_len(version)?;
147                }
148            } else {
149                len += array_length_len();
150                for el in &self.members {
151                    len += el.encoded_len(version)?;
152                }
153            }
154        } else if self.members != Vec::new() {
155            return Err(UnsupportedFieldVersion::new(13, "members", version).into());
156        }
157        if version >= 4 {
158            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
159            all_tags.sort_by_key(|f| f.tag);
160            len += tagged_fields_len(&all_tags)?;
161        }
162        Ok(len)
163    }
164}
165#[derive(Debug, Clone, PartialEq)]
166pub struct MemberResponse {
167    /// The member ID to remove from the group.
168    pub member_id: KafkaString,
169    /// The group instance ID to remove from the group.
170    pub group_instance_id: Option<KafkaString>,
171    /// The error code, or 0 if there was no error.
172    pub error_code: i16,
173    pub _unknown_tagged_fields: Vec<RawTaggedField>,
174}
175impl Default for MemberResponse {
176    fn default() -> Self {
177        Self {
178            member_id: KafkaString::default(),
179            group_instance_id: None,
180            error_code: 0_i16,
181            _unknown_tagged_fields: Vec::new(),
182        }
183    }
184}
185impl MemberResponse {
186    pub fn with_member_id(mut self, value: KafkaString) -> Self {
187        self.member_id = value;
188        self
189    }
190    pub fn with_group_instance_id(mut self, value: Option<KafkaString>) -> Self {
191        self.group_instance_id = value;
192        self
193    }
194    pub fn with_error_code(mut self, value: i16) -> Self {
195        self.error_code = value;
196        self
197    }
198    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
199        let member_id;
200        let group_instance_id;
201        let error_code;
202        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
203        if version >= 4 {
204            member_id = read_compact_string(buf)?;
205        } else {
206            member_id = read_string(buf)?;
207        }
208        if version >= 4 {
209            group_instance_id = read_compact_nullable_string(buf)?;
210        } else {
211            group_instance_id = read_nullable_string(buf)?;
212        }
213        error_code = read_i16(buf)?;
214        if version >= 4 {
215            let tagged_fields = read_tagged_fields(buf)?;
216            for field in &tagged_fields {
217                match field.tag {
218                    _ => {
219                        _unknown_tagged_fields.push(field.clone());
220                    },
221                }
222            }
223        }
224        Ok(Self {
225            member_id,
226            group_instance_id,
227            error_code,
228            _unknown_tagged_fields,
229        })
230    }
231    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
232        if version >= 4 {
233            write_compact_string(buf, &self.member_id)?;
234        } else {
235            write_string(buf, &self.member_id)?;
236        }
237        if version >= 4 {
238            write_compact_nullable_string(buf, self.group_instance_id.as_ref())?;
239        } else {
240            write_nullable_string(buf, self.group_instance_id.as_ref())?;
241        }
242        write_i16(buf, self.error_code);
243        if version >= 4 {
244            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
245            all_tags.sort_by_key(|f| f.tag);
246            write_tagged_fields(buf, &all_tags)?;
247        }
248        Ok(())
249    }
250    pub fn encoded_len(&self, version: i16) -> Result<usize> {
251        let mut len: usize = 0;
252        if version >= 4 {
253            len += compact_string_len(&self.member_id)?;
254        } else {
255            len += string_len(&self.member_id)?;
256        }
257        if version >= 4 {
258            len += compact_nullable_string_len(self.group_instance_id.as_ref())?;
259        } else {
260            len += nullable_string_len(self.group_instance_id.as_ref())?;
261        }
262        len += 2;
263        if version >= 4 {
264            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
265            all_tags.sort_by_key(|f| f.tag);
266            len += tagged_fields_len(&all_tags)?;
267        }
268        Ok(len)
269    }
270}
kacrab_protocol/generated/leave_group_response.rs

kacrab_protocol/generated/
leave_group_response.rs
