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