krabka_protocol/opt/rustwide/workdir/generated/
AlterConfigsRequest.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::alter_configs_request,
7    primitives::{
8        array::{array_len_prefix_len, get_array_len, put_array_len},
9        fixed::{get_bool, get_i8, put_bool, put_i8},
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 = 33;
23pub const MIN_VERSION: i16 = 0;
24pub const MAX_VERSION: i16 = 2;
25pub const LATEST_STABLE_VERSION: i16 = 2;
26pub const FLEXIBLE_MIN: i16 = 2;
27#[inline]
28#[must_use]
29pub fn is_flexible(version: i16) -> bool {
30    version >= FLEXIBLE_MIN
31}
32#[derive(Debug, Clone, PartialEq, Eq, Default)]
33pub struct AlterConfigsRequest<'a> {
34    pub resources: Vec<AlterConfigsResource<'a>>,
35    pub validate_only: bool,
36    pub unknown_tagged_fields: UnknownTaggedFields,
37}
38impl AlterConfigsRequest<'_> {
39    #[must_use]
40    pub fn to_owned(&self) -> alter_configs_request::AlterConfigsRequest {
41        alter_configs_request::AlterConfigsRequest {
42            resources: (self.resources)
43                .iter()
44                .map(AlterConfigsResource::to_owned)
45                .collect(),
46            validate_only: (self.validate_only),
47            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
48        }
49    }
50}
51impl Encode for AlterConfigsRequest<'_> {
52    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
53        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
54            return Err(ProtocolError::UnsupportedVersion {
55                api_key: API_KEY,
56                version,
57            });
58        }
59        let flex = is_flexible(version);
60        if version >= 0 {
61            {
62                put_array_len(buf, (self.resources).len(), flex)?;
63                for it in &self.resources {
64                    it.encode(buf, version)?;
65                }
66            }
67        }
68        if version >= 0 {
69            put_bool(buf, self.validate_only);
70        }
71        if flex {
72            let tagged = WriteTaggedFields::new();
73            tagged.write(buf, &self.unknown_tagged_fields)?;
74        }
75        Ok(())
76    }
77    fn encoded_len(&self, version: i16) -> usize {
78        let flex = is_flexible(version);
79        let mut n: usize = 0;
80        if version >= 0 {
81            n += {
82                let prefix = array_len_prefix_len((self.resources).len(), flex);
83                let body: usize = (self.resources)
84                    .iter()
85                    .map(|it| it.encoded_len(version))
86                    .sum();
87                prefix + body
88            };
89        }
90        if version >= 0 {
91            n += 1;
92        }
93        if flex {
94            let known_pairs: Vec<(u32, usize)> = Vec::new();
95            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
96        }
97        n
98    }
99}
100impl<'de> DecodeBorrow<'de> for AlterConfigsRequest<'de> {
101    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
102        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
103            return Err(ProtocolError::UnsupportedVersion {
104                api_key: API_KEY,
105                version,
106            });
107        }
108        let flex = is_flexible(version);
109        let mut out = Self::default();
110        if version >= 0 {
111            out.resources = {
112                let n = get_array_len(buf, flex)?;
113                let mut v = Vec::with_capacity(n);
114                for _ in 0..n {
115                    v.push(AlterConfigsResource::decode_borrow(buf, version)?);
116                }
117                v
118            };
119        }
120        if version >= 0 {
121            out.validate_only = get_bool(buf)?;
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 AlterConfigsRequest<'_> {
131    #[must_use]
132    pub fn populated(version: i16) -> Self {
133        let mut m = Self::default();
134        if version >= 0 {
135            m.resources = vec![AlterConfigsResource::populated(version)];
136        }
137        if version >= 0 {
138            m.validate_only = true;
139        }
140        m
141    }
142}
143#[derive(Debug, Clone, PartialEq, Eq, Default)]
144pub struct AlterConfigsResource<'a> {
145    pub resource_type: i8,
146    pub resource_name: &'a str,
147    pub configs: Vec<AlterableConfig<'a>>,
148    pub unknown_tagged_fields: UnknownTaggedFields,
149}
150impl AlterConfigsResource<'_> {
151    #[must_use]
152    pub fn to_owned(&self) -> alter_configs_request::AlterConfigsResource {
153        alter_configs_request::AlterConfigsResource {
154            resource_type: (self.resource_type),
155            resource_name: (self.resource_name).to_owned(),
156            configs: (self.configs)
157                .iter()
158                .map(AlterableConfig::to_owned)
159                .collect(),
160            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
161        }
162    }
163}
164impl Encode for AlterConfigsResource<'_> {
165    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
166        let flex = version >= 2;
167        if version >= 0 {
168            put_i8(buf, self.resource_type);
169        }
170        if version >= 0 {
171            if flex {
172                put_compact_string(buf, self.resource_name)?;
173            } else {
174                put_string(buf, self.resource_name)?;
175            }
176        }
177        if version >= 0 {
178            {
179                put_array_len(buf, (self.configs).len(), flex)?;
180                for it in &self.configs {
181                    it.encode(buf, version)?;
182                }
183            }
184        }
185        if flex {
186            let tagged = WriteTaggedFields::new();
187            tagged.write(buf, &self.unknown_tagged_fields)?;
188        }
189        Ok(())
190    }
191    fn encoded_len(&self, version: i16) -> usize {
192        let flex = version >= 2;
193        let mut n: usize = 0;
194        if version >= 0 {
195            n += 1;
196        }
197        if version >= 0 {
198            n += if flex {
199                compact_string_len(self.resource_name)
200            } else {
201                string_len(self.resource_name)
202            };
203        }
204        if version >= 0 {
205            n += {
206                let prefix = array_len_prefix_len((self.configs).len(), flex);
207                let body: usize = (self.configs)
208                    .iter()
209                    .map(|it| it.encoded_len(version))
210                    .sum();
211                prefix + body
212            };
213        }
214        if flex {
215            let known_pairs: Vec<(u32, usize)> = Vec::new();
216            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
217        }
218        n
219    }
220}
221impl<'de> DecodeBorrow<'de> for AlterConfigsResource<'de> {
222    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
223        let flex = version >= 2;
224        let mut out = Self::default();
225        if version >= 0 {
226            out.resource_type = get_i8(buf)?;
227        }
228        if version >= 0 {
229            out.resource_name = if flex {
230                get_compact_string_borrowed(buf)?
231            } else {
232                get_string_borrowed(buf)?
233            };
234        }
235        if version >= 0 {
236            out.configs = {
237                let n = get_array_len(buf, flex)?;
238                let mut v = Vec::with_capacity(n);
239                for _ in 0..n {
240                    v.push(AlterableConfig::decode_borrow(buf, version)?);
241                }
242                v
243            };
244        }
245        if flex {
246            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
247        }
248        Ok(out)
249    }
250}
251#[cfg(test)]
252impl AlterConfigsResource<'_> {
253    #[must_use]
254    pub fn populated(version: i16) -> Self {
255        let mut m = Self::default();
256        if version >= 0 {
257            m.resource_type = 1i8;
258        }
259        if version >= 0 {
260            m.resource_name = "x";
261        }
262        if version >= 0 {
263            m.configs = vec![AlterableConfig::populated(version)];
264        }
265        m
266    }
267}
268#[derive(Debug, Clone, PartialEq, Eq)]
269pub struct AlterableConfig<'a> {
270    pub name: &'a str,
271    pub value: Option<&'a str>,
272    pub unknown_tagged_fields: UnknownTaggedFields,
273}
274impl Default for AlterableConfig<'_> {
275    fn default() -> Self {
276        Self {
277            name: "",
278            value: Some(""),
279            unknown_tagged_fields: UnknownTaggedFields::default(),
280        }
281    }
282}
283impl AlterableConfig<'_> {
284    #[must_use]
285    pub fn to_owned(&self) -> alter_configs_request::AlterableConfig {
286        alter_configs_request::AlterableConfig {
287            name: (self.name).to_owned(),
288            value: (self.value).map(str::to_owned),
289            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
290        }
291    }
292}
293impl Encode for AlterableConfig<'_> {
294    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
295        let flex = version >= 2;
296        if version >= 0 {
297            if flex {
298                put_compact_string(buf, self.name)?;
299            } else {
300                put_string(buf, self.name)?;
301            }
302        }
303        if version >= 0 {
304            if flex {
305                put_compact_nullable_string(buf, self.value)?;
306            } else {
307                put_nullable_string(buf, self.value)?;
308            }
309        }
310        if flex {
311            let tagged = WriteTaggedFields::new();
312            tagged.write(buf, &self.unknown_tagged_fields)?;
313        }
314        Ok(())
315    }
316    fn encoded_len(&self, version: i16) -> usize {
317        let flex = version >= 2;
318        let mut n: usize = 0;
319        if version >= 0 {
320            n += if flex {
321                compact_string_len(self.name)
322            } else {
323                string_len(self.name)
324            };
325        }
326        if version >= 0 {
327            n += if flex {
328                compact_nullable_string_len(self.value)
329            } else {
330                nullable_string_len(self.value)
331            };
332        }
333        if flex {
334            let known_pairs: Vec<(u32, usize)> = Vec::new();
335            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
336        }
337        n
338    }
339}
340impl<'de> DecodeBorrow<'de> for AlterableConfig<'de> {
341    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
342        let flex = version >= 2;
343        let mut out = Self::default();
344        if version >= 0 {
345            out.name = if flex {
346                get_compact_string_borrowed(buf)?
347            } else {
348                get_string_borrowed(buf)?
349            };
350        }
351        if version >= 0 {
352            out.value = if flex {
353                get_compact_nullable_string_borrowed(buf)?
354            } else {
355                get_nullable_string_borrowed(buf)?
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 AlterableConfig<'_> {
366    #[must_use]
367    pub fn populated(version: i16) -> Self {
368        let mut m = Self::default();
369        if version >= 0 {
370            m.name = "x";
371        }
372        if version >= 0 {
373            m.value = Some("x");
374        }
375        m
376    }
377}
krabka_protocol/opt/rustwide/workdir/generated/AlterConfigsRequest.borrowed.rs

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