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

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