kacrab_protocol/generated/
read_share_group_state_response.rs

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

kacrab_protocol/generated/
read_share_group_state_response.rs
