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

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

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