kacrab_protocol/generated/
leave_group_request.rs

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

kacrab_protocol/generated/
leave_group_request.rs
