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