crabka_protocol/opt/rustwide/workdir/generated/
ReadShareGroupStateResponse.borrowed.rs

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

crabka_protocol/opt/rustwide/workdir/generated/
ReadShareGroupStateResponse.borrowed.rs
