krabka_protocol/opt/rustwide/workdir/generated/
AccessControlEntryRecord.owned.rs

1// AUTO-GENERATED by krabka-protocol-codegen against a9ce3221537b8653448750697915607dc7936cf3. Do not edit.
2
3use bytes::{Buf, BufMut};
4
5use crate::{
6    Decode, Encode, ProtocolError, UnknownTaggedFields,
7    primitives::{
8        fixed::{get_i8, put_i8},
9        string_bytes::{
10            compact_string_len, get_compact_string_owned, get_string_owned, put_compact_string,
11            put_string, string_len,
12        },
13        uuid::{Uuid, get_uuid, put_uuid},
14    },
15    tagged_fields::{WriteTaggedFields, read_tagged_fields, tagged_fields_len},
16};
17pub const MIN_VERSION: i16 = 0;
18pub const MAX_VERSION: i16 = 0;
19pub const FLEXIBLE_MIN: i16 = 0;
20#[inline]
21#[must_use]
22pub fn is_flexible(version: i16) -> bool {
23    version >= FLEXIBLE_MIN
24}
25#[derive(Debug, Clone, PartialEq, Eq, Default)]
26pub struct AccessControlEntryRecord {
27    pub id: Uuid,
28    pub resource_type: i8,
29    pub resource_name: String,
30    pub pattern_type: i8,
31    pub principal: String,
32    pub host: String,
33    pub operation: i8,
34    pub permission_type: i8,
35    pub unknown_tagged_fields: UnknownTaggedFields,
36}
37impl AccessControlEntryRecord {
38    fn encode_field_0<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
39        if version >= 0 {
40            put_uuid(buf, self.id);
41        }
42    }
43    fn encode_field_1<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
44        if version >= 0 {
45            put_i8(buf, self.resource_type);
46        }
47    }
48    fn encode_field_2<B: BufMut>(
49        &self,
50        buf: &mut B,
51        version: i16,
52        flex: bool,
53    ) -> Result<(), ProtocolError> {
54        if version >= 0 {
55            if flex {
56                put_compact_string(buf, &self.resource_name)?;
57            } else {
58                put_string(buf, &self.resource_name)?;
59            }
60        }
61        Ok(())
62    }
63    fn encode_field_3<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
64        if version >= 0 {
65            put_i8(buf, self.pattern_type);
66        }
67    }
68    fn encode_field_4<B: BufMut>(
69        &self,
70        buf: &mut B,
71        version: i16,
72        flex: bool,
73    ) -> Result<(), ProtocolError> {
74        if version >= 0 {
75            if flex {
76                put_compact_string(buf, &self.principal)?;
77            } else {
78                put_string(buf, &self.principal)?;
79            }
80        }
81        Ok(())
82    }
83    fn encode_field_5<B: BufMut>(
84        &self,
85        buf: &mut B,
86        version: i16,
87        flex: bool,
88    ) -> Result<(), ProtocolError> {
89        if version >= 0 {
90            if flex {
91                put_compact_string(buf, &self.host)?;
92            } else {
93                put_string(buf, &self.host)?;
94            }
95        }
96        Ok(())
97    }
98    fn encode_field_6<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
99        if version >= 0 {
100            put_i8(buf, self.operation);
101        }
102    }
103    fn encode_field_7<B: BufMut>(&self, buf: &mut B, version: i16, _flex: bool) {
104        if version >= 0 {
105            put_i8(buf, self.permission_type);
106        }
107    }
108    fn encode_tagged_fields<B: BufMut>(
109        &self,
110        buf: &mut B,
111        _version: i16,
112        flex: bool,
113    ) -> Result<(), ProtocolError> {
114        if flex {
115            let tagged = WriteTaggedFields::new();
116            tagged.write(buf, &self.unknown_tagged_fields)?;
117        }
118        Ok(())
119    }
120    fn decode_field_0<B: Buf>(
121        out: &mut Self,
122        buf: &mut B,
123        version: i16,
124        _flex: bool,
125    ) -> Result<(), ProtocolError> {
126        if version >= 0 {
127            out.id = get_uuid(buf)?;
128        }
129        Ok(())
130    }
131    fn decode_field_1<B: Buf>(
132        out: &mut Self,
133        buf: &mut B,
134        version: i16,
135        _flex: bool,
136    ) -> Result<(), ProtocolError> {
137        if version >= 0 {
138            out.resource_type = get_i8(buf)?;
139        }
140        Ok(())
141    }
142    fn decode_field_2<B: Buf>(
143        out: &mut Self,
144        buf: &mut B,
145        version: i16,
146        flex: bool,
147    ) -> Result<(), ProtocolError> {
148        if version >= 0 {
149            out.resource_name = if flex {
150                get_compact_string_owned(buf)?
151            } else {
152                get_string_owned(buf)?
153            };
154        }
155        Ok(())
156    }
157    fn decode_field_3<B: Buf>(
158        out: &mut Self,
159        buf: &mut B,
160        version: i16,
161        _flex: bool,
162    ) -> Result<(), ProtocolError> {
163        if version >= 0 {
164            out.pattern_type = get_i8(buf)?;
165        }
166        Ok(())
167    }
168    fn decode_field_4<B: Buf>(
169        out: &mut Self,
170        buf: &mut B,
171        version: i16,
172        flex: bool,
173    ) -> Result<(), ProtocolError> {
174        if version >= 0 {
175            out.principal = if flex {
176                get_compact_string_owned(buf)?
177            } else {
178                get_string_owned(buf)?
179            };
180        }
181        Ok(())
182    }
183    fn decode_field_5<B: Buf>(
184        out: &mut Self,
185        buf: &mut B,
186        version: i16,
187        flex: bool,
188    ) -> Result<(), ProtocolError> {
189        if version >= 0 {
190            out.host = if flex {
191                get_compact_string_owned(buf)?
192            } else {
193                get_string_owned(buf)?
194            };
195        }
196        Ok(())
197    }
198    fn decode_field_6<B: Buf>(
199        out: &mut Self,
200        buf: &mut B,
201        version: i16,
202        _flex: bool,
203    ) -> Result<(), ProtocolError> {
204        if version >= 0 {
205            out.operation = get_i8(buf)?;
206        }
207        Ok(())
208    }
209    fn decode_field_7<B: Buf>(
210        out: &mut Self,
211        buf: &mut B,
212        version: i16,
213        _flex: bool,
214    ) -> Result<(), ProtocolError> {
215        if version >= 0 {
216            out.permission_type = get_i8(buf)?;
217        }
218        Ok(())
219    }
220    fn decode_tagged_fields<B: Buf>(
221        out: &mut Self,
222        buf: &mut B,
223        _version: i16,
224        flex: bool,
225    ) -> Result<(), ProtocolError> {
226        if flex {
227            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
228        }
229        Ok(())
230    }
231}
232impl Encode for AccessControlEntryRecord {
233    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
234        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
235            return Err(ProtocolError::SchemaMismatch(
236                "AccessControlEntryRecord version out of range",
237            ));
238        }
239        let flex = is_flexible(version);
240        self.encode_field_0(buf, version, flex);
241        self.encode_field_1(buf, version, flex);
242        self.encode_field_2(buf, version, flex)?;
243        self.encode_field_3(buf, version, flex);
244        self.encode_field_4(buf, version, flex)?;
245        self.encode_field_5(buf, version, flex)?;
246        self.encode_field_6(buf, version, flex);
247        self.encode_field_7(buf, version, flex);
248        self.encode_tagged_fields(buf, version, flex)?;
249        Ok(())
250    }
251    fn encoded_len(&self, version: i16) -> usize {
252        let flex = is_flexible(version);
253        let mut n: usize = 0;
254        if version >= 0 {
255            n += 16;
256        }
257        if version >= 0 {
258            n += 1;
259        }
260        if version >= 0 {
261            n += if flex {
262                compact_string_len(&self.resource_name)
263            } else {
264                string_len(&self.resource_name)
265            };
266        }
267        if version >= 0 {
268            n += 1;
269        }
270        if version >= 0 {
271            n += if flex {
272                compact_string_len(&self.principal)
273            } else {
274                string_len(&self.principal)
275            };
276        }
277        if version >= 0 {
278            n += if flex {
279                compact_string_len(&self.host)
280            } else {
281                string_len(&self.host)
282            };
283        }
284        if version >= 0 {
285            n += 1;
286        }
287        if version >= 0 {
288            n += 1;
289        }
290        if flex {
291            let known_pairs: Vec<(u32, usize)> = Vec::new();
292            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
293        }
294        n
295    }
296}
297impl Decode<'_> for AccessControlEntryRecord {
298    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
299        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
300            return Err(ProtocolError::SchemaMismatch(
301                "AccessControlEntryRecord version out of range",
302            ));
303        }
304        let flex = is_flexible(version);
305        let mut out = Self::default();
306        Self::decode_field_0(&mut out, buf, version, flex)?;
307        Self::decode_field_1(&mut out, buf, version, flex)?;
308        Self::decode_field_2(&mut out, buf, version, flex)?;
309        Self::decode_field_3(&mut out, buf, version, flex)?;
310        Self::decode_field_4(&mut out, buf, version, flex)?;
311        Self::decode_field_5(&mut out, buf, version, flex)?;
312        Self::decode_field_6(&mut out, buf, version, flex)?;
313        Self::decode_field_7(&mut out, buf, version, flex)?;
314        Self::decode_tagged_fields(&mut out, buf, version, flex)?;
315        Ok(out)
316    }
317}
318#[cfg(test)]
319impl AccessControlEntryRecord {
320    #[must_use]
321    pub fn populated(version: i16) -> Self {
322        let mut m = Self::default();
323        if version >= 0 {
324            m.id = Uuid([1u8; 16]);
325        }
326        if version >= 0 {
327            m.resource_type = 1i8;
328        }
329        if version >= 0 {
330            m.resource_name = "x".to_owned();
331        }
332        if version >= 0 {
333            m.pattern_type = 1i8;
334        }
335        if version >= 0 {
336            m.principal = "x".to_owned();
337        }
338        if version >= 0 {
339            m.host = "x".to_owned();
340        }
341        if version >= 0 {
342            m.operation = 1i8;
343        }
344        if version >= 0 {
345            m.permission_type = 1i8;
346        }
347        m
348    }
349}
350/// Default JSON payload matching `Self::default()` for JVM oracle differential testing.
351/// Only includes fields valid for the given version.
352#[must_use]
353#[allow(unused_comparisons)]
354pub fn default_json(_version: i16) -> ::serde_json::Value {
355    let mut obj = ::serde_json::Map::new();
356    obj.insert(
357        "id".to_owned(),
358        ::serde_json::Value::String("AAAAAAAAAAAAAAAAAAAAAA".to_owned()),
359    );
360    obj.insert("resourceType".to_owned(), ::serde_json::json!(0));
361    obj.insert(
362        "resourceName".to_owned(),
363        ::serde_json::Value::String(String::new()),
364    );
365    obj.insert("patternType".to_owned(), ::serde_json::json!(0));
366    obj.insert(
367        "principal".to_owned(),
368        ::serde_json::Value::String(String::new()),
369    );
370    obj.insert(
371        "host".to_owned(),
372        ::serde_json::Value::String(String::new()),
373    );
374    obj.insert("operation".to_owned(), ::serde_json::json!(0));
375    obj.insert("permissionType".to_owned(), ::serde_json::json!(0));
376    ::serde_json::Value::Object(obj)
377}
krabka_protocol/opt/rustwide/workdir/generated/AccessControlEntryRecord.owned.rs

krabka_protocol/opt/rustwide/workdir/generated/
AccessControlEntryRecord.owned.rs
