krabka_protocol/opt/rustwide/workdir/generated/
ShareFetchResponse.borrowed.rs

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

krabka_protocol/opt/rustwide/workdir/generated/
ShareFetchResponse.borrowed.rs
