kacrab_protocol/generated/
leader_change_message.rs

1//! Generated from LeaderChangeMessage.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 LeaderChangeMessageData {
17    /// The version of the leader change message.
18    pub version: i16,
19    /// The ID of the newly elected leader.
20    pub leader_id: i32,
21    /// The set of voters in the quorum for this epoch.
22    pub voters: Vec<Voter>,
23    /// The voters who voted for the leader at the time of election.
24    pub granting_voters: Vec<Voter>,
25    pub _unknown_tagged_fields: Vec<RawTaggedField>,
26}
27impl Default for LeaderChangeMessageData {
28    fn default() -> Self {
29        Self {
30            version: 0_i16,
31            leader_id: 0_i32,
32            voters: Vec::new(),
33            granting_voters: Vec::new(),
34            _unknown_tagged_fields: Vec::new(),
35        }
36    }
37}
38impl LeaderChangeMessageData {
39    pub fn with_version(mut self, value: i16) -> Self {
40        self.version = value;
41        self
42    }
43    pub fn with_leader_id(mut self, value: i32) -> Self {
44        self.leader_id = value;
45        self
46    }
47    pub fn with_voters(mut self, value: Vec<Voter>) -> Self {
48        self.voters = value;
49        self
50    }
51    pub fn with_granting_voters(mut self, value: Vec<Voter>) -> Self {
52        self.granting_voters = value;
53        self
54    }
55    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
56        let version_;
57        let leader_id;
58        let voters;
59        let granting_voters;
60        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
61        version_ = read_i16(buf)?;
62        leader_id = read_i32(buf)?;
63        voters = {
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(Voter::read(buf, version)?);
68            }
69            arr
70        };
71        granting_voters = {
72            let len = read_compact_array_length(buf)?;
73            let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
74            for _ in 0..len {
75                arr.push(Voter::read(buf, version)?);
76            }
77            arr
78        };
79        let tagged_fields = read_tagged_fields(buf)?;
80        for field in &tagged_fields {
81            match field.tag {
82                _ => {
83                    _unknown_tagged_fields.push(field.clone());
84                },
85            }
86        }
87        Ok(Self {
88            version: version_,
89            leader_id,
90            voters,
91            granting_voters,
92            _unknown_tagged_fields,
93        })
94    }
95    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
96        write_i16(buf, self.version);
97        write_i32(buf, self.leader_id);
98        write_compact_array_length(buf, self.voters.len() as i32);
99        for el in &self.voters {
100            el.write(buf, version)?;
101        }
102        write_compact_array_length(buf, self.granting_voters.len() as i32);
103        for el in &self.granting_voters {
104            el.write(buf, version)?;
105        }
106        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
107        all_tags.sort_by_key(|f| f.tag);
108        write_tagged_fields(buf, &all_tags)?;
109        Ok(())
110    }
111    pub fn encoded_len(&self, version: i16) -> Result<usize> {
112        let mut len: usize = 0;
113        len += 2;
114        len += 4;
115        len += compact_array_length_len(self.voters.len() as i32);
116        for el in &self.voters {
117            len += el.encoded_len(version)?;
118        }
119        len += compact_array_length_len(self.granting_voters.len() as i32);
120        for el in &self.granting_voters {
121            len += el.encoded_len(version)?;
122        }
123        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
124        all_tags.sort_by_key(|f| f.tag);
125        len += tagged_fields_len(&all_tags)?;
126        Ok(len)
127    }
128}
129#[derive(Debug, Clone, PartialEq)]
130pub struct Voter {
131    /// The ID of the voter.
132    pub voter_id: i32,
133    /// The directory id of the voter.
134    pub voter_directory_id: KafkaUuid,
135    pub _unknown_tagged_fields: Vec<RawTaggedField>,
136}
137impl Default for Voter {
138    fn default() -> Self {
139        Self {
140            voter_id: 0_i32,
141            voter_directory_id: KafkaUuid::ZERO,
142            _unknown_tagged_fields: Vec::new(),
143        }
144    }
145}
146impl Voter {
147    pub fn with_voter_id(mut self, value: i32) -> Self {
148        self.voter_id = value;
149        self
150    }
151    pub fn with_voter_directory_id(mut self, value: KafkaUuid) -> Self {
152        self.voter_directory_id = value;
153        self
154    }
155    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
156        let voter_id;
157        let mut voter_directory_id = KafkaUuid::ZERO;
158        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
159        voter_id = read_i32(buf)?;
160        if version >= 1 {
161            voter_directory_id = read_uuid(buf)?;
162        }
163        let tagged_fields = read_tagged_fields(buf)?;
164        for field in &tagged_fields {
165            match field.tag {
166                _ => {
167                    _unknown_tagged_fields.push(field.clone());
168                },
169            }
170        }
171        Ok(Self {
172            voter_id,
173            voter_directory_id,
174            _unknown_tagged_fields,
175        })
176    }
177    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
178        write_i32(buf, self.voter_id);
179        if version >= 1 {
180            write_uuid(buf, &self.voter_directory_id);
181        }
182        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
183        all_tags.sort_by_key(|f| f.tag);
184        write_tagged_fields(buf, &all_tags)?;
185        Ok(())
186    }
187    pub fn encoded_len(&self, version: i16) -> Result<usize> {
188        let mut len: usize = 0;
189        len += 4;
190        if version >= 1 {
191            len += 16;
192        }
193        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
194        all_tags.sort_by_key(|f| f.tag);
195        len += tagged_fields_len(&all_tags)?;
196        Ok(len)
197    }
198}
kacrab_protocol/generated/leader_change_message.rs

kacrab_protocol/generated/
leader_change_message.rs
