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

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