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

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

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