krabka_protocol/opt/rustwide/workdir/generated/
ApiVersionsResponse.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    primitives::{
7        fixed::{get_bool, get_i16, get_i32, get_i64, put_bool, put_i16, put_i32, put_i64},
8        string_bytes::{compact_string_len, put_compact_string, put_string, string_len},
9        string_bytes_borrowed::{get_compact_string_borrowed, get_string_borrowed},
10    },
11    tagged_fields::{WriteTaggedFields, encode_to_bytes, read_tagged_fields, tagged_fields_len},
12};
13pub const API_KEY: i16 = 18;
14pub const MIN_VERSION: i16 = 0;
15pub const MAX_VERSION: i16 = 5;
16pub const FLEXIBLE_MIN: i16 = 3;
17#[inline]
18#[must_use]
19pub fn is_flexible(version: i16) -> bool {
20    version >= FLEXIBLE_MIN
21}
22#[derive(Debug, Clone, PartialEq, Eq)]
23pub struct ApiVersionsResponse {
24    pub error_code: i16,
25    pub api_keys: Vec<ApiVersion>,
26    pub throttle_time_ms: i32,
27    pub supported_features: Vec<crate::owned::api_versions_response::SupportedFeatureKey>,
28    pub finalized_features_epoch: i64,
29    pub finalized_features: Vec<crate::owned::api_versions_response::FinalizedFeatureKey>,
30    pub zk_migration_ready: bool,
31    pub unknown_tagged_fields: UnknownTaggedFields,
32}
33impl Default for ApiVersionsResponse {
34    fn default() -> Self {
35        Self {
36            error_code: 0i16,
37            api_keys: Vec::new(),
38            throttle_time_ms: 0i32,
39            supported_features: Vec::new(),
40            finalized_features_epoch: -1i64,
41            finalized_features: Vec::new(),
42            zk_migration_ready: false,
43            unknown_tagged_fields: UnknownTaggedFields::default(),
44        }
45    }
46}
47impl ApiVersionsResponse {
48    /// # Panics
49    ///
50    /// Panics if a records field contains an invalid encoded record batch.
51    #[must_use]
52    pub fn to_owned(&self) -> crate::owned::api_versions_response::ApiVersionsResponse {
53        crate::owned::api_versions_response::ApiVersionsResponse {
54            error_code: (self.error_code),
55            api_keys: (self.api_keys).iter().map(ApiVersion::to_owned).collect(),
56            throttle_time_ms: (self.throttle_time_ms),
57            supported_features: self.supported_features.clone(),
58            finalized_features_epoch: (self.finalized_features_epoch),
59            finalized_features: self.finalized_features.clone(),
60            zk_migration_ready: (self.zk_migration_ready),
61            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
62        }
63    }
64}
65impl Encode for ApiVersionsResponse {
66    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
67        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
68            return Err(ProtocolError::UnsupportedVersion {
69                api_key: API_KEY,
70                version,
71            });
72        }
73        let flex = is_flexible(version);
74        if version >= 0 {
75            put_i16(buf, self.error_code);
76        }
77        if version >= 0 {
78            {
79                crate::primitives::array::put_array_len(buf, (self.api_keys).len(), flex);
80                for it in &self.api_keys {
81                    it.encode(buf, version)?;
82                }
83            };
84        }
85        if version >= 1 {
86            put_i32(buf, self.throttle_time_ms);
87        }
88        if flex {
89            let mut tagged = WriteTaggedFields::new();
90            if !(crate::codegen_helpers::is_default(&self.supported_features)) {
91                let payload = encode_to_bytes(
92                    {
93                        let prefix = crate::primitives::array::array_len_prefix_len(
94                            (self.supported_features).len(),
95                            flex,
96                        );
97                        let body: usize = (self.supported_features)
98                            .iter()
99                            .map(|it| it.encoded_len(version))
100                            .sum();
101                        prefix + body
102                    },
103                    |b| {
104                        {
105                            crate::primitives::array::put_array_len(
106                                b,
107                                (self.supported_features).len(),
108                                flex,
109                            );
110                            for it in &self.supported_features {
111                                it.encode(b, version)?;
112                            }
113                        };
114                        Ok(())
115                    },
116                );
117                tagged.add(0, payload);
118            }
119            if self.finalized_features_epoch != -1i64 {
120                let payload = encode_to_bytes(8, |b| {
121                    put_i64(b, self.finalized_features_epoch);
122                    Ok(())
123                });
124                tagged.add(1, payload);
125            }
126            if !(crate::codegen_helpers::is_default(&self.finalized_features)) {
127                let payload = encode_to_bytes(
128                    {
129                        let prefix = crate::primitives::array::array_len_prefix_len(
130                            (self.finalized_features).len(),
131                            flex,
132                        );
133                        let body: usize = (self.finalized_features)
134                            .iter()
135                            .map(|it| it.encoded_len(version))
136                            .sum();
137                        prefix + body
138                    },
139                    |b| {
140                        {
141                            crate::primitives::array::put_array_len(
142                                b,
143                                (self.finalized_features).len(),
144                                flex,
145                            );
146                            for it in &self.finalized_features {
147                                it.encode(b, version)?;
148                            }
149                        };
150                        Ok(())
151                    },
152                );
153                tagged.add(2, payload);
154            }
155            if self.zk_migration_ready {
156                let payload = encode_to_bytes(1, |b| {
157                    put_bool(b, self.zk_migration_ready);
158                    Ok(())
159                });
160                tagged.add(3, payload);
161            }
162            tagged.write(buf, &self.unknown_tagged_fields);
163        }
164        Ok(())
165    }
166    fn encoded_len(&self, version: i16) -> usize {
167        let flex = is_flexible(version);
168        let mut n: usize = 0;
169        if version >= 0 {
170            n += 2;
171        }
172        if version >= 0 {
173            n += {
174                let prefix =
175                    crate::primitives::array::array_len_prefix_len((self.api_keys).len(), flex);
176                let body: usize = (self.api_keys)
177                    .iter()
178                    .map(|it| it.encoded_len(version))
179                    .sum();
180                prefix + body
181            };
182        }
183        if version >= 1 {
184            n += 4;
185        }
186        if flex {
187            let mut known_pairs: Vec<(u32, usize)> = Vec::new();
188            if !(crate::codegen_helpers::is_default(&self.supported_features)) {
189                known_pairs.push((0, {
190                    let prefix = crate::primitives::array::array_len_prefix_len(
191                        (self.supported_features).len(),
192                        flex,
193                    );
194                    let body: usize = (self.supported_features)
195                        .iter()
196                        .map(|it| it.encoded_len(version))
197                        .sum();
198                    prefix + body
199                }));
200            }
201            if self.finalized_features_epoch != -1i64 {
202                known_pairs.push((1, 8));
203            }
204            if !(crate::codegen_helpers::is_default(&self.finalized_features)) {
205                known_pairs.push((2, {
206                    let prefix = crate::primitives::array::array_len_prefix_len(
207                        (self.finalized_features).len(),
208                        flex,
209                    );
210                    let body: usize = (self.finalized_features)
211                        .iter()
212                        .map(|it| it.encoded_len(version))
213                        .sum();
214                    prefix + body
215                }));
216            }
217            if self.zk_migration_ready {
218                known_pairs.push((3, 1));
219            }
220            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
221        }
222        n
223    }
224}
225impl<'de> DecodeBorrow<'de> for ApiVersionsResponse {
226    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
227        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
228            return Err(ProtocolError::UnsupportedVersion {
229                api_key: API_KEY,
230                version,
231            });
232        }
233        let flex = is_flexible(version);
234        let mut out = Self::default();
235        if version >= 0 {
236            out.error_code = get_i16(buf)?;
237        }
238        if version >= 0 {
239            out.api_keys = {
240                let n = crate::primitives::array::get_array_len(buf, flex)?;
241                let mut v = Vec::with_capacity(n);
242                for _ in 0..n {
243                    v.push(ApiVersion::decode_borrow(buf, version)?);
244                }
245                v
246            };
247        }
248        if version >= 1 {
249            out.throttle_time_ms = get_i32(buf)?;
250        }
251        if flex {
252            let mut tag_supported_features = None;
253            let mut tag_finalized_features_epoch = None;
254            let mut tag_finalized_features = None;
255            let mut tag_zk_migration_ready = None;
256            out.unknown_tagged_fields = read_tagged_fields(buf, |tag, payload| match tag {
257                0 => {
258                    tag_supported_features = Some({
259                        let b: &mut &[u8] = payload;
260                        {
261                            let n = crate::primitives::array::get_array_len(b, flex)?;
262                            let mut v = Vec::with_capacity(n);
263                            for _ in 0..n {
264                                v.push(crate::owned::api_versions_response::SupportedFeatureKey::decode(b, version)?);
265                            }
266                            v
267                        }
268                    });
269                    Ok(true)
270                }
271                1 => {
272                    tag_finalized_features_epoch = Some({
273                        let b: &mut &[u8] = payload;
274                        get_i64(b)?
275                    });
276                    Ok(true)
277                }
278                2 => {
279                    tag_finalized_features = Some({
280                        let b: &mut &[u8] = payload;
281                        {
282                            let n = crate::primitives::array::get_array_len(b, flex)?;
283                            let mut v = Vec::with_capacity(n);
284                            for _ in 0..n {
285                                v.push(crate::owned::api_versions_response::FinalizedFeatureKey::decode(b, version)?);
286                            }
287                            v
288                        }
289                    });
290                    Ok(true)
291                }
292                3 => {
293                    tag_zk_migration_ready = Some({
294                        let b: &mut &[u8] = payload;
295                        get_bool(b)?
296                    });
297                    Ok(true)
298                }
299                _ => Ok(false),
300            })?;
301            if let Some(v) = tag_supported_features {
302                out.supported_features = v;
303            }
304            if let Some(v) = tag_finalized_features_epoch {
305                out.finalized_features_epoch = v;
306            }
307            if let Some(v) = tag_finalized_features {
308                out.finalized_features = v;
309            }
310            if let Some(v) = tag_zk_migration_ready {
311                out.zk_migration_ready = v;
312            }
313        }
314        Ok(out)
315    }
316}
317#[cfg(test)]
318impl ApiVersionsResponse {
319    #[must_use]
320    pub fn populated(version: i16) -> Self {
321        let mut m = Self::default();
322        if version >= 0 {
323            m.error_code = 1i16;
324        }
325        if version >= 0 {
326            m.api_keys = vec![ApiVersion::populated(version)];
327        }
328        if version >= 1 {
329            m.throttle_time_ms = 1i32;
330        }
331        if version >= 3 {
332            m.supported_features =
333                vec![crate::owned::api_versions_response::SupportedFeatureKey::populated(version)];
334        }
335        if version >= 3 {
336            m.finalized_features_epoch = 1i64;
337        }
338        if version >= 3 {
339            m.finalized_features =
340                vec![crate::owned::api_versions_response::FinalizedFeatureKey::populated(version)];
341        }
342        if version >= 3 {
343            m.zk_migration_ready = true;
344        }
345        m
346    }
347}
348#[derive(Debug, Clone, PartialEq, Eq, Default)]
349pub struct ApiVersion {
350    pub api_key: i16,
351    pub min_version: i16,
352    pub max_version: i16,
353    pub unknown_tagged_fields: UnknownTaggedFields,
354}
355impl ApiVersion {
356    /// # Panics
357    ///
358    /// Panics if a records field contains an invalid encoded record batch.
359    #[must_use]
360    pub fn to_owned(&self) -> crate::owned::api_versions_response::ApiVersion {
361        crate::owned::api_versions_response::ApiVersion {
362            api_key: (self.api_key),
363            min_version: (self.min_version),
364            max_version: (self.max_version),
365            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
366        }
367    }
368}
369impl Encode for ApiVersion {
370    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
371        let flex = version >= 3;
372        if version >= 0 {
373            put_i16(buf, self.api_key);
374        }
375        if version >= 0 {
376            put_i16(buf, self.min_version);
377        }
378        if version >= 0 {
379            put_i16(buf, self.max_version);
380        }
381        if flex {
382            let tagged = WriteTaggedFields::new();
383            tagged.write(buf, &self.unknown_tagged_fields);
384        }
385        Ok(())
386    }
387    fn encoded_len(&self, version: i16) -> usize {
388        let flex = version >= 3;
389        let mut n: usize = 0;
390        if version >= 0 {
391            n += 2;
392        }
393        if version >= 0 {
394            n += 2;
395        }
396        if version >= 0 {
397            n += 2;
398        }
399        if flex {
400            let known_pairs: Vec<(u32, usize)> = Vec::new();
401            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
402        }
403        n
404    }
405}
406impl<'de> DecodeBorrow<'de> for ApiVersion {
407    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
408        let flex = version >= 3;
409        let mut out = Self::default();
410        if version >= 0 {
411            out.api_key = get_i16(buf)?;
412        }
413        if version >= 0 {
414            out.min_version = get_i16(buf)?;
415        }
416        if version >= 0 {
417            out.max_version = get_i16(buf)?;
418        }
419        if flex {
420            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
421        }
422        Ok(out)
423    }
424}
425#[cfg(test)]
426impl ApiVersion {
427    #[must_use]
428    pub fn populated(version: i16) -> Self {
429        let mut m = Self::default();
430        if version >= 0 {
431            m.api_key = 1i16;
432        }
433        if version >= 0 {
434            m.min_version = 1i16;
435        }
436        if version >= 0 {
437            m.max_version = 1i16;
438        }
439        m
440    }
441}
442#[derive(Debug, Clone, PartialEq, Eq, Default)]
443pub struct SupportedFeatureKey<'a> {
444    pub name: &'a str,
445    pub min_version: i16,
446    pub max_version: i16,
447    pub unknown_tagged_fields: UnknownTaggedFields,
448}
449impl SupportedFeatureKey<'_> {
450    /// # Panics
451    ///
452    /// Panics if a records field contains an invalid encoded record batch.
453    #[must_use]
454    pub fn to_owned(&self) -> crate::owned::api_versions_response::SupportedFeatureKey {
455        crate::owned::api_versions_response::SupportedFeatureKey {
456            name: (self.name).to_string(),
457            min_version: (self.min_version),
458            max_version: (self.max_version),
459            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
460        }
461    }
462}
463impl Encode for SupportedFeatureKey<'_> {
464    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
465        let flex = version >= 3;
466        if version >= 3 {
467            if flex {
468                let () = put_compact_string(buf, self.name);
469            } else {
470                let () = put_string(buf, self.name);
471            }
472        }
473        if version >= 3 {
474            put_i16(buf, self.min_version);
475        }
476        if version >= 3 {
477            put_i16(buf, self.max_version);
478        }
479        if flex {
480            let tagged = WriteTaggedFields::new();
481            tagged.write(buf, &self.unknown_tagged_fields);
482        }
483        Ok(())
484    }
485    fn encoded_len(&self, version: i16) -> usize {
486        let flex = version >= 3;
487        let mut n: usize = 0;
488        if version >= 3 {
489            n += if flex {
490                compact_string_len(self.name)
491            } else {
492                string_len(self.name)
493            };
494        }
495        if version >= 3 {
496            n += 2;
497        }
498        if version >= 3 {
499            n += 2;
500        }
501        if flex {
502            let known_pairs: Vec<(u32, usize)> = Vec::new();
503            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
504        }
505        n
506    }
507}
508impl<'de> DecodeBorrow<'de> for SupportedFeatureKey<'de> {
509    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
510        let flex = version >= 3;
511        let mut out = Self::default();
512        if version >= 3 {
513            out.name = if flex {
514                get_compact_string_borrowed(buf)?
515            } else {
516                get_string_borrowed(buf)?
517            };
518        }
519        if version >= 3 {
520            out.min_version = get_i16(buf)?;
521        }
522        if version >= 3 {
523            out.max_version = get_i16(buf)?;
524        }
525        if flex {
526            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
527        }
528        Ok(out)
529    }
530}
531#[cfg(test)]
532impl SupportedFeatureKey<'_> {
533    #[must_use]
534    pub fn populated(version: i16) -> Self {
535        let mut m = Self::default();
536        if version >= 3 {
537            m.name = "x";
538        }
539        if version >= 3 {
540            m.min_version = 1i16;
541        }
542        if version >= 3 {
543            m.max_version = 1i16;
544        }
545        m
546    }
547}
548#[derive(Debug, Clone, PartialEq, Eq, Default)]
549pub struct FinalizedFeatureKey<'a> {
550    pub name: &'a str,
551    pub max_version_level: i16,
552    pub min_version_level: i16,
553    pub unknown_tagged_fields: UnknownTaggedFields,
554}
555impl FinalizedFeatureKey<'_> {
556    /// # Panics
557    ///
558    /// Panics if a records field contains an invalid encoded record batch.
559    #[must_use]
560    pub fn to_owned(&self) -> crate::owned::api_versions_response::FinalizedFeatureKey {
561        crate::owned::api_versions_response::FinalizedFeatureKey {
562            name: (self.name).to_string(),
563            max_version_level: (self.max_version_level),
564            min_version_level: (self.min_version_level),
565            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
566        }
567    }
568}
569impl Encode for FinalizedFeatureKey<'_> {
570    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
571        let flex = version >= 3;
572        if version >= 3 {
573            if flex {
574                let () = put_compact_string(buf, self.name);
575            } else {
576                let () = put_string(buf, self.name);
577            }
578        }
579        if version >= 3 {
580            put_i16(buf, self.max_version_level);
581        }
582        if version >= 3 {
583            put_i16(buf, self.min_version_level);
584        }
585        if flex {
586            let tagged = WriteTaggedFields::new();
587            tagged.write(buf, &self.unknown_tagged_fields);
588        }
589        Ok(())
590    }
591    fn encoded_len(&self, version: i16) -> usize {
592        let flex = version >= 3;
593        let mut n: usize = 0;
594        if version >= 3 {
595            n += if flex {
596                compact_string_len(self.name)
597            } else {
598                string_len(self.name)
599            };
600        }
601        if version >= 3 {
602            n += 2;
603        }
604        if version >= 3 {
605            n += 2;
606        }
607        if flex {
608            let known_pairs: Vec<(u32, usize)> = Vec::new();
609            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
610        }
611        n
612    }
613}
614impl<'de> DecodeBorrow<'de> for FinalizedFeatureKey<'de> {
615    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
616        let flex = version >= 3;
617        let mut out = Self::default();
618        if version >= 3 {
619            out.name = if flex {
620                get_compact_string_borrowed(buf)?
621            } else {
622                get_string_borrowed(buf)?
623            };
624        }
625        if version >= 3 {
626            out.max_version_level = get_i16(buf)?;
627        }
628        if version >= 3 {
629            out.min_version_level = get_i16(buf)?;
630        }
631        if flex {
632            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
633        }
634        Ok(out)
635    }
636}
637#[cfg(test)]
638impl FinalizedFeatureKey<'_> {
639    #[must_use]
640    pub fn populated(version: i16) -> Self {
641        let mut m = Self::default();
642        if version >= 3 {
643            m.name = "x";
644        }
645        if version >= 3 {
646            m.max_version_level = 1i16;
647        }
648        if version >= 3 {
649            m.min_version_level = 1i16;
650        }
651        m
652    }
653}
krabka_protocol/opt/rustwide/workdir/generated/ApiVersionsResponse.borrowed.rs

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