kafka_protocol/messages/
voters_record.rs

1//! VotersRecord
2//!
3//! See the schema for this message [here](https://github.com/apache/kafka/blob/trunk/clients/src/main/resources/common/message/VotersRecord.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
21#[non_exhaustive]
22#[derive(Debug, Clone, PartialEq)]
23pub struct Endpoint {
24    /// The name of the endpoint
25    ///
26    /// Supported API versions: 0
27    pub name: StrBytes,
28
29    /// The hostname
30    ///
31    /// Supported API versions: 0
32    pub host: StrBytes,
33
34    /// The port
35    ///
36    /// Supported API versions: 0
37    pub port: u16,
38
39    /// Other tagged fields
40    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
41}
42
43impl Endpoint {
44    /// Sets `name` to the passed value.
45    ///
46    /// The name of the endpoint
47    ///
48    /// Supported API versions: 0
49    pub fn with_name(mut self, value: StrBytes) -> Self {
50        self.name = value;
51        self
52    }
53    /// Sets `host` to the passed value.
54    ///
55    /// The hostname
56    ///
57    /// Supported API versions: 0
58    pub fn with_host(mut self, value: StrBytes) -> Self {
59        self.host = value;
60        self
61    }
62    /// Sets `port` to the passed value.
63    ///
64    /// The port
65    ///
66    /// Supported API versions: 0
67    pub fn with_port(mut self, value: u16) -> Self {
68        self.port = 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
83impl Encodable for Endpoint {
84    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
85        if version != 0 {
86            bail!("specified version not supported by this message type");
87        }
88        types::CompactString.encode(buf, &self.name)?;
89        types::CompactString.encode(buf, &self.host)?;
90        types::UInt16.encode(buf, &self.port)?;
91        let num_tagged_fields = self.unknown_tagged_fields.len();
92        if num_tagged_fields > std::u32::MAX as usize {
93            bail!(
94                "Too many tagged fields to encode ({} fields)",
95                num_tagged_fields
96            );
97        }
98        types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
99
100        write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
101        Ok(())
102    }
103    fn compute_size(&self, version: i16) -> Result<usize> {
104        let mut total_size = 0;
105        total_size += types::CompactString.compute_size(&self.name)?;
106        total_size += types::CompactString.compute_size(&self.host)?;
107        total_size += types::UInt16.compute_size(&self.port)?;
108        let num_tagged_fields = self.unknown_tagged_fields.len();
109        if num_tagged_fields > std::u32::MAX as usize {
110            bail!(
111                "Too many tagged fields to encode ({} fields)",
112                num_tagged_fields
113            );
114        }
115        total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
116
117        total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
118        Ok(total_size)
119    }
120}
121
122impl Decodable for Endpoint {
123    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
124        if version != 0 {
125            bail!("specified version not supported by this message type");
126        }
127        let name = types::CompactString.decode(buf)?;
128        let host = types::CompactString.decode(buf)?;
129        let port = types::UInt16.decode(buf)?;
130        let mut unknown_tagged_fields = BTreeMap::new();
131        let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
132        for _ in 0..num_tagged_fields {
133            let tag: u32 = types::UnsignedVarInt.decode(buf)?;
134            let size: u32 = types::UnsignedVarInt.decode(buf)?;
135            let unknown_value = buf.try_get_bytes(size as usize)?;
136            unknown_tagged_fields.insert(tag as i32, unknown_value);
137        }
138        Ok(Self {
139            name,
140            host,
141            port,
142            unknown_tagged_fields,
143        })
144    }
145}
146
147impl Default for Endpoint {
148    fn default() -> Self {
149        Self {
150            name: Default::default(),
151            host: Default::default(),
152            port: 0,
153            unknown_tagged_fields: BTreeMap::new(),
154        }
155    }
156}
157
158impl Message for Endpoint {
159    const VERSIONS: VersionRange = VersionRange { min: 0, max: 0 };
160    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
161}
162
163/// Valid versions: 0
164#[non_exhaustive]
165#[derive(Debug, Clone, PartialEq)]
166pub struct KRaftVersionFeature {
167    /// The minimum supported KRaft protocol version
168    ///
169    /// Supported API versions: 0
170    pub min_supported_version: i16,
171
172    /// The maximum supported KRaft protocol version
173    ///
174    /// Supported API versions: 0
175    pub max_supported_version: i16,
176
177    /// Other tagged fields
178    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
179}
180
181impl KRaftVersionFeature {
182    /// Sets `min_supported_version` to the passed value.
183    ///
184    /// The minimum supported KRaft protocol version
185    ///
186    /// Supported API versions: 0
187    pub fn with_min_supported_version(mut self, value: i16) -> Self {
188        self.min_supported_version = value;
189        self
190    }
191    /// Sets `max_supported_version` to the passed value.
192    ///
193    /// The maximum supported KRaft protocol version
194    ///
195    /// Supported API versions: 0
196    pub fn with_max_supported_version(mut self, value: i16) -> Self {
197        self.max_supported_version = value;
198        self
199    }
200    /// Sets unknown_tagged_fields to the passed value.
201    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
202        self.unknown_tagged_fields = value;
203        self
204    }
205    /// Inserts an entry into unknown_tagged_fields.
206    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
207        self.unknown_tagged_fields.insert(key, value);
208        self
209    }
210}
211
212impl Encodable for KRaftVersionFeature {
213    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
214        if version != 0 {
215            bail!("specified version not supported by this message type");
216        }
217        types::Int16.encode(buf, &self.min_supported_version)?;
218        types::Int16.encode(buf, &self.max_supported_version)?;
219        let num_tagged_fields = self.unknown_tagged_fields.len();
220        if num_tagged_fields > std::u32::MAX as usize {
221            bail!(
222                "Too many tagged fields to encode ({} fields)",
223                num_tagged_fields
224            );
225        }
226        types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
227
228        write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
229        Ok(())
230    }
231    fn compute_size(&self, version: i16) -> Result<usize> {
232        let mut total_size = 0;
233        total_size += types::Int16.compute_size(&self.min_supported_version)?;
234        total_size += types::Int16.compute_size(&self.max_supported_version)?;
235        let num_tagged_fields = self.unknown_tagged_fields.len();
236        if num_tagged_fields > std::u32::MAX as usize {
237            bail!(
238                "Too many tagged fields to encode ({} fields)",
239                num_tagged_fields
240            );
241        }
242        total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
243
244        total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
245        Ok(total_size)
246    }
247}
248
249impl Decodable for KRaftVersionFeature {
250    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
251        if version != 0 {
252            bail!("specified version not supported by this message type");
253        }
254        let min_supported_version = types::Int16.decode(buf)?;
255        let max_supported_version = types::Int16.decode(buf)?;
256        let mut unknown_tagged_fields = BTreeMap::new();
257        let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
258        for _ in 0..num_tagged_fields {
259            let tag: u32 = types::UnsignedVarInt.decode(buf)?;
260            let size: u32 = types::UnsignedVarInt.decode(buf)?;
261            let unknown_value = buf.try_get_bytes(size as usize)?;
262            unknown_tagged_fields.insert(tag as i32, unknown_value);
263        }
264        Ok(Self {
265            min_supported_version,
266            max_supported_version,
267            unknown_tagged_fields,
268        })
269    }
270}
271
272impl Default for KRaftVersionFeature {
273    fn default() -> Self {
274        Self {
275            min_supported_version: 0,
276            max_supported_version: 0,
277            unknown_tagged_fields: BTreeMap::new(),
278        }
279    }
280}
281
282impl Message for KRaftVersionFeature {
283    const VERSIONS: VersionRange = VersionRange { min: 0, max: 0 };
284    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
285}
286
287/// Valid versions: 0
288#[non_exhaustive]
289#[derive(Debug, Clone, PartialEq)]
290pub struct Voter {
291    /// The replica id of the voter in the topic partition
292    ///
293    /// Supported API versions: 0
294    pub voter_id: super::BrokerId,
295
296    /// The directory id of the voter in the topic partition
297    ///
298    /// Supported API versions: 0
299    pub voter_directory_id: Uuid,
300
301    /// The endpoint that can be used to communicate with the voter
302    ///
303    /// Supported API versions: 0
304    pub endpoints: Vec<Endpoint>,
305
306    /// The range of versions of the protocol that the replica supports
307    ///
308    /// Supported API versions: 0
309    pub k_raft_version_feature: KRaftVersionFeature,
310
311    /// Other tagged fields
312    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
313}
314
315impl Voter {
316    /// Sets `voter_id` to the passed value.
317    ///
318    /// The replica id of the voter in the topic partition
319    ///
320    /// Supported API versions: 0
321    pub fn with_voter_id(mut self, value: super::BrokerId) -> Self {
322        self.voter_id = value;
323        self
324    }
325    /// Sets `voter_directory_id` to the passed value.
326    ///
327    /// The directory id of the voter in the topic partition
328    ///
329    /// Supported API versions: 0
330    pub fn with_voter_directory_id(mut self, value: Uuid) -> Self {
331        self.voter_directory_id = value;
332        self
333    }
334    /// Sets `endpoints` to the passed value.
335    ///
336    /// The endpoint that can be used to communicate with the voter
337    ///
338    /// Supported API versions: 0
339    pub fn with_endpoints(mut self, value: Vec<Endpoint>) -> Self {
340        self.endpoints = value;
341        self
342    }
343    /// Sets `k_raft_version_feature` to the passed value.
344    ///
345    /// The range of versions of the protocol that the replica supports
346    ///
347    /// Supported API versions: 0
348    pub fn with_k_raft_version_feature(mut self, value: KRaftVersionFeature) -> Self {
349        self.k_raft_version_feature = value;
350        self
351    }
352    /// Sets unknown_tagged_fields to the passed value.
353    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
354        self.unknown_tagged_fields = value;
355        self
356    }
357    /// Inserts an entry into unknown_tagged_fields.
358    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
359        self.unknown_tagged_fields.insert(key, value);
360        self
361    }
362}
363
364impl Encodable for Voter {
365    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
366        if version != 0 {
367            bail!("specified version not supported by this message type");
368        }
369        types::Int32.encode(buf, &self.voter_id)?;
370        types::Uuid.encode(buf, &self.voter_directory_id)?;
371        types::CompactArray(types::Struct { version }).encode(buf, &self.endpoints)?;
372        types::Struct { version }.encode(buf, &self.k_raft_version_feature)?;
373        let num_tagged_fields = self.unknown_tagged_fields.len();
374        if num_tagged_fields > std::u32::MAX as usize {
375            bail!(
376                "Too many tagged fields to encode ({} fields)",
377                num_tagged_fields
378            );
379        }
380        types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
381
382        write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
383        Ok(())
384    }
385    fn compute_size(&self, version: i16) -> Result<usize> {
386        let mut total_size = 0;
387        total_size += types::Int32.compute_size(&self.voter_id)?;
388        total_size += types::Uuid.compute_size(&self.voter_directory_id)?;
389        total_size +=
390            types::CompactArray(types::Struct { version }).compute_size(&self.endpoints)?;
391        total_size += types::Struct { version }.compute_size(&self.k_raft_version_feature)?;
392        let num_tagged_fields = self.unknown_tagged_fields.len();
393        if num_tagged_fields > std::u32::MAX as usize {
394            bail!(
395                "Too many tagged fields to encode ({} fields)",
396                num_tagged_fields
397            );
398        }
399        total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
400
401        total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
402        Ok(total_size)
403    }
404}
405
406impl Decodable for Voter {
407    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
408        if version != 0 {
409            bail!("specified version not supported by this message type");
410        }
411        let voter_id = types::Int32.decode(buf)?;
412        let voter_directory_id = types::Uuid.decode(buf)?;
413        let endpoints = types::CompactArray(types::Struct { version }).decode(buf)?;
414        let k_raft_version_feature = types::Struct { version }.decode(buf)?;
415        let mut unknown_tagged_fields = BTreeMap::new();
416        let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
417        for _ in 0..num_tagged_fields {
418            let tag: u32 = types::UnsignedVarInt.decode(buf)?;
419            let size: u32 = types::UnsignedVarInt.decode(buf)?;
420            let unknown_value = buf.try_get_bytes(size as usize)?;
421            unknown_tagged_fields.insert(tag as i32, unknown_value);
422        }
423        Ok(Self {
424            voter_id,
425            voter_directory_id,
426            endpoints,
427            k_raft_version_feature,
428            unknown_tagged_fields,
429        })
430    }
431}
432
433impl Default for Voter {
434    fn default() -> Self {
435        Self {
436            voter_id: (0).into(),
437            voter_directory_id: Uuid::nil(),
438            endpoints: Default::default(),
439            k_raft_version_feature: Default::default(),
440            unknown_tagged_fields: BTreeMap::new(),
441        }
442    }
443}
444
445impl Message for Voter {
446    const VERSIONS: VersionRange = VersionRange { min: 0, max: 0 };
447    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
448}
449
450/// Valid versions: 0
451#[non_exhaustive]
452#[derive(Debug, Clone, PartialEq)]
453pub struct VotersRecord {
454    /// The version of the voters record
455    ///
456    /// Supported API versions: 0
457    pub version: i16,
458
459    ///
460    ///
461    /// Supported API versions: 0
462    pub voters: Vec<Voter>,
463
464    /// Other tagged fields
465    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
466}
467
468impl VotersRecord {
469    /// Sets `version` to the passed value.
470    ///
471    /// The version of the voters record
472    ///
473    /// Supported API versions: 0
474    pub fn with_version(mut self, value: i16) -> Self {
475        self.version = value;
476        self
477    }
478    /// Sets `voters` to the passed value.
479    ///
480    ///
481    ///
482    /// Supported API versions: 0
483    pub fn with_voters(mut self, value: Vec<Voter>) -> Self {
484        self.voters = value;
485        self
486    }
487    /// Sets unknown_tagged_fields to the passed value.
488    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
489        self.unknown_tagged_fields = value;
490        self
491    }
492    /// Inserts an entry into unknown_tagged_fields.
493    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
494        self.unknown_tagged_fields.insert(key, value);
495        self
496    }
497}
498
499impl Encodable for VotersRecord {
500    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
501        if version != 0 {
502            bail!("specified version not supported by this message type");
503        }
504        types::Int16.encode(buf, &self.version)?;
505        types::CompactArray(types::Struct { version }).encode(buf, &self.voters)?;
506        let num_tagged_fields = self.unknown_tagged_fields.len();
507        if num_tagged_fields > std::u32::MAX as usize {
508            bail!(
509                "Too many tagged fields to encode ({} fields)",
510                num_tagged_fields
511            );
512        }
513        types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
514
515        write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
516        Ok(())
517    }
518    fn compute_size(&self, version: i16) -> Result<usize> {
519        let mut total_size = 0;
520        total_size += types::Int16.compute_size(&self.version)?;
521        total_size += types::CompactArray(types::Struct { version }).compute_size(&self.voters)?;
522        let num_tagged_fields = self.unknown_tagged_fields.len();
523        if num_tagged_fields > std::u32::MAX as usize {
524            bail!(
525                "Too many tagged fields to encode ({} fields)",
526                num_tagged_fields
527            );
528        }
529        total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
530
531        total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
532        Ok(total_size)
533    }
534}
535
536impl Decodable for VotersRecord {
537    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
538        if version != 0 {
539            bail!("specified version not supported by this message type");
540        }
541        let version = types::Int16.decode(buf)?;
542        let voters = types::CompactArray(types::Struct { version }).decode(buf)?;
543        let mut unknown_tagged_fields = BTreeMap::new();
544        let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
545        for _ in 0..num_tagged_fields {
546            let tag: u32 = types::UnsignedVarInt.decode(buf)?;
547            let size: u32 = types::UnsignedVarInt.decode(buf)?;
548            let unknown_value = buf.try_get_bytes(size as usize)?;
549            unknown_tagged_fields.insert(tag as i32, unknown_value);
550        }
551        Ok(Self {
552            version,
553            voters,
554            unknown_tagged_fields,
555        })
556    }
557}
558
559impl Default for VotersRecord {
560    fn default() -> Self {
561        Self {
562            version: 0,
563            voters: Default::default(),
564            unknown_tagged_fields: BTreeMap::new(),
565        }
566    }
567}
568
569impl Message for VotersRecord {
570    const VERSIONS: VersionRange = VersionRange { min: 0, max: 0 };
571    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
572}
kafka_protocol/messages/voters_record.rs

kafka_protocol/messages/
voters_record.rs
