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