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