kacrab_protocol/generated/
find_coordinator_response.rs

1//! Generated from FindCoordinatorResponse.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 FindCoordinatorResponseData {
17    /// The duration in milliseconds for which the request was throttled due to a quota violation,
18    /// or zero if the request did not violate any quota.
19    pub throttle_time_ms: i32,
20    /// The error code, or 0 if there was no error.
21    pub error_code: i16,
22    /// The error message, or null if there was no error.
23    pub error_message: Option<KafkaString>,
24    /// The node id.
25    pub node_id: i32,
26    /// The host name.
27    pub host: KafkaString,
28    /// The port.
29    pub port: i32,
30    /// Each coordinator result in the response.
31    pub coordinators: Vec<Coordinator>,
32    pub _unknown_tagged_fields: Vec<RawTaggedField>,
33}
34impl Default for FindCoordinatorResponseData {
35    fn default() -> Self {
36        Self {
37            throttle_time_ms: 0_i32,
38            error_code: 0_i16,
39            error_message: None,
40            node_id: 0_i32,
41            host: KafkaString::default(),
42            port: 0_i32,
43            coordinators: Vec::new(),
44            _unknown_tagged_fields: Vec::new(),
45        }
46    }
47}
48impl FindCoordinatorResponseData {
49    pub fn with_throttle_time_ms(mut self, value: i32) -> Self {
50        self.throttle_time_ms = value;
51        self
52    }
53    pub fn with_error_code(mut self, value: i16) -> Self {
54        self.error_code = value;
55        self
56    }
57    pub fn with_error_message(mut self, value: Option<KafkaString>) -> Self {
58        self.error_message = value;
59        self
60    }
61    pub fn with_node_id(mut self, value: i32) -> Self {
62        self.node_id = value;
63        self
64    }
65    pub fn with_host(mut self, value: KafkaString) -> Self {
66        self.host = value;
67        self
68    }
69    pub fn with_port(mut self, value: i32) -> Self {
70        self.port = value;
71        self
72    }
73    pub fn with_coordinators(mut self, value: Vec<Coordinator>) -> Self {
74        self.coordinators = value;
75        self
76    }
77    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
78        if version < 0 || version > 6 {
79            return Err(UnsupportedVersion::new(10, version).into());
80        }
81        let mut throttle_time_ms = 0_i32;
82        let mut error_code = 0_i16;
83        let mut error_message = None;
84        let mut node_id = 0_i32;
85        let mut host = KafkaString::default();
86        let mut port = 0_i32;
87        let mut coordinators = Vec::new();
88        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
89        if version >= 1 {
90            throttle_time_ms = read_i32(buf)?;
91        }
92        if version <= 3 {
93            error_code = read_i16(buf)?;
94        }
95        if version >= 1 && version <= 3 {
96            if version >= 3 {
97                error_message = read_compact_nullable_string(buf)?;
98            } else {
99                error_message = read_nullable_string(buf)?;
100            }
101        }
102        if version <= 3 {
103            node_id = read_i32(buf)?;
104        }
105        if version <= 3 {
106            if version >= 3 {
107                host = read_compact_string(buf)?;
108            } else {
109                host = read_string(buf)?;
110            }
111        }
112        if version <= 3 {
113            port = read_i32(buf)?;
114        }
115        if version >= 4 {
116            coordinators = {
117                let len = read_compact_array_length(buf)?;
118                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
119                for _ in 0..len {
120                    arr.push(Coordinator::read(buf, version)?);
121                }
122                arr
123            };
124        }
125        if version >= 3 {
126            let tagged_fields = read_tagged_fields(buf)?;
127            for field in &tagged_fields {
128                match field.tag {
129                    _ => {
130                        _unknown_tagged_fields.push(field.clone());
131                    },
132                }
133            }
134        }
135        Ok(Self {
136            throttle_time_ms,
137            error_code,
138            error_message,
139            node_id,
140            host,
141            port,
142            coordinators,
143            _unknown_tagged_fields,
144        })
145    }
146    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
147        if version < 0 || version > 6 {
148            return Err(UnsupportedVersion::new(10, version).into());
149        }
150        if version >= 1 {
151            write_i32(buf, self.throttle_time_ms);
152        } else if self.throttle_time_ms != 0_i32 {
153            return Err(UnsupportedFieldVersion::new(10, "throttle_time_ms", version).into());
154        }
155        if version <= 3 {
156            write_i16(buf, self.error_code);
157        } else if self.error_code != 0_i16 {
158            return Err(UnsupportedFieldVersion::new(10, "error_code", version).into());
159        }
160        if version >= 1 && version <= 3 {
161            if version >= 3 {
162                write_compact_nullable_string(buf, self.error_message.as_ref())?;
163            } else {
164                write_nullable_string(buf, self.error_message.as_ref())?;
165            }
166        } else if self.error_message != None {
167            return Err(UnsupportedFieldVersion::new(10, "error_message", version).into());
168        }
169        if version <= 3 {
170            write_i32(buf, self.node_id);
171        } else if self.node_id != 0_i32 {
172            return Err(UnsupportedFieldVersion::new(10, "node_id", version).into());
173        }
174        if version <= 3 {
175            if version >= 3 {
176                write_compact_string(buf, &self.host)?;
177            } else {
178                write_string(buf, &self.host)?;
179            }
180        } else if self.host != KafkaString::default() {
181            return Err(UnsupportedFieldVersion::new(10, "host", version).into());
182        }
183        if version <= 3 {
184            write_i32(buf, self.port);
185        } else if self.port != 0_i32 {
186            return Err(UnsupportedFieldVersion::new(10, "port", version).into());
187        }
188        if version >= 4 {
189            write_compact_array_length(buf, self.coordinators.len() as i32);
190            for el in &self.coordinators {
191                el.write(buf, version)?;
192            }
193        } else if self.coordinators != Vec::new() {
194            return Err(UnsupportedFieldVersion::new(10, "coordinators", version).into());
195        }
196        if version >= 3 {
197            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
198            all_tags.sort_by_key(|f| f.tag);
199            write_tagged_fields(buf, &all_tags)?;
200        }
201        Ok(())
202    }
203    pub fn encoded_len(&self, version: i16) -> Result<usize> {
204        if version < 0 || version > 6 {
205            return Err(UnsupportedVersion::new(10, version).into());
206        }
207        let mut len: usize = 0;
208        if version >= 1 {
209            len += 4;
210        } else if self.throttle_time_ms != 0_i32 {
211            return Err(UnsupportedFieldVersion::new(10, "throttle_time_ms", version).into());
212        }
213        if version <= 3 {
214            len += 2;
215        } else if self.error_code != 0_i16 {
216            return Err(UnsupportedFieldVersion::new(10, "error_code", version).into());
217        }
218        if version >= 1 && version <= 3 {
219            if version >= 3 {
220                len += compact_nullable_string_len(self.error_message.as_ref())?;
221            } else {
222                len += nullable_string_len(self.error_message.as_ref())?;
223            }
224        } else if self.error_message != None {
225            return Err(UnsupportedFieldVersion::new(10, "error_message", version).into());
226        }
227        if version <= 3 {
228            len += 4;
229        } else if self.node_id != 0_i32 {
230            return Err(UnsupportedFieldVersion::new(10, "node_id", version).into());
231        }
232        if version <= 3 {
233            if version >= 3 {
234                len += compact_string_len(&self.host)?;
235            } else {
236                len += string_len(&self.host)?;
237            }
238        } else if self.host != KafkaString::default() {
239            return Err(UnsupportedFieldVersion::new(10, "host", version).into());
240        }
241        if version <= 3 {
242            len += 4;
243        } else if self.port != 0_i32 {
244            return Err(UnsupportedFieldVersion::new(10, "port", version).into());
245        }
246        if version >= 4 {
247            len += compact_array_length_len(self.coordinators.len() as i32);
248            for el in &self.coordinators {
249                len += el.encoded_len(version)?;
250            }
251        } else if self.coordinators != Vec::new() {
252            return Err(UnsupportedFieldVersion::new(10, "coordinators", version).into());
253        }
254        if version >= 3 {
255            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
256            all_tags.sort_by_key(|f| f.tag);
257            len += tagged_fields_len(&all_tags)?;
258        }
259        Ok(len)
260    }
261}
262#[derive(Debug, Clone, PartialEq)]
263pub struct Coordinator {
264    /// The coordinator key.
265    pub key: KafkaString,
266    /// The node id.
267    pub node_id: i32,
268    /// The host name.
269    pub host: KafkaString,
270    /// The port.
271    pub port: i32,
272    /// The error code, or 0 if there was no error.
273    pub error_code: i16,
274    /// The error message, or null if there was no error.
275    pub error_message: Option<KafkaString>,
276    pub _unknown_tagged_fields: Vec<RawTaggedField>,
277}
278impl Default for Coordinator {
279    fn default() -> Self {
280        Self {
281            key: KafkaString::default(),
282            node_id: 0_i32,
283            host: KafkaString::default(),
284            port: 0_i32,
285            error_code: 0_i16,
286            error_message: None,
287            _unknown_tagged_fields: Vec::new(),
288        }
289    }
290}
291impl Coordinator {
292    pub fn with_key(mut self, value: KafkaString) -> Self {
293        self.key = value;
294        self
295    }
296    pub fn with_node_id(mut self, value: i32) -> Self {
297        self.node_id = value;
298        self
299    }
300    pub fn with_host(mut self, value: KafkaString) -> Self {
301        self.host = value;
302        self
303    }
304    pub fn with_port(mut self, value: i32) -> Self {
305        self.port = value;
306        self
307    }
308    pub fn with_error_code(mut self, value: i16) -> Self {
309        self.error_code = value;
310        self
311    }
312    pub fn with_error_message(mut self, value: Option<KafkaString>) -> Self {
313        self.error_message = value;
314        self
315    }
316    pub fn read(buf: &mut Bytes, _version: i16) -> Result<Self> {
317        let key;
318        let node_id;
319        let host;
320        let port;
321        let error_code;
322        let error_message;
323        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
324        key = read_compact_string(buf)?;
325        node_id = read_i32(buf)?;
326        host = read_compact_string(buf)?;
327        port = read_i32(buf)?;
328        error_code = read_i16(buf)?;
329        error_message = read_compact_nullable_string(buf)?;
330        let tagged_fields = read_tagged_fields(buf)?;
331        for field in &tagged_fields {
332            match field.tag {
333                _ => {
334                    _unknown_tagged_fields.push(field.clone());
335                },
336            }
337        }
338        Ok(Self {
339            key,
340            node_id,
341            host,
342            port,
343            error_code,
344            error_message,
345            _unknown_tagged_fields,
346        })
347    }
348    pub fn write(&self, buf: &mut BytesMut, _version: i16) -> Result<()> {
349        write_compact_string(buf, &self.key)?;
350        write_i32(buf, self.node_id);
351        write_compact_string(buf, &self.host)?;
352        write_i32(buf, self.port);
353        write_i16(buf, self.error_code);
354        write_compact_nullable_string(buf, self.error_message.as_ref())?;
355        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
356        all_tags.sort_by_key(|f| f.tag);
357        write_tagged_fields(buf, &all_tags)?;
358        Ok(())
359    }
360    pub fn encoded_len(&self, _version: i16) -> Result<usize> {
361        let mut len: usize = 0;
362        len += compact_string_len(&self.key)?;
363        len += 4;
364        len += compact_string_len(&self.host)?;
365        len += 4;
366        len += 2;
367        len += compact_nullable_string_len(self.error_message.as_ref())?;
368        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
369        all_tags.sort_by_key(|f| f.tag);
370        len += tagged_fields_len(&all_tags)?;
371        Ok(len)
372    }
373}
kacrab_protocol/generated/find_coordinator_response.rs

kacrab_protocol/generated/
find_coordinator_response.rs
