krabka_protocol/opt/rustwide/workdir/generated/
EnvelopeResponse.owned.rs1use bytes::{Buf, BufMut};
4
5use crate::{
6 Decode, Encode, ProtocolError, UnknownTaggedFields,
7 primitives::{
8 fixed::{get_i16, put_i16},
9 string_bytes::{
10 compact_nullable_bytes_len, get_compact_nullable_bytes_owned, get_nullable_bytes_owned,
11 nullable_bytes_len, put_compact_nullable_bytes, put_nullable_bytes,
12 },
13 },
14 tagged_fields::{WriteTaggedFields, read_tagged_fields, tagged_fields_len},
15};
16pub const API_KEY: i16 = 58;
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 EnvelopeResponse {
27 pub response_data: Option<::bytes::Bytes>,
28 pub error_code: i16,
29 pub unknown_tagged_fields: UnknownTaggedFields,
30}
31impl Encode for EnvelopeResponse {
32 fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
33 if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
34 return Err(ProtocolError::UnsupportedVersion {
35 api_key: API_KEY,
36 version,
37 });
38 }
39 let flex = is_flexible(version);
40 if version >= 0 {
41 if flex {
42 let () = put_compact_nullable_bytes(buf, self.response_data.as_deref());
43 } else {
44 let () = put_nullable_bytes(buf, self.response_data.as_deref());
45 }
46 }
47 if version >= 0 {
48 put_i16(buf, self.error_code);
49 }
50 if flex {
51 let tagged = WriteTaggedFields::new();
52 tagged.write(buf, &self.unknown_tagged_fields);
53 }
54 Ok(())
55 }
56 fn encoded_len(&self, version: i16) -> usize {
57 let flex = is_flexible(version);
58 let mut n: usize = 0;
59 if version >= 0 {
60 n += if flex {
61 compact_nullable_bytes_len(self.response_data.as_deref())
62 } else {
63 nullable_bytes_len(self.response_data.as_deref())
64 };
65 }
66 if version >= 0 {
67 n += 2;
68 }
69 if flex {
70 let known_pairs: Vec<(u32, usize)> = Vec::new();
71 n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
72 }
73 n
74 }
75}
76impl Decode<'_> for EnvelopeResponse {
77 fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
78 if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
79 return Err(ProtocolError::UnsupportedVersion {
80 api_key: API_KEY,
81 version,
82 });
83 }
84 let flex = is_flexible(version);
85 let mut out = Self::default();
86 if version >= 0 {
87 out.response_data = if flex {
88 get_compact_nullable_bytes_owned(buf)?
89 } else {
90 get_nullable_bytes_owned(buf)?
91 };
92 }
93 if version >= 0 {
94 out.error_code = get_i16(buf)?;
95 }
96 if flex {
97 out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
98 }
99 Ok(out)
100 }
101}
102#[cfg(test)]
103impl EnvelopeResponse {
104 #[must_use]
105 pub fn populated(version: i16) -> Self {
106 let mut m = Self::default();
107 if version >= 0 {
108 m.response_data = Some(::bytes::Bytes::from_static(b"x"));
109 }
110 if version >= 0 {
111 m.error_code = 1i16;
112 }
113 m
114 }
115}
116#[must_use]
119#[allow(unused_comparisons)]
120pub fn default_json(_version: i16) -> ::serde_json::Value {
121 let mut obj = ::serde_json::Map::new();
122 obj.insert("responseData".to_string(), ::serde_json::Value::Null);
123 obj.insert("errorCode".to_string(), ::serde_json::json!(0));
124 ::serde_json::Value::Object(obj)
125}