1#![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
11pub type HeaderName = Vec<u8>;
13
14pub type HeaderValue = Vec<u8>;
16
17pub type Method = String;
18
19#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
21#[repr(u32)]
22pub enum Error {
23 Internal = 1,
26 UnableToParse = 2,
28 ChannelClosed = 3,
30 Connect = 4,
32 DeadlineExceeded = 5,
34}
35
36impl Error {
37 #[inline]
38 pub fn from_primitive(prim: u32) -> Option<Self> {
39 match prim {
40 1 => Some(Self::Internal),
41 2 => Some(Self::UnableToParse),
42 3 => Some(Self::ChannelClosed),
43 4 => Some(Self::Connect),
44 5 => Some(Self::DeadlineExceeded),
45 _ => None,
46 }
47 }
48
49 #[inline]
50 pub const fn into_primitive(self) -> u32 {
51 self as u32
52 }
53}
54
55#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
57pub struct Header {
58 pub name: Vec<u8>,
60 pub value: Vec<u8>,
62}
63
64impl fidl::Persistable for Header {}
65
66#[derive(Clone, Debug, Default, PartialEq)]
72pub struct RedirectTarget {
73 pub method: Option<String>,
75 pub url: Option<String>,
77 pub referrer: Option<String>,
79 #[doc(hidden)]
80 pub __source_breaking: fidl::marker::SourceBreaking,
81}
82
83impl fidl::Persistable for RedirectTarget {}
84
85pub mod loader_ordinals {
86 pub const FETCH: u64 = 0x66d973be70dc2029;
87 pub const START: u64 = 0x7165335e1d7dd48e;
88}
89
90pub mod loader_client_ordinals {
91 pub const ON_RESPONSE: u64 = 0x595ada171c7ebf89;
92}
93
94mod internal {
95 use super::*;
96 unsafe impl fidl::encoding::TypeMarker for Error {
97 type Owned = Self;
98
99 #[inline(always)]
100 fn inline_align(_context: fidl::encoding::Context) -> usize {
101 std::mem::align_of::<u32>()
102 }
103
104 #[inline(always)]
105 fn inline_size(_context: fidl::encoding::Context) -> usize {
106 std::mem::size_of::<u32>()
107 }
108
109 #[inline(always)]
110 fn encode_is_copy() -> bool {
111 true
112 }
113
114 #[inline(always)]
115 fn decode_is_copy() -> bool {
116 false
117 }
118 }
119
120 impl fidl::encoding::ValueTypeMarker for Error {
121 type Borrowed<'a> = Self;
122 #[inline(always)]
123 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
124 *value
125 }
126 }
127
128 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Error {
129 #[inline]
130 unsafe fn encode(
131 self,
132 encoder: &mut fidl::encoding::Encoder<'_, D>,
133 offset: usize,
134 _depth: fidl::encoding::Depth,
135 ) -> fidl::Result<()> {
136 encoder.debug_check_bounds::<Self>(offset);
137 encoder.write_num(self.into_primitive(), offset);
138 Ok(())
139 }
140 }
141
142 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Error {
143 #[inline(always)]
144 fn new_empty() -> Self {
145 Self::Internal
146 }
147
148 #[inline]
149 unsafe fn decode(
150 &mut self,
151 decoder: &mut fidl::encoding::Decoder<'_, D>,
152 offset: usize,
153 _depth: fidl::encoding::Depth,
154 ) -> fidl::Result<()> {
155 decoder.debug_check_bounds::<Self>(offset);
156 let prim = decoder.read_num::<u32>(offset);
157
158 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
159 Ok(())
160 }
161 }
162
163 impl fidl::encoding::ValueTypeMarker for Header {
164 type Borrowed<'a> = &'a Self;
165 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
166 value
167 }
168 }
169
170 unsafe impl fidl::encoding::TypeMarker for Header {
171 type Owned = Self;
172
173 #[inline(always)]
174 fn inline_align(_context: fidl::encoding::Context) -> usize {
175 8
176 }
177
178 #[inline(always)]
179 fn inline_size(_context: fidl::encoding::Context) -> usize {
180 32
181 }
182 }
183
184 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Header, D> for &Header {
185 #[inline]
186 unsafe fn encode(
187 self,
188 encoder: &mut fidl::encoding::Encoder<'_, D>,
189 offset: usize,
190 _depth: fidl::encoding::Depth,
191 ) -> fidl::Result<()> {
192 encoder.debug_check_bounds::<Header>(offset);
193 fidl::encoding::Encode::<Header, D>::encode(
195 (
196 <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
197 <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
198 ),
199 encoder, offset, _depth
200 )
201 }
202 }
203 unsafe impl<
204 D: fidl::encoding::ResourceDialect,
205 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
206 T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
207 > fidl::encoding::Encode<Header, D> for (T0, T1)
208 {
209 #[inline]
210 unsafe fn encode(
211 self,
212 encoder: &mut fidl::encoding::Encoder<'_, D>,
213 offset: usize,
214 depth: fidl::encoding::Depth,
215 ) -> fidl::Result<()> {
216 encoder.debug_check_bounds::<Header>(offset);
217 self.0.encode(encoder, offset + 0, depth)?;
221 self.1.encode(encoder, offset + 16, depth)?;
222 Ok(())
223 }
224 }
225
226 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Header {
227 #[inline(always)]
228 fn new_empty() -> Self {
229 Self {
230 name: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
231 value: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
232 }
233 }
234
235 #[inline]
236 unsafe fn decode(
237 &mut self,
238 decoder: &mut fidl::encoding::Decoder<'_, D>,
239 offset: usize,
240 _depth: fidl::encoding::Depth,
241 ) -> fidl::Result<()> {
242 decoder.debug_check_bounds::<Self>(offset);
243 fidl::decode!(
245 fidl::encoding::UnboundedVector<u8>,
246 D,
247 &mut self.name,
248 decoder,
249 offset + 0,
250 _depth
251 )?;
252 fidl::decode!(
253 fidl::encoding::UnboundedVector<u8>,
254 D,
255 &mut self.value,
256 decoder,
257 offset + 16,
258 _depth
259 )?;
260 Ok(())
261 }
262 }
263
264 impl RedirectTarget {
265 #[inline(always)]
266 fn max_ordinal_present(&self) -> u64 {
267 if let Some(_) = self.referrer {
268 return 3;
269 }
270 if let Some(_) = self.url {
271 return 2;
272 }
273 if let Some(_) = self.method {
274 return 1;
275 }
276 0
277 }
278 }
279
280 impl fidl::encoding::ValueTypeMarker for RedirectTarget {
281 type Borrowed<'a> = &'a Self;
282 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
283 value
284 }
285 }
286
287 unsafe impl fidl::encoding::TypeMarker for RedirectTarget {
288 type Owned = Self;
289
290 #[inline(always)]
291 fn inline_align(_context: fidl::encoding::Context) -> usize {
292 8
293 }
294
295 #[inline(always)]
296 fn inline_size(_context: fidl::encoding::Context) -> usize {
297 16
298 }
299 }
300
301 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RedirectTarget, D>
302 for &RedirectTarget
303 {
304 unsafe fn encode(
305 self,
306 encoder: &mut fidl::encoding::Encoder<'_, D>,
307 offset: usize,
308 mut depth: fidl::encoding::Depth,
309 ) -> fidl::Result<()> {
310 encoder.debug_check_bounds::<RedirectTarget>(offset);
311 let max_ordinal: u64 = self.max_ordinal_present();
313 encoder.write_num(max_ordinal, offset);
314 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
315 if max_ordinal == 0 {
317 return Ok(());
318 }
319 depth.increment()?;
320 let envelope_size = 8;
321 let bytes_len = max_ordinal as usize * envelope_size;
322 #[allow(unused_variables)]
323 let offset = encoder.out_of_line_offset(bytes_len);
324 let mut _prev_end_offset: usize = 0;
325 if 1 > max_ordinal {
326 return Ok(());
327 }
328
329 let cur_offset: usize = (1 - 1) * envelope_size;
332
333 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
335
336 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
341 self.method.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
342 encoder, offset + cur_offset, depth
343 )?;
344
345 _prev_end_offset = cur_offset + envelope_size;
346 if 2 > max_ordinal {
347 return Ok(());
348 }
349
350 let cur_offset: usize = (2 - 1) * envelope_size;
353
354 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
356
357 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
362 self.url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
363 encoder, offset + cur_offset, depth
364 )?;
365
366 _prev_end_offset = cur_offset + envelope_size;
367 if 3 > max_ordinal {
368 return Ok(());
369 }
370
371 let cur_offset: usize = (3 - 1) * envelope_size;
374
375 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
377
378 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
383 self.referrer.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
384 encoder, offset + cur_offset, depth
385 )?;
386
387 _prev_end_offset = cur_offset + envelope_size;
388
389 Ok(())
390 }
391 }
392
393 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RedirectTarget {
394 #[inline(always)]
395 fn new_empty() -> Self {
396 Self::default()
397 }
398
399 unsafe fn decode(
400 &mut self,
401 decoder: &mut fidl::encoding::Decoder<'_, D>,
402 offset: usize,
403 mut depth: fidl::encoding::Depth,
404 ) -> fidl::Result<()> {
405 decoder.debug_check_bounds::<Self>(offset);
406 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
407 None => return Err(fidl::Error::NotNullable),
408 Some(len) => len,
409 };
410 if len == 0 {
412 return Ok(());
413 };
414 depth.increment()?;
415 let envelope_size = 8;
416 let bytes_len = len * envelope_size;
417 let offset = decoder.out_of_line_offset(bytes_len)?;
418 let mut _next_ordinal_to_read = 0;
420 let mut next_offset = offset;
421 let end_offset = offset + bytes_len;
422 _next_ordinal_to_read += 1;
423 if next_offset >= end_offset {
424 return Ok(());
425 }
426
427 while _next_ordinal_to_read < 1 {
429 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
430 _next_ordinal_to_read += 1;
431 next_offset += envelope_size;
432 }
433
434 let next_out_of_line = decoder.next_out_of_line();
435 let handles_before = decoder.remaining_handles();
436 if let Some((inlined, num_bytes, num_handles)) =
437 fidl::encoding::decode_envelope_header(decoder, next_offset)?
438 {
439 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
440 if inlined != (member_inline_size <= 4) {
441 return Err(fidl::Error::InvalidInlineBitInEnvelope);
442 }
443 let inner_offset;
444 let mut inner_depth = depth.clone();
445 if inlined {
446 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
447 inner_offset = next_offset;
448 } else {
449 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
450 inner_depth.increment()?;
451 }
452 let val_ref = self.method.get_or_insert_with(|| {
453 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
454 });
455 fidl::decode!(
456 fidl::encoding::BoundedString<1024>,
457 D,
458 val_ref,
459 decoder,
460 inner_offset,
461 inner_depth
462 )?;
463 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
464 {
465 return Err(fidl::Error::InvalidNumBytesInEnvelope);
466 }
467 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
468 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
469 }
470 }
471
472 next_offset += envelope_size;
473 _next_ordinal_to_read += 1;
474 if next_offset >= end_offset {
475 return Ok(());
476 }
477
478 while _next_ordinal_to_read < 2 {
480 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
481 _next_ordinal_to_read += 1;
482 next_offset += envelope_size;
483 }
484
485 let next_out_of_line = decoder.next_out_of_line();
486 let handles_before = decoder.remaining_handles();
487 if let Some((inlined, num_bytes, num_handles)) =
488 fidl::encoding::decode_envelope_header(decoder, next_offset)?
489 {
490 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
491 if inlined != (member_inline_size <= 4) {
492 return Err(fidl::Error::InvalidInlineBitInEnvelope);
493 }
494 let inner_offset;
495 let mut inner_depth = depth.clone();
496 if inlined {
497 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
498 inner_offset = next_offset;
499 } else {
500 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
501 inner_depth.increment()?;
502 }
503 let val_ref = self.url.get_or_insert_with(|| {
504 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
505 });
506 fidl::decode!(
507 fidl::encoding::BoundedString<4096>,
508 D,
509 val_ref,
510 decoder,
511 inner_offset,
512 inner_depth
513 )?;
514 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
515 {
516 return Err(fidl::Error::InvalidNumBytesInEnvelope);
517 }
518 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
519 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
520 }
521 }
522
523 next_offset += envelope_size;
524 _next_ordinal_to_read += 1;
525 if next_offset >= end_offset {
526 return Ok(());
527 }
528
529 while _next_ordinal_to_read < 3 {
531 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
532 _next_ordinal_to_read += 1;
533 next_offset += envelope_size;
534 }
535
536 let next_out_of_line = decoder.next_out_of_line();
537 let handles_before = decoder.remaining_handles();
538 if let Some((inlined, num_bytes, num_handles)) =
539 fidl::encoding::decode_envelope_header(decoder, next_offset)?
540 {
541 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
542 if inlined != (member_inline_size <= 4) {
543 return Err(fidl::Error::InvalidInlineBitInEnvelope);
544 }
545 let inner_offset;
546 let mut inner_depth = depth.clone();
547 if inlined {
548 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
549 inner_offset = next_offset;
550 } else {
551 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
552 inner_depth.increment()?;
553 }
554 let val_ref = self.referrer.get_or_insert_with(|| {
555 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
556 });
557 fidl::decode!(
558 fidl::encoding::BoundedString<4096>,
559 D,
560 val_ref,
561 decoder,
562 inner_offset,
563 inner_depth
564 )?;
565 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
566 {
567 return Err(fidl::Error::InvalidNumBytesInEnvelope);
568 }
569 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
570 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
571 }
572 }
573
574 next_offset += envelope_size;
575
576 while next_offset < end_offset {
578 _next_ordinal_to_read += 1;
579 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
580 next_offset += envelope_size;
581 }
582
583 Ok(())
584 }
585 }
586}