kacrab_protocol/generated/
list_offsets_response.rs

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

kacrab_protocol/generated/
list_offsets_response.rs
