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

1// AUTO-GENERATED by krabka-protocol-codegen against a9ce3221537b8653448750697915607dc7936cf3. Do not edit.
2use bytes::BufMut;
3
4use crate::{
5    Decode, DecodeBorrow, Encode, ProtocolError, UnknownTaggedFields,
6    codegen_helpers::is_default,
7    owned::fetch_snapshot_response,
8    primitives::{
9        array::{array_len_prefix_len, get_array_len, put_array_len},
10        fixed::{get_i16, get_i32, get_i64, get_u16, put_i16, put_i32, put_i64, put_u16},
11        string_bytes::{
12            compact_bytes_len_from_size, compact_string_len, put_bytes, put_compact_bytes,
13            put_compact_string, put_string, string_len,
14        },
15        string_bytes_borrowed::{
16            get_bytes_borrowed, get_compact_bytes_borrowed, get_compact_string_borrowed,
17            get_string_borrowed,
18        },
19    },
20    records::{RecordsError, RecordsPayloadBorrowed},
21    tagged_fields::{WriteTaggedFields, encode_to_bytes, read_tagged_fields, tagged_fields_len},
22};
23pub const API_KEY: i16 = 59;
24pub const MIN_VERSION: i16 = 0;
25pub const MAX_VERSION: i16 = 1;
26pub const FLEXIBLE_MIN: i16 = 0;
27#[inline]
28#[must_use]
29pub fn is_flexible(version: i16) -> bool {
30    version >= FLEXIBLE_MIN
31}
32#[derive(Debug, Clone, PartialEq, Eq, Default)]
33pub struct FetchSnapshotResponse<'a> {
34    pub throttle_time_ms: i32,
35    pub error_code: i16,
36    pub topics: Vec<TopicSnapshot<'a>>,
37    pub node_endpoints: Vec<fetch_snapshot_response::NodeEndpoint>,
38    pub unknown_tagged_fields: UnknownTaggedFields,
39}
40impl FetchSnapshotResponse<'_> {
41    /// # Errors
42    ///
43    /// Returns the error of a records field that holds an invalid
44    /// encoded record batch.
45    pub fn to_owned(&self) -> Result<fetch_snapshot_response::FetchSnapshotResponse, RecordsError> {
46        Ok(fetch_snapshot_response::FetchSnapshotResponse {
47            throttle_time_ms: (self.throttle_time_ms),
48            error_code: (self.error_code),
49            topics: (self.topics)
50                .iter()
51                .map(TopicSnapshot::to_owned)
52                .collect::<Result<_, _>>()?,
53            node_endpoints: self.node_endpoints.clone(),
54            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
55        })
56    }
57}
58impl Encode for FetchSnapshotResponse<'_> {
59    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
60        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
61            return Err(ProtocolError::UnsupportedVersion {
62                api_key: API_KEY,
63                version,
64            });
65        }
66        let flex = is_flexible(version);
67        if version >= 0 {
68            put_i32(buf, self.throttle_time_ms);
69        }
70        if version >= 0 {
71            put_i16(buf, self.error_code);
72        }
73        if version >= 0 {
74            {
75                put_array_len(buf, (self.topics).len(), flex)?;
76                for it in &self.topics {
77                    it.encode(buf, version)?;
78                }
79            }
80        }
81        if flex {
82            let mut tagged = WriteTaggedFields::new();
83            if version >= 1 && !(is_default(&self.node_endpoints)) {
84                let payload = encode_to_bytes(
85                    {
86                        let prefix = array_len_prefix_len((self.node_endpoints).len(), flex);
87                        let body: usize = (self.node_endpoints)
88                            .iter()
89                            .map(|it| it.encoded_len(version))
90                            .sum();
91                        prefix + body
92                    },
93                    |b| {
94                        {
95                            put_array_len(b, (self.node_endpoints).len(), flex)?;
96                            for it in &self.node_endpoints {
97                                it.encode(b, version)?;
98                            }
99                        }
100                        Ok(())
101                    },
102                )?;
103                tagged.add(0, payload);
104            }
105            tagged.write(buf, &self.unknown_tagged_fields)?;
106        }
107        Ok(())
108    }
109    fn encoded_len(&self, version: i16) -> usize {
110        let flex = is_flexible(version);
111        let mut n: usize = 0;
112        if version >= 0 {
113            n += 4;
114        }
115        if version >= 0 {
116            n += 2;
117        }
118        if version >= 0 {
119            n += {
120                let prefix = array_len_prefix_len((self.topics).len(), flex);
121                let body: usize = (self.topics).iter().map(|it| it.encoded_len(version)).sum();
122                prefix + body
123            };
124        }
125        if flex {
126            let mut known_pairs: Vec<(u32, usize)> = Vec::new();
127            if version >= 1 && !(is_default(&self.node_endpoints)) {
128                known_pairs.push((0, {
129                    let prefix = array_len_prefix_len((self.node_endpoints).len(), flex);
130                    let body: usize = (self.node_endpoints)
131                        .iter()
132                        .map(|it| it.encoded_len(version))
133                        .sum();
134                    prefix + body
135                }));
136            }
137            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
138        }
139        n
140    }
141}
142impl<'de> DecodeBorrow<'de> for FetchSnapshotResponse<'de> {
143    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
144        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
145            return Err(ProtocolError::UnsupportedVersion {
146                api_key: API_KEY,
147                version,
148            });
149        }
150        let flex = is_flexible(version);
151        let mut out = Self::default();
152        if version >= 0 {
153            out.throttle_time_ms = get_i32(buf)?;
154        }
155        if version >= 0 {
156            out.error_code = get_i16(buf)?;
157        }
158        if version >= 0 {
159            out.topics = {
160                let n = get_array_len(buf, flex)?;
161                let mut v = Vec::with_capacity(n);
162                for _ in 0..n {
163                    v.push(TopicSnapshot::decode_borrow(buf, version)?);
164                }
165                v
166            };
167        }
168        if flex {
169            let mut tag_node_endpoints = None;
170            out.unknown_tagged_fields = read_tagged_fields(buf, |tag, payload| match tag {
171                0 if version >= 1 => {
172                    tag_node_endpoints = Some({
173                        let b: &mut &[u8] = payload;
174                        {
175                            let n = get_array_len(b, flex)?;
176                            let mut v = Vec::with_capacity(n);
177                            for _ in 0..n {
178                                v.push(fetch_snapshot_response::NodeEndpoint::decode(b, version)?);
179                            }
180                            v
181                        }
182                    });
183                    Ok(true)
184                }
185                0 => Err(ProtocolError::TagNotValidForVersion { tag: 0, version }),
186                _ => Ok(false),
187            })?;
188            if let Some(v) = tag_node_endpoints {
189                out.node_endpoints = v;
190            }
191        }
192        Ok(out)
193    }
194}
195#[cfg(test)]
196impl FetchSnapshotResponse<'_> {
197    #[must_use]
198    pub fn populated(version: i16) -> Self {
199        let mut m = Self::default();
200        if version >= 0 {
201            m.throttle_time_ms = 1i32;
202        }
203        if version >= 0 {
204            m.error_code = 1i16;
205        }
206        if version >= 0 {
207            m.topics = vec![TopicSnapshot::populated(version)];
208        }
209        if version >= 1 {
210            m.node_endpoints = vec![fetch_snapshot_response::NodeEndpoint::populated(version)];
211        }
212        m
213    }
214}
215#[derive(Debug, Clone, PartialEq, Eq, Default)]
216pub struct TopicSnapshot<'a> {
217    pub name: &'a str,
218    pub partitions: Vec<PartitionSnapshot<'a>>,
219    pub unknown_tagged_fields: UnknownTaggedFields,
220}
221impl TopicSnapshot<'_> {
222    /// # Errors
223    ///
224    /// Returns the error of a records field that holds an invalid
225    /// encoded record batch.
226    pub fn to_owned(&self) -> Result<fetch_snapshot_response::TopicSnapshot, RecordsError> {
227        Ok(fetch_snapshot_response::TopicSnapshot {
228            name: (self.name).to_owned(),
229            partitions: (self.partitions)
230                .iter()
231                .map(PartitionSnapshot::to_owned)
232                .collect::<Result<_, _>>()?,
233            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
234        })
235    }
236}
237impl Encode for TopicSnapshot<'_> {
238    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
239        let flex = version >= 0;
240        if version >= 0 {
241            if flex {
242                put_compact_string(buf, self.name)?;
243            } else {
244                put_string(buf, self.name)?;
245            }
246        }
247        if version >= 0 {
248            {
249                put_array_len(buf, (self.partitions).len(), flex)?;
250                for it in &self.partitions {
251                    it.encode(buf, version)?;
252                }
253            }
254        }
255        if flex {
256            let tagged = WriteTaggedFields::new();
257            tagged.write(buf, &self.unknown_tagged_fields)?;
258        }
259        Ok(())
260    }
261    fn encoded_len(&self, version: i16) -> usize {
262        let flex = version >= 0;
263        let mut n: usize = 0;
264        if version >= 0 {
265            n += if flex {
266                compact_string_len(self.name)
267            } else {
268                string_len(self.name)
269            };
270        }
271        if version >= 0 {
272            n += {
273                let prefix = array_len_prefix_len((self.partitions).len(), flex);
274                let body: usize = (self.partitions)
275                    .iter()
276                    .map(|it| it.encoded_len(version))
277                    .sum();
278                prefix + body
279            };
280        }
281        if flex {
282            let known_pairs: Vec<(u32, usize)> = Vec::new();
283            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
284        }
285        n
286    }
287}
288impl<'de> DecodeBorrow<'de> for TopicSnapshot<'de> {
289    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
290        let flex = version >= 0;
291        let mut out = Self::default();
292        if version >= 0 {
293            out.name = if flex {
294                get_compact_string_borrowed(buf)?
295            } else {
296                get_string_borrowed(buf)?
297            };
298        }
299        if version >= 0 {
300            out.partitions = {
301                let n = get_array_len(buf, flex)?;
302                let mut v = Vec::with_capacity(n);
303                for _ in 0..n {
304                    v.push(PartitionSnapshot::decode_borrow(buf, version)?);
305                }
306                v
307            };
308        }
309        if flex {
310            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
311        }
312        Ok(out)
313    }
314}
315#[cfg(test)]
316impl TopicSnapshot<'_> {
317    #[must_use]
318    pub fn populated(version: i16) -> Self {
319        let mut m = Self::default();
320        if version >= 0 {
321            m.name = "x";
322        }
323        if version >= 0 {
324            m.partitions = vec![PartitionSnapshot::populated(version)];
325        }
326        m
327    }
328}
329#[derive(Debug, Clone, PartialEq, Eq, Default)]
330pub struct PartitionSnapshot<'a> {
331    pub index: i32,
332    pub error_code: i16,
333    pub snapshot_id: SnapshotId,
334    pub size: i64,
335    pub position: i64,
336    pub unaligned_records: RecordsPayloadBorrowed<'a>,
337    pub current_leader: LeaderIdAndEpoch,
338    pub unknown_tagged_fields: UnknownTaggedFields,
339}
340impl PartitionSnapshot<'_> {
341    /// # Errors
342    ///
343    /// Returns the error of a records field that holds an invalid
344    /// encoded record batch.
345    pub fn to_owned(&self) -> Result<fetch_snapshot_response::PartitionSnapshot, RecordsError> {
346        Ok(fetch_snapshot_response::PartitionSnapshot {
347            index: (self.index),
348            error_code: (self.error_code),
349            snapshot_id: (self.snapshot_id).to_owned(),
350            size: (self.size),
351            position: (self.position),
352            unaligned_records: (self.unaligned_records).to_owned()?,
353            current_leader: (self.current_leader).to_owned(),
354            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
355        })
356    }
357}
358impl Encode for PartitionSnapshot<'_> {
359    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
360        let flex = version >= 0;
361        if version >= 0 {
362            put_i32(buf, self.index);
363        }
364        if version >= 0 {
365            put_i16(buf, self.error_code);
366        }
367        if version >= 0 {
368            self.snapshot_id.encode(buf, version)?;
369        }
370        if version >= 0 {
371            put_i64(buf, self.size);
372        }
373        if version >= 0 {
374            put_i64(buf, self.position);
375        }
376        if version >= 0 {
377            {
378                let mut __rb_buf = bytes::BytesMut::new();
379                <RecordsPayloadBorrowed as crate::Encode>::encode(
380                    &self.unaligned_records,
381                    &mut __rb_buf,
382                    version,
383                )?;
384                if flex {
385                    put_compact_bytes(buf, &__rb_buf)?;
386                } else {
387                    put_bytes(buf, &__rb_buf)?;
388                }
389            }
390        }
391        if flex {
392            let mut tagged = WriteTaggedFields::new();
393            if !(is_default(&self.current_leader)) {
394                let payload = encode_to_bytes(self.current_leader.encoded_len(version), |b| {
395                    self.current_leader.encode(b, version)?;
396                    Ok(())
397                })?;
398                tagged.add(0, payload);
399            }
400            tagged.write(buf, &self.unknown_tagged_fields)?;
401        }
402        Ok(())
403    }
404    fn encoded_len(&self, version: i16) -> usize {
405        let flex = version >= 0;
406        let mut n: usize = 0;
407        if version >= 0 {
408            n += 4;
409        }
410        if version >= 0 {
411            n += 2;
412        }
413        if version >= 0 {
414            n += self.snapshot_id.encoded_len(version);
415        }
416        if version >= 0 {
417            n += 8;
418        }
419        if version >= 0 {
420            n += 8;
421        }
422        if version >= 0 {
423            n += {
424                let __rb_len = <RecordsPayloadBorrowed as crate::Encode>::encoded_len(
425                    &(self.unaligned_records),
426                    version,
427                );
428                if flex {
429                    compact_bytes_len_from_size(__rb_len)
430                } else {
431                    4 + __rb_len
432                }
433            };
434        }
435        if flex {
436            let mut known_pairs: Vec<(u32, usize)> = Vec::new();
437            if !(is_default(&self.current_leader)) {
438                known_pairs.push((0, self.current_leader.encoded_len(version)));
439            }
440            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
441        }
442        n
443    }
444}
445impl<'de> DecodeBorrow<'de> for PartitionSnapshot<'de> {
446    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
447        let flex = version >= 0;
448        let mut out = Self::default();
449        if version >= 0 {
450            out.index = get_i32(buf)?;
451        }
452        if version >= 0 {
453            out.error_code = get_i16(buf)?;
454        }
455        if version >= 0 {
456            out.snapshot_id = SnapshotId::decode_borrow(buf, version)?;
457        }
458        if version >= 0 {
459            out.size = get_i64(buf)?;
460        }
461        if version >= 0 {
462            out.position = get_i64(buf)?;
463        }
464        if version >= 0 {
465            out.unaligned_records = {
466                let __rb_slice = if flex {
467                    get_compact_bytes_borrowed(buf)?
468                } else {
469                    get_bytes_borrowed(buf)?
470                };
471                let mut __rb_cur = __rb_slice;
472                <RecordsPayloadBorrowed as crate::DecodeBorrow>::decode_borrow(
473                    &mut __rb_cur,
474                    version,
475                )?
476            };
477        }
478        if flex {
479            let mut tag_current_leader = None;
480            out.unknown_tagged_fields = read_tagged_fields(buf, |tag, payload| match tag {
481                0 => {
482                    tag_current_leader = Some({
483                        let b: &mut &[u8] = payload;
484                        LeaderIdAndEpoch::decode_borrow(b, version)?
485                    });
486                    Ok(true)
487                }
488                _ => Ok(false),
489            })?;
490            if let Some(v) = tag_current_leader {
491                out.current_leader = v;
492            }
493        }
494        Ok(out)
495    }
496}
497#[cfg(test)]
498impl PartitionSnapshot<'_> {
499    #[must_use]
500    pub fn populated(version: i16) -> Self {
501        let mut m = Self::default();
502        if version >= 0 {
503            m.index = 1i32;
504        }
505        if version >= 0 {
506            m.error_code = 1i16;
507        }
508        if version >= 0 {
509            m.snapshot_id = SnapshotId::populated(version);
510        }
511        if version >= 0 {
512            m.size = 1i64;
513        }
514        if version >= 0 {
515            m.position = 1i64;
516        }
517        if version >= 0 {
518            m.current_leader = LeaderIdAndEpoch::populated(version);
519        }
520        m
521    }
522}
523#[derive(Debug, Clone, PartialEq, Eq, Default)]
524pub struct SnapshotId {
525    pub end_offset: i64,
526    pub epoch: i32,
527    pub unknown_tagged_fields: UnknownTaggedFields,
528}
529impl SnapshotId {
530    #[must_use]
531    pub fn to_owned(&self) -> fetch_snapshot_response::SnapshotId {
532        fetch_snapshot_response::SnapshotId {
533            end_offset: (self.end_offset),
534            epoch: (self.epoch),
535            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
536        }
537    }
538}
539impl Encode for SnapshotId {
540    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
541        let flex = version >= 0;
542        if version >= 0 {
543            put_i64(buf, self.end_offset);
544        }
545        if version >= 0 {
546            put_i32(buf, self.epoch);
547        }
548        if flex {
549            let tagged = WriteTaggedFields::new();
550            tagged.write(buf, &self.unknown_tagged_fields)?;
551        }
552        Ok(())
553    }
554    fn encoded_len(&self, version: i16) -> usize {
555        let flex = version >= 0;
556        let mut n: usize = 0;
557        if version >= 0 {
558            n += 8;
559        }
560        if version >= 0 {
561            n += 4;
562        }
563        if flex {
564            let known_pairs: Vec<(u32, usize)> = Vec::new();
565            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
566        }
567        n
568    }
569}
570impl<'de> DecodeBorrow<'de> for SnapshotId {
571    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
572        let flex = version >= 0;
573        let mut out = Self::default();
574        if version >= 0 {
575            out.end_offset = get_i64(buf)?;
576        }
577        if version >= 0 {
578            out.epoch = get_i32(buf)?;
579        }
580        if flex {
581            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
582        }
583        Ok(out)
584    }
585}
586#[cfg(test)]
587impl SnapshotId {
588    #[must_use]
589    pub fn populated(version: i16) -> Self {
590        let mut m = Self::default();
591        if version >= 0 {
592            m.end_offset = 1i64;
593        }
594        if version >= 0 {
595            m.epoch = 1i32;
596        }
597        m
598    }
599}
600#[derive(Debug, Clone, PartialEq, Eq, Default)]
601pub struct LeaderIdAndEpoch {
602    pub leader_id: i32,
603    pub leader_epoch: i32,
604    pub unknown_tagged_fields: UnknownTaggedFields,
605}
606impl LeaderIdAndEpoch {
607    #[must_use]
608    pub fn to_owned(&self) -> fetch_snapshot_response::LeaderIdAndEpoch {
609        fetch_snapshot_response::LeaderIdAndEpoch {
610            leader_id: (self.leader_id),
611            leader_epoch: (self.leader_epoch),
612            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
613        }
614    }
615}
616impl Encode for LeaderIdAndEpoch {
617    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
618        let flex = version >= 0;
619        if version >= 0 {
620            put_i32(buf, self.leader_id);
621        }
622        if version >= 0 {
623            put_i32(buf, self.leader_epoch);
624        }
625        if flex {
626            let tagged = WriteTaggedFields::new();
627            tagged.write(buf, &self.unknown_tagged_fields)?;
628        }
629        Ok(())
630    }
631    fn encoded_len(&self, version: i16) -> usize {
632        let flex = version >= 0;
633        let mut n: usize = 0;
634        if version >= 0 {
635            n += 4;
636        }
637        if version >= 0 {
638            n += 4;
639        }
640        if flex {
641            let known_pairs: Vec<(u32, usize)> = Vec::new();
642            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
643        }
644        n
645    }
646}
647impl<'de> DecodeBorrow<'de> for LeaderIdAndEpoch {
648    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
649        let flex = version >= 0;
650        let mut out = Self::default();
651        if version >= 0 {
652            out.leader_id = get_i32(buf)?;
653        }
654        if version >= 0 {
655            out.leader_epoch = get_i32(buf)?;
656        }
657        if flex {
658            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
659        }
660        Ok(out)
661    }
662}
663#[cfg(test)]
664impl LeaderIdAndEpoch {
665    #[must_use]
666    pub fn populated(version: i16) -> Self {
667        let mut m = Self::default();
668        if version >= 0 {
669            m.leader_id = 1i32;
670        }
671        if version >= 0 {
672            m.leader_epoch = 1i32;
673        }
674        m
675    }
676}
677#[derive(Debug, Clone, PartialEq, Eq, Default)]
678pub struct NodeEndpoint<'a> {
679    pub node_id: i32,
680    pub host: &'a str,
681    pub port: u16,
682    pub unknown_tagged_fields: UnknownTaggedFields,
683}
684impl NodeEndpoint<'_> {
685    #[must_use]
686    pub fn to_owned(&self) -> fetch_snapshot_response::NodeEndpoint {
687        fetch_snapshot_response::NodeEndpoint {
688            node_id: (self.node_id),
689            host: (self.host).to_owned(),
690            port: (self.port),
691            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
692        }
693    }
694}
695impl Encode for NodeEndpoint<'_> {
696    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
697        let flex = version >= 0;
698        if version >= 1 {
699            put_i32(buf, self.node_id);
700        }
701        if version >= 1 {
702            if flex {
703                put_compact_string(buf, self.host)?;
704            } else {
705                put_string(buf, self.host)?;
706            }
707        }
708        if version >= 1 {
709            put_u16(buf, self.port);
710        }
711        if flex {
712            let tagged = WriteTaggedFields::new();
713            tagged.write(buf, &self.unknown_tagged_fields)?;
714        }
715        Ok(())
716    }
717    fn encoded_len(&self, version: i16) -> usize {
718        let flex = version >= 0;
719        let mut n: usize = 0;
720        if version >= 1 {
721            n += 4;
722        }
723        if version >= 1 {
724            n += if flex {
725                compact_string_len(self.host)
726            } else {
727                string_len(self.host)
728            };
729        }
730        if version >= 1 {
731            n += 2;
732        }
733        if flex {
734            let known_pairs: Vec<(u32, usize)> = Vec::new();
735            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
736        }
737        n
738    }
739}
740impl<'de> DecodeBorrow<'de> for NodeEndpoint<'de> {
741    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
742        let flex = version >= 0;
743        let mut out = Self::default();
744        if version >= 1 {
745            out.node_id = get_i32(buf)?;
746        }
747        if version >= 1 {
748            out.host = if flex {
749                get_compact_string_borrowed(buf)?
750            } else {
751                get_string_borrowed(buf)?
752            };
753        }
754        if version >= 1 {
755            out.port = get_u16(buf)?;
756        }
757        if flex {
758            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
759        }
760        Ok(out)
761    }
762}
763#[cfg(test)]
764impl NodeEndpoint<'_> {
765    #[must_use]
766    pub fn populated(version: i16) -> Self {
767        let mut m = Self::default();
768        if version >= 1 {
769            m.node_id = 1i32;
770        }
771        if version >= 1 {
772            m.host = "x";
773        }
774        if version >= 1 {
775            m.port = 1u16;
776        }
777        m
778    }
779}
krabka_protocol/opt/rustwide/workdir/generated/FetchSnapshotResponse.borrowed.rs

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