kacrab_protocol/generated/
offset_fetch_response.rs

1//! Generated from OffsetFetchResponse.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 OffsetFetchResponseData {
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 responses per topic.
21    pub topics: Vec<OffsetFetchResponseTopic>,
22    /// The top-level error code, or 0 if there was no error.
23    pub error_code: i16,
24    /// The responses per group id.
25    pub groups: Vec<OffsetFetchResponseGroup>,
26    pub _unknown_tagged_fields: Vec<RawTaggedField>,
27}
28impl Default for OffsetFetchResponseData {
29    fn default() -> Self {
30        Self {
31            throttle_time_ms: 0_i32,
32            topics: Vec::new(),
33            error_code: 0i16,
34            groups: Vec::new(),
35            _unknown_tagged_fields: Vec::new(),
36        }
37    }
38}
39impl OffsetFetchResponseData {
40    pub fn with_throttle_time_ms(mut self, value: i32) -> Self {
41        self.throttle_time_ms = value;
42        self
43    }
44    pub fn with_topics(mut self, value: Vec<OffsetFetchResponseTopic>) -> Self {
45        self.topics = value;
46        self
47    }
48    pub fn with_error_code(mut self, value: i16) -> Self {
49        self.error_code = value;
50        self
51    }
52    pub fn with_groups(mut self, value: Vec<OffsetFetchResponseGroup>) -> Self {
53        self.groups = value;
54        self
55    }
56    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
57        if version < 1 || version > 10 {
58            return Err(UnsupportedVersion::new(9, version).into());
59        }
60        let mut throttle_time_ms = 0_i32;
61        let mut topics = Vec::new();
62        let mut error_code = 0i16;
63        let mut groups = Vec::new();
64        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
65        if version >= 3 {
66            throttle_time_ms = read_i32(buf)?;
67        }
68        if version <= 7 {
69            if version >= 6 {
70                topics = {
71                    let len = read_compact_array_length(buf)?;
72                    let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
73                    for _ in 0..len {
74                        arr.push(OffsetFetchResponseTopic::read(buf, version)?);
75                    }
76                    arr
77                };
78            } else {
79                topics = {
80                    let len = read_array_length(buf)?;
81                    let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
82                    for _ in 0..len {
83                        arr.push(OffsetFetchResponseTopic::read(buf, version)?);
84                    }
85                    arr
86                };
87            }
88        }
89        if version >= 2 && version <= 7 {
90            error_code = read_i16(buf)?;
91        }
92        if version >= 8 {
93            groups = {
94                let len = read_compact_array_length(buf)?;
95                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
96                for _ in 0..len {
97                    arr.push(OffsetFetchResponseGroup::read(buf, version)?);
98                }
99                arr
100            };
101        }
102        if version >= 6 {
103            let tagged_fields = read_tagged_fields(buf)?;
104            for field in &tagged_fields {
105                match field.tag {
106                    _ => {
107                        _unknown_tagged_fields.push(field.clone());
108                    },
109                }
110            }
111        }
112        Ok(Self {
113            throttle_time_ms,
114            topics,
115            error_code,
116            groups,
117            _unknown_tagged_fields,
118        })
119    }
120    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
121        if version < 1 || version > 10 {
122            return Err(UnsupportedVersion::new(9, version).into());
123        }
124        if version >= 3 {
125            write_i32(buf, self.throttle_time_ms);
126        } else if self.throttle_time_ms != 0_i32 {
127            return Err(UnsupportedFieldVersion::new(9, "throttle_time_ms", version).into());
128        }
129        if version <= 7 {
130            if version >= 6 {
131                write_compact_array_length(buf, self.topics.len() as i32);
132                for el in &self.topics {
133                    el.write(buf, version)?;
134                }
135            } else {
136                write_array_length(buf, self.topics.len() as i32);
137                for el in &self.topics {
138                    el.write(buf, version)?;
139                }
140            }
141        } else if self.topics != Vec::new() {
142            return Err(UnsupportedFieldVersion::new(9, "topics", version).into());
143        }
144        if version >= 2 && version <= 7 {
145            write_i16(buf, self.error_code);
146        } else if self.error_code != 0i16 {
147            return Err(UnsupportedFieldVersion::new(9, "error_code", version).into());
148        }
149        if version >= 8 {
150            write_compact_array_length(buf, self.groups.len() as i32);
151            for el in &self.groups {
152                el.write(buf, version)?;
153            }
154        } else if self.groups != Vec::new() {
155            return Err(UnsupportedFieldVersion::new(9, "groups", version).into());
156        }
157        if version >= 6 {
158            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
159            all_tags.sort_by_key(|f| f.tag);
160            write_tagged_fields(buf, &all_tags)?;
161        }
162        Ok(())
163    }
164    pub fn encoded_len(&self, version: i16) -> Result<usize> {
165        if version < 1 || version > 10 {
166            return Err(UnsupportedVersion::new(9, version).into());
167        }
168        let mut len: usize = 0;
169        if version >= 3 {
170            len += 4;
171        } else if self.throttle_time_ms != 0_i32 {
172            return Err(UnsupportedFieldVersion::new(9, "throttle_time_ms", version).into());
173        }
174        if version <= 7 {
175            if version >= 6 {
176                len += compact_array_length_len(self.topics.len() as i32);
177                for el in &self.topics {
178                    len += el.encoded_len(version)?;
179                }
180            } else {
181                len += array_length_len();
182                for el in &self.topics {
183                    len += el.encoded_len(version)?;
184                }
185            }
186        } else if self.topics != Vec::new() {
187            return Err(UnsupportedFieldVersion::new(9, "topics", version).into());
188        }
189        if version >= 2 && version <= 7 {
190            len += 2;
191        } else if self.error_code != 0i16 {
192            return Err(UnsupportedFieldVersion::new(9, "error_code", version).into());
193        }
194        if version >= 8 {
195            len += compact_array_length_len(self.groups.len() as i32);
196            for el in &self.groups {
197                len += el.encoded_len(version)?;
198            }
199        } else if self.groups != Vec::new() {
200            return Err(UnsupportedFieldVersion::new(9, "groups", version).into());
201        }
202        if version >= 6 {
203            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
204            all_tags.sort_by_key(|f| f.tag);
205            len += tagged_fields_len(&all_tags)?;
206        }
207        Ok(len)
208    }
209}
210#[derive(Debug, Clone, PartialEq)]
211pub struct OffsetFetchResponseTopic {
212    /// The topic name.
213    pub name: KafkaString,
214    /// The responses per partition.
215    pub partitions: Vec<OffsetFetchResponsePartition>,
216    pub _unknown_tagged_fields: Vec<RawTaggedField>,
217}
218impl Default for OffsetFetchResponseTopic {
219    fn default() -> Self {
220        Self {
221            name: KafkaString::default(),
222            partitions: Vec::new(),
223            _unknown_tagged_fields: Vec::new(),
224        }
225    }
226}
227impl OffsetFetchResponseTopic {
228    pub fn with_name(mut self, value: KafkaString) -> Self {
229        self.name = value;
230        self
231    }
232    pub fn with_partitions(mut self, value: Vec<OffsetFetchResponsePartition>) -> Self {
233        self.partitions = value;
234        self
235    }
236    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
237        let name;
238        let partitions;
239        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
240        if version >= 6 {
241            name = read_compact_string(buf)?;
242        } else {
243            name = read_string(buf)?;
244        }
245        if version >= 6 {
246            partitions = {
247                let len = read_compact_array_length(buf)?;
248                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
249                for _ in 0..len {
250                    arr.push(OffsetFetchResponsePartition::read(buf, version)?);
251                }
252                arr
253            };
254        } else {
255            partitions = {
256                let len = read_array_length(buf)?;
257                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
258                for _ in 0..len {
259                    arr.push(OffsetFetchResponsePartition::read(buf, version)?);
260                }
261                arr
262            };
263        }
264        if version >= 6 {
265            let tagged_fields = read_tagged_fields(buf)?;
266            for field in &tagged_fields {
267                match field.tag {
268                    _ => {
269                        _unknown_tagged_fields.push(field.clone());
270                    },
271                }
272            }
273        }
274        Ok(Self {
275            name,
276            partitions,
277            _unknown_tagged_fields,
278        })
279    }
280    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
281        if version >= 6 {
282            write_compact_string(buf, &self.name)?;
283        } else {
284            write_string(buf, &self.name)?;
285        }
286        if version >= 6 {
287            write_compact_array_length(buf, self.partitions.len() as i32);
288            for el in &self.partitions {
289                el.write(buf, version)?;
290            }
291        } else {
292            write_array_length(buf, self.partitions.len() as i32);
293            for el in &self.partitions {
294                el.write(buf, version)?;
295            }
296        }
297        if version >= 6 {
298            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
299            all_tags.sort_by_key(|f| f.tag);
300            write_tagged_fields(buf, &all_tags)?;
301        }
302        Ok(())
303    }
304    pub fn encoded_len(&self, version: i16) -> Result<usize> {
305        let mut len: usize = 0;
306        if version >= 6 {
307            len += compact_string_len(&self.name)?;
308        } else {
309            len += string_len(&self.name)?;
310        }
311        if version >= 6 {
312            len += compact_array_length_len(self.partitions.len() as i32);
313            for el in &self.partitions {
314                len += el.encoded_len(version)?;
315            }
316        } else {
317            len += array_length_len();
318            for el in &self.partitions {
319                len += el.encoded_len(version)?;
320            }
321        }
322        if version >= 6 {
323            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
324            all_tags.sort_by_key(|f| f.tag);
325            len += tagged_fields_len(&all_tags)?;
326        }
327        Ok(len)
328    }
329}
330#[derive(Debug, Clone, PartialEq)]
331pub struct OffsetFetchResponsePartition {
332    /// The partition index.
333    pub partition_index: i32,
334    /// The committed message offset.
335    pub committed_offset: i64,
336    /// The leader epoch.
337    pub committed_leader_epoch: i32,
338    /// The partition metadata.
339    pub metadata: Option<KafkaString>,
340    /// The error code, or 0 if there was no error.
341    pub error_code: i16,
342    pub _unknown_tagged_fields: Vec<RawTaggedField>,
343}
344impl Default for OffsetFetchResponsePartition {
345    fn default() -> Self {
346        Self {
347            partition_index: 0_i32,
348            committed_offset: 0_i64,
349            committed_leader_epoch: -1i32,
350            metadata: None,
351            error_code: 0_i16,
352            _unknown_tagged_fields: Vec::new(),
353        }
354    }
355}
356impl OffsetFetchResponsePartition {
357    pub fn with_partition_index(mut self, value: i32) -> Self {
358        self.partition_index = value;
359        self
360    }
361    pub fn with_committed_offset(mut self, value: i64) -> Self {
362        self.committed_offset = value;
363        self
364    }
365    pub fn with_committed_leader_epoch(mut self, value: i32) -> Self {
366        self.committed_leader_epoch = value;
367        self
368    }
369    pub fn with_metadata(mut self, value: Option<KafkaString>) -> Self {
370        self.metadata = value;
371        self
372    }
373    pub fn with_error_code(mut self, value: i16) -> Self {
374        self.error_code = value;
375        self
376    }
377    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
378        let partition_index;
379        let committed_offset;
380        let mut committed_leader_epoch = -1i32;
381        let metadata;
382        let error_code;
383        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
384        partition_index = read_i32(buf)?;
385        committed_offset = read_i64(buf)?;
386        if version >= 5 {
387            committed_leader_epoch = read_i32(buf)?;
388        }
389        if version >= 6 {
390            metadata = read_compact_nullable_string(buf)?;
391        } else {
392            metadata = read_nullable_string(buf)?;
393        }
394        error_code = read_i16(buf)?;
395        if version >= 6 {
396            let tagged_fields = read_tagged_fields(buf)?;
397            for field in &tagged_fields {
398                match field.tag {
399                    _ => {
400                        _unknown_tagged_fields.push(field.clone());
401                    },
402                }
403            }
404        }
405        Ok(Self {
406            partition_index,
407            committed_offset,
408            committed_leader_epoch,
409            metadata,
410            error_code,
411            _unknown_tagged_fields,
412        })
413    }
414    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
415        write_i32(buf, self.partition_index);
416        write_i64(buf, self.committed_offset);
417        if version >= 5 {
418            write_i32(buf, self.committed_leader_epoch);
419        } else if self.committed_leader_epoch != -1i32 {
420            return Err(UnsupportedFieldVersion::new(9, "committed_leader_epoch", version).into());
421        }
422        if version >= 6 {
423            write_compact_nullable_string(buf, self.metadata.as_ref())?;
424        } else {
425            write_nullable_string(buf, self.metadata.as_ref())?;
426        }
427        write_i16(buf, self.error_code);
428        if version >= 6 {
429            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
430            all_tags.sort_by_key(|f| f.tag);
431            write_tagged_fields(buf, &all_tags)?;
432        }
433        Ok(())
434    }
435    pub fn encoded_len(&self, version: i16) -> Result<usize> {
436        let mut len: usize = 0;
437        len += 4;
438        len += 8;
439        if version >= 5 {
440            len += 4;
441        } else if self.committed_leader_epoch != -1i32 {
442            return Err(UnsupportedFieldVersion::new(9, "committed_leader_epoch", version).into());
443        }
444        if version >= 6 {
445            len += compact_nullable_string_len(self.metadata.as_ref())?;
446        } else {
447            len += nullable_string_len(self.metadata.as_ref())?;
448        }
449        len += 2;
450        if version >= 6 {
451            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
452            all_tags.sort_by_key(|f| f.tag);
453            len += tagged_fields_len(&all_tags)?;
454        }
455        Ok(len)
456    }
457}
458#[derive(Debug, Clone, PartialEq)]
459pub struct OffsetFetchResponseGroup {
460    /// The group ID.
461    pub group_id: KafkaString,
462    /// The responses per topic.
463    pub topics: Vec<OffsetFetchResponseTopics>,
464    /// The group-level error code, or 0 if there was no error.
465    pub error_code: i16,
466    pub _unknown_tagged_fields: Vec<RawTaggedField>,
467}
468impl Default for OffsetFetchResponseGroup {
469    fn default() -> Self {
470        Self {
471            group_id: KafkaString::default(),
472            topics: Vec::new(),
473            error_code: 0i16,
474            _unknown_tagged_fields: Vec::new(),
475        }
476    }
477}
478impl OffsetFetchResponseGroup {
479    pub fn with_group_id(mut self, value: KafkaString) -> Self {
480        self.group_id = value;
481        self
482    }
483    pub fn with_topics(mut self, value: Vec<OffsetFetchResponseTopics>) -> Self {
484        self.topics = value;
485        self
486    }
487    pub fn with_error_code(mut self, value: i16) -> Self {
488        self.error_code = value;
489        self
490    }
491    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
492        let group_id;
493        let topics;
494        let error_code;
495        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
496        group_id = read_compact_string(buf)?;
497        topics = {
498            let len = read_compact_array_length(buf)?;
499            let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
500            for _ in 0..len {
501                arr.push(OffsetFetchResponseTopics::read(buf, version)?);
502            }
503            arr
504        };
505        error_code = read_i16(buf)?;
506        let tagged_fields = read_tagged_fields(buf)?;
507        for field in &tagged_fields {
508            match field.tag {
509                _ => {
510                    _unknown_tagged_fields.push(field.clone());
511                },
512            }
513        }
514        Ok(Self {
515            group_id,
516            topics,
517            error_code,
518            _unknown_tagged_fields,
519        })
520    }
521    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
522        write_compact_string(buf, &self.group_id)?;
523        write_compact_array_length(buf, self.topics.len() as i32);
524        for el in &self.topics {
525            el.write(buf, version)?;
526        }
527        write_i16(buf, self.error_code);
528        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
529        all_tags.sort_by_key(|f| f.tag);
530        write_tagged_fields(buf, &all_tags)?;
531        Ok(())
532    }
533    pub fn encoded_len(&self, version: i16) -> Result<usize> {
534        let mut len: usize = 0;
535        len += compact_string_len(&self.group_id)?;
536        len += compact_array_length_len(self.topics.len() as i32);
537        for el in &self.topics {
538            len += el.encoded_len(version)?;
539        }
540        len += 2;
541        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
542        all_tags.sort_by_key(|f| f.tag);
543        len += tagged_fields_len(&all_tags)?;
544        Ok(len)
545    }
546}
547#[derive(Debug, Clone, PartialEq)]
548pub struct OffsetFetchResponseTopics {
549    /// The topic name.
550    pub name: KafkaString,
551    /// The topic ID.
552    pub topic_id: KafkaUuid,
553    /// The responses per partition.
554    pub partitions: Vec<OffsetFetchResponsePartitions>,
555    pub _unknown_tagged_fields: Vec<RawTaggedField>,
556}
557impl Default for OffsetFetchResponseTopics {
558    fn default() -> Self {
559        Self {
560            name: KafkaString::default(),
561            topic_id: KafkaUuid::ZERO,
562            partitions: Vec::new(),
563            _unknown_tagged_fields: Vec::new(),
564        }
565    }
566}
567impl OffsetFetchResponseTopics {
568    pub fn with_name(mut self, value: KafkaString) -> Self {
569        self.name = value;
570        self
571    }
572    pub fn with_topic_id(mut self, value: KafkaUuid) -> Self {
573        self.topic_id = value;
574        self
575    }
576    pub fn with_partitions(mut self, value: Vec<OffsetFetchResponsePartitions>) -> Self {
577        self.partitions = value;
578        self
579    }
580    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
581        let mut name = KafkaString::default();
582        let mut topic_id = KafkaUuid::ZERO;
583        let partitions;
584        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
585        if version <= 9 {
586            name = read_compact_string(buf)?;
587        }
588        if version >= 10 {
589            topic_id = read_uuid(buf)?;
590        }
591        partitions = {
592            let len = read_compact_array_length(buf)?;
593            let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
594            for _ in 0..len {
595                arr.push(OffsetFetchResponsePartitions::read(buf, version)?);
596            }
597            arr
598        };
599        let tagged_fields = read_tagged_fields(buf)?;
600        for field in &tagged_fields {
601            match field.tag {
602                _ => {
603                    _unknown_tagged_fields.push(field.clone());
604                },
605            }
606        }
607        Ok(Self {
608            name,
609            topic_id,
610            partitions,
611            _unknown_tagged_fields,
612        })
613    }
614    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
615        if version <= 9 {
616            write_compact_string(buf, &self.name)?;
617        } else if self.name != KafkaString::default() {
618            return Err(UnsupportedFieldVersion::new(9, "name", version).into());
619        }
620        if version >= 10 {
621            write_uuid(buf, &self.topic_id);
622        } else if self.topic_id != KafkaUuid::ZERO {
623            return Err(UnsupportedFieldVersion::new(9, "topic_id", version).into());
624        }
625        write_compact_array_length(buf, self.partitions.len() as i32);
626        for el in &self.partitions {
627            el.write(buf, version)?;
628        }
629        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
630        all_tags.sort_by_key(|f| f.tag);
631        write_tagged_fields(buf, &all_tags)?;
632        Ok(())
633    }
634    pub fn encoded_len(&self, version: i16) -> Result<usize> {
635        let mut len: usize = 0;
636        if version <= 9 {
637            len += compact_string_len(&self.name)?;
638        } else if self.name != KafkaString::default() {
639            return Err(UnsupportedFieldVersion::new(9, "name", version).into());
640        }
641        if version >= 10 {
642            len += 16;
643        } else if self.topic_id != KafkaUuid::ZERO {
644            return Err(UnsupportedFieldVersion::new(9, "topic_id", version).into());
645        }
646        len += compact_array_length_len(self.partitions.len() as i32);
647        for el in &self.partitions {
648            len += el.encoded_len(version)?;
649        }
650        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
651        all_tags.sort_by_key(|f| f.tag);
652        len += tagged_fields_len(&all_tags)?;
653        Ok(len)
654    }
655}
656#[derive(Debug, Clone, PartialEq)]
657pub struct OffsetFetchResponsePartitions {
658    /// The partition index.
659    pub partition_index: i32,
660    /// The committed message offset.
661    pub committed_offset: i64,
662    /// The leader epoch.
663    pub committed_leader_epoch: i32,
664    /// The partition metadata.
665    pub metadata: Option<KafkaString>,
666    /// The partition-level error code, or 0 if there was no error.
667    pub error_code: i16,
668    pub _unknown_tagged_fields: Vec<RawTaggedField>,
669}
670impl Default for OffsetFetchResponsePartitions {
671    fn default() -> Self {
672        Self {
673            partition_index: 0_i32,
674            committed_offset: 0_i64,
675            committed_leader_epoch: -1i32,
676            metadata: None,
677            error_code: 0_i16,
678            _unknown_tagged_fields: Vec::new(),
679        }
680    }
681}
682impl OffsetFetchResponsePartitions {
683    pub fn with_partition_index(mut self, value: i32) -> Self {
684        self.partition_index = value;
685        self
686    }
687    pub fn with_committed_offset(mut self, value: i64) -> Self {
688        self.committed_offset = value;
689        self
690    }
691    pub fn with_committed_leader_epoch(mut self, value: i32) -> Self {
692        self.committed_leader_epoch = value;
693        self
694    }
695    pub fn with_metadata(mut self, value: Option<KafkaString>) -> Self {
696        self.metadata = value;
697        self
698    }
699    pub fn with_error_code(mut self, value: i16) -> Self {
700        self.error_code = value;
701        self
702    }
703    pub fn read(buf: &mut Bytes, _version: i16) -> Result<Self> {
704        let partition_index;
705        let committed_offset;
706        let committed_leader_epoch;
707        let metadata;
708        let error_code;
709        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
710        partition_index = read_i32(buf)?;
711        committed_offset = read_i64(buf)?;
712        committed_leader_epoch = read_i32(buf)?;
713        metadata = read_compact_nullable_string(buf)?;
714        error_code = read_i16(buf)?;
715        let tagged_fields = read_tagged_fields(buf)?;
716        for field in &tagged_fields {
717            match field.tag {
718                _ => {
719                    _unknown_tagged_fields.push(field.clone());
720                },
721            }
722        }
723        Ok(Self {
724            partition_index,
725            committed_offset,
726            committed_leader_epoch,
727            metadata,
728            error_code,
729            _unknown_tagged_fields,
730        })
731    }
732    pub fn write(&self, buf: &mut BytesMut, _version: i16) -> Result<()> {
733        write_i32(buf, self.partition_index);
734        write_i64(buf, self.committed_offset);
735        write_i32(buf, self.committed_leader_epoch);
736        write_compact_nullable_string(buf, self.metadata.as_ref())?;
737        write_i16(buf, self.error_code);
738        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
739        all_tags.sort_by_key(|f| f.tag);
740        write_tagged_fields(buf, &all_tags)?;
741        Ok(())
742    }
743    pub fn encoded_len(&self, _version: i16) -> Result<usize> {
744        let mut len: usize = 0;
745        len += 4;
746        len += 8;
747        len += 4;
748        len += compact_nullable_string_len(self.metadata.as_ref())?;
749        len += 2;
750        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
751        all_tags.sort_by_key(|f| f.tag);
752        len += tagged_fields_len(&all_tags)?;
753        Ok(len)
754    }
755}
kacrab_protocol/generated/offset_fetch_response.rs

kacrab_protocol/generated/
offset_fetch_response.rs
