krabka_protocol/opt/rustwide/workdir/generated/
LeaveGroupResponse.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::leave_group_response,
7    primitives::{
8        array::{array_len_prefix_len, get_array_len, put_array_len},
9        fixed::{get_i16, get_i32, put_i16, put_i32},
10        string_bytes::{
11            compact_nullable_string_len, compact_string_len, nullable_string_len,
12            put_compact_nullable_string, put_compact_string, put_nullable_string, put_string,
13            string_len,
14        },
15        string_bytes_borrowed::{
16            get_compact_nullable_string_borrowed, get_compact_string_borrowed,
17            get_nullable_string_borrowed, get_string_borrowed,
18        },
19    },
20    tagged_fields::{WriteTaggedFields, read_tagged_fields, tagged_fields_len},
21};
22pub const API_KEY: i16 = 13;
23pub const MIN_VERSION: i16 = 0;
24pub const MAX_VERSION: i16 = 5;
25pub const FLEXIBLE_MIN: i16 = 4;
26#[inline]
27#[must_use]
28pub fn is_flexible(version: i16) -> bool {
29    version >= FLEXIBLE_MIN
30}
31#[derive(Debug, Clone, PartialEq, Eq, Default)]
32pub struct LeaveGroupResponse<'a> {
33    pub throttle_time_ms: i32,
34    pub error_code: i16,
35    pub members: Vec<MemberResponse<'a>>,
36    pub unknown_tagged_fields: UnknownTaggedFields,
37}
38impl LeaveGroupResponse<'_> {
39    #[must_use]
40    pub fn to_owned(&self) -> leave_group_response::LeaveGroupResponse {
41        leave_group_response::LeaveGroupResponse {
42            throttle_time_ms: (self.throttle_time_ms),
43            error_code: (self.error_code),
44            members: (self.members)
45                .iter()
46                .map(MemberResponse::to_owned)
47                .collect(),
48            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
49        }
50    }
51}
52impl Encode for LeaveGroupResponse<'_> {
53    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
54        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
55            return Err(ProtocolError::UnsupportedVersion {
56                api_key: API_KEY,
57                version,
58            });
59        }
60        let flex = is_flexible(version);
61        if version >= 1 {
62            put_i32(buf, self.throttle_time_ms);
63        }
64        if version >= 0 {
65            put_i16(buf, self.error_code);
66        }
67        if version >= 3 {
68            {
69                put_array_len(buf, (self.members).len(), flex)?;
70                for it in &self.members {
71                    it.encode(buf, version)?;
72                }
73            }
74        }
75        if flex {
76            let tagged = WriteTaggedFields::new();
77            tagged.write(buf, &self.unknown_tagged_fields)?;
78        }
79        Ok(())
80    }
81    fn encoded_len(&self, version: i16) -> usize {
82        let flex = is_flexible(version);
83        let mut n: usize = 0;
84        if version >= 1 {
85            n += 4;
86        }
87        if version >= 0 {
88            n += 2;
89        }
90        if version >= 3 {
91            n += {
92                let prefix = array_len_prefix_len((self.members).len(), flex);
93                let body: usize = (self.members)
94                    .iter()
95                    .map(|it| it.encoded_len(version))
96                    .sum();
97                prefix + body
98            };
99        }
100        if flex {
101            let known_pairs: Vec<(u32, usize)> = Vec::new();
102            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
103        }
104        n
105    }
106}
107impl<'de> DecodeBorrow<'de> for LeaveGroupResponse<'de> {
108    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
109        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
110            return Err(ProtocolError::UnsupportedVersion {
111                api_key: API_KEY,
112                version,
113            });
114        }
115        let flex = is_flexible(version);
116        let mut out = Self::default();
117        if version >= 1 {
118            out.throttle_time_ms = get_i32(buf)?;
119        }
120        if version >= 0 {
121            out.error_code = get_i16(buf)?;
122        }
123        if version >= 3 {
124            out.members = {
125                let n = get_array_len(buf, flex)?;
126                let mut v = Vec::with_capacity(n);
127                for _ in 0..n {
128                    v.push(MemberResponse::decode_borrow(buf, version)?);
129                }
130                v
131            };
132        }
133        if flex {
134            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
135        }
136        Ok(out)
137    }
138}
139#[cfg(test)]
140impl LeaveGroupResponse<'_> {
141    #[must_use]
142    pub fn populated(version: i16) -> Self {
143        let mut m = Self::default();
144        if version >= 1 {
145            m.throttle_time_ms = 1i32;
146        }
147        if version >= 0 {
148            m.error_code = 1i16;
149        }
150        if version >= 3 {
151            m.members = vec![MemberResponse::populated(version)];
152        }
153        m
154    }
155}
156#[derive(Debug, Clone, PartialEq, Eq)]
157pub struct MemberResponse<'a> {
158    pub member_id: &'a str,
159    pub group_instance_id: Option<&'a str>,
160    pub error_code: i16,
161    pub unknown_tagged_fields: UnknownTaggedFields,
162}
163impl Default for MemberResponse<'_> {
164    fn default() -> Self {
165        Self {
166            member_id: "",
167            group_instance_id: Some(""),
168            error_code: 0i16,
169            unknown_tagged_fields: UnknownTaggedFields::default(),
170        }
171    }
172}
173impl MemberResponse<'_> {
174    #[must_use]
175    pub fn to_owned(&self) -> leave_group_response::MemberResponse {
176        leave_group_response::MemberResponse {
177            member_id: (self.member_id).to_owned(),
178            group_instance_id: (self.group_instance_id).map(str::to_owned),
179            error_code: (self.error_code),
180            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
181        }
182    }
183}
184impl Encode for MemberResponse<'_> {
185    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
186        let flex = version >= 4;
187        if version >= 3 {
188            if flex {
189                put_compact_string(buf, self.member_id)?;
190            } else {
191                put_string(buf, self.member_id)?;
192            }
193        }
194        if version >= 3 {
195            if flex {
196                put_compact_nullable_string(buf, self.group_instance_id)?;
197            } else {
198                put_nullable_string(buf, self.group_instance_id)?;
199            }
200        }
201        if version >= 3 {
202            put_i16(buf, self.error_code);
203        }
204        if flex {
205            let tagged = WriteTaggedFields::new();
206            tagged.write(buf, &self.unknown_tagged_fields)?;
207        }
208        Ok(())
209    }
210    fn encoded_len(&self, version: i16) -> usize {
211        let flex = version >= 4;
212        let mut n: usize = 0;
213        if version >= 3 {
214            n += if flex {
215                compact_string_len(self.member_id)
216            } else {
217                string_len(self.member_id)
218            };
219        }
220        if version >= 3 {
221            n += if flex {
222                compact_nullable_string_len(self.group_instance_id)
223            } else {
224                nullable_string_len(self.group_instance_id)
225            };
226        }
227        if version >= 3 {
228            n += 2;
229        }
230        if flex {
231            let known_pairs: Vec<(u32, usize)> = Vec::new();
232            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
233        }
234        n
235    }
236}
237impl<'de> DecodeBorrow<'de> for MemberResponse<'de> {
238    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
239        let flex = version >= 4;
240        let mut out = Self::default();
241        if version >= 3 {
242            out.member_id = if flex {
243                get_compact_string_borrowed(buf)?
244            } else {
245                get_string_borrowed(buf)?
246            };
247        }
248        if version >= 3 {
249            out.group_instance_id = if flex {
250                get_compact_nullable_string_borrowed(buf)?
251            } else {
252                get_nullable_string_borrowed(buf)?
253            };
254        }
255        if version >= 3 {
256            out.error_code = get_i16(buf)?;
257        }
258        if flex {
259            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
260        }
261        Ok(out)
262    }
263}
264#[cfg(test)]
265impl MemberResponse<'_> {
266    #[must_use]
267    pub fn populated(version: i16) -> Self {
268        let mut m = Self::default();
269        if version >= 3 {
270            m.member_id = "x";
271        }
272        if version >= 3 {
273            m.group_instance_id = Some("x");
274        }
275        if version >= 3 {
276            m.error_code = 1i16;
277        }
278        m
279    }
280}
krabka_protocol/opt/rustwide/workdir/generated/LeaveGroupResponse.borrowed.rs

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