kacrab_protocol/generated/
heartbeat_request.rs

1//! Generated from HeartbeatRequest.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 HeartbeatRequestData {
17    /// The group id.
18    pub group_id: KafkaString,
19    /// The generation of the group.
20    pub generation_id: i32,
21    /// The member ID.
22    pub member_id: KafkaString,
23    /// The unique identifier of the consumer instance provided by end user.
24    pub group_instance_id: Option<KafkaString>,
25    pub _unknown_tagged_fields: Vec<RawTaggedField>,
26}
27impl Default for HeartbeatRequestData {
28    fn default() -> Self {
29        Self {
30            group_id: KafkaString::default(),
31            generation_id: 0_i32,
32            member_id: KafkaString::default(),
33            group_instance_id: None,
34            _unknown_tagged_fields: Vec::new(),
35        }
36    }
37}
38impl HeartbeatRequestData {
39    pub fn with_group_id(mut self, value: KafkaString) -> Self {
40        self.group_id = value;
41        self
42    }
43    pub fn with_generation_id(mut self, value: i32) -> Self {
44        self.generation_id = value;
45        self
46    }
47    pub fn with_member_id(mut self, value: KafkaString) -> Self {
48        self.member_id = value;
49        self
50    }
51    pub fn with_group_instance_id(mut self, value: Option<KafkaString>) -> Self {
52        self.group_instance_id = value;
53        self
54    }
55    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
56        if version < 0 || version > 4 {
57            return Err(UnsupportedVersion::new(12, version).into());
58        }
59        let group_id;
60        let generation_id;
61        let member_id;
62        let mut group_instance_id = None;
63        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
64        if version >= 4 {
65            group_id = read_compact_string(buf)?;
66        } else {
67            group_id = read_string(buf)?;
68        }
69        generation_id = read_i32(buf)?;
70        if version >= 4 {
71            member_id = read_compact_string(buf)?;
72        } else {
73            member_id = read_string(buf)?;
74        }
75        if version >= 3 {
76            if version >= 4 {
77                group_instance_id = read_compact_nullable_string(buf)?;
78            } else {
79                group_instance_id = read_nullable_string(buf)?;
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            group_id,
94            generation_id,
95            member_id,
96            group_instance_id,
97            _unknown_tagged_fields,
98        })
99    }
100    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
101        if version < 0 || version > 4 {
102            return Err(UnsupportedVersion::new(12, version).into());
103        }
104        if version >= 4 {
105            write_compact_string(buf, &self.group_id)?;
106        } else {
107            write_string(buf, &self.group_id)?;
108        }
109        write_i32(buf, self.generation_id);
110        if version >= 4 {
111            write_compact_string(buf, &self.member_id)?;
112        } else {
113            write_string(buf, &self.member_id)?;
114        }
115        if version >= 3 {
116            if version >= 4 {
117                write_compact_nullable_string(buf, self.group_instance_id.as_ref())?;
118            } else {
119                write_nullable_string(buf, self.group_instance_id.as_ref())?;
120            }
121        } else if self.group_instance_id != None {
122            return Err(UnsupportedFieldVersion::new(12, "group_instance_id", 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 > 4 {
133            return Err(UnsupportedVersion::new(12, version).into());
134        }
135        let mut len: usize = 0;
136        if version >= 4 {
137            len += compact_string_len(&self.group_id)?;
138        } else {
139            len += string_len(&self.group_id)?;
140        }
141        len += 4;
142        if version >= 4 {
143            len += compact_string_len(&self.member_id)?;
144        } else {
145            len += string_len(&self.member_id)?;
146        }
147        if version >= 3 {
148            if version >= 4 {
149                len += compact_nullable_string_len(self.group_instance_id.as_ref())?;
150            } else {
151                len += nullable_string_len(self.group_instance_id.as_ref())?;
152            }
153        } else if self.group_instance_id != None {
154            return Err(UnsupportedFieldVersion::new(12, "group_instance_id", version).into());
155        }
156        if version >= 4 {
157            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
158            all_tags.sort_by_key(|f| f.tag);
159            len += tagged_fields_len(&all_tags)?;
160        }
161        Ok(len)
162    }
163}
kacrab_protocol/generated/heartbeat_request.rs

kacrab_protocol/generated/
heartbeat_request.rs
