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

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