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

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

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