fidl_examples_keyvaluestore_baseline__common/
fidl_examples_keyvaluestore_baseline__common.rs1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
13pub enum WriteError {
14 Unknown,
15 InvalidKey,
16 InvalidValue,
17 AlreadyExists,
18 #[doc(hidden)]
19 __SourceBreaking {
20 unknown_ordinal: u32,
21 },
22}
23
24#[macro_export]
26macro_rules! WriteErrorUnknown {
27 () => {
28 _
29 };
30}
31
32impl WriteError {
33 #[inline]
34 pub fn from_primitive(prim: u32) -> Option<Self> {
35 match prim {
36 0 => Some(Self::Unknown),
37 1 => Some(Self::InvalidKey),
38 2 => Some(Self::InvalidValue),
39 3 => Some(Self::AlreadyExists),
40 _ => None,
41 }
42 }
43
44 #[inline]
45 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
46 match prim {
47 0 => Self::Unknown,
48 1 => Self::InvalidKey,
49 2 => Self::InvalidValue,
50 3 => Self::AlreadyExists,
51 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
52 }
53 }
54
55 #[inline]
56 pub fn unknown() -> Self {
57 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
58 }
59
60 #[inline]
61 pub const fn into_primitive(self) -> u32 {
62 match self {
63 Self::Unknown => 0,
64 Self::InvalidKey => 1,
65 Self::InvalidValue => 2,
66 Self::AlreadyExists => 3,
67 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
68 }
69 }
70
71 #[inline]
72 pub fn is_unknown(&self) -> bool {
73 match self {
74 Self::__SourceBreaking { unknown_ordinal: _ } => true,
75 _ => false,
76 }
77 }
78}
79
80#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
84pub struct Item {
85 pub key: String,
86 pub value: Vec<u8>,
87}
88
89impl fidl::Persistable for Item {}
90
91#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
92pub struct StoreWriteItemRequest {
93 pub attempt: Item,
94}
95
96impl fidl::Persistable for StoreWriteItemRequest {}
97
98pub mod store_ordinals {
99 pub const WRITE_ITEM: u64 = 0x29623dc6b3a4bf63;
100}
101
102mod internal {
103 use super::*;
104 unsafe impl fidl::encoding::TypeMarker for WriteError {
105 type Owned = Self;
106
107 #[inline(always)]
108 fn inline_align(_context: fidl::encoding::Context) -> usize {
109 std::mem::align_of::<u32>()
110 }
111
112 #[inline(always)]
113 fn inline_size(_context: fidl::encoding::Context) -> usize {
114 std::mem::size_of::<u32>()
115 }
116
117 #[inline(always)]
118 fn encode_is_copy() -> bool {
119 false
120 }
121
122 #[inline(always)]
123 fn decode_is_copy() -> bool {
124 false
125 }
126 }
127
128 impl fidl::encoding::ValueTypeMarker for WriteError {
129 type Borrowed<'a> = Self;
130 #[inline(always)]
131 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
132 *value
133 }
134 }
135
136 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WriteError {
137 #[inline]
138 unsafe fn encode(
139 self,
140 encoder: &mut fidl::encoding::Encoder<'_, D>,
141 offset: usize,
142 _depth: fidl::encoding::Depth,
143 ) -> fidl::Result<()> {
144 encoder.debug_check_bounds::<Self>(offset);
145 encoder.write_num(self.into_primitive(), offset);
146 Ok(())
147 }
148 }
149
150 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WriteError {
151 #[inline(always)]
152 fn new_empty() -> Self {
153 Self::unknown()
154 }
155
156 #[inline]
157 unsafe fn decode(
158 &mut self,
159 decoder: &mut fidl::encoding::Decoder<'_, D>,
160 offset: usize,
161 _depth: fidl::encoding::Depth,
162 ) -> fidl::Result<()> {
163 decoder.debug_check_bounds::<Self>(offset);
164 let prim = decoder.read_num::<u32>(offset);
165
166 *self = Self::from_primitive_allow_unknown(prim);
167 Ok(())
168 }
169 }
170
171 impl fidl::encoding::ValueTypeMarker for Item {
172 type Borrowed<'a> = &'a Self;
173 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
174 value
175 }
176 }
177
178 unsafe impl fidl::encoding::TypeMarker for Item {
179 type Owned = Self;
180
181 #[inline(always)]
182 fn inline_align(_context: fidl::encoding::Context) -> usize {
183 8
184 }
185
186 #[inline(always)]
187 fn inline_size(_context: fidl::encoding::Context) -> usize {
188 32
189 }
190 }
191
192 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Item, D> for &Item {
193 #[inline]
194 unsafe fn encode(
195 self,
196 encoder: &mut fidl::encoding::Encoder<'_, D>,
197 offset: usize,
198 _depth: fidl::encoding::Depth,
199 ) -> fidl::Result<()> {
200 encoder.debug_check_bounds::<Item>(offset);
201 fidl::encoding::Encode::<Item, D>::encode(
203 (
204 <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow(
205 &self.key,
206 ),
207 <fidl::encoding::Vector<u8, 64000> as fidl::encoding::ValueTypeMarker>::borrow(
208 &self.value,
209 ),
210 ),
211 encoder,
212 offset,
213 _depth,
214 )
215 }
216 }
217 unsafe impl<
218 D: fidl::encoding::ResourceDialect,
219 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<128>, D>,
220 T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 64000>, D>,
221 > fidl::encoding::Encode<Item, D> for (T0, T1)
222 {
223 #[inline]
224 unsafe fn encode(
225 self,
226 encoder: &mut fidl::encoding::Encoder<'_, D>,
227 offset: usize,
228 depth: fidl::encoding::Depth,
229 ) -> fidl::Result<()> {
230 encoder.debug_check_bounds::<Item>(offset);
231 self.0.encode(encoder, offset + 0, depth)?;
235 self.1.encode(encoder, offset + 16, depth)?;
236 Ok(())
237 }
238 }
239
240 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Item {
241 #[inline(always)]
242 fn new_empty() -> Self {
243 Self {
244 key: fidl::new_empty!(fidl::encoding::BoundedString<128>, D),
245 value: fidl::new_empty!(fidl::encoding::Vector<u8, 64000>, D),
246 }
247 }
248
249 #[inline]
250 unsafe fn decode(
251 &mut self,
252 decoder: &mut fidl::encoding::Decoder<'_, D>,
253 offset: usize,
254 _depth: fidl::encoding::Depth,
255 ) -> fidl::Result<()> {
256 decoder.debug_check_bounds::<Self>(offset);
257 fidl::decode!(
259 fidl::encoding::BoundedString<128>,
260 D,
261 &mut self.key,
262 decoder,
263 offset + 0,
264 _depth
265 )?;
266 fidl::decode!(fidl::encoding::Vector<u8, 64000>, D, &mut self.value, decoder, offset + 16, _depth)?;
267 Ok(())
268 }
269 }
270
271 impl fidl::encoding::ValueTypeMarker for StoreWriteItemRequest {
272 type Borrowed<'a> = &'a Self;
273 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
274 value
275 }
276 }
277
278 unsafe impl fidl::encoding::TypeMarker for StoreWriteItemRequest {
279 type Owned = Self;
280
281 #[inline(always)]
282 fn inline_align(_context: fidl::encoding::Context) -> usize {
283 8
284 }
285
286 #[inline(always)]
287 fn inline_size(_context: fidl::encoding::Context) -> usize {
288 32
289 }
290 }
291
292 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StoreWriteItemRequest, D>
293 for &StoreWriteItemRequest
294 {
295 #[inline]
296 unsafe fn encode(
297 self,
298 encoder: &mut fidl::encoding::Encoder<'_, D>,
299 offset: usize,
300 _depth: fidl::encoding::Depth,
301 ) -> fidl::Result<()> {
302 encoder.debug_check_bounds::<StoreWriteItemRequest>(offset);
303 fidl::encoding::Encode::<StoreWriteItemRequest, D>::encode(
305 (<Item as fidl::encoding::ValueTypeMarker>::borrow(&self.attempt),),
306 encoder,
307 offset,
308 _depth,
309 )
310 }
311 }
312 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Item, D>>
313 fidl::encoding::Encode<StoreWriteItemRequest, D> for (T0,)
314 {
315 #[inline]
316 unsafe fn encode(
317 self,
318 encoder: &mut fidl::encoding::Encoder<'_, D>,
319 offset: usize,
320 depth: fidl::encoding::Depth,
321 ) -> fidl::Result<()> {
322 encoder.debug_check_bounds::<StoreWriteItemRequest>(offset);
323 self.0.encode(encoder, offset + 0, depth)?;
327 Ok(())
328 }
329 }
330
331 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StoreWriteItemRequest {
332 #[inline(always)]
333 fn new_empty() -> Self {
334 Self { attempt: fidl::new_empty!(Item, D) }
335 }
336
337 #[inline]
338 unsafe fn decode(
339 &mut self,
340 decoder: &mut fidl::encoding::Decoder<'_, D>,
341 offset: usize,
342 _depth: fidl::encoding::Depth,
343 ) -> fidl::Result<()> {
344 decoder.debug_check_bounds::<Self>(offset);
345 fidl::decode!(Item, D, &mut self.attempt, decoder, offset + 0, _depth)?;
347 Ok(())
348 }
349 }
350}