krabka_protocol/opt/rustwide/workdir/generated/
EnvelopeRequest.borrowed.rs1use bytes::{BufMut, Bytes};
3
4use crate::{
5 DecodeBorrow, Encode, ProtocolError, UnknownTaggedFields,
6 owned::envelope_request,
7 primitives::{
8 string_bytes::{
9 bytes_len, compact_bytes_len, compact_nullable_bytes_len, nullable_bytes_len,
10 put_bytes, put_compact_bytes, put_compact_nullable_bytes, put_nullable_bytes,
11 },
12 string_bytes_borrowed::{
13 get_bytes_borrowed, get_compact_bytes_borrowed, get_compact_nullable_bytes_borrowed,
14 get_nullable_bytes_borrowed,
15 },
16 },
17 tagged_fields::{WriteTaggedFields, read_tagged_fields, tagged_fields_len},
18};
19pub const API_KEY: i16 = 58;
20pub const MIN_VERSION: i16 = 0;
21pub const MAX_VERSION: i16 = 0;
22pub const LATEST_STABLE_VERSION: i16 = 0;
23pub const FLEXIBLE_MIN: i16 = 0;
24#[inline]
25#[must_use]
26pub fn is_flexible(version: i16) -> bool {
27 version >= FLEXIBLE_MIN
28}
29#[derive(Debug, Clone, PartialEq, Eq)]
30pub struct EnvelopeRequest<'a> {
31 pub request_data: &'a [u8],
32 pub request_principal: Option<&'a [u8]>,
33 pub client_host_address: &'a [u8],
34 pub unknown_tagged_fields: UnknownTaggedFields,
35}
36impl Default for EnvelopeRequest<'_> {
37 fn default() -> Self {
38 Self {
39 request_data: &[],
40 request_principal: Some(&[]),
41 client_host_address: &[],
42 unknown_tagged_fields: UnknownTaggedFields::default(),
43 }
44 }
45}
46impl EnvelopeRequest<'_> {
47 #[must_use]
48 pub fn to_owned(&self) -> envelope_request::EnvelopeRequest {
49 envelope_request::EnvelopeRequest {
50 request_data: Bytes::copy_from_slice(self.request_data),
51 request_principal: (self.request_principal).map(Bytes::copy_from_slice),
52 client_host_address: Bytes::copy_from_slice(self.client_host_address),
53 unknown_tagged_fields: self.unknown_tagged_fields.clone(),
54 }
55 }
56}
57impl Encode for EnvelopeRequest<'_> {
58 fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
59 if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
60 return Err(ProtocolError::UnsupportedVersion {
61 api_key: API_KEY,
62 version,
63 });
64 }
65 let flex = is_flexible(version);
66 if version >= 0 {
67 if flex {
68 put_compact_bytes(buf, self.request_data)?;
69 } else {
70 put_bytes(buf, self.request_data)?;
71 }
72 }
73 if version >= 0 {
74 if flex {
75 put_compact_nullable_bytes(buf, self.request_principal)?;
76 } else {
77 put_nullable_bytes(buf, self.request_principal)?;
78 }
79 }
80 if version >= 0 {
81 if flex {
82 put_compact_bytes(buf, self.client_host_address)?;
83 } else {
84 put_bytes(buf, self.client_host_address)?;
85 }
86 }
87 if flex {
88 let tagged = WriteTaggedFields::new();
89 tagged.write(buf, &self.unknown_tagged_fields)?;
90 }
91 Ok(())
92 }
93 fn encoded_len(&self, version: i16) -> usize {
94 let flex = is_flexible(version);
95 let mut n: usize = 0;
96 if version >= 0 {
97 n += if flex {
98 compact_bytes_len(self.request_data)
99 } else {
100 bytes_len(self.request_data)
101 };
102 }
103 if version >= 0 {
104 n += if flex {
105 compact_nullable_bytes_len(self.request_principal)
106 } else {
107 nullable_bytes_len(self.request_principal)
108 };
109 }
110 if version >= 0 {
111 n += if flex {
112 compact_bytes_len(self.client_host_address)
113 } else {
114 bytes_len(self.client_host_address)
115 };
116 }
117 if flex {
118 let known_pairs: Vec<(u32, usize)> = Vec::new();
119 n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
120 }
121 n
122 }
123}
124impl<'de> DecodeBorrow<'de> for EnvelopeRequest<'de> {
125 fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
126 if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
127 return Err(ProtocolError::UnsupportedVersion {
128 api_key: API_KEY,
129 version,
130 });
131 }
132 let flex = is_flexible(version);
133 let mut out = Self::default();
134 if version >= 0 {
135 out.request_data = if flex {
136 get_compact_bytes_borrowed(buf)?
137 } else {
138 get_bytes_borrowed(buf)?
139 };
140 }
141 if version >= 0 {
142 out.request_principal = if flex {
143 get_compact_nullable_bytes_borrowed(buf)?
144 } else {
145 get_nullable_bytes_borrowed(buf)?
146 };
147 }
148 if version >= 0 {
149 out.client_host_address = if flex {
150 get_compact_bytes_borrowed(buf)?
151 } else {
152 get_bytes_borrowed(buf)?
153 };
154 }
155 if flex {
156 out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
157 }
158 Ok(out)
159 }
160}
161#[cfg(test)]
162impl EnvelopeRequest<'_> {
163 #[must_use]
164 pub fn populated(version: i16) -> Self {
165 let mut m = Self::default();
166 if version >= 0 {
167 m.request_data = &b"x"[..];
168 }
169 if version >= 0 {
170 m.request_principal = Some(&b"x"[..]);
171 }
172 if version >= 0 {
173 m.client_host_address = &b"x"[..];
174 }
175 m
176 }
177}