krabka_protocol/opt/rustwide/workdir/generated/
ProduceResponse.owned.rs

1// AUTO-GENERATED by krabka-protocol-codegen against a9ce3221537b8653448750697915607dc7936cf3. Do not edit.
2
3use bytes::{Buf, BufMut};
4
5use crate::{
6    Decode, Encode, ProtocolError, UnknownTaggedFields,
7    codegen_helpers::is_default,
8    primitives::{
9        array::{array_len_prefix_len, get_array_len, put_array_len},
10        fixed::{get_i16, get_i32, get_i64, put_i16, put_i32, put_i64},
11        string_bytes::{
12            compact_nullable_string_len, compact_string_len, get_compact_nullable_string_owned,
13            get_compact_string_owned, get_nullable_string_owned, get_string_owned,
14            nullable_string_len, put_compact_nullable_string, put_compact_string,
15            put_nullable_string, put_string, string_len,
16        },
17        uuid::{Uuid, get_uuid, put_uuid},
18    },
19    tagged_fields::{WriteTaggedFields, encode_to_bytes, read_tagged_fields, tagged_fields_len},
20};
21pub const API_KEY: i16 = 0;
22pub const MIN_VERSION: i16 = 3;
23pub const MAX_VERSION: i16 = 13;
24pub const FLEXIBLE_MIN: i16 = 9;
25#[inline]
26#[must_use]
27pub fn is_flexible(version: i16) -> bool {
28    version >= FLEXIBLE_MIN
29}
30#[derive(Debug, Clone, PartialEq, Eq, Default)]
31pub struct ProduceResponse {
32    pub responses: Vec<TopicProduceResponse>,
33    pub throttle_time_ms: i32,
34    pub node_endpoints: Vec<NodeEndpoint>,
35    pub unknown_tagged_fields: UnknownTaggedFields,
36}
37impl Encode for ProduceResponse {
38    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
39        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
40            return Err(ProtocolError::UnsupportedVersion {
41                api_key: API_KEY,
42                version,
43            });
44        }
45        let flex = is_flexible(version);
46        if version >= 0 {
47            {
48                put_array_len(buf, (self.responses).len(), flex)?;
49                for it in &self.responses {
50                    it.encode(buf, version)?;
51                }
52            }
53        }
54        if version >= 1 {
55            put_i32(buf, self.throttle_time_ms);
56        }
57        if flex {
58            let mut tagged = WriteTaggedFields::new();
59            if version >= 10 && !(is_default(&self.node_endpoints)) {
60                let payload = encode_to_bytes(
61                    {
62                        let prefix = array_len_prefix_len((self.node_endpoints).len(), flex);
63                        let body: usize = (self.node_endpoints)
64                            .iter()
65                            .map(|it| it.encoded_len(version))
66                            .sum();
67                        prefix + body
68                    },
69                    |b| {
70                        {
71                            put_array_len(b, (self.node_endpoints).len(), flex)?;
72                            for it in &self.node_endpoints {
73                                it.encode(b, version)?;
74                            }
75                        }
76                        Ok(())
77                    },
78                )?;
79                tagged.add(0, payload);
80            }
81            tagged.write(buf, &self.unknown_tagged_fields)?;
82        }
83        Ok(())
84    }
85    fn encoded_len(&self, version: i16) -> usize {
86        let flex = is_flexible(version);
87        let mut n: usize = 0;
88        if version >= 0 {
89            n += {
90                let prefix = array_len_prefix_len((self.responses).len(), flex);
91                let body: usize = (self.responses)
92                    .iter()
93                    .map(|it| it.encoded_len(version))
94                    .sum();
95                prefix + body
96            };
97        }
98        if version >= 1 {
99            n += 4;
100        }
101        if flex {
102            let mut known_pairs: Vec<(u32, usize)> = Vec::new();
103            if version >= 10 && !(is_default(&self.node_endpoints)) {
104                known_pairs.push((0, {
105                    let prefix = array_len_prefix_len((self.node_endpoints).len(), flex);
106                    let body: usize = (self.node_endpoints)
107                        .iter()
108                        .map(|it| it.encoded_len(version))
109                        .sum();
110                    prefix + body
111                }));
112            }
113            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
114        }
115        n
116    }
117}
118impl Decode<'_> for ProduceResponse {
119    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
120        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
121            return Err(ProtocolError::UnsupportedVersion {
122                api_key: API_KEY,
123                version,
124            });
125        }
126        let flex = is_flexible(version);
127        let mut out = Self::default();
128        if version >= 0 {
129            out.responses = {
130                let n = get_array_len(buf, flex)?;
131                let mut v = Vec::with_capacity(n);
132                for _ in 0..n {
133                    v.push(TopicProduceResponse::decode(buf, version)?);
134                }
135                v
136            };
137        }
138        if version >= 1 {
139            out.throttle_time_ms = get_i32(buf)?;
140        }
141        if flex {
142            let mut tag_node_endpoints = None;
143            out.unknown_tagged_fields = read_tagged_fields(buf, |tag, payload| match tag {
144                0 if version >= 10 => {
145                    tag_node_endpoints = Some({
146                        let b: &mut &[u8] = payload;
147                        {
148                            let n = get_array_len(b, flex)?;
149                            let mut v = Vec::with_capacity(n);
150                            for _ in 0..n {
151                                v.push(NodeEndpoint::decode(b, version)?);
152                            }
153                            v
154                        }
155                    });
156                    Ok(true)
157                }
158                0 => Err(ProtocolError::TagNotValidForVersion { tag: 0, version }),
159                _ => Ok(false),
160            })?;
161            if let Some(v) = tag_node_endpoints {
162                out.node_endpoints = v;
163            }
164        }
165        Ok(out)
166    }
167}
168#[cfg(test)]
169impl ProduceResponse {
170    #[must_use]
171    pub fn populated(version: i16) -> Self {
172        let mut m = Self::default();
173        if version >= 0 {
174            m.responses = vec![TopicProduceResponse::populated(version)];
175        }
176        if version >= 1 {
177            m.throttle_time_ms = 1i32;
178        }
179        if version >= 10 {
180            m.node_endpoints = vec![NodeEndpoint::populated(version)];
181        }
182        m
183    }
184}
185#[derive(Debug, Clone, PartialEq, Eq, Default)]
186pub struct TopicProduceResponse {
187    pub name: String,
188    pub topic_id: Uuid,
189    pub partition_responses: Vec<PartitionProduceResponse>,
190    pub unknown_tagged_fields: UnknownTaggedFields,
191}
192impl Encode for TopicProduceResponse {
193    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
194        let flex = version >= 9;
195        if (0..=12).contains(&version) {
196            if flex {
197                put_compact_string(buf, &self.name)?;
198            } else {
199                put_string(buf, &self.name)?;
200            }
201        }
202        if version >= 13 {
203            put_uuid(buf, self.topic_id);
204        }
205        if version >= 0 {
206            {
207                put_array_len(buf, (self.partition_responses).len(), flex)?;
208                for it in &self.partition_responses {
209                    it.encode(buf, version)?;
210                }
211            }
212        }
213        if flex {
214            let tagged = WriteTaggedFields::new();
215            tagged.write(buf, &self.unknown_tagged_fields)?;
216        }
217        Ok(())
218    }
219    fn encoded_len(&self, version: i16) -> usize {
220        let flex = version >= 9;
221        let mut n: usize = 0;
222        if (0..=12).contains(&version) {
223            n += if flex {
224                compact_string_len(&self.name)
225            } else {
226                string_len(&self.name)
227            };
228        }
229        if version >= 13 {
230            n += 16;
231        }
232        if version >= 0 {
233            n += {
234                let prefix = array_len_prefix_len((self.partition_responses).len(), flex);
235                let body: usize = (self.partition_responses)
236                    .iter()
237                    .map(|it| it.encoded_len(version))
238                    .sum();
239                prefix + body
240            };
241        }
242        if flex {
243            let known_pairs: Vec<(u32, usize)> = Vec::new();
244            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
245        }
246        n
247    }
248}
249impl Decode<'_> for TopicProduceResponse {
250    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
251        let flex = version >= 9;
252        let mut out = Self::default();
253        if (0..=12).contains(&version) {
254            out.name = if flex {
255                get_compact_string_owned(buf)?
256            } else {
257                get_string_owned(buf)?
258            };
259        }
260        if version >= 13 {
261            out.topic_id = get_uuid(buf)?;
262        }
263        if version >= 0 {
264            out.partition_responses = {
265                let n = get_array_len(buf, flex)?;
266                let mut v = Vec::with_capacity(n);
267                for _ in 0..n {
268                    v.push(PartitionProduceResponse::decode(buf, version)?);
269                }
270                v
271            };
272        }
273        if flex {
274            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
275        }
276        Ok(out)
277    }
278}
279#[cfg(test)]
280impl TopicProduceResponse {
281    #[must_use]
282    pub fn populated(version: i16) -> Self {
283        let mut m = Self::default();
284        if (0..=12).contains(&version) {
285            m.name = "x".to_owned();
286        }
287        if version >= 13 {
288            m.topic_id = Uuid([1u8; 16]);
289        }
290        if version >= 0 {
291            m.partition_responses = vec![PartitionProduceResponse::populated(version)];
292        }
293        m
294    }
295}
296#[derive(Debug, Clone, PartialEq, Eq)]
297pub struct PartitionProduceResponse {
298    pub index: i32,
299    pub error_code: i16,
300    pub base_offset: i64,
301    pub log_append_time_ms: i64,
302    pub log_start_offset: i64,
303    pub record_errors: Vec<BatchIndexAndErrorMessage>,
304    pub error_message: Option<String>,
305    pub current_leader: LeaderIdAndEpoch,
306    pub unknown_tagged_fields: UnknownTaggedFields,
307}
308impl Default for PartitionProduceResponse {
309    fn default() -> Self {
310        Self {
311            index: 0i32,
312            error_code: 0i16,
313            base_offset: 0i64,
314            log_append_time_ms: -1i64,
315            log_start_offset: -1i64,
316            record_errors: Vec::new(),
317            error_message: None,
318            current_leader: LeaderIdAndEpoch::default(),
319            unknown_tagged_fields: UnknownTaggedFields::default(),
320        }
321    }
322}
323impl PartitionProduceResponse {
324    fn encode_field_0<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
325        if version >= 0 {
326            put_i32(buf, self.index);
327        }
328    }
329    fn encode_field_1<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
330        if version >= 0 {
331            put_i16(buf, self.error_code);
332        }
333    }
334    fn encode_field_2<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
335        if version >= 0 {
336            put_i64(buf, self.base_offset);
337        }
338    }
339    fn encode_field_3<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
340        if version >= 2 {
341            put_i64(buf, self.log_append_time_ms);
342        }
343    }
344    fn encode_field_4<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
345        if version >= 5 {
346            put_i64(buf, self.log_start_offset);
347        }
348    }
349    fn encode_field_5<B: BufMut>(
350        &self,
351        buf: &mut B,
352        version: i16,
353        flex: bool,
354    ) -> Result<(), ProtocolError> {
355        if version >= 8 {
356            {
357                put_array_len(buf, (self.record_errors).len(), flex)?;
358                for it in &self.record_errors {
359                    it.encode(buf, version)?;
360                }
361            }
362        }
363        Ok(())
364    }
365    fn encode_field_6<B: BufMut>(
366        &self,
367        buf: &mut B,
368        version: i16,
369        flex: bool,
370    ) -> Result<(), ProtocolError> {
371        if version >= 8 {
372            if flex {
373                put_compact_nullable_string(buf, self.error_message.as_deref())?;
374            } else {
375                put_nullable_string(buf, self.error_message.as_deref())?;
376            }
377        }
378        Ok(())
379    }
380    fn encode_tagged_fields<B: BufMut>(
381        &self,
382        buf: &mut B,
383        version: i16,
384        flex: bool,
385    ) -> Result<(), ProtocolError> {
386        if flex {
387            let mut tagged = WriteTaggedFields::new();
388            if version >= 10 && !(is_default(&self.current_leader)) {
389                let payload = encode_to_bytes(self.current_leader.encoded_len(version), |b| {
390                    self.current_leader.encode(b, version)?;
391                    Ok(())
392                })?;
393                tagged.add(0, payload);
394            }
395            tagged.write(buf, &self.unknown_tagged_fields)?;
396        }
397        Ok(())
398    }
399    fn decode_field_0<B: Buf>(
400        out: &mut Self,
401        buf: &mut B,
402        version: i16,
403        _flex: bool,
404    ) -> Result<(), ProtocolError> {
405        if version >= 0 {
406            out.index = get_i32(buf)?;
407        }
408        Ok(())
409    }
410    fn decode_field_1<B: Buf>(
411        out: &mut Self,
412        buf: &mut B,
413        version: i16,
414        _flex: bool,
415    ) -> Result<(), ProtocolError> {
416        if version >= 0 {
417            out.error_code = get_i16(buf)?;
418        }
419        Ok(())
420    }
421    fn decode_field_2<B: Buf>(
422        out: &mut Self,
423        buf: &mut B,
424        version: i16,
425        _flex: bool,
426    ) -> Result<(), ProtocolError> {
427        if version >= 0 {
428            out.base_offset = get_i64(buf)?;
429        }
430        Ok(())
431    }
432    fn decode_field_3<B: Buf>(
433        out: &mut Self,
434        buf: &mut B,
435        version: i16,
436        _flex: bool,
437    ) -> Result<(), ProtocolError> {
438        if version >= 2 {
439            out.log_append_time_ms = get_i64(buf)?;
440        }
441        Ok(())
442    }
443    fn decode_field_4<B: Buf>(
444        out: &mut Self,
445        buf: &mut B,
446        version: i16,
447        _flex: bool,
448    ) -> Result<(), ProtocolError> {
449        if version >= 5 {
450            out.log_start_offset = get_i64(buf)?;
451        }
452        Ok(())
453    }
454    fn decode_field_5<B: Buf>(
455        out: &mut Self,
456        buf: &mut B,
457        version: i16,
458        flex: bool,
459    ) -> Result<(), ProtocolError> {
460        if version >= 8 {
461            out.record_errors = {
462                let n = get_array_len(buf, flex)?;
463                let mut v = Vec::with_capacity(n);
464                for _ in 0..n {
465                    v.push(BatchIndexAndErrorMessage::decode(buf, version)?);
466                }
467                v
468            };
469        }
470        Ok(())
471    }
472    fn decode_field_6<B: Buf>(
473        out: &mut Self,
474        buf: &mut B,
475        version: i16,
476        flex: bool,
477    ) -> Result<(), ProtocolError> {
478        if version >= 8 {
479            out.error_message = if flex {
480                get_compact_nullable_string_owned(buf)?
481            } else {
482                get_nullable_string_owned(buf)?
483            };
484        }
485        Ok(())
486    }
487    fn decode_tagged_fields<B: Buf>(
488        out: &mut Self,
489        buf: &mut B,
490        version: i16,
491        flex: bool,
492    ) -> Result<(), ProtocolError> {
493        if flex {
494            let mut tag_current_leader = None;
495            out.unknown_tagged_fields = read_tagged_fields(buf, |tag, payload| match tag {
496                0 if version >= 10 => {
497                    tag_current_leader = Some({
498                        let b: &mut &[u8] = payload;
499                        LeaderIdAndEpoch::decode(b, version)?
500                    });
501                    Ok(true)
502                }
503                0 => Err(ProtocolError::TagNotValidForVersion { tag: 0, version }),
504                _ => Ok(false),
505            })?;
506            if let Some(v) = tag_current_leader {
507                out.current_leader = v;
508            }
509        }
510        Ok(())
511    }
512}
513impl Encode for PartitionProduceResponse {
514    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
515        let flex = version >= 9;
516        self.encode_field_0(buf, version, flex);
517        self.encode_field_1(buf, version, flex);
518        self.encode_field_2(buf, version, flex);
519        self.encode_field_3(buf, version, flex);
520        self.encode_field_4(buf, version, flex);
521        self.encode_field_5(buf, version, flex)?;
522        self.encode_field_6(buf, version, flex)?;
523        self.encode_tagged_fields(buf, version, flex)?;
524        Ok(())
525    }
526    fn encoded_len(&self, version: i16) -> usize {
527        let flex = version >= 9;
528        let mut n: usize = 0;
529        if version >= 0 {
530            n += 4;
531        }
532        if version >= 0 {
533            n += 2;
534        }
535        if version >= 0 {
536            n += 8;
537        }
538        if version >= 2 {
539            n += 8;
540        }
541        if version >= 5 {
542            n += 8;
543        }
544        if version >= 8 {
545            n += {
546                let prefix = array_len_prefix_len((self.record_errors).len(), flex);
547                let body: usize = (self.record_errors)
548                    .iter()
549                    .map(|it| it.encoded_len(version))
550                    .sum();
551                prefix + body
552            };
553        }
554        if version >= 8 {
555            n += if flex {
556                compact_nullable_string_len(self.error_message.as_deref())
557            } else {
558                nullable_string_len(self.error_message.as_deref())
559            };
560        }
561        if flex {
562            let mut known_pairs: Vec<(u32, usize)> = Vec::new();
563            if version >= 10 && !(is_default(&self.current_leader)) {
564                known_pairs.push((0, self.current_leader.encoded_len(version)));
565            }
566            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
567        }
568        n
569    }
570}
571impl Decode<'_> for PartitionProduceResponse {
572    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
573        let flex = version >= 9;
574        let mut out = Self::default();
575        Self::decode_field_0(&mut out, buf, version, flex)?;
576        Self::decode_field_1(&mut out, buf, version, flex)?;
577        Self::decode_field_2(&mut out, buf, version, flex)?;
578        Self::decode_field_3(&mut out, buf, version, flex)?;
579        Self::decode_field_4(&mut out, buf, version, flex)?;
580        Self::decode_field_5(&mut out, buf, version, flex)?;
581        Self::decode_field_6(&mut out, buf, version, flex)?;
582        Self::decode_tagged_fields(&mut out, buf, version, flex)?;
583        Ok(out)
584    }
585}
586#[cfg(test)]
587impl PartitionProduceResponse {
588    #[must_use]
589    pub fn populated(version: i16) -> Self {
590        let mut m = Self::default();
591        if version >= 0 {
592            m.index = 1i32;
593        }
594        if version >= 0 {
595            m.error_code = 1i16;
596        }
597        if version >= 0 {
598            m.base_offset = 1i64;
599        }
600        if version >= 2 {
601            m.log_append_time_ms = 1i64;
602        }
603        if version >= 5 {
604            m.log_start_offset = 1i64;
605        }
606        if version >= 8 {
607            m.record_errors = vec![BatchIndexAndErrorMessage::populated(version)];
608        }
609        if version >= 8 {
610            m.error_message = Some("x".to_owned());
611        }
612        if version >= 10 {
613            m.current_leader = LeaderIdAndEpoch::populated(version);
614        }
615        m
616    }
617}
618#[derive(Debug, Clone, PartialEq, Eq, Default)]
619pub struct BatchIndexAndErrorMessage {
620    pub batch_index: i32,
621    pub batch_index_error_message: Option<String>,
622    pub unknown_tagged_fields: UnknownTaggedFields,
623}
624impl Encode for BatchIndexAndErrorMessage {
625    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
626        let flex = version >= 9;
627        if version >= 8 {
628            put_i32(buf, self.batch_index);
629        }
630        if version >= 8 {
631            if flex {
632                put_compact_nullable_string(buf, self.batch_index_error_message.as_deref())?;
633            } else {
634                put_nullable_string(buf, self.batch_index_error_message.as_deref())?;
635            }
636        }
637        if flex {
638            let tagged = WriteTaggedFields::new();
639            tagged.write(buf, &self.unknown_tagged_fields)?;
640        }
641        Ok(())
642    }
643    fn encoded_len(&self, version: i16) -> usize {
644        let flex = version >= 9;
645        let mut n: usize = 0;
646        if version >= 8 {
647            n += 4;
648        }
649        if version >= 8 {
650            n += if flex {
651                compact_nullable_string_len(self.batch_index_error_message.as_deref())
652            } else {
653                nullable_string_len(self.batch_index_error_message.as_deref())
654            };
655        }
656        if flex {
657            let known_pairs: Vec<(u32, usize)> = Vec::new();
658            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
659        }
660        n
661    }
662}
663impl Decode<'_> for BatchIndexAndErrorMessage {
664    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
665        let flex = version >= 9;
666        let mut out = Self::default();
667        if version >= 8 {
668            out.batch_index = get_i32(buf)?;
669        }
670        if version >= 8 {
671            out.batch_index_error_message = if flex {
672                get_compact_nullable_string_owned(buf)?
673            } else {
674                get_nullable_string_owned(buf)?
675            };
676        }
677        if flex {
678            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
679        }
680        Ok(out)
681    }
682}
683#[cfg(test)]
684impl BatchIndexAndErrorMessage {
685    #[must_use]
686    pub fn populated(version: i16) -> Self {
687        let mut m = Self::default();
688        if version >= 8 {
689            m.batch_index = 1i32;
690        }
691        if version >= 8 {
692            m.batch_index_error_message = Some("x".to_owned());
693        }
694        m
695    }
696}
697#[derive(Debug, Clone, PartialEq, Eq)]
698pub struct LeaderIdAndEpoch {
699    pub leader_id: i32,
700    pub leader_epoch: i32,
701    pub unknown_tagged_fields: UnknownTaggedFields,
702}
703impl Default for LeaderIdAndEpoch {
704    fn default() -> Self {
705        Self {
706            leader_id: -1i32,
707            leader_epoch: -1i32,
708            unknown_tagged_fields: UnknownTaggedFields::default(),
709        }
710    }
711}
712impl Encode for LeaderIdAndEpoch {
713    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
714        let flex = version >= 9;
715        if version >= 10 {
716            put_i32(buf, self.leader_id);
717        }
718        if version >= 10 {
719            put_i32(buf, self.leader_epoch);
720        }
721        if flex {
722            let tagged = WriteTaggedFields::new();
723            tagged.write(buf, &self.unknown_tagged_fields)?;
724        }
725        Ok(())
726    }
727    fn encoded_len(&self, version: i16) -> usize {
728        let flex = version >= 9;
729        let mut n: usize = 0;
730        if version >= 10 {
731            n += 4;
732        }
733        if version >= 10 {
734            n += 4;
735        }
736        if flex {
737            let known_pairs: Vec<(u32, usize)> = Vec::new();
738            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
739        }
740        n
741    }
742}
743impl Decode<'_> for LeaderIdAndEpoch {
744    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
745        let flex = version >= 9;
746        let mut out = Self::default();
747        if version >= 10 {
748            out.leader_id = get_i32(buf)?;
749        }
750        if version >= 10 {
751            out.leader_epoch = get_i32(buf)?;
752        }
753        if flex {
754            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
755        }
756        Ok(out)
757    }
758}
759#[cfg(test)]
760impl LeaderIdAndEpoch {
761    #[must_use]
762    pub fn populated(version: i16) -> Self {
763        let mut m = Self::default();
764        if version >= 10 {
765            m.leader_id = 1i32;
766        }
767        if version >= 10 {
768            m.leader_epoch = 1i32;
769        }
770        m
771    }
772}
773#[derive(Debug, Clone, PartialEq, Eq, Default)]
774pub struct NodeEndpoint {
775    pub node_id: i32,
776    pub host: String,
777    pub port: i32,
778    pub rack: Option<String>,
779    pub unknown_tagged_fields: UnknownTaggedFields,
780}
781impl Encode for NodeEndpoint {
782    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
783        let flex = version >= 9;
784        if version >= 10 {
785            put_i32(buf, self.node_id);
786        }
787        if version >= 10 {
788            if flex {
789                put_compact_string(buf, &self.host)?;
790            } else {
791                put_string(buf, &self.host)?;
792            }
793        }
794        if version >= 10 {
795            put_i32(buf, self.port);
796        }
797        if version >= 10 {
798            if flex {
799                put_compact_nullable_string(buf, self.rack.as_deref())?;
800            } else {
801                put_nullable_string(buf, self.rack.as_deref())?;
802            }
803        }
804        if flex {
805            let tagged = WriteTaggedFields::new();
806            tagged.write(buf, &self.unknown_tagged_fields)?;
807        }
808        Ok(())
809    }
810    fn encoded_len(&self, version: i16) -> usize {
811        let flex = version >= 9;
812        let mut n: usize = 0;
813        if version >= 10 {
814            n += 4;
815        }
816        if version >= 10 {
817            n += if flex {
818                compact_string_len(&self.host)
819            } else {
820                string_len(&self.host)
821            };
822        }
823        if version >= 10 {
824            n += 4;
825        }
826        if version >= 10 {
827            n += if flex {
828                compact_nullable_string_len(self.rack.as_deref())
829            } else {
830                nullable_string_len(self.rack.as_deref())
831            };
832        }
833        if flex {
834            let known_pairs: Vec<(u32, usize)> = Vec::new();
835            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
836        }
837        n
838    }
839}
840impl Decode<'_> for NodeEndpoint {
841    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
842        let flex = version >= 9;
843        let mut out = Self::default();
844        if version >= 10 {
845            out.node_id = get_i32(buf)?;
846        }
847        if version >= 10 {
848            out.host = if flex {
849                get_compact_string_owned(buf)?
850            } else {
851                get_string_owned(buf)?
852            };
853        }
854        if version >= 10 {
855            out.port = get_i32(buf)?;
856        }
857        if version >= 10 {
858            out.rack = if flex {
859                get_compact_nullable_string_owned(buf)?
860            } else {
861                get_nullable_string_owned(buf)?
862            };
863        }
864        if flex {
865            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
866        }
867        Ok(out)
868    }
869}
870#[cfg(test)]
871impl NodeEndpoint {
872    #[must_use]
873    pub fn populated(version: i16) -> Self {
874        let mut m = Self::default();
875        if version >= 10 {
876            m.node_id = 1i32;
877        }
878        if version >= 10 {
879            m.host = "x".to_owned();
880        }
881        if version >= 10 {
882            m.port = 1i32;
883        }
884        if version >= 10 {
885            m.rack = Some("x".to_owned());
886        }
887        m
888    }
889}
890/// Default JSON payload matching `Self::default()` for JVM oracle differential testing.
891/// Only includes fields valid for the given version.
892#[must_use]
893#[allow(unused_comparisons)]
894pub fn default_json(version: i16) -> ::serde_json::Value {
895    let mut obj = ::serde_json::Map::new();
896    obj.insert("responses".to_owned(), ::serde_json::Value::Array(vec![]));
897    if version >= 1 {
898        obj.insert("throttleTimeMs".to_owned(), ::serde_json::json!(0));
899    }
900    if version >= 10 {
901        obj.insert(
902            "nodeEndpoints".to_owned(),
903            ::serde_json::Value::Array(vec![]),
904        );
905    }
906    ::serde_json::Value::Object(obj)
907}
908/// A message with a non-default value in every tagged field, at every depth, for
909/// the JVM oracle differential sweep. The value is the same at every version.
910#[must_use]
911pub fn tagged_fixture() -> ProduceResponse {
912    ProduceResponse {
913        responses: vec![TopicProduceResponse {
914            partition_responses: vec![PartitionProduceResponse {
915                current_leader: LeaderIdAndEpoch {
916                    leader_id: 1i32,
917                    leader_epoch: 1i32,
918                    ..LeaderIdAndEpoch::default()
919                },
920                ..PartitionProduceResponse::default()
921            }],
922            ..TopicProduceResponse::default()
923        }],
924        node_endpoints: vec![NodeEndpoint {
925            node_id: 1i32,
926            host: "x".to_owned(),
927            port: 1i32,
928            rack: Some("x".to_owned()),
929            ..NodeEndpoint::default()
930        }],
931        ..ProduceResponse::default()
932    }
933}
934/// The JSON form of `tagged_fixture()` that Kafka's JSON converter reads at
935/// `version`. It holds only the fields that the schema declares at that version.
936#[must_use]
937pub fn tagged_fixture_json(version: i16) -> ::serde_json::Value {
938    let mut m = ::serde_json::Map::new();
939    m.insert(
940        "responses".to_owned(),
941        ::serde_json::Value::Array(vec![{
942            let mut m = ::serde_json::Map::new();
943            if version <= 12 {
944                m.insert(
945                    "name".to_owned(),
946                    ::serde_json::Value::String(String::new()),
947                );
948            }
949            if version == 13 {
950                m.insert(
951                    "topicId".to_owned(),
952                    ::serde_json::Value::String("AAAAAAAAAAAAAAAAAAAAAA".to_owned()),
953                );
954            }
955            m.insert(
956                "partitionResponses".to_owned(),
957                ::serde_json::Value::Array(vec![{
958                    let mut m = ::serde_json::Map::new();
959                    m.insert("index".to_owned(), ::serde_json::json!(0));
960                    m.insert("errorCode".to_owned(), ::serde_json::json!(0));
961                    m.insert("baseOffset".to_owned(), ::serde_json::json!(0));
962                    m.insert("logAppendTimeMs".to_owned(), ::serde_json::json!(-1));
963                    if version >= 5 {
964                        m.insert("logStartOffset".to_owned(), ::serde_json::json!(-1));
965                    }
966                    if version >= 8 {
967                        m.insert(
968                            "recordErrors".to_owned(),
969                            ::serde_json::Value::Array(vec![]),
970                        );
971                    }
972                    if version >= 8 {
973                        m.insert("errorMessage".to_owned(), ::serde_json::Value::Null);
974                    }
975                    if version >= 10 {
976                        m.insert("currentLeader".to_owned(), {
977                            let mut m = ::serde_json::Map::new();
978                            m.insert("leaderId".to_owned(), ::serde_json::json!(1));
979                            m.insert("leaderEpoch".to_owned(), ::serde_json::json!(1));
980                            ::serde_json::Value::Object(m)
981                        });
982                    }
983                    ::serde_json::Value::Object(m)
984                }]),
985            );
986            ::serde_json::Value::Object(m)
987        }]),
988    );
989    m.insert("throttleTimeMs".to_owned(), ::serde_json::json!(0));
990    if version >= 10 {
991        m.insert(
992            "nodeEndpoints".to_owned(),
993            ::serde_json::Value::Array(vec![{
994                let mut m = ::serde_json::Map::new();
995                m.insert("nodeId".to_owned(), ::serde_json::json!(1));
996                m.insert(
997                    "host".to_owned(),
998                    ::serde_json::Value::String("x".to_owned()),
999                );
1000                m.insert("port".to_owned(), ::serde_json::json!(1));
1001                m.insert(
1002                    "rack".to_owned(),
1003                    ::serde_json::Value::String("x".to_owned()),
1004                );
1005                ::serde_json::Value::Object(m)
1006            }]),
1007        );
1008    }
1009    ::serde_json::Value::Object(m)
1010}
krabka_protocol/opt/rustwide/workdir/generated/ProduceResponse.owned.rs

krabka_protocol/opt/rustwide/workdir/generated/
ProduceResponse.owned.rs
