krabka_protocol/opt/rustwide/workdir/generated/
WriteShareGroupStateRequest.borrowed.rs

1// AUTO-GENERATED by krabka-protocol-codegen against a9ce3221537b8653448750697915607dc7936cf3. Do not edit.
2use bytes::BufMut;
3
4use crate::{
5    DecodeBorrow, Encode, ProtocolError, UnknownTaggedFields,
6    owned::write_share_group_state_request,
7    primitives::{
8        array::{array_len_prefix_len, get_array_len, put_array_len},
9        fixed::{get_i8, get_i16, get_i32, get_i64, put_i8, put_i16, put_i32, put_i64},
10        string_bytes::{compact_string_len, put_compact_string, put_string, string_len},
11        string_bytes_borrowed::{get_compact_string_borrowed, get_string_borrowed},
12        uuid::{Uuid, get_uuid, put_uuid},
13    },
14    tagged_fields::{WriteTaggedFields, read_tagged_fields, tagged_fields_len},
15};
16pub const API_KEY: i16 = 85;
17pub const MIN_VERSION: i16 = 0;
18pub const MAX_VERSION: i16 = 1;
19pub const LATEST_STABLE_VERSION: i16 = 1;
20pub const FLEXIBLE_MIN: i16 = 0;
21#[inline]
22#[must_use]
23pub fn is_flexible(version: i16) -> bool {
24    version >= FLEXIBLE_MIN
25}
26#[derive(Debug, Clone, PartialEq, Eq, Default)]
27pub struct WriteShareGroupStateRequest<'a> {
28    pub group_id: &'a str,
29    pub topics: Vec<WriteStateData>,
30    pub unknown_tagged_fields: UnknownTaggedFields,
31}
32impl WriteShareGroupStateRequest<'_> {
33    #[must_use]
34    pub fn to_owned(&self) -> write_share_group_state_request::WriteShareGroupStateRequest {
35        write_share_group_state_request::WriteShareGroupStateRequest {
36            group_id: (self.group_id).to_owned(),
37            topics: (self.topics).iter().map(WriteStateData::to_owned).collect(),
38            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
39        }
40    }
41}
42impl Encode for WriteShareGroupStateRequest<'_> {
43    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
44        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
45            return Err(ProtocolError::UnsupportedVersion {
46                api_key: API_KEY,
47                version,
48            });
49        }
50        let flex = is_flexible(version);
51        if version >= 0 {
52            if flex {
53                put_compact_string(buf, self.group_id)?;
54            } else {
55                put_string(buf, self.group_id)?;
56            }
57        }
58        if version >= 0 {
59            {
60                put_array_len(buf, (self.topics).len(), flex)?;
61                for it in &self.topics {
62                    it.encode(buf, version)?;
63                }
64            }
65        }
66        if flex {
67            let tagged = WriteTaggedFields::new();
68            tagged.write(buf, &self.unknown_tagged_fields)?;
69        }
70        Ok(())
71    }
72    fn encoded_len(&self, version: i16) -> usize {
73        let flex = is_flexible(version);
74        let mut n: usize = 0;
75        if version >= 0 {
76            n += if flex {
77                compact_string_len(self.group_id)
78            } else {
79                string_len(self.group_id)
80            };
81        }
82        if version >= 0 {
83            n += {
84                let prefix = array_len_prefix_len((self.topics).len(), flex);
85                let body: usize = (self.topics).iter().map(|it| it.encoded_len(version)).sum();
86                prefix + body
87            };
88        }
89        if flex {
90            let known_pairs: Vec<(u32, usize)> = Vec::new();
91            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
92        }
93        n
94    }
95}
96impl<'de> DecodeBorrow<'de> for WriteShareGroupStateRequest<'de> {
97    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
98        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
99            return Err(ProtocolError::UnsupportedVersion {
100                api_key: API_KEY,
101                version,
102            });
103        }
104        let flex = is_flexible(version);
105        let mut out = Self::default();
106        if version >= 0 {
107            out.group_id = if flex {
108                get_compact_string_borrowed(buf)?
109            } else {
110                get_string_borrowed(buf)?
111            };
112        }
113        if version >= 0 {
114            out.topics = {
115                let n = get_array_len(buf, flex)?;
116                let mut v = Vec::with_capacity(n);
117                for _ in 0..n {
118                    v.push(WriteStateData::decode_borrow(buf, version)?);
119                }
120                v
121            };
122        }
123        if flex {
124            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
125        }
126        Ok(out)
127    }
128}
129#[cfg(test)]
130impl WriteShareGroupStateRequest<'_> {
131    #[must_use]
132    pub fn populated(version: i16) -> Self {
133        let mut m = Self::default();
134        if version >= 0 {
135            m.group_id = "x";
136        }
137        if version >= 0 {
138            m.topics = vec![WriteStateData::populated(version)];
139        }
140        m
141    }
142}
143#[derive(Debug, Clone, PartialEq, Eq, Default)]
144pub struct WriteStateData {
145    pub topic_id: Uuid,
146    pub partitions: Vec<PartitionData>,
147    pub unknown_tagged_fields: UnknownTaggedFields,
148}
149impl WriteStateData {
150    #[must_use]
151    pub fn to_owned(&self) -> write_share_group_state_request::WriteStateData {
152        write_share_group_state_request::WriteStateData {
153            topic_id: (self.topic_id),
154            partitions: (self.partitions)
155                .iter()
156                .map(PartitionData::to_owned)
157                .collect(),
158            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
159        }
160    }
161}
162impl Encode for WriteStateData {
163    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
164        let flex = version >= 0;
165        if version >= 0 {
166            put_uuid(buf, self.topic_id);
167        }
168        if version >= 0 {
169            {
170                put_array_len(buf, (self.partitions).len(), flex)?;
171                for it in &self.partitions {
172                    it.encode(buf, version)?;
173                }
174            }
175        }
176        if flex {
177            let tagged = WriteTaggedFields::new();
178            tagged.write(buf, &self.unknown_tagged_fields)?;
179        }
180        Ok(())
181    }
182    fn encoded_len(&self, version: i16) -> usize {
183        let flex = version >= 0;
184        let mut n: usize = 0;
185        if version >= 0 {
186            n += 16;
187        }
188        if version >= 0 {
189            n += {
190                let prefix = array_len_prefix_len((self.partitions).len(), flex);
191                let body: usize = (self.partitions)
192                    .iter()
193                    .map(|it| it.encoded_len(version))
194                    .sum();
195                prefix + body
196            };
197        }
198        if flex {
199            let known_pairs: Vec<(u32, usize)> = Vec::new();
200            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
201        }
202        n
203    }
204}
205impl<'de> DecodeBorrow<'de> for WriteStateData {
206    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
207        let flex = version >= 0;
208        let mut out = Self::default();
209        if version >= 0 {
210            out.topic_id = get_uuid(buf)?;
211        }
212        if version >= 0 {
213            out.partitions = {
214                let n = get_array_len(buf, flex)?;
215                let mut v = Vec::with_capacity(n);
216                for _ in 0..n {
217                    v.push(PartitionData::decode_borrow(buf, version)?);
218                }
219                v
220            };
221        }
222        if flex {
223            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
224        }
225        Ok(out)
226    }
227}
228#[cfg(test)]
229impl WriteStateData {
230    #[must_use]
231    pub fn populated(version: i16) -> Self {
232        let mut m = Self::default();
233        if version >= 0 {
234            m.topic_id = Uuid([1u8; 16]);
235        }
236        if version >= 0 {
237            m.partitions = vec![PartitionData::populated(version)];
238        }
239        m
240    }
241}
242#[derive(Debug, Clone, PartialEq, Eq)]
243pub struct PartitionData {
244    pub partition: i32,
245    pub state_epoch: i32,
246    pub leader_epoch: i32,
247    pub start_offset: i64,
248    pub delivery_complete_count: i32,
249    pub state_batches: Vec<StateBatch>,
250    pub unknown_tagged_fields: UnknownTaggedFields,
251}
252impl Default for PartitionData {
253    fn default() -> Self {
254        Self {
255            partition: 0i32,
256            state_epoch: 0i32,
257            leader_epoch: 0i32,
258            start_offset: 0i64,
259            delivery_complete_count: -1i32,
260            state_batches: Vec::new(),
261            unknown_tagged_fields: UnknownTaggedFields::default(),
262        }
263    }
264}
265impl PartitionData {
266    #[must_use]
267    pub fn to_owned(&self) -> write_share_group_state_request::PartitionData {
268        write_share_group_state_request::PartitionData {
269            partition: (self.partition),
270            state_epoch: (self.state_epoch),
271            leader_epoch: (self.leader_epoch),
272            start_offset: (self.start_offset),
273            delivery_complete_count: (self.delivery_complete_count),
274            state_batches: (self.state_batches)
275                .iter()
276                .map(StateBatch::to_owned)
277                .collect(),
278            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
279        }
280    }
281}
282impl Encode for PartitionData {
283    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
284        let flex = version >= 0;
285        if version >= 0 {
286            put_i32(buf, self.partition);
287        }
288        if version >= 0 {
289            put_i32(buf, self.state_epoch);
290        }
291        if version >= 0 {
292            put_i32(buf, self.leader_epoch);
293        }
294        if version >= 0 {
295            put_i64(buf, self.start_offset);
296        }
297        if version >= 1 {
298            put_i32(buf, self.delivery_complete_count);
299        }
300        if version >= 0 {
301            {
302                put_array_len(buf, (self.state_batches).len(), flex)?;
303                for it in &self.state_batches {
304                    it.encode(buf, version)?;
305                }
306            }
307        }
308        if flex {
309            let tagged = WriteTaggedFields::new();
310            tagged.write(buf, &self.unknown_tagged_fields)?;
311        }
312        Ok(())
313    }
314    fn encoded_len(&self, version: i16) -> usize {
315        let flex = version >= 0;
316        let mut n: usize = 0;
317        if version >= 0 {
318            n += 4;
319        }
320        if version >= 0 {
321            n += 4;
322        }
323        if version >= 0 {
324            n += 4;
325        }
326        if version >= 0 {
327            n += 8;
328        }
329        if version >= 1 {
330            n += 4;
331        }
332        if version >= 0 {
333            n += {
334                let prefix = array_len_prefix_len((self.state_batches).len(), flex);
335                let body: usize = (self.state_batches)
336                    .iter()
337                    .map(|it| it.encoded_len(version))
338                    .sum();
339                prefix + body
340            };
341        }
342        if flex {
343            let known_pairs: Vec<(u32, usize)> = Vec::new();
344            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
345        }
346        n
347    }
348}
349impl<'de> DecodeBorrow<'de> for PartitionData {
350    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
351        let flex = version >= 0;
352        let mut out = Self::default();
353        if version >= 0 {
354            out.partition = get_i32(buf)?;
355        }
356        if version >= 0 {
357            out.state_epoch = get_i32(buf)?;
358        }
359        if version >= 0 {
360            out.leader_epoch = get_i32(buf)?;
361        }
362        if version >= 0 {
363            out.start_offset = get_i64(buf)?;
364        }
365        if version >= 1 {
366            out.delivery_complete_count = get_i32(buf)?;
367        }
368        if version >= 0 {
369            out.state_batches = {
370                let n = get_array_len(buf, flex)?;
371                let mut v = Vec::with_capacity(n);
372                for _ in 0..n {
373                    v.push(StateBatch::decode_borrow(buf, version)?);
374                }
375                v
376            };
377        }
378        if flex {
379            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
380        }
381        Ok(out)
382    }
383}
384#[cfg(test)]
385impl PartitionData {
386    #[must_use]
387    pub fn populated(version: i16) -> Self {
388        let mut m = Self::default();
389        if version >= 0 {
390            m.partition = 1i32;
391        }
392        if version >= 0 {
393            m.state_epoch = 1i32;
394        }
395        if version >= 0 {
396            m.leader_epoch = 1i32;
397        }
398        if version >= 0 {
399            m.start_offset = 1i64;
400        }
401        if version >= 1 {
402            m.delivery_complete_count = 1i32;
403        }
404        if version >= 0 {
405            m.state_batches = vec![StateBatch::populated(version)];
406        }
407        m
408    }
409}
410#[derive(Debug, Clone, PartialEq, Eq, Default)]
411pub struct StateBatch {
412    pub first_offset: i64,
413    pub last_offset: i64,
414    pub delivery_state: i8,
415    pub delivery_count: i16,
416    pub unknown_tagged_fields: UnknownTaggedFields,
417}
418impl StateBatch {
419    #[must_use]
420    pub fn to_owned(&self) -> write_share_group_state_request::StateBatch {
421        write_share_group_state_request::StateBatch {
422            first_offset: (self.first_offset),
423            last_offset: (self.last_offset),
424            delivery_state: (self.delivery_state),
425            delivery_count: (self.delivery_count),
426            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
427        }
428    }
429}
430impl Encode for StateBatch {
431    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
432        let flex = version >= 0;
433        if version >= 0 {
434            put_i64(buf, self.first_offset);
435        }
436        if version >= 0 {
437            put_i64(buf, self.last_offset);
438        }
439        if version >= 0 {
440            put_i8(buf, self.delivery_state);
441        }
442        if version >= 0 {
443            put_i16(buf, self.delivery_count);
444        }
445        if flex {
446            let tagged = WriteTaggedFields::new();
447            tagged.write(buf, &self.unknown_tagged_fields)?;
448        }
449        Ok(())
450    }
451    fn encoded_len(&self, version: i16) -> usize {
452        let flex = version >= 0;
453        let mut n: usize = 0;
454        if version >= 0 {
455            n += 8;
456        }
457        if version >= 0 {
458            n += 8;
459        }
460        if version >= 0 {
461            n += 1;
462        }
463        if version >= 0 {
464            n += 2;
465        }
466        if flex {
467            let known_pairs: Vec<(u32, usize)> = Vec::new();
468            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
469        }
470        n
471    }
472}
473impl<'de> DecodeBorrow<'de> for StateBatch {
474    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
475        let flex = version >= 0;
476        let mut out = Self::default();
477        if version >= 0 {
478            out.first_offset = get_i64(buf)?;
479        }
480        if version >= 0 {
481            out.last_offset = get_i64(buf)?;
482        }
483        if version >= 0 {
484            out.delivery_state = get_i8(buf)?;
485        }
486        if version >= 0 {
487            out.delivery_count = get_i16(buf)?;
488        }
489        if flex {
490            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
491        }
492        Ok(out)
493    }
494}
495#[cfg(test)]
496impl StateBatch {
497    #[must_use]
498    pub fn populated(version: i16) -> Self {
499        let mut m = Self::default();
500        if version >= 0 {
501            m.first_offset = 1i64;
502        }
503        if version >= 0 {
504            m.last_offset = 1i64;
505        }
506        if version >= 0 {
507            m.delivery_state = 1i8;
508        }
509        if version >= 0 {
510            m.delivery_count = 1i16;
511        }
512        m
513    }
514}
krabka_protocol/opt/rustwide/workdir/generated/WriteShareGroupStateRequest.borrowed.rs

krabka_protocol/opt/rustwide/workdir/generated/
WriteShareGroupStateRequest.borrowed.rs
