kafka_protocol/messages/
leave_group_request.rs

1//! LeaveGroupRequest
2//!
3//! See the schema for this message [here](https://github.com/apache/kafka/blob/trunk/clients/src/main/resources/common/message/LeaveGroupRequest.json).
4// WARNING: the items of this module are generated and should not be edited directly
5#![allow(unused)]
6
7use std::borrow::Borrow;
8use std::collections::BTreeMap;
9
10use anyhow::{bail, Result};
11use bytes::Bytes;
12use uuid::Uuid;
13
14use crate::protocol::{
15    buf::{ByteBuf, ByteBufMut},
16    compute_unknown_tagged_fields_size, types, write_unknown_tagged_fields, Decodable, Decoder,
17    Encodable, Encoder, HeaderVersion, Message, StrBytes, VersionRange,
18};
19
20/// Valid versions: 0-5
21#[non_exhaustive]
22#[derive(Debug, Clone, PartialEq)]
23pub struct LeaveGroupRequest {
24    /// The ID of the group to leave.
25    ///
26    /// Supported API versions: 0-5
27    pub group_id: super::GroupId,
28
29    /// The member ID to remove from the group.
30    ///
31    /// Supported API versions: 0-2
32    pub member_id: StrBytes,
33
34    /// List of leaving member identities.
35    ///
36    /// Supported API versions: 3-5
37    pub members: Vec<MemberIdentity>,
38
39    /// Other tagged fields
40    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
41}
42
43impl LeaveGroupRequest {
44    /// Sets `group_id` to the passed value.
45    ///
46    /// The ID of the group to leave.
47    ///
48    /// Supported API versions: 0-5
49    pub fn with_group_id(mut self, value: super::GroupId) -> Self {
50        self.group_id = value;
51        self
52    }
53    /// Sets `member_id` to the passed value.
54    ///
55    /// The member ID to remove from the group.
56    ///
57    /// Supported API versions: 0-2
58    pub fn with_member_id(mut self, value: StrBytes) -> Self {
59        self.member_id = value;
60        self
61    }
62    /// Sets `members` to the passed value.
63    ///
64    /// List of leaving member identities.
65    ///
66    /// Supported API versions: 3-5
67    pub fn with_members(mut self, value: Vec<MemberIdentity>) -> Self {
68        self.members = value;
69        self
70    }
71    /// Sets unknown_tagged_fields to the passed value.
72    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
73        self.unknown_tagged_fields = value;
74        self
75    }
76    /// Inserts an entry into unknown_tagged_fields.
77    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
78        self.unknown_tagged_fields.insert(key, value);
79        self
80    }
81}
82
83#[cfg(feature = "client")]
84impl Encodable for LeaveGroupRequest {
85    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
86        if version >= 4 {
87            types::CompactString.encode(buf, &self.group_id)?;
88        } else {
89            types::String.encode(buf, &self.group_id)?;
90        }
91        if version <= 2 {
92            types::String.encode(buf, &self.member_id)?;
93        } else {
94            if !self.member_id.is_empty() {
95                bail!("A field is set that is not available on the selected protocol version");
96            }
97        }
98        if version >= 3 {
99            if version >= 4 {
100                types::CompactArray(types::Struct { version }).encode(buf, &self.members)?;
101            } else {
102                types::Array(types::Struct { version }).encode(buf, &self.members)?;
103            }
104        } else {
105            if !self.members.is_empty() {
106                bail!("A field is set that is not available on the selected protocol version");
107            }
108        }
109        if version >= 4 {
110            let num_tagged_fields = self.unknown_tagged_fields.len();
111            if num_tagged_fields > std::u32::MAX as usize {
112                bail!(
113                    "Too many tagged fields to encode ({} fields)",
114                    num_tagged_fields
115                );
116            }
117            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
118
119            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
120        }
121        Ok(())
122    }
123    fn compute_size(&self, version: i16) -> Result<usize> {
124        let mut total_size = 0;
125        if version >= 4 {
126            total_size += types::CompactString.compute_size(&self.group_id)?;
127        } else {
128            total_size += types::String.compute_size(&self.group_id)?;
129        }
130        if version <= 2 {
131            total_size += types::String.compute_size(&self.member_id)?;
132        } else {
133            if !self.member_id.is_empty() {
134                bail!("A field is set that is not available on the selected protocol version");
135            }
136        }
137        if version >= 3 {
138            if version >= 4 {
139                total_size +=
140                    types::CompactArray(types::Struct { version }).compute_size(&self.members)?;
141            } else {
142                total_size +=
143                    types::Array(types::Struct { version }).compute_size(&self.members)?;
144            }
145        } else {
146            if !self.members.is_empty() {
147                bail!("A field is set that is not available on the selected protocol version");
148            }
149        }
150        if version >= 4 {
151            let num_tagged_fields = self.unknown_tagged_fields.len();
152            if num_tagged_fields > std::u32::MAX as usize {
153                bail!(
154                    "Too many tagged fields to encode ({} fields)",
155                    num_tagged_fields
156                );
157            }
158            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
159
160            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
161        }
162        Ok(total_size)
163    }
164}
165
166#[cfg(feature = "broker")]
167impl Decodable for LeaveGroupRequest {
168    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
169        let group_id = if version >= 4 {
170            types::CompactString.decode(buf)?
171        } else {
172            types::String.decode(buf)?
173        };
174        let member_id = if version <= 2 {
175            types::String.decode(buf)?
176        } else {
177            Default::default()
178        };
179        let members = if version >= 3 {
180            if version >= 4 {
181                types::CompactArray(types::Struct { version }).decode(buf)?
182            } else {
183                types::Array(types::Struct { version }).decode(buf)?
184            }
185        } else {
186            Default::default()
187        };
188        let mut unknown_tagged_fields = BTreeMap::new();
189        if version >= 4 {
190            let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
191            for _ in 0..num_tagged_fields {
192                let tag: u32 = types::UnsignedVarInt.decode(buf)?;
193                let size: u32 = types::UnsignedVarInt.decode(buf)?;
194                let unknown_value = buf.try_get_bytes(size as usize)?;
195                unknown_tagged_fields.insert(tag as i32, unknown_value);
196            }
197        }
198        Ok(Self {
199            group_id,
200            member_id,
201            members,
202            unknown_tagged_fields,
203        })
204    }
205}
206
207impl Default for LeaveGroupRequest {
208    fn default() -> Self {
209        Self {
210            group_id: Default::default(),
211            member_id: Default::default(),
212            members: Default::default(),
213            unknown_tagged_fields: BTreeMap::new(),
214        }
215    }
216}
217
218impl Message for LeaveGroupRequest {
219    const VERSIONS: VersionRange = VersionRange { min: 0, max: 5 };
220    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
221}
222
223/// Valid versions: 0-5
224#[non_exhaustive]
225#[derive(Debug, Clone, PartialEq)]
226pub struct MemberIdentity {
227    /// The member ID to remove from the group.
228    ///
229    /// Supported API versions: 3-5
230    pub member_id: StrBytes,
231
232    /// The group instance ID to remove from the group.
233    ///
234    /// Supported API versions: 3-5
235    pub group_instance_id: Option<StrBytes>,
236
237    /// The reason why the member left the group.
238    ///
239    /// Supported API versions: 5
240    pub reason: Option<StrBytes>,
241
242    /// Other tagged fields
243    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
244}
245
246impl MemberIdentity {
247    /// Sets `member_id` to the passed value.
248    ///
249    /// The member ID to remove from the group.
250    ///
251    /// Supported API versions: 3-5
252    pub fn with_member_id(mut self, value: StrBytes) -> Self {
253        self.member_id = value;
254        self
255    }
256    /// Sets `group_instance_id` to the passed value.
257    ///
258    /// The group instance ID to remove from the group.
259    ///
260    /// Supported API versions: 3-5
261    pub fn with_group_instance_id(mut self, value: Option<StrBytes>) -> Self {
262        self.group_instance_id = value;
263        self
264    }
265    /// Sets `reason` to the passed value.
266    ///
267    /// The reason why the member left the group.
268    ///
269    /// Supported API versions: 5
270    pub fn with_reason(mut self, value: Option<StrBytes>) -> Self {
271        self.reason = value;
272        self
273    }
274    /// Sets unknown_tagged_fields to the passed value.
275    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
276        self.unknown_tagged_fields = value;
277        self
278    }
279    /// Inserts an entry into unknown_tagged_fields.
280    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
281        self.unknown_tagged_fields.insert(key, value);
282        self
283    }
284}
285
286#[cfg(feature = "client")]
287impl Encodable for MemberIdentity {
288    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
289        if version >= 3 {
290            if version >= 4 {
291                types::CompactString.encode(buf, &self.member_id)?;
292            } else {
293                types::String.encode(buf, &self.member_id)?;
294            }
295        } else {
296            if !self.member_id.is_empty() {
297                bail!("A field is set that is not available on the selected protocol version");
298            }
299        }
300        if version >= 3 {
301            if version >= 4 {
302                types::CompactString.encode(buf, &self.group_instance_id)?;
303            } else {
304                types::String.encode(buf, &self.group_instance_id)?;
305            }
306        } else {
307            if !self.group_instance_id.is_none() {
308                bail!("A field is set that is not available on the selected protocol version");
309            }
310        }
311        if version >= 5 {
312            types::CompactString.encode(buf, &self.reason)?;
313        }
314        if version >= 4 {
315            let num_tagged_fields = self.unknown_tagged_fields.len();
316            if num_tagged_fields > std::u32::MAX as usize {
317                bail!(
318                    "Too many tagged fields to encode ({} fields)",
319                    num_tagged_fields
320                );
321            }
322            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
323
324            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
325        }
326        Ok(())
327    }
328    fn compute_size(&self, version: i16) -> Result<usize> {
329        let mut total_size = 0;
330        if version >= 3 {
331            if version >= 4 {
332                total_size += types::CompactString.compute_size(&self.member_id)?;
333            } else {
334                total_size += types::String.compute_size(&self.member_id)?;
335            }
336        } else {
337            if !self.member_id.is_empty() {
338                bail!("A field is set that is not available on the selected protocol version");
339            }
340        }
341        if version >= 3 {
342            if version >= 4 {
343                total_size += types::CompactString.compute_size(&self.group_instance_id)?;
344            } else {
345                total_size += types::String.compute_size(&self.group_instance_id)?;
346            }
347        } else {
348            if !self.group_instance_id.is_none() {
349                bail!("A field is set that is not available on the selected protocol version");
350            }
351        }
352        if version >= 5 {
353            total_size += types::CompactString.compute_size(&self.reason)?;
354        }
355        if version >= 4 {
356            let num_tagged_fields = self.unknown_tagged_fields.len();
357            if num_tagged_fields > std::u32::MAX as usize {
358                bail!(
359                    "Too many tagged fields to encode ({} fields)",
360                    num_tagged_fields
361                );
362            }
363            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
364
365            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
366        }
367        Ok(total_size)
368    }
369}
370
371#[cfg(feature = "broker")]
372impl Decodable for MemberIdentity {
373    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
374        let member_id = if version >= 3 {
375            if version >= 4 {
376                types::CompactString.decode(buf)?
377            } else {
378                types::String.decode(buf)?
379            }
380        } else {
381            Default::default()
382        };
383        let group_instance_id = if version >= 3 {
384            if version >= 4 {
385                types::CompactString.decode(buf)?
386            } else {
387                types::String.decode(buf)?
388            }
389        } else {
390            None
391        };
392        let reason = if version >= 5 {
393            types::CompactString.decode(buf)?
394        } else {
395            None
396        };
397        let mut unknown_tagged_fields = BTreeMap::new();
398        if version >= 4 {
399            let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
400            for _ in 0..num_tagged_fields {
401                let tag: u32 = types::UnsignedVarInt.decode(buf)?;
402                let size: u32 = types::UnsignedVarInt.decode(buf)?;
403                let unknown_value = buf.try_get_bytes(size as usize)?;
404                unknown_tagged_fields.insert(tag as i32, unknown_value);
405            }
406        }
407        Ok(Self {
408            member_id,
409            group_instance_id,
410            reason,
411            unknown_tagged_fields,
412        })
413    }
414}
415
416impl Default for MemberIdentity {
417    fn default() -> Self {
418        Self {
419            member_id: Default::default(),
420            group_instance_id: None,
421            reason: None,
422            unknown_tagged_fields: BTreeMap::new(),
423        }
424    }
425}
426
427impl Message for MemberIdentity {
428    const VERSIONS: VersionRange = VersionRange { min: 0, max: 5 };
429    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
430}
431
432impl HeaderVersion for LeaveGroupRequest {
433    fn header_version(version: i16) -> i16 {
434        if version >= 4 {
435            2
436        } else {
437            1
438        }
439    }
440}
kafka_protocol/messages/leave_group_request.rs

kafka_protocol/messages/
leave_group_request.rs
