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

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

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