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

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

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