1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 ::fidl_next::bitflags::bitflags! {
8 #[doc = " The common members definition behind [`Rights`] and [`Abilities`]. Some operations may apply\n only to certain node types (e.g. [`Operations.MODIFY_DIRECTORY`] only applies to directories).\n"]#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct Operations: u64 {
9 #[doc = " Connecting to a service in a directory.\n"]const CONNECT = 1;
10 #[doc = " Read byte contents of a node or its children.\n"]const READ_BYTES = 2;
11 #[doc = " Writing to the byte contents of a node or its children.\n"]const WRITE_BYTES = 4;
12 #[doc = " Execute the byte contents of a node or its children.\n"]const EXECUTE = 8;
13 #[doc = " Reading the attributes of a node and/or its children.\n"]const GET_ATTRIBUTES = 16;
14 #[doc = " Updating the attributes of a node and/or its children.\n"]const UPDATE_ATTRIBUTES = 32;
15 #[doc = " Reading the list of nodes in a directory.\n"]const ENUMERATE = 64;
16 #[doc = " Opening a node from a directory. Must be specified with [`Rights.ENUMERATE`], as directory\n contents can be probed by opening children.\n"]const TRAVERSE = 128;
17 #[doc = " Modifying the list of nodes in a directory, e.g. creating, renaming, link/unlink, etc...\n Must be specified with [`Rights.ENUMERATE`], as directory contents can be probed via name\n conflicts during node creation.\n"]const MODIFY_DIRECTORY = 256;
18
19 }
20 }
21
22 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Operations, ___E> for Operations
23 where
24 ___E: ?Sized,
25 {
26 #[inline]
27 fn encode(
28 self,
29 encoder: &mut ___E,
30 out: &mut ::core::mem::MaybeUninit<crate::wire::Operations>,
31 _: (),
32 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
33 ::fidl_next::Encode::encode(&self, encoder, out, ())
34 }
35 }
36
37 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Operations, ___E> for &'a Operations
38 where
39 ___E: ?Sized,
40 {
41 #[inline]
42 fn encode(
43 self,
44 _: &mut ___E,
45 out: &mut ::core::mem::MaybeUninit<crate::wire::Operations>,
46 _: (),
47 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
48 ::fidl_next::munge!(let crate::wire::Operations { value } = out);
49
50 if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
51 return Err(::fidl_next::EncodeError::InvalidStrictBits);
52 }
53
54 let _ = value.write(::fidl_next::wire::Uint64::from(self.bits()));
55 Ok(())
56 }
57 }
58
59 impl ::core::convert::From<crate::wire::Operations> for Operations {
60 fn from(wire: crate::wire::Operations) -> Self {
61 Self::from_bits_retain(u64::from(wire.value))
62 }
63 }
64
65 impl ::fidl_next::FromWire<crate::wire::Operations> for Operations {
66 #[inline]
67 fn from_wire(wire: crate::wire::Operations) -> Self {
68 Self::from(wire)
69 }
70 }
71
72 impl ::fidl_next::FromWireRef<crate::wire::Operations> for Operations {
73 #[inline]
74 fn from_wire_ref(wire: &crate::wire::Operations) -> Self {
75 Self::from(*wire)
76 }
77 }
78
79 #[doc = " Abilities are properties intrinsic to a node. They specify which operations are supported by it.\n\n Invoking an operation on a node that does not support it results in `ZX_ERR_NOT_SUPPORTED`.\n Note `ZX_ERR_ACCESS_DENIED` takes precedence over `ZX_ERR_NOT_SUPPORTED` when both apply.\n"]
80 pub type Abilities = crate::natural::Operations;
81
82 #[doc = " The reference point for updating the seek offset. See [`File.Seek`].\n\n This enum matches the `zx_stream_seek_origin_t` enum.\n"]
83 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
84 #[repr(u32)]
85 pub enum SeekOrigin {
86 Start = 0,
87 Current = 1,
88 End = 2,
89 }
90 impl ::core::convert::TryFrom<u32> for SeekOrigin {
91 type Error = ::fidl_next::UnknownStrictEnumMemberError;
92 fn try_from(
93 value: u32,
94 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
95 match value {
96 0 => Ok(Self::Start),
97 1 => Ok(Self::Current),
98 2 => Ok(Self::End),
99
100 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
101 }
102 }
103 }
104
105 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SeekOrigin, ___E> for SeekOrigin
106 where
107 ___E: ?Sized,
108 {
109 #[inline]
110 fn encode(
111 self,
112 encoder: &mut ___E,
113 out: &mut ::core::mem::MaybeUninit<crate::wire::SeekOrigin>,
114 _: (),
115 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
116 ::fidl_next::Encode::encode(&self, encoder, out, ())
117 }
118 }
119
120 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SeekOrigin, ___E> for &'a SeekOrigin
121 where
122 ___E: ?Sized,
123 {
124 #[inline]
125 fn encode(
126 self,
127 encoder: &mut ___E,
128 out: &mut ::core::mem::MaybeUninit<crate::wire::SeekOrigin>,
129 _: (),
130 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
131 ::fidl_next::munge!(let crate::wire::SeekOrigin { value } = out);
132 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
133 SeekOrigin::Start => 0,
134
135 SeekOrigin::Current => 1,
136
137 SeekOrigin::End => 2,
138 }));
139
140 Ok(())
141 }
142 }
143
144 impl ::core::convert::From<crate::wire::SeekOrigin> for SeekOrigin {
145 fn from(wire: crate::wire::SeekOrigin) -> Self {
146 match u32::from(wire.value) {
147 0 => Self::Start,
148
149 1 => Self::Current,
150
151 2 => Self::End,
152
153 _ => unsafe { ::core::hint::unreachable_unchecked() },
154 }
155 }
156 }
157
158 impl ::fidl_next::FromWire<crate::wire::SeekOrigin> for SeekOrigin {
159 #[inline]
160 fn from_wire(wire: crate::wire::SeekOrigin) -> Self {
161 Self::from(wire)
162 }
163 }
164
165 impl ::fidl_next::FromWireRef<crate::wire::SeekOrigin> for SeekOrigin {
166 #[inline]
167 fn from_wire_ref(wire: &crate::wire::SeekOrigin) -> Self {
168 Self::from(*wire)
169 }
170 }
171
172 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
173 pub struct AdvisoryLockRange {
174 pub origin: crate::natural::SeekOrigin,
175
176 pub offset: i64,
177
178 pub length: i64,
179 }
180
181 unsafe impl<___E> ::fidl_next::Encode<crate::wire::AdvisoryLockRange, ___E> for AdvisoryLockRange
182 where
183 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
184 {
185 #[inline]
186 fn encode(
187 self,
188 encoder_: &mut ___E,
189 out_: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockRange>,
190 _: (),
191 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
192 ::fidl_next::munge! {
193 let crate::wire::AdvisoryLockRange {
194 origin,
195 offset,
196 length,
197
198 } = out_;
199 }
200
201 ::fidl_next::Encode::encode(self.origin, encoder_, origin, ())?;
202
203 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(origin.as_mut_ptr()) };
204
205 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
206
207 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
208
209 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
210
211 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
212
213 Ok(())
214 }
215 }
216
217 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::AdvisoryLockRange, ___E>
218 for &'a AdvisoryLockRange
219 where
220 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
221 {
222 #[inline]
223 fn encode(
224 self,
225 encoder_: &mut ___E,
226 out_: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockRange>,
227 _: (),
228 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
229 ::fidl_next::munge! {
230 let crate::wire::AdvisoryLockRange {
231
232 origin,
233 offset,
234 length,
235
236 } = out_;
237 }
238
239 ::fidl_next::Encode::encode(&self.origin, encoder_, origin, ())?;
240
241 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(origin.as_mut_ptr()) };
242
243 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
244
245 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
246
247 ::fidl_next::Encode::encode(&self.length, encoder_, length, ())?;
248
249 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
250
251 Ok(())
252 }
253 }
254
255 unsafe impl<___E>
256 ::fidl_next::EncodeOption<
257 ::fidl_next::wire::Box<'static, crate::wire::AdvisoryLockRange>,
258 ___E,
259 > for AdvisoryLockRange
260 where
261 ___E: ::fidl_next::Encoder + ?Sized,
262 AdvisoryLockRange: ::fidl_next::Encode<crate::wire::AdvisoryLockRange, ___E>,
263 {
264 #[inline]
265 fn encode_option(
266 this: ::core::option::Option<Self>,
267 encoder: &mut ___E,
268 out: &mut ::core::mem::MaybeUninit<
269 ::fidl_next::wire::Box<'static, crate::wire::AdvisoryLockRange>,
270 >,
271 _: (),
272 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
273 if let Some(inner) = this {
274 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
275 ::fidl_next::wire::Box::encode_present(out);
276 } else {
277 ::fidl_next::wire::Box::encode_absent(out);
278 }
279
280 Ok(())
281 }
282 }
283
284 unsafe impl<'a, ___E>
285 ::fidl_next::EncodeOption<
286 ::fidl_next::wire::Box<'static, crate::wire::AdvisoryLockRange>,
287 ___E,
288 > for &'a AdvisoryLockRange
289 where
290 ___E: ::fidl_next::Encoder + ?Sized,
291 &'a AdvisoryLockRange: ::fidl_next::Encode<crate::wire::AdvisoryLockRange, ___E>,
292 {
293 #[inline]
294 fn encode_option(
295 this: ::core::option::Option<Self>,
296 encoder: &mut ___E,
297 out: &mut ::core::mem::MaybeUninit<
298 ::fidl_next::wire::Box<'static, crate::wire::AdvisoryLockRange>,
299 >,
300 _: (),
301 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
302 if let Some(inner) = this {
303 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
304 ::fidl_next::wire::Box::encode_present(out);
305 } else {
306 ::fidl_next::wire::Box::encode_absent(out);
307 }
308
309 Ok(())
310 }
311 }
312
313 impl ::fidl_next::FromWire<crate::wire::AdvisoryLockRange> for AdvisoryLockRange {
314 #[inline]
315 fn from_wire(wire: crate::wire::AdvisoryLockRange) -> Self {
316 Self {
317 origin: ::fidl_next::FromWire::from_wire(wire.origin),
318
319 offset: ::fidl_next::FromWire::from_wire(wire.offset),
320
321 length: ::fidl_next::FromWire::from_wire(wire.length),
322 }
323 }
324 }
325
326 impl ::fidl_next::FromWireRef<crate::wire::AdvisoryLockRange> for AdvisoryLockRange {
327 #[inline]
328 fn from_wire_ref(wire: &crate::wire::AdvisoryLockRange) -> Self {
329 Self {
330 origin: ::fidl_next::FromWireRef::from_wire_ref(&wire.origin),
331
332 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
333
334 length: ::fidl_next::FromWireRef::from_wire_ref(&wire.length),
335 }
336 }
337 }
338
339 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
340 #[repr(u32)]
341 pub enum AdvisoryLockType {
342 Read = 1,
343 Write = 2,
344 Unlock = 3,
345 }
346 impl ::core::convert::TryFrom<u32> for AdvisoryLockType {
347 type Error = ::fidl_next::UnknownStrictEnumMemberError;
348 fn try_from(
349 value: u32,
350 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
351 match value {
352 1 => Ok(Self::Read),
353 2 => Ok(Self::Write),
354 3 => Ok(Self::Unlock),
355
356 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
357 }
358 }
359 }
360
361 unsafe impl<___E> ::fidl_next::Encode<crate::wire::AdvisoryLockType, ___E> for AdvisoryLockType
362 where
363 ___E: ?Sized,
364 {
365 #[inline]
366 fn encode(
367 self,
368 encoder: &mut ___E,
369 out: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockType>,
370 _: (),
371 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
372 ::fidl_next::Encode::encode(&self, encoder, out, ())
373 }
374 }
375
376 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::AdvisoryLockType, ___E>
377 for &'a AdvisoryLockType
378 where
379 ___E: ?Sized,
380 {
381 #[inline]
382 fn encode(
383 self,
384 encoder: &mut ___E,
385 out: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockType>,
386 _: (),
387 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
388 ::fidl_next::munge!(let crate::wire::AdvisoryLockType { value } = out);
389 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
390 AdvisoryLockType::Read => 1,
391
392 AdvisoryLockType::Write => 2,
393
394 AdvisoryLockType::Unlock => 3,
395 }));
396
397 Ok(())
398 }
399 }
400
401 impl ::core::convert::From<crate::wire::AdvisoryLockType> for AdvisoryLockType {
402 fn from(wire: crate::wire::AdvisoryLockType) -> Self {
403 match u32::from(wire.value) {
404 1 => Self::Read,
405
406 2 => Self::Write,
407
408 3 => Self::Unlock,
409
410 _ => unsafe { ::core::hint::unreachable_unchecked() },
411 }
412 }
413 }
414
415 impl ::fidl_next::FromWire<crate::wire::AdvisoryLockType> for AdvisoryLockType {
416 #[inline]
417 fn from_wire(wire: crate::wire::AdvisoryLockType) -> Self {
418 Self::from(wire)
419 }
420 }
421
422 impl ::fidl_next::FromWireRef<crate::wire::AdvisoryLockType> for AdvisoryLockType {
423 #[inline]
424 fn from_wire_ref(wire: &crate::wire::AdvisoryLockType) -> Self {
425 Self::from(*wire)
426 }
427 }
428
429 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
430 pub struct AdvisoryLockRequest {
431 pub type_: ::core::option::Option<crate::natural::AdvisoryLockType>,
432
433 pub range: ::core::option::Option<crate::natural::AdvisoryLockRange>,
434
435 pub wait: ::core::option::Option<bool>,
436 }
437
438 impl AdvisoryLockRequest {
439 fn __max_ordinal(&self) -> usize {
440 if self.wait.is_some() {
441 return 3;
442 }
443
444 if self.range.is_some() {
445 return 2;
446 }
447
448 if self.type_.is_some() {
449 return 1;
450 }
451
452 0
453 }
454 }
455
456 unsafe impl<___E> ::fidl_next::Encode<crate::wire::AdvisoryLockRequest<'static>, ___E>
457 for AdvisoryLockRequest
458 where
459 ___E: ::fidl_next::Encoder + ?Sized,
460 {
461 #[inline]
462 fn encode(
463 mut self,
464 encoder: &mut ___E,
465 out: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockRequest<'static>>,
466 _: (),
467 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
468 ::fidl_next::munge!(let crate::wire::AdvisoryLockRequest { table } = out);
469
470 let max_ord = self.__max_ordinal();
471
472 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
473 ::fidl_next::Wire::zero_padding(&mut out);
474
475 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
476 ::fidl_next::wire::Envelope,
477 >(encoder, max_ord);
478
479 for i in 1..=max_ord {
480 match i {
481 3 => {
482 if let Some(value) = self.wait.take() {
483 ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
484 value,
485 preallocated.encoder,
486 &mut out,
487 (),
488 )?;
489 } else {
490 ::fidl_next::wire::Envelope::encode_zero(&mut out)
491 }
492 }
493
494 2 => {
495 if let Some(value) = self.range.take() {
496 ::fidl_next::wire::Envelope::encode_value::<
497 crate::wire::AdvisoryLockRange,
498 ___E,
499 >(
500 value, preallocated.encoder, &mut out, ()
501 )?;
502 } else {
503 ::fidl_next::wire::Envelope::encode_zero(&mut out)
504 }
505 }
506
507 1 => {
508 if let Some(value) = self.type_.take() {
509 ::fidl_next::wire::Envelope::encode_value::<
510 crate::wire::AdvisoryLockType,
511 ___E,
512 >(
513 value, preallocated.encoder, &mut out, ()
514 )?;
515 } else {
516 ::fidl_next::wire::Envelope::encode_zero(&mut out)
517 }
518 }
519
520 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
521 }
522 unsafe {
523 preallocated.write_next(out.assume_init_ref());
524 }
525 }
526
527 ::fidl_next::wire::Table::encode_len(table, max_ord);
528
529 Ok(())
530 }
531 }
532
533 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::AdvisoryLockRequest<'static>, ___E>
534 for &'a AdvisoryLockRequest
535 where
536 ___E: ::fidl_next::Encoder + ?Sized,
537 {
538 #[inline]
539 fn encode(
540 self,
541 encoder: &mut ___E,
542 out: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockRequest<'static>>,
543 _: (),
544 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
545 ::fidl_next::munge!(let crate::wire::AdvisoryLockRequest { table } = out);
546
547 let max_ord = self.__max_ordinal();
548
549 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
550 ::fidl_next::Wire::zero_padding(&mut out);
551
552 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
553 ::fidl_next::wire::Envelope,
554 >(encoder, max_ord);
555
556 for i in 1..=max_ord {
557 match i {
558 3 => {
559 if let Some(value) = &self.wait {
560 ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
561 value,
562 preallocated.encoder,
563 &mut out,
564 (),
565 )?;
566 } else {
567 ::fidl_next::wire::Envelope::encode_zero(&mut out)
568 }
569 }
570
571 2 => {
572 if let Some(value) = &self.range {
573 ::fidl_next::wire::Envelope::encode_value::<
574 crate::wire::AdvisoryLockRange,
575 ___E,
576 >(
577 value, preallocated.encoder, &mut out, ()
578 )?;
579 } else {
580 ::fidl_next::wire::Envelope::encode_zero(&mut out)
581 }
582 }
583
584 1 => {
585 if let Some(value) = &self.type_ {
586 ::fidl_next::wire::Envelope::encode_value::<
587 crate::wire::AdvisoryLockType,
588 ___E,
589 >(
590 value, preallocated.encoder, &mut out, ()
591 )?;
592 } else {
593 ::fidl_next::wire::Envelope::encode_zero(&mut out)
594 }
595 }
596
597 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
598 }
599 unsafe {
600 preallocated.write_next(out.assume_init_ref());
601 }
602 }
603
604 ::fidl_next::wire::Table::encode_len(table, max_ord);
605
606 Ok(())
607 }
608 }
609
610 impl<'de> ::fidl_next::FromWire<crate::wire::AdvisoryLockRequest<'de>> for AdvisoryLockRequest {
611 #[inline]
612 fn from_wire(wire_: crate::wire::AdvisoryLockRequest<'de>) -> Self {
613 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
614
615 let type_ = wire_.table.get(1);
616
617 let range = wire_.table.get(2);
618
619 let wait = wire_.table.get(3);
620
621 Self {
622 type_: type_.map(|envelope| {
623 ::fidl_next::FromWire::from_wire(unsafe {
624 envelope.read_unchecked::<crate::wire::AdvisoryLockType>()
625 })
626 }),
627
628 range: range.map(|envelope| {
629 ::fidl_next::FromWire::from_wire(unsafe {
630 envelope.read_unchecked::<crate::wire::AdvisoryLockRange>()
631 })
632 }),
633
634 wait: wait.map(|envelope| {
635 ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
636 }),
637 }
638 }
639 }
640
641 impl<'de> ::fidl_next::FromWireRef<crate::wire::AdvisoryLockRequest<'de>> for AdvisoryLockRequest {
642 #[inline]
643 fn from_wire_ref(wire: &crate::wire::AdvisoryLockRequest<'de>) -> Self {
644 Self {
645 type_: wire.table.get(1).map(|envelope| {
646 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
647 envelope.deref_unchecked::<crate::wire::AdvisoryLockType>()
648 })
649 }),
650
651 range: wire.table.get(2).map(|envelope| {
652 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
653 envelope.deref_unchecked::<crate::wire::AdvisoryLockRange>()
654 })
655 }),
656
657 wait: wire.table.get(3).map(|envelope| {
658 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
659 envelope.deref_unchecked::<bool>()
660 })
661 }),
662 }
663 }
664 }
665
666 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
667 pub struct AdvisoryLockingAdvisoryLockRequest {
668 pub request: crate::natural::AdvisoryLockRequest,
669 }
670
671 unsafe impl<___E>
672 ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>, ___E>
673 for AdvisoryLockingAdvisoryLockRequest
674 where
675 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
676 ___E: ::fidl_next::Encoder,
677 {
678 #[inline]
679 fn encode(
680 self,
681 encoder_: &mut ___E,
682 out_: &mut ::core::mem::MaybeUninit<
683 crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
684 >,
685 _: (),
686 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
687 ::fidl_next::munge! {
688 let crate::wire::AdvisoryLockingAdvisoryLockRequest {
689 request,
690
691 } = out_;
692 }
693
694 ::fidl_next::Encode::encode(self.request, encoder_, request, ())?;
695
696 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(request.as_mut_ptr()) };
697
698 Ok(())
699 }
700 }
701
702 unsafe impl<'a, ___E>
703 ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>, ___E>
704 for &'a AdvisoryLockingAdvisoryLockRequest
705 where
706 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
707 ___E: ::fidl_next::Encoder,
708 {
709 #[inline]
710 fn encode(
711 self,
712 encoder_: &mut ___E,
713 out_: &mut ::core::mem::MaybeUninit<
714 crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
715 >,
716 _: (),
717 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
718 ::fidl_next::munge! {
719 let crate::wire::AdvisoryLockingAdvisoryLockRequest {
720
721 request,
722
723 } = out_;
724 }
725
726 ::fidl_next::Encode::encode(&self.request, encoder_, request, ())?;
727
728 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(request.as_mut_ptr()) };
729
730 Ok(())
731 }
732 }
733
734 unsafe impl<___E>
735 ::fidl_next::EncodeOption<
736 ::fidl_next::wire::Box<
737 'static,
738 crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
739 >,
740 ___E,
741 > for AdvisoryLockingAdvisoryLockRequest
742 where
743 ___E: ::fidl_next::Encoder + ?Sized,
744 AdvisoryLockingAdvisoryLockRequest:
745 ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>, ___E>,
746 {
747 #[inline]
748 fn encode_option(
749 this: ::core::option::Option<Self>,
750 encoder: &mut ___E,
751 out: &mut ::core::mem::MaybeUninit<
752 ::fidl_next::wire::Box<
753 'static,
754 crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
755 >,
756 >,
757 _: (),
758 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
759 if let Some(inner) = this {
760 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
761 ::fidl_next::wire::Box::encode_present(out);
762 } else {
763 ::fidl_next::wire::Box::encode_absent(out);
764 }
765
766 Ok(())
767 }
768 }
769
770 unsafe impl<'a, ___E>
771 ::fidl_next::EncodeOption<
772 ::fidl_next::wire::Box<
773 'static,
774 crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
775 >,
776 ___E,
777 > for &'a AdvisoryLockingAdvisoryLockRequest
778 where
779 ___E: ::fidl_next::Encoder + ?Sized,
780 &'a AdvisoryLockingAdvisoryLockRequest:
781 ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>, ___E>,
782 {
783 #[inline]
784 fn encode_option(
785 this: ::core::option::Option<Self>,
786 encoder: &mut ___E,
787 out: &mut ::core::mem::MaybeUninit<
788 ::fidl_next::wire::Box<
789 'static,
790 crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
791 >,
792 >,
793 _: (),
794 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
795 if let Some(inner) = this {
796 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
797 ::fidl_next::wire::Box::encode_present(out);
798 } else {
799 ::fidl_next::wire::Box::encode_absent(out);
800 }
801
802 Ok(())
803 }
804 }
805
806 impl<'de> ::fidl_next::FromWire<crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>>
807 for AdvisoryLockingAdvisoryLockRequest
808 {
809 #[inline]
810 fn from_wire(wire: crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>) -> Self {
811 Self { request: ::fidl_next::FromWire::from_wire(wire.request) }
812 }
813 }
814
815 impl<'de> ::fidl_next::FromWireRef<crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>>
816 for AdvisoryLockingAdvisoryLockRequest
817 {
818 #[inline]
819 fn from_wire_ref(wire: &crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>) -> Self {
820 Self { request: ::fidl_next::FromWireRef::from_wire_ref(&wire.request) }
821 }
822 }
823
824 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
825 #[repr(C)]
826 pub struct AdvisoryLockingAdvisoryLockResponse {}
827
828 unsafe impl<___E> ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockResponse, ___E>
829 for AdvisoryLockingAdvisoryLockResponse
830 where
831 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
832 {
833 #[inline]
834 fn encode(
835 self,
836 encoder_: &mut ___E,
837 out_: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockingAdvisoryLockResponse>,
838 _: (),
839 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
840 ::fidl_next::munge! {
841 let crate::wire::AdvisoryLockingAdvisoryLockResponse {
842
843 _empty,
844
845 } = out_;
846 }
847
848 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
849
850 Ok(())
851 }
852 }
853
854 unsafe impl<'a, ___E>
855 ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockResponse, ___E>
856 for &'a AdvisoryLockingAdvisoryLockResponse
857 where
858 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
859 {
860 #[inline]
861 fn encode(
862 self,
863 encoder_: &mut ___E,
864 out_: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockingAdvisoryLockResponse>,
865 _: (),
866 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
867 ::fidl_next::munge! {
868 let crate::wire::AdvisoryLockingAdvisoryLockResponse {
869
870 _empty,
871
872
873 } = out_;
874 }
875
876 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
877
878 Ok(())
879 }
880 }
881
882 unsafe impl<___E>
883 ::fidl_next::EncodeOption<
884 ::fidl_next::wire::Box<'static, crate::wire::AdvisoryLockingAdvisoryLockResponse>,
885 ___E,
886 > for AdvisoryLockingAdvisoryLockResponse
887 where
888 ___E: ::fidl_next::Encoder + ?Sized,
889 AdvisoryLockingAdvisoryLockResponse:
890 ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockResponse, ___E>,
891 {
892 #[inline]
893 fn encode_option(
894 this: ::core::option::Option<Self>,
895 encoder: &mut ___E,
896 out: &mut ::core::mem::MaybeUninit<
897 ::fidl_next::wire::Box<'static, crate::wire::AdvisoryLockingAdvisoryLockResponse>,
898 >,
899 _: (),
900 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
901 if let Some(inner) = this {
902 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
903 ::fidl_next::wire::Box::encode_present(out);
904 } else {
905 ::fidl_next::wire::Box::encode_absent(out);
906 }
907
908 Ok(())
909 }
910 }
911
912 unsafe impl<'a, ___E>
913 ::fidl_next::EncodeOption<
914 ::fidl_next::wire::Box<'static, crate::wire::AdvisoryLockingAdvisoryLockResponse>,
915 ___E,
916 > for &'a AdvisoryLockingAdvisoryLockResponse
917 where
918 ___E: ::fidl_next::Encoder + ?Sized,
919 &'a AdvisoryLockingAdvisoryLockResponse:
920 ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockResponse, ___E>,
921 {
922 #[inline]
923 fn encode_option(
924 this: ::core::option::Option<Self>,
925 encoder: &mut ___E,
926 out: &mut ::core::mem::MaybeUninit<
927 ::fidl_next::wire::Box<'static, crate::wire::AdvisoryLockingAdvisoryLockResponse>,
928 >,
929 _: (),
930 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
931 if let Some(inner) = this {
932 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
933 ::fidl_next::wire::Box::encode_present(out);
934 } else {
935 ::fidl_next::wire::Box::encode_absent(out);
936 }
937
938 Ok(())
939 }
940 }
941
942 impl ::fidl_next::FromWire<crate::wire::AdvisoryLockingAdvisoryLockResponse>
943 for AdvisoryLockingAdvisoryLockResponse
944 {
945 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
946 crate::wire::AdvisoryLockingAdvisoryLockResponse,
947 Self,
948 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
949
950 #[inline]
951 fn from_wire(wire: crate::wire::AdvisoryLockingAdvisoryLockResponse) -> Self {
952 Self {}
953 }
954 }
955
956 impl ::fidl_next::FromWireRef<crate::wire::AdvisoryLockingAdvisoryLockResponse>
957 for AdvisoryLockingAdvisoryLockResponse
958 {
959 #[inline]
960 fn from_wire_ref(wire: &crate::wire::AdvisoryLockingAdvisoryLockResponse) -> Self {
961 Self {}
962 }
963 }
964
965 ::fidl_next::bitflags::bitflags! {
966 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct AllocateMode: u32 {
967 const KEEP_SIZE = 1;
968 const UNSHARE_RANGE = 2;
969 const PUNCH_HOLE = 4;
970 const COLLAPSE_RANGE = 8;
971 const ZERO_RANGE = 16;
972 const INSERT_RANGE = 32;
973 const _ = !0;
974 }
975 }
976
977 unsafe impl<___E> ::fidl_next::Encode<crate::wire::AllocateMode, ___E> for AllocateMode
978 where
979 ___E: ?Sized,
980 {
981 #[inline]
982 fn encode(
983 self,
984 encoder: &mut ___E,
985 out: &mut ::core::mem::MaybeUninit<crate::wire::AllocateMode>,
986 _: (),
987 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
988 ::fidl_next::Encode::encode(&self, encoder, out, ())
989 }
990 }
991
992 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::AllocateMode, ___E> for &'a AllocateMode
993 where
994 ___E: ?Sized,
995 {
996 #[inline]
997 fn encode(
998 self,
999 _: &mut ___E,
1000 out: &mut ::core::mem::MaybeUninit<crate::wire::AllocateMode>,
1001 _: (),
1002 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1003 ::fidl_next::munge!(let crate::wire::AllocateMode { value } = out);
1004
1005 let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
1006 Ok(())
1007 }
1008 }
1009
1010 impl ::core::convert::From<crate::wire::AllocateMode> for AllocateMode {
1011 fn from(wire: crate::wire::AllocateMode) -> Self {
1012 Self::from_bits_retain(u32::from(wire.value))
1013 }
1014 }
1015
1016 impl ::fidl_next::FromWire<crate::wire::AllocateMode> for AllocateMode {
1017 #[inline]
1018 fn from_wire(wire: crate::wire::AllocateMode) -> Self {
1019 Self::from(wire)
1020 }
1021 }
1022
1023 impl ::fidl_next::FromWireRef<crate::wire::AllocateMode> for AllocateMode {
1024 #[inline]
1025 fn from_wire_ref(wire: &crate::wire::AllocateMode) -> Self {
1026 Self::from(*wire)
1027 }
1028 }
1029
1030 #[doc = " Rights are properties specific to a connection. They limit which operations are allowed on a\n connection, including those which may be granted to new connections.\n\n Invoking an operation without the corresponding right results in `ZX_ERR_ACCESS_DENIED`\n even if the node does not have support for the operation.\n"]
1031 pub type Rights = crate::natural::Operations;
1032
1033 #[doc = " The type to identify a node, if the implementation supports some notion of\n unique node ID.\n\n ## Uniqueness Guarantees\n\n A client is usually presented with a directory tree that is the result\n of composing together multiple backing implementation instances. An ID\n would be unique within the corresponding instance only.\n Their boundaries are rather implicit on Fuchsia, as a result of\n transparently-forwarding directory proxies. It could be common for a client\n to observe identical `Id`s when traversing a directory tree, when it\n encounters nodes from different backing instances. Therefore, the ID is best\n used for debugging and informational purposes.\n\n The [`fuchsia.fs/FilesystemInfo.fs_id`] field may be used to disambiguate\n IDs from different backing instances.\n"]
1034 pub type Id = u64;
1035
1036 ::fidl_next::bitflags::bitflags! {
1037 #[doc = " DEPRECATED - Use Flags instead.\n"]#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct OpenFlags: u32 {
1038 #[doc = " Can read from target object.\n"]const RIGHT_READABLE = 1;
1039 #[doc = " Can write to target object.\n"]const RIGHT_WRITABLE = 2;
1040 #[doc = " Connection can map target object executable.\n"]const RIGHT_EXECUTABLE = 8;
1041 #[doc = " Create the object if it doesn\'t exist.\n"]const CREATE = 65536;
1042 #[doc = " (with Create) Fail if the object already exists.\n"]const CREATE_IF_ABSENT = 131072;
1043 #[doc = " Truncate the object before usage.\n"]const TRUNCATE = 262144;
1044 #[doc = " Assert that the object to be opened is a directory.\n Return an error if the target object is not a directory.\n"]const DIRECTORY = 524288;
1045 #[doc = " Seek to the end of the object before all writes.\n"]const APPEND = 1048576;
1046 #[doc = " Open a reference to the object, not the object itself.\n It is ONLY valid to pass the following flags together with `NODE_REFERENCE`:\n - `DIRECTORY`\n - `NOT_DIRECTORY`\n - `DESCRIBE`\n otherwise an error is returned.\n If an object is opened or cloned using this method, the resulting connection does not carry\n any permission flags.\n The resulting connection allows a limited set of operations: `GetAttr`, `Clone`, `Close`,\n `Describe`, and `GetFlags`. The connection will speak the `Node` protocol. Calling `SetAttr`\n or `SetFlags` will result in `ZX_ERR_BAD_HANDLE`.\n"]const NODE_REFERENCE = 4194304;
1047 #[doc = " Requests that an \"OnOpen\" event is sent to the interface request.\n\n The event will contain a non-null `NodeInfoDeprecated` if the open/clone is successful. This\n can be used to open a protocol that does not compose fuchsia.io/Node; the event is sent as\n if the protocol is fuchsia.io/Node and then the target protocol is used exclusively.\n"]const DESCRIBE = 8388608;
1048 #[doc = " Specify this flag to request POSIX-compatibility with respect to write permission handling.\n Currently, it affects permission handling specifically during Open:\n - If the target path is a directory, the rights on the new connection expand to include\n `WRITABLE` if and only if the current connection and all intermediate mount points\n are writable.\n - Otherwise, this flag is ignored. It is an access denied error to request more rights\n than those on the current connection, or any intermediate mount points.\n\n If this flag is omitted, opening always uses the requested rights, failing the operation with\n access denied error if requested rights exceeds the rights attached to the current connection.\n\n If the requesting connection is read-only and the requested rights are read-only, the flag\n may be ignored by the server, and is not forwarded downstream. This is an implementation detail,\n necessary to enforce hierarchical permissions across mount points, and should have no effect\n on the expected behavior for clients.\n"]const POSIX_WRITABLE = 134217728;
1049 #[doc = " Specify this flag to request POSIX-compatibility with respect to execute permission handling.\n Currently, it affects permission handling specifically during Open:\n - If the target path is a directory, the rights on the new connection expand to include\n `EXECUTABLE` if and only if the current connection and all intermediate mount\n points are executable.\n - Otherwise, this flag is ignored. It is an access denied error to request more rights\n than those on the current connection, or any intermediate mount points.\n\n If this flag is omitted, opening always uses the requested rights, failing the operation with\n access denied error if requested rights exceeds the rights attached to the current connection.\n\n If the requesting connection is read-only and the requested rights are read-only, the flag\n may be ignored by the server, and is not forwarded downstream. This is an implementation detail,\n necessary to enforce hierarchical permissions across mount points, and should have no effect\n on the expected behavior for clients.\n"]const POSIX_EXECUTABLE = 268435456;
1050 #[doc = " Assert that the object to be opened is not a directory.\n Return an error if the target object is a directory.\n"]const NOT_DIRECTORY = 33554432;
1051 #[doc = " When used during clone, the new connection inherits the rights on the source connection,\n regardless if it is a file or directory. Otherwise, clone attempts to use the requested rights.\n It is invalid to pass any of the `RIGHT_*` flags together with `OpenFlags.CLONE_SAME_RIGHTS`.\n"]const CLONE_SAME_RIGHTS = 67108864;
1052 #[doc = " Open the target object as a block device.\n"]const BLOCK_DEVICE = 16777216;
1053
1054 }
1055 }
1056
1057 unsafe impl<___E> ::fidl_next::Encode<crate::wire::OpenFlags, ___E> for OpenFlags
1058 where
1059 ___E: ?Sized,
1060 {
1061 #[inline]
1062 fn encode(
1063 self,
1064 encoder: &mut ___E,
1065 out: &mut ::core::mem::MaybeUninit<crate::wire::OpenFlags>,
1066 _: (),
1067 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1068 ::fidl_next::Encode::encode(&self, encoder, out, ())
1069 }
1070 }
1071
1072 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::OpenFlags, ___E> for &'a OpenFlags
1073 where
1074 ___E: ?Sized,
1075 {
1076 #[inline]
1077 fn encode(
1078 self,
1079 _: &mut ___E,
1080 out: &mut ::core::mem::MaybeUninit<crate::wire::OpenFlags>,
1081 _: (),
1082 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1083 ::fidl_next::munge!(let crate::wire::OpenFlags { value } = out);
1084
1085 if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
1086 return Err(::fidl_next::EncodeError::InvalidStrictBits);
1087 }
1088
1089 let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
1090 Ok(())
1091 }
1092 }
1093
1094 impl ::core::convert::From<crate::wire::OpenFlags> for OpenFlags {
1095 fn from(wire: crate::wire::OpenFlags) -> Self {
1096 Self::from_bits_retain(u32::from(wire.value))
1097 }
1098 }
1099
1100 impl ::fidl_next::FromWire<crate::wire::OpenFlags> for OpenFlags {
1101 #[inline]
1102 fn from_wire(wire: crate::wire::OpenFlags) -> Self {
1103 Self::from(wire)
1104 }
1105 }
1106
1107 impl ::fidl_next::FromWireRef<crate::wire::OpenFlags> for OpenFlags {
1108 #[inline]
1109 fn from_wire_ref(wire: &crate::wire::OpenFlags) -> Self {
1110 Self::from(*wire)
1111 }
1112 }
1113
1114 #[doc = " NodeAttributes defines generic information about a filesystem node.\n"]
1115 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1116 pub struct NodeAttributes {
1117 pub mode: u32,
1118
1119 pub id: u64,
1120
1121 pub content_size: u64,
1122
1123 pub storage_size: u64,
1124
1125 pub link_count: u64,
1126
1127 pub creation_time: u64,
1128
1129 pub modification_time: u64,
1130 }
1131
1132 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeAttributes, ___E> for NodeAttributes
1133 where
1134 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1135 {
1136 #[inline]
1137 fn encode(
1138 self,
1139 encoder_: &mut ___E,
1140 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributes>,
1141 _: (),
1142 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1143 ::fidl_next::munge! {
1144 let crate::wire::NodeAttributes {
1145 mode,
1146 id,
1147 content_size,
1148 storage_size,
1149 link_count,
1150 creation_time,
1151 modification_time,
1152
1153 } = out_;
1154 }
1155
1156 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
1157
1158 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
1159
1160 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1161
1162 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1163
1164 ::fidl_next::Encode::encode(self.content_size, encoder_, content_size, ())?;
1165
1166 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(content_size.as_mut_ptr()) };
1167
1168 ::fidl_next::Encode::encode(self.storage_size, encoder_, storage_size, ())?;
1169
1170 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(storage_size.as_mut_ptr()) };
1171
1172 ::fidl_next::Encode::encode(self.link_count, encoder_, link_count, ())?;
1173
1174 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(link_count.as_mut_ptr()) };
1175
1176 ::fidl_next::Encode::encode(self.creation_time, encoder_, creation_time, ())?;
1177
1178 let mut _field =
1179 unsafe { ::fidl_next::Slot::new_unchecked(creation_time.as_mut_ptr()) };
1180
1181 ::fidl_next::Encode::encode(self.modification_time, encoder_, modification_time, ())?;
1182
1183 let mut _field =
1184 unsafe { ::fidl_next::Slot::new_unchecked(modification_time.as_mut_ptr()) };
1185
1186 Ok(())
1187 }
1188 }
1189
1190 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeAttributes, ___E> for &'a NodeAttributes
1191 where
1192 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1193 {
1194 #[inline]
1195 fn encode(
1196 self,
1197 encoder_: &mut ___E,
1198 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributes>,
1199 _: (),
1200 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1201 ::fidl_next::munge! {
1202 let crate::wire::NodeAttributes {
1203
1204 mode,
1205 id,
1206 content_size,
1207 storage_size,
1208 link_count,
1209 creation_time,
1210 modification_time,
1211
1212 } = out_;
1213 }
1214
1215 ::fidl_next::Encode::encode(&self.mode, encoder_, mode, ())?;
1216
1217 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
1218
1219 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
1220
1221 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1222
1223 ::fidl_next::Encode::encode(&self.content_size, encoder_, content_size, ())?;
1224
1225 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(content_size.as_mut_ptr()) };
1226
1227 ::fidl_next::Encode::encode(&self.storage_size, encoder_, storage_size, ())?;
1228
1229 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(storage_size.as_mut_ptr()) };
1230
1231 ::fidl_next::Encode::encode(&self.link_count, encoder_, link_count, ())?;
1232
1233 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(link_count.as_mut_ptr()) };
1234
1235 ::fidl_next::Encode::encode(&self.creation_time, encoder_, creation_time, ())?;
1236
1237 let mut _field =
1238 unsafe { ::fidl_next::Slot::new_unchecked(creation_time.as_mut_ptr()) };
1239
1240 ::fidl_next::Encode::encode(&self.modification_time, encoder_, modification_time, ())?;
1241
1242 let mut _field =
1243 unsafe { ::fidl_next::Slot::new_unchecked(modification_time.as_mut_ptr()) };
1244
1245 Ok(())
1246 }
1247 }
1248
1249 unsafe impl<___E>
1250 ::fidl_next::EncodeOption<
1251 ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes>,
1252 ___E,
1253 > for NodeAttributes
1254 where
1255 ___E: ::fidl_next::Encoder + ?Sized,
1256 NodeAttributes: ::fidl_next::Encode<crate::wire::NodeAttributes, ___E>,
1257 {
1258 #[inline]
1259 fn encode_option(
1260 this: ::core::option::Option<Self>,
1261 encoder: &mut ___E,
1262 out: &mut ::core::mem::MaybeUninit<
1263 ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes>,
1264 >,
1265 _: (),
1266 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1267 if let Some(inner) = this {
1268 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1269 ::fidl_next::wire::Box::encode_present(out);
1270 } else {
1271 ::fidl_next::wire::Box::encode_absent(out);
1272 }
1273
1274 Ok(())
1275 }
1276 }
1277
1278 unsafe impl<'a, ___E>
1279 ::fidl_next::EncodeOption<
1280 ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes>,
1281 ___E,
1282 > for &'a NodeAttributes
1283 where
1284 ___E: ::fidl_next::Encoder + ?Sized,
1285 &'a NodeAttributes: ::fidl_next::Encode<crate::wire::NodeAttributes, ___E>,
1286 {
1287 #[inline]
1288 fn encode_option(
1289 this: ::core::option::Option<Self>,
1290 encoder: &mut ___E,
1291 out: &mut ::core::mem::MaybeUninit<
1292 ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes>,
1293 >,
1294 _: (),
1295 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1296 if let Some(inner) = this {
1297 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1298 ::fidl_next::wire::Box::encode_present(out);
1299 } else {
1300 ::fidl_next::wire::Box::encode_absent(out);
1301 }
1302
1303 Ok(())
1304 }
1305 }
1306
1307 impl ::fidl_next::FromWire<crate::wire::NodeAttributes> for NodeAttributes {
1308 #[inline]
1309 fn from_wire(wire: crate::wire::NodeAttributes) -> Self {
1310 Self {
1311 mode: ::fidl_next::FromWire::from_wire(wire.mode),
1312
1313 id: ::fidl_next::FromWire::from_wire(wire.id),
1314
1315 content_size: ::fidl_next::FromWire::from_wire(wire.content_size),
1316
1317 storage_size: ::fidl_next::FromWire::from_wire(wire.storage_size),
1318
1319 link_count: ::fidl_next::FromWire::from_wire(wire.link_count),
1320
1321 creation_time: ::fidl_next::FromWire::from_wire(wire.creation_time),
1322
1323 modification_time: ::fidl_next::FromWire::from_wire(wire.modification_time),
1324 }
1325 }
1326 }
1327
1328 impl ::fidl_next::FromWireRef<crate::wire::NodeAttributes> for NodeAttributes {
1329 #[inline]
1330 fn from_wire_ref(wire: &crate::wire::NodeAttributes) -> Self {
1331 Self {
1332 mode: ::fidl_next::FromWireRef::from_wire_ref(&wire.mode),
1333
1334 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
1335
1336 content_size: ::fidl_next::FromWireRef::from_wire_ref(&wire.content_size),
1337
1338 storage_size: ::fidl_next::FromWireRef::from_wire_ref(&wire.storage_size),
1339
1340 link_count: ::fidl_next::FromWireRef::from_wire_ref(&wire.link_count),
1341
1342 creation_time: ::fidl_next::FromWireRef::from_wire_ref(&wire.creation_time),
1343
1344 modification_time: ::fidl_next::FromWireRef::from_wire_ref(&wire.modification_time),
1345 }
1346 }
1347 }
1348
1349 ::fidl_next::bitflags::bitflags! {
1350 #[doc = " The fields of \'attributes\' which are used to update the Node are indicated\n by the \'flags\' argument.\n"]#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct NodeAttributeFlags: u32 {
1351 const CREATION_TIME = 1;
1352 const MODIFICATION_TIME = 2;
1353
1354 }
1355 }
1356
1357 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeAttributeFlags, ___E> for NodeAttributeFlags
1358 where
1359 ___E: ?Sized,
1360 {
1361 #[inline]
1362 fn encode(
1363 self,
1364 encoder: &mut ___E,
1365 out: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributeFlags>,
1366 _: (),
1367 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1368 ::fidl_next::Encode::encode(&self, encoder, out, ())
1369 }
1370 }
1371
1372 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeAttributeFlags, ___E>
1373 for &'a NodeAttributeFlags
1374 where
1375 ___E: ?Sized,
1376 {
1377 #[inline]
1378 fn encode(
1379 self,
1380 _: &mut ___E,
1381 out: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributeFlags>,
1382 _: (),
1383 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1384 ::fidl_next::munge!(let crate::wire::NodeAttributeFlags { value } = out);
1385
1386 if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
1387 return Err(::fidl_next::EncodeError::InvalidStrictBits);
1388 }
1389
1390 let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
1391 Ok(())
1392 }
1393 }
1394
1395 impl ::core::convert::From<crate::wire::NodeAttributeFlags> for NodeAttributeFlags {
1396 fn from(wire: crate::wire::NodeAttributeFlags) -> Self {
1397 Self::from_bits_retain(u32::from(wire.value))
1398 }
1399 }
1400
1401 impl ::fidl_next::FromWire<crate::wire::NodeAttributeFlags> for NodeAttributeFlags {
1402 #[inline]
1403 fn from_wire(wire: crate::wire::NodeAttributeFlags) -> Self {
1404 Self::from(wire)
1405 }
1406 }
1407
1408 impl ::fidl_next::FromWireRef<crate::wire::NodeAttributeFlags> for NodeAttributeFlags {
1409 #[inline]
1410 fn from_wire_ref(wire: &crate::wire::NodeAttributeFlags) -> Self {
1411 Self::from(*wire)
1412 }
1413 }
1414
1415 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1416 pub struct NodeQueryFilesystemResponse {
1417 pub s: i32,
1418
1419 pub info: ::core::option::Option<::std::boxed::Box<crate::natural::FilesystemInfo>>,
1420 }
1421
1422 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeQueryFilesystemResponse<'static>, ___E>
1423 for NodeQueryFilesystemResponse
1424 where
1425 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1426 ___E: ::fidl_next::Encoder,
1427 {
1428 #[inline]
1429 fn encode(
1430 self,
1431 encoder_: &mut ___E,
1432 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeQueryFilesystemResponse<'static>>,
1433 _: (),
1434 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1435 ::fidl_next::munge! {
1436 let crate::wire::NodeQueryFilesystemResponse {
1437 s,
1438 info,
1439
1440 } = out_;
1441 }
1442
1443 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
1444
1445 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
1446
1447 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
1448
1449 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
1450
1451 Ok(())
1452 }
1453 }
1454
1455 unsafe impl<'a, ___E>
1456 ::fidl_next::Encode<crate::wire::NodeQueryFilesystemResponse<'static>, ___E>
1457 for &'a NodeQueryFilesystemResponse
1458 where
1459 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1460 ___E: ::fidl_next::Encoder,
1461 {
1462 #[inline]
1463 fn encode(
1464 self,
1465 encoder_: &mut ___E,
1466 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeQueryFilesystemResponse<'static>>,
1467 _: (),
1468 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1469 ::fidl_next::munge! {
1470 let crate::wire::NodeQueryFilesystemResponse {
1471
1472 s,
1473 info,
1474
1475 } = out_;
1476 }
1477
1478 ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
1479
1480 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
1481
1482 ::fidl_next::Encode::encode(&self.info, encoder_, info, ())?;
1483
1484 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
1485
1486 Ok(())
1487 }
1488 }
1489
1490 unsafe impl<___E>
1491 ::fidl_next::EncodeOption<
1492 ::fidl_next::wire::Box<'static, crate::wire::NodeQueryFilesystemResponse<'static>>,
1493 ___E,
1494 > for NodeQueryFilesystemResponse
1495 where
1496 ___E: ::fidl_next::Encoder + ?Sized,
1497 NodeQueryFilesystemResponse:
1498 ::fidl_next::Encode<crate::wire::NodeQueryFilesystemResponse<'static>, ___E>,
1499 {
1500 #[inline]
1501 fn encode_option(
1502 this: ::core::option::Option<Self>,
1503 encoder: &mut ___E,
1504 out: &mut ::core::mem::MaybeUninit<
1505 ::fidl_next::wire::Box<'static, crate::wire::NodeQueryFilesystemResponse<'static>>,
1506 >,
1507 _: (),
1508 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1509 if let Some(inner) = this {
1510 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1511 ::fidl_next::wire::Box::encode_present(out);
1512 } else {
1513 ::fidl_next::wire::Box::encode_absent(out);
1514 }
1515
1516 Ok(())
1517 }
1518 }
1519
1520 unsafe impl<'a, ___E>
1521 ::fidl_next::EncodeOption<
1522 ::fidl_next::wire::Box<'static, crate::wire::NodeQueryFilesystemResponse<'static>>,
1523 ___E,
1524 > for &'a NodeQueryFilesystemResponse
1525 where
1526 ___E: ::fidl_next::Encoder + ?Sized,
1527 &'a NodeQueryFilesystemResponse:
1528 ::fidl_next::Encode<crate::wire::NodeQueryFilesystemResponse<'static>, ___E>,
1529 {
1530 #[inline]
1531 fn encode_option(
1532 this: ::core::option::Option<Self>,
1533 encoder: &mut ___E,
1534 out: &mut ::core::mem::MaybeUninit<
1535 ::fidl_next::wire::Box<'static, crate::wire::NodeQueryFilesystemResponse<'static>>,
1536 >,
1537 _: (),
1538 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1539 if let Some(inner) = this {
1540 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1541 ::fidl_next::wire::Box::encode_present(out);
1542 } else {
1543 ::fidl_next::wire::Box::encode_absent(out);
1544 }
1545
1546 Ok(())
1547 }
1548 }
1549
1550 impl<'de> ::fidl_next::FromWire<crate::wire::NodeQueryFilesystemResponse<'de>>
1551 for NodeQueryFilesystemResponse
1552 {
1553 #[inline]
1554 fn from_wire(wire: crate::wire::NodeQueryFilesystemResponse<'de>) -> Self {
1555 Self {
1556 s: ::fidl_next::FromWire::from_wire(wire.s),
1557
1558 info: ::fidl_next::FromWire::from_wire(wire.info),
1559 }
1560 }
1561 }
1562
1563 impl<'de> ::fidl_next::FromWireRef<crate::wire::NodeQueryFilesystemResponse<'de>>
1564 for NodeQueryFilesystemResponse
1565 {
1566 #[inline]
1567 fn from_wire_ref(wire: &crate::wire::NodeQueryFilesystemResponse<'de>) -> Self {
1568 Self {
1569 s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s),
1570
1571 info: ::fidl_next::FromWireRef::from_wire_ref(&wire.info),
1572 }
1573 }
1574 }
1575
1576 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1577 #[repr(C)]
1578 pub struct NodeUpdateAttributesResponse {}
1579
1580 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeUpdateAttributesResponse, ___E>
1581 for NodeUpdateAttributesResponse
1582 where
1583 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1584 {
1585 #[inline]
1586 fn encode(
1587 self,
1588 encoder_: &mut ___E,
1589 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeUpdateAttributesResponse>,
1590 _: (),
1591 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1592 ::fidl_next::munge! {
1593 let crate::wire::NodeUpdateAttributesResponse {
1594
1595 _empty,
1596
1597 } = out_;
1598 }
1599
1600 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
1601
1602 Ok(())
1603 }
1604 }
1605
1606 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeUpdateAttributesResponse, ___E>
1607 for &'a NodeUpdateAttributesResponse
1608 where
1609 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1610 {
1611 #[inline]
1612 fn encode(
1613 self,
1614 encoder_: &mut ___E,
1615 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeUpdateAttributesResponse>,
1616 _: (),
1617 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1618 ::fidl_next::munge! {
1619 let crate::wire::NodeUpdateAttributesResponse {
1620
1621 _empty,
1622
1623
1624 } = out_;
1625 }
1626
1627 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
1628
1629 Ok(())
1630 }
1631 }
1632
1633 unsafe impl<___E>
1634 ::fidl_next::EncodeOption<
1635 ::fidl_next::wire::Box<'static, crate::wire::NodeUpdateAttributesResponse>,
1636 ___E,
1637 > for NodeUpdateAttributesResponse
1638 where
1639 ___E: ::fidl_next::Encoder + ?Sized,
1640 NodeUpdateAttributesResponse:
1641 ::fidl_next::Encode<crate::wire::NodeUpdateAttributesResponse, ___E>,
1642 {
1643 #[inline]
1644 fn encode_option(
1645 this: ::core::option::Option<Self>,
1646 encoder: &mut ___E,
1647 out: &mut ::core::mem::MaybeUninit<
1648 ::fidl_next::wire::Box<'static, crate::wire::NodeUpdateAttributesResponse>,
1649 >,
1650 _: (),
1651 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1652 if let Some(inner) = this {
1653 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1654 ::fidl_next::wire::Box::encode_present(out);
1655 } else {
1656 ::fidl_next::wire::Box::encode_absent(out);
1657 }
1658
1659 Ok(())
1660 }
1661 }
1662
1663 unsafe impl<'a, ___E>
1664 ::fidl_next::EncodeOption<
1665 ::fidl_next::wire::Box<'static, crate::wire::NodeUpdateAttributesResponse>,
1666 ___E,
1667 > for &'a NodeUpdateAttributesResponse
1668 where
1669 ___E: ::fidl_next::Encoder + ?Sized,
1670 &'a NodeUpdateAttributesResponse:
1671 ::fidl_next::Encode<crate::wire::NodeUpdateAttributesResponse, ___E>,
1672 {
1673 #[inline]
1674 fn encode_option(
1675 this: ::core::option::Option<Self>,
1676 encoder: &mut ___E,
1677 out: &mut ::core::mem::MaybeUninit<
1678 ::fidl_next::wire::Box<'static, crate::wire::NodeUpdateAttributesResponse>,
1679 >,
1680 _: (),
1681 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1682 if let Some(inner) = this {
1683 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1684 ::fidl_next::wire::Box::encode_present(out);
1685 } else {
1686 ::fidl_next::wire::Box::encode_absent(out);
1687 }
1688
1689 Ok(())
1690 }
1691 }
1692
1693 impl ::fidl_next::FromWire<crate::wire::NodeUpdateAttributesResponse>
1694 for NodeUpdateAttributesResponse
1695 {
1696 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1697 crate::wire::NodeUpdateAttributesResponse,
1698 Self,
1699 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
1700
1701 #[inline]
1702 fn from_wire(wire: crate::wire::NodeUpdateAttributesResponse) -> Self {
1703 Self {}
1704 }
1705 }
1706
1707 impl ::fidl_next::FromWireRef<crate::wire::NodeUpdateAttributesResponse>
1708 for NodeUpdateAttributesResponse
1709 {
1710 #[inline]
1711 fn from_wire_ref(wire: &crate::wire::NodeUpdateAttributesResponse) -> Self {
1712 Self {}
1713 }
1714 }
1715
1716 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1717 #[repr(C)]
1718 pub struct NodeSyncResponse {}
1719
1720 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeSyncResponse, ___E> for NodeSyncResponse
1721 where
1722 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1723 {
1724 #[inline]
1725 fn encode(
1726 self,
1727 encoder_: &mut ___E,
1728 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeSyncResponse>,
1729 _: (),
1730 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1731 ::fidl_next::munge! {
1732 let crate::wire::NodeSyncResponse {
1733
1734 _empty,
1735
1736 } = out_;
1737 }
1738
1739 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
1740
1741 Ok(())
1742 }
1743 }
1744
1745 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeSyncResponse, ___E>
1746 for &'a NodeSyncResponse
1747 where
1748 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1749 {
1750 #[inline]
1751 fn encode(
1752 self,
1753 encoder_: &mut ___E,
1754 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeSyncResponse>,
1755 _: (),
1756 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1757 ::fidl_next::munge! {
1758 let crate::wire::NodeSyncResponse {
1759
1760 _empty,
1761
1762
1763 } = out_;
1764 }
1765
1766 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
1767
1768 Ok(())
1769 }
1770 }
1771
1772 unsafe impl<___E>
1773 ::fidl_next::EncodeOption<
1774 ::fidl_next::wire::Box<'static, crate::wire::NodeSyncResponse>,
1775 ___E,
1776 > for NodeSyncResponse
1777 where
1778 ___E: ::fidl_next::Encoder + ?Sized,
1779 NodeSyncResponse: ::fidl_next::Encode<crate::wire::NodeSyncResponse, ___E>,
1780 {
1781 #[inline]
1782 fn encode_option(
1783 this: ::core::option::Option<Self>,
1784 encoder: &mut ___E,
1785 out: &mut ::core::mem::MaybeUninit<
1786 ::fidl_next::wire::Box<'static, crate::wire::NodeSyncResponse>,
1787 >,
1788 _: (),
1789 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1790 if let Some(inner) = this {
1791 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1792 ::fidl_next::wire::Box::encode_present(out);
1793 } else {
1794 ::fidl_next::wire::Box::encode_absent(out);
1795 }
1796
1797 Ok(())
1798 }
1799 }
1800
1801 unsafe impl<'a, ___E>
1802 ::fidl_next::EncodeOption<
1803 ::fidl_next::wire::Box<'static, crate::wire::NodeSyncResponse>,
1804 ___E,
1805 > for &'a NodeSyncResponse
1806 where
1807 ___E: ::fidl_next::Encoder + ?Sized,
1808 &'a NodeSyncResponse: ::fidl_next::Encode<crate::wire::NodeSyncResponse, ___E>,
1809 {
1810 #[inline]
1811 fn encode_option(
1812 this: ::core::option::Option<Self>,
1813 encoder: &mut ___E,
1814 out: &mut ::core::mem::MaybeUninit<
1815 ::fidl_next::wire::Box<'static, crate::wire::NodeSyncResponse>,
1816 >,
1817 _: (),
1818 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1819 if let Some(inner) = this {
1820 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1821 ::fidl_next::wire::Box::encode_present(out);
1822 } else {
1823 ::fidl_next::wire::Box::encode_absent(out);
1824 }
1825
1826 Ok(())
1827 }
1828 }
1829
1830 impl ::fidl_next::FromWire<crate::wire::NodeSyncResponse> for NodeSyncResponse {
1831 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1832 crate::wire::NodeSyncResponse,
1833 Self,
1834 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
1835
1836 #[inline]
1837 fn from_wire(wire: crate::wire::NodeSyncResponse) -> Self {
1838 Self {}
1839 }
1840 }
1841
1842 impl ::fidl_next::FromWireRef<crate::wire::NodeSyncResponse> for NodeSyncResponse {
1843 #[inline]
1844 fn from_wire_ref(wire: &crate::wire::NodeSyncResponse) -> Self {
1845 Self {}
1846 }
1847 }
1848
1849 ::fidl_next::bitflags::bitflags! {
1850 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct ModeType: u32 {
1851 const DO_NOT_USE = 2147483648;
1852
1853 }
1854 }
1855
1856 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ModeType, ___E> for ModeType
1857 where
1858 ___E: ?Sized,
1859 {
1860 #[inline]
1861 fn encode(
1862 self,
1863 encoder: &mut ___E,
1864 out: &mut ::core::mem::MaybeUninit<crate::wire::ModeType>,
1865 _: (),
1866 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1867 ::fidl_next::Encode::encode(&self, encoder, out, ())
1868 }
1869 }
1870
1871 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ModeType, ___E> for &'a ModeType
1872 where
1873 ___E: ?Sized,
1874 {
1875 #[inline]
1876 fn encode(
1877 self,
1878 _: &mut ___E,
1879 out: &mut ::core::mem::MaybeUninit<crate::wire::ModeType>,
1880 _: (),
1881 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1882 ::fidl_next::munge!(let crate::wire::ModeType { value } = out);
1883
1884 if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
1885 return Err(::fidl_next::EncodeError::InvalidStrictBits);
1886 }
1887
1888 let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
1889 Ok(())
1890 }
1891 }
1892
1893 impl ::core::convert::From<crate::wire::ModeType> for ModeType {
1894 fn from(wire: crate::wire::ModeType) -> Self {
1895 Self::from_bits_retain(u32::from(wire.value))
1896 }
1897 }
1898
1899 impl ::fidl_next::FromWire<crate::wire::ModeType> for ModeType {
1900 #[inline]
1901 fn from_wire(wire: crate::wire::ModeType) -> Self {
1902 Self::from(wire)
1903 }
1904 }
1905
1906 impl ::fidl_next::FromWireRef<crate::wire::ModeType> for ModeType {
1907 #[inline]
1908 fn from_wire_ref(wire: &crate::wire::ModeType) -> Self {
1909 Self::from(*wire)
1910 }
1911 }
1912
1913 #[doc = " A path is a string of one or more components, separated by \"/\".\n E.g. `foo/bar/baz`\n\n ## Invariants\n\n A valid path must meet the following criteria:\n\n * It cannot be empty.\n * It cannot be longer than [`MAX_PATH_LENGTH`].\n * It cannot have a leading \"/\".\n * It cannot have a trailing \"/\".\n * It must be exactly \".\" OR each of its components must be a valid [`Name`].\n\n Paths should be transformed into their canonical forms at client side.\n For example, a client should convert `\"foo/bar/.././baz/\"` to `\"foo/baz\"`\n before using it as a path.\n"]
1914 pub type Path = ::std::string::String;
1915
1916 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1917 #[repr(C)]
1918 pub struct DirectoryReadDirentsRequest {
1919 pub max_bytes: u64,
1920 }
1921
1922 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryReadDirentsRequest, ___E>
1923 for DirectoryReadDirentsRequest
1924 where
1925 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1926 {
1927 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1928 Self,
1929 crate::wire::DirectoryReadDirentsRequest,
1930 > = unsafe {
1931 ::fidl_next::CopyOptimization::enable_if(
1932 true
1933
1934 && <
1935 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
1936 >::COPY_OPTIMIZATION.is_enabled()
1937
1938 )
1939 };
1940
1941 #[inline]
1942 fn encode(
1943 self,
1944 encoder_: &mut ___E,
1945 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryReadDirentsRequest>,
1946 _: (),
1947 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1948 ::fidl_next::munge! {
1949 let crate::wire::DirectoryReadDirentsRequest {
1950 max_bytes,
1951
1952 } = out_;
1953 }
1954
1955 ::fidl_next::Encode::encode(self.max_bytes, encoder_, max_bytes, ())?;
1956
1957 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(max_bytes.as_mut_ptr()) };
1958
1959 Ok(())
1960 }
1961 }
1962
1963 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryReadDirentsRequest, ___E>
1964 for &'a DirectoryReadDirentsRequest
1965 where
1966 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1967 {
1968 #[inline]
1969 fn encode(
1970 self,
1971 encoder_: &mut ___E,
1972 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryReadDirentsRequest>,
1973 _: (),
1974 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1975 ::fidl_next::munge! {
1976 let crate::wire::DirectoryReadDirentsRequest {
1977
1978 max_bytes,
1979
1980 } = out_;
1981 }
1982
1983 ::fidl_next::Encode::encode(&self.max_bytes, encoder_, max_bytes, ())?;
1984
1985 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(max_bytes.as_mut_ptr()) };
1986
1987 Ok(())
1988 }
1989 }
1990
1991 unsafe impl<___E>
1992 ::fidl_next::EncodeOption<
1993 ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsRequest>,
1994 ___E,
1995 > for DirectoryReadDirentsRequest
1996 where
1997 ___E: ::fidl_next::Encoder + ?Sized,
1998 DirectoryReadDirentsRequest:
1999 ::fidl_next::Encode<crate::wire::DirectoryReadDirentsRequest, ___E>,
2000 {
2001 #[inline]
2002 fn encode_option(
2003 this: ::core::option::Option<Self>,
2004 encoder: &mut ___E,
2005 out: &mut ::core::mem::MaybeUninit<
2006 ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsRequest>,
2007 >,
2008 _: (),
2009 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2010 if let Some(inner) = this {
2011 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2012 ::fidl_next::wire::Box::encode_present(out);
2013 } else {
2014 ::fidl_next::wire::Box::encode_absent(out);
2015 }
2016
2017 Ok(())
2018 }
2019 }
2020
2021 unsafe impl<'a, ___E>
2022 ::fidl_next::EncodeOption<
2023 ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsRequest>,
2024 ___E,
2025 > for &'a DirectoryReadDirentsRequest
2026 where
2027 ___E: ::fidl_next::Encoder + ?Sized,
2028 &'a DirectoryReadDirentsRequest:
2029 ::fidl_next::Encode<crate::wire::DirectoryReadDirentsRequest, ___E>,
2030 {
2031 #[inline]
2032 fn encode_option(
2033 this: ::core::option::Option<Self>,
2034 encoder: &mut ___E,
2035 out: &mut ::core::mem::MaybeUninit<
2036 ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsRequest>,
2037 >,
2038 _: (),
2039 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2040 if let Some(inner) = this {
2041 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2042 ::fidl_next::wire::Box::encode_present(out);
2043 } else {
2044 ::fidl_next::wire::Box::encode_absent(out);
2045 }
2046
2047 Ok(())
2048 }
2049 }
2050
2051 impl ::fidl_next::FromWire<crate::wire::DirectoryReadDirentsRequest>
2052 for DirectoryReadDirentsRequest
2053 {
2054 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2055 crate::wire::DirectoryReadDirentsRequest,
2056 Self,
2057 > = unsafe {
2058 ::fidl_next::CopyOptimization::enable_if(
2059 true
2060 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
2061 .is_enabled(),
2062 )
2063 };
2064
2065 #[inline]
2066 fn from_wire(wire: crate::wire::DirectoryReadDirentsRequest) -> Self {
2067 Self { max_bytes: ::fidl_next::FromWire::from_wire(wire.max_bytes) }
2068 }
2069 }
2070
2071 impl ::fidl_next::FromWireRef<crate::wire::DirectoryReadDirentsRequest>
2072 for DirectoryReadDirentsRequest
2073 {
2074 #[inline]
2075 fn from_wire_ref(wire: &crate::wire::DirectoryReadDirentsRequest) -> Self {
2076 Self { max_bytes: ::fidl_next::FromWireRef::from_wire_ref(&wire.max_bytes) }
2077 }
2078 }
2079
2080 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2081 pub struct DirectoryReadDirentsResponse {
2082 pub s: i32,
2083
2084 pub dirents: ::std::vec::Vec<u8>,
2085 }
2086
2087 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryReadDirentsResponse<'static>, ___E>
2088 for DirectoryReadDirentsResponse
2089 where
2090 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2091 ___E: ::fidl_next::Encoder,
2092 {
2093 #[inline]
2094 fn encode(
2095 self,
2096 encoder_: &mut ___E,
2097 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryReadDirentsResponse<'static>>,
2098 _: (),
2099 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2100 ::fidl_next::munge! {
2101 let crate::wire::DirectoryReadDirentsResponse {
2102 s,
2103 dirents,
2104
2105 } = out_;
2106 }
2107
2108 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
2109
2110 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
2111
2112 ::fidl_next::Encode::encode(self.dirents, encoder_, dirents, (8192, ()))?;
2113
2114 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dirents.as_mut_ptr()) };
2115 ::fidl_next::Constrained::validate(_field, (8192, ()))?;
2116
2117 Ok(())
2118 }
2119 }
2120
2121 unsafe impl<'a, ___E>
2122 ::fidl_next::Encode<crate::wire::DirectoryReadDirentsResponse<'static>, ___E>
2123 for &'a DirectoryReadDirentsResponse
2124 where
2125 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2126 ___E: ::fidl_next::Encoder,
2127 {
2128 #[inline]
2129 fn encode(
2130 self,
2131 encoder_: &mut ___E,
2132 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryReadDirentsResponse<'static>>,
2133 _: (),
2134 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2135 ::fidl_next::munge! {
2136 let crate::wire::DirectoryReadDirentsResponse {
2137
2138 s,
2139 dirents,
2140
2141 } = out_;
2142 }
2143
2144 ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
2145
2146 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
2147
2148 ::fidl_next::Encode::encode(&self.dirents, encoder_, dirents, (8192, ()))?;
2149
2150 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dirents.as_mut_ptr()) };
2151 ::fidl_next::Constrained::validate(_field, (8192, ()))?;
2152
2153 Ok(())
2154 }
2155 }
2156
2157 unsafe impl<___E>
2158 ::fidl_next::EncodeOption<
2159 ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsResponse<'static>>,
2160 ___E,
2161 > for DirectoryReadDirentsResponse
2162 where
2163 ___E: ::fidl_next::Encoder + ?Sized,
2164 DirectoryReadDirentsResponse:
2165 ::fidl_next::Encode<crate::wire::DirectoryReadDirentsResponse<'static>, ___E>,
2166 {
2167 #[inline]
2168 fn encode_option(
2169 this: ::core::option::Option<Self>,
2170 encoder: &mut ___E,
2171 out: &mut ::core::mem::MaybeUninit<
2172 ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsResponse<'static>>,
2173 >,
2174 _: (),
2175 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2176 if let Some(inner) = this {
2177 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2178 ::fidl_next::wire::Box::encode_present(out);
2179 } else {
2180 ::fidl_next::wire::Box::encode_absent(out);
2181 }
2182
2183 Ok(())
2184 }
2185 }
2186
2187 unsafe impl<'a, ___E>
2188 ::fidl_next::EncodeOption<
2189 ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsResponse<'static>>,
2190 ___E,
2191 > for &'a DirectoryReadDirentsResponse
2192 where
2193 ___E: ::fidl_next::Encoder + ?Sized,
2194 &'a DirectoryReadDirentsResponse:
2195 ::fidl_next::Encode<crate::wire::DirectoryReadDirentsResponse<'static>, ___E>,
2196 {
2197 #[inline]
2198 fn encode_option(
2199 this: ::core::option::Option<Self>,
2200 encoder: &mut ___E,
2201 out: &mut ::core::mem::MaybeUninit<
2202 ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsResponse<'static>>,
2203 >,
2204 _: (),
2205 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2206 if let Some(inner) = this {
2207 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2208 ::fidl_next::wire::Box::encode_present(out);
2209 } else {
2210 ::fidl_next::wire::Box::encode_absent(out);
2211 }
2212
2213 Ok(())
2214 }
2215 }
2216
2217 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryReadDirentsResponse<'de>>
2218 for DirectoryReadDirentsResponse
2219 {
2220 #[inline]
2221 fn from_wire(wire: crate::wire::DirectoryReadDirentsResponse<'de>) -> Self {
2222 Self {
2223 s: ::fidl_next::FromWire::from_wire(wire.s),
2224
2225 dirents: ::fidl_next::FromWire::from_wire(wire.dirents),
2226 }
2227 }
2228 }
2229
2230 impl<'de> ::fidl_next::FromWireRef<crate::wire::DirectoryReadDirentsResponse<'de>>
2231 for DirectoryReadDirentsResponse
2232 {
2233 #[inline]
2234 fn from_wire_ref(wire: &crate::wire::DirectoryReadDirentsResponse<'de>) -> Self {
2235 Self {
2236 s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s),
2237
2238 dirents: ::fidl_next::FromWireRef::from_wire_ref(&wire.dirents),
2239 }
2240 }
2241 }
2242
2243 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2244 #[repr(C)]
2245 pub struct DirectoryRewindResponse {
2246 pub s: i32,
2247 }
2248
2249 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryRewindResponse, ___E>
2250 for DirectoryRewindResponse
2251 where
2252 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2253 {
2254 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2255 Self,
2256 crate::wire::DirectoryRewindResponse,
2257 > = unsafe {
2258 ::fidl_next::CopyOptimization::enable_if(
2259 true
2260
2261 && <
2262 i32 as ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>
2263 >::COPY_OPTIMIZATION.is_enabled()
2264
2265 )
2266 };
2267
2268 #[inline]
2269 fn encode(
2270 self,
2271 encoder_: &mut ___E,
2272 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRewindResponse>,
2273 _: (),
2274 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2275 ::fidl_next::munge! {
2276 let crate::wire::DirectoryRewindResponse {
2277 s,
2278
2279 } = out_;
2280 }
2281
2282 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
2283
2284 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
2285
2286 Ok(())
2287 }
2288 }
2289
2290 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryRewindResponse, ___E>
2291 for &'a DirectoryRewindResponse
2292 where
2293 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2294 {
2295 #[inline]
2296 fn encode(
2297 self,
2298 encoder_: &mut ___E,
2299 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRewindResponse>,
2300 _: (),
2301 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2302 ::fidl_next::munge! {
2303 let crate::wire::DirectoryRewindResponse {
2304
2305 s,
2306
2307 } = out_;
2308 }
2309
2310 ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
2311
2312 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
2313
2314 Ok(())
2315 }
2316 }
2317
2318 unsafe impl<___E>
2319 ::fidl_next::EncodeOption<
2320 ::fidl_next::wire::Box<'static, crate::wire::DirectoryRewindResponse>,
2321 ___E,
2322 > for DirectoryRewindResponse
2323 where
2324 ___E: ::fidl_next::Encoder + ?Sized,
2325 DirectoryRewindResponse: ::fidl_next::Encode<crate::wire::DirectoryRewindResponse, ___E>,
2326 {
2327 #[inline]
2328 fn encode_option(
2329 this: ::core::option::Option<Self>,
2330 encoder: &mut ___E,
2331 out: &mut ::core::mem::MaybeUninit<
2332 ::fidl_next::wire::Box<'static, crate::wire::DirectoryRewindResponse>,
2333 >,
2334 _: (),
2335 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2336 if let Some(inner) = this {
2337 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2338 ::fidl_next::wire::Box::encode_present(out);
2339 } else {
2340 ::fidl_next::wire::Box::encode_absent(out);
2341 }
2342
2343 Ok(())
2344 }
2345 }
2346
2347 unsafe impl<'a, ___E>
2348 ::fidl_next::EncodeOption<
2349 ::fidl_next::wire::Box<'static, crate::wire::DirectoryRewindResponse>,
2350 ___E,
2351 > for &'a DirectoryRewindResponse
2352 where
2353 ___E: ::fidl_next::Encoder + ?Sized,
2354 &'a DirectoryRewindResponse:
2355 ::fidl_next::Encode<crate::wire::DirectoryRewindResponse, ___E>,
2356 {
2357 #[inline]
2358 fn encode_option(
2359 this: ::core::option::Option<Self>,
2360 encoder: &mut ___E,
2361 out: &mut ::core::mem::MaybeUninit<
2362 ::fidl_next::wire::Box<'static, crate::wire::DirectoryRewindResponse>,
2363 >,
2364 _: (),
2365 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2366 if let Some(inner) = this {
2367 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2368 ::fidl_next::wire::Box::encode_present(out);
2369 } else {
2370 ::fidl_next::wire::Box::encode_absent(out);
2371 }
2372
2373 Ok(())
2374 }
2375 }
2376
2377 impl ::fidl_next::FromWire<crate::wire::DirectoryRewindResponse> for DirectoryRewindResponse {
2378 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2379 crate::wire::DirectoryRewindResponse,
2380 Self,
2381 > = unsafe {
2382 ::fidl_next::CopyOptimization::enable_if(
2383 true && <i32 as ::fidl_next::FromWire<::fidl_next::wire::Int32>>::COPY_OPTIMIZATION
2384 .is_enabled(),
2385 )
2386 };
2387
2388 #[inline]
2389 fn from_wire(wire: crate::wire::DirectoryRewindResponse) -> Self {
2390 Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
2391 }
2392 }
2393
2394 impl ::fidl_next::FromWireRef<crate::wire::DirectoryRewindResponse> for DirectoryRewindResponse {
2395 #[inline]
2396 fn from_wire_ref(wire: &crate::wire::DirectoryRewindResponse) -> Self {
2397 Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
2398 }
2399 }
2400
2401 #[doc = " The type for the name of a node, i.e. a single path component.\n E.g. `foo`\n\n ## Invariants\n\n A valid node name must meet the following criteria:\n\n * It cannot be longer than [`MAX_NAME_LENGTH`].\n * It cannot be empty.\n * It cannot be \"..\" (dot-dot).\n * It cannot be \".\" (single dot).\n * It cannot contain \"/\".\n * It cannot contain embedded NUL.\n"]
2402 pub type Name = ::std::string::String;
2403
2404 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2405 #[repr(C)]
2406 pub struct DirectoryLinkResponse {
2407 pub s: i32,
2408 }
2409
2410 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryLinkResponse, ___E>
2411 for DirectoryLinkResponse
2412 where
2413 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2414 {
2415 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2416 Self,
2417 crate::wire::DirectoryLinkResponse,
2418 > = unsafe {
2419 ::fidl_next::CopyOptimization::enable_if(
2420 true
2421
2422 && <
2423 i32 as ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>
2424 >::COPY_OPTIMIZATION.is_enabled()
2425
2426 )
2427 };
2428
2429 #[inline]
2430 fn encode(
2431 self,
2432 encoder_: &mut ___E,
2433 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkResponse>,
2434 _: (),
2435 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2436 ::fidl_next::munge! {
2437 let crate::wire::DirectoryLinkResponse {
2438 s,
2439
2440 } = out_;
2441 }
2442
2443 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
2444
2445 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
2446
2447 Ok(())
2448 }
2449 }
2450
2451 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryLinkResponse, ___E>
2452 for &'a DirectoryLinkResponse
2453 where
2454 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2455 {
2456 #[inline]
2457 fn encode(
2458 self,
2459 encoder_: &mut ___E,
2460 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkResponse>,
2461 _: (),
2462 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2463 ::fidl_next::munge! {
2464 let crate::wire::DirectoryLinkResponse {
2465
2466 s,
2467
2468 } = out_;
2469 }
2470
2471 ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
2472
2473 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
2474
2475 Ok(())
2476 }
2477 }
2478
2479 unsafe impl<___E>
2480 ::fidl_next::EncodeOption<
2481 ::fidl_next::wire::Box<'static, crate::wire::DirectoryLinkResponse>,
2482 ___E,
2483 > for DirectoryLinkResponse
2484 where
2485 ___E: ::fidl_next::Encoder + ?Sized,
2486 DirectoryLinkResponse: ::fidl_next::Encode<crate::wire::DirectoryLinkResponse, ___E>,
2487 {
2488 #[inline]
2489 fn encode_option(
2490 this: ::core::option::Option<Self>,
2491 encoder: &mut ___E,
2492 out: &mut ::core::mem::MaybeUninit<
2493 ::fidl_next::wire::Box<'static, crate::wire::DirectoryLinkResponse>,
2494 >,
2495 _: (),
2496 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2497 if let Some(inner) = this {
2498 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2499 ::fidl_next::wire::Box::encode_present(out);
2500 } else {
2501 ::fidl_next::wire::Box::encode_absent(out);
2502 }
2503
2504 Ok(())
2505 }
2506 }
2507
2508 unsafe impl<'a, ___E>
2509 ::fidl_next::EncodeOption<
2510 ::fidl_next::wire::Box<'static, crate::wire::DirectoryLinkResponse>,
2511 ___E,
2512 > for &'a DirectoryLinkResponse
2513 where
2514 ___E: ::fidl_next::Encoder + ?Sized,
2515 &'a DirectoryLinkResponse: ::fidl_next::Encode<crate::wire::DirectoryLinkResponse, ___E>,
2516 {
2517 #[inline]
2518 fn encode_option(
2519 this: ::core::option::Option<Self>,
2520 encoder: &mut ___E,
2521 out: &mut ::core::mem::MaybeUninit<
2522 ::fidl_next::wire::Box<'static, crate::wire::DirectoryLinkResponse>,
2523 >,
2524 _: (),
2525 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2526 if let Some(inner) = this {
2527 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2528 ::fidl_next::wire::Box::encode_present(out);
2529 } else {
2530 ::fidl_next::wire::Box::encode_absent(out);
2531 }
2532
2533 Ok(())
2534 }
2535 }
2536
2537 impl ::fidl_next::FromWire<crate::wire::DirectoryLinkResponse> for DirectoryLinkResponse {
2538 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2539 crate::wire::DirectoryLinkResponse,
2540 Self,
2541 > = unsafe {
2542 ::fidl_next::CopyOptimization::enable_if(
2543 true && <i32 as ::fidl_next::FromWire<::fidl_next::wire::Int32>>::COPY_OPTIMIZATION
2544 .is_enabled(),
2545 )
2546 };
2547
2548 #[inline]
2549 fn from_wire(wire: crate::wire::DirectoryLinkResponse) -> Self {
2550 Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
2551 }
2552 }
2553
2554 impl ::fidl_next::FromWireRef<crate::wire::DirectoryLinkResponse> for DirectoryLinkResponse {
2555 #[inline]
2556 fn from_wire_ref(wire: &crate::wire::DirectoryLinkResponse) -> Self {
2557 Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
2558 }
2559 }
2560
2561 ::fidl_next::bitflags::bitflags! {
2562 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct UnlinkFlags: u64 {
2563 #[doc = " If set, the unlink will fail (with ZX_ERR_NOT_DIR) if the\n object is not a directory.\n"]const MUST_BE_DIRECTORY = 1;
2564 const _ = !0;
2565 }
2566 }
2567
2568 unsafe impl<___E> ::fidl_next::Encode<crate::wire::UnlinkFlags, ___E> for UnlinkFlags
2569 where
2570 ___E: ?Sized,
2571 {
2572 #[inline]
2573 fn encode(
2574 self,
2575 encoder: &mut ___E,
2576 out: &mut ::core::mem::MaybeUninit<crate::wire::UnlinkFlags>,
2577 _: (),
2578 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2579 ::fidl_next::Encode::encode(&self, encoder, out, ())
2580 }
2581 }
2582
2583 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::UnlinkFlags, ___E> for &'a UnlinkFlags
2584 where
2585 ___E: ?Sized,
2586 {
2587 #[inline]
2588 fn encode(
2589 self,
2590 _: &mut ___E,
2591 out: &mut ::core::mem::MaybeUninit<crate::wire::UnlinkFlags>,
2592 _: (),
2593 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2594 ::fidl_next::munge!(let crate::wire::UnlinkFlags { value } = out);
2595
2596 let _ = value.write(::fidl_next::wire::Uint64::from(self.bits()));
2597 Ok(())
2598 }
2599 }
2600
2601 impl ::core::convert::From<crate::wire::UnlinkFlags> for UnlinkFlags {
2602 fn from(wire: crate::wire::UnlinkFlags) -> Self {
2603 Self::from_bits_retain(u64::from(wire.value))
2604 }
2605 }
2606
2607 impl ::fidl_next::FromWire<crate::wire::UnlinkFlags> for UnlinkFlags {
2608 #[inline]
2609 fn from_wire(wire: crate::wire::UnlinkFlags) -> Self {
2610 Self::from(wire)
2611 }
2612 }
2613
2614 impl ::fidl_next::FromWireRef<crate::wire::UnlinkFlags> for UnlinkFlags {
2615 #[inline]
2616 fn from_wire_ref(wire: &crate::wire::UnlinkFlags) -> Self {
2617 Self::from(*wire)
2618 }
2619 }
2620
2621 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2622 pub struct UnlinkOptions {
2623 pub flags: ::core::option::Option<crate::natural::UnlinkFlags>,
2624 }
2625
2626 impl UnlinkOptions {
2627 fn __max_ordinal(&self) -> usize {
2628 if self.flags.is_some() {
2629 return 1;
2630 }
2631
2632 0
2633 }
2634 }
2635
2636 unsafe impl<___E> ::fidl_next::Encode<crate::wire::UnlinkOptions<'static>, ___E> for UnlinkOptions
2637 where
2638 ___E: ::fidl_next::Encoder + ?Sized,
2639 {
2640 #[inline]
2641 fn encode(
2642 mut self,
2643 encoder: &mut ___E,
2644 out: &mut ::core::mem::MaybeUninit<crate::wire::UnlinkOptions<'static>>,
2645 _: (),
2646 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2647 ::fidl_next::munge!(let crate::wire::UnlinkOptions { table } = out);
2648
2649 let max_ord = self.__max_ordinal();
2650
2651 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
2652 ::fidl_next::Wire::zero_padding(&mut out);
2653
2654 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
2655 ::fidl_next::wire::Envelope,
2656 >(encoder, max_ord);
2657
2658 for i in 1..=max_ord {
2659 match i {
2660 1 => {
2661 if let Some(value) = self.flags.take() {
2662 ::fidl_next::wire::Envelope::encode_value::<
2663 crate::wire::UnlinkFlags,
2664 ___E,
2665 >(
2666 value, preallocated.encoder, &mut out, ()
2667 )?;
2668 } else {
2669 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2670 }
2671 }
2672
2673 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
2674 }
2675 unsafe {
2676 preallocated.write_next(out.assume_init_ref());
2677 }
2678 }
2679
2680 ::fidl_next::wire::Table::encode_len(table, max_ord);
2681
2682 Ok(())
2683 }
2684 }
2685
2686 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::UnlinkOptions<'static>, ___E>
2687 for &'a UnlinkOptions
2688 where
2689 ___E: ::fidl_next::Encoder + ?Sized,
2690 {
2691 #[inline]
2692 fn encode(
2693 self,
2694 encoder: &mut ___E,
2695 out: &mut ::core::mem::MaybeUninit<crate::wire::UnlinkOptions<'static>>,
2696 _: (),
2697 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2698 ::fidl_next::munge!(let crate::wire::UnlinkOptions { table } = out);
2699
2700 let max_ord = self.__max_ordinal();
2701
2702 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
2703 ::fidl_next::Wire::zero_padding(&mut out);
2704
2705 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
2706 ::fidl_next::wire::Envelope,
2707 >(encoder, max_ord);
2708
2709 for i in 1..=max_ord {
2710 match i {
2711 1 => {
2712 if let Some(value) = &self.flags {
2713 ::fidl_next::wire::Envelope::encode_value::<
2714 crate::wire::UnlinkFlags,
2715 ___E,
2716 >(
2717 value, preallocated.encoder, &mut out, ()
2718 )?;
2719 } else {
2720 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2721 }
2722 }
2723
2724 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
2725 }
2726 unsafe {
2727 preallocated.write_next(out.assume_init_ref());
2728 }
2729 }
2730
2731 ::fidl_next::wire::Table::encode_len(table, max_ord);
2732
2733 Ok(())
2734 }
2735 }
2736
2737 impl<'de> ::fidl_next::FromWire<crate::wire::UnlinkOptions<'de>> for UnlinkOptions {
2738 #[inline]
2739 fn from_wire(wire_: crate::wire::UnlinkOptions<'de>) -> Self {
2740 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
2741
2742 let flags = wire_.table.get(1);
2743
2744 Self {
2745 flags: flags.map(|envelope| {
2746 ::fidl_next::FromWire::from_wire(unsafe {
2747 envelope.read_unchecked::<crate::wire::UnlinkFlags>()
2748 })
2749 }),
2750 }
2751 }
2752 }
2753
2754 impl<'de> ::fidl_next::FromWireRef<crate::wire::UnlinkOptions<'de>> for UnlinkOptions {
2755 #[inline]
2756 fn from_wire_ref(wire: &crate::wire::UnlinkOptions<'de>) -> Self {
2757 Self {
2758 flags: wire.table.get(1).map(|envelope| {
2759 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
2760 envelope.deref_unchecked::<crate::wire::UnlinkFlags>()
2761 })
2762 }),
2763 }
2764 }
2765 }
2766
2767 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2768 pub struct DirectoryUnlinkRequest {
2769 pub name: ::std::string::String,
2770
2771 pub options: crate::natural::UnlinkOptions,
2772 }
2773
2774 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryUnlinkRequest<'static>, ___E>
2775 for DirectoryUnlinkRequest
2776 where
2777 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2778 ___E: ::fidl_next::Encoder,
2779 {
2780 #[inline]
2781 fn encode(
2782 self,
2783 encoder_: &mut ___E,
2784 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryUnlinkRequest<'static>>,
2785 _: (),
2786 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2787 ::fidl_next::munge! {
2788 let crate::wire::DirectoryUnlinkRequest {
2789 name,
2790 options,
2791
2792 } = out_;
2793 }
2794
2795 ::fidl_next::Encode::encode(self.name, encoder_, name, 255)?;
2796
2797 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
2798 ::fidl_next::Constrained::validate(_field, 255)?;
2799
2800 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
2801
2802 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
2803
2804 Ok(())
2805 }
2806 }
2807
2808 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryUnlinkRequest<'static>, ___E>
2809 for &'a DirectoryUnlinkRequest
2810 where
2811 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2812 ___E: ::fidl_next::Encoder,
2813 {
2814 #[inline]
2815 fn encode(
2816 self,
2817 encoder_: &mut ___E,
2818 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryUnlinkRequest<'static>>,
2819 _: (),
2820 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2821 ::fidl_next::munge! {
2822 let crate::wire::DirectoryUnlinkRequest {
2823
2824 name,
2825 options,
2826
2827 } = out_;
2828 }
2829
2830 ::fidl_next::Encode::encode(&self.name, encoder_, name, 255)?;
2831
2832 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
2833 ::fidl_next::Constrained::validate(_field, 255)?;
2834
2835 ::fidl_next::Encode::encode(&self.options, encoder_, options, ())?;
2836
2837 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
2838
2839 Ok(())
2840 }
2841 }
2842
2843 unsafe impl<___E>
2844 ::fidl_next::EncodeOption<
2845 ::fidl_next::wire::Box<'static, crate::wire::DirectoryUnlinkRequest<'static>>,
2846 ___E,
2847 > for DirectoryUnlinkRequest
2848 where
2849 ___E: ::fidl_next::Encoder + ?Sized,
2850 DirectoryUnlinkRequest:
2851 ::fidl_next::Encode<crate::wire::DirectoryUnlinkRequest<'static>, ___E>,
2852 {
2853 #[inline]
2854 fn encode_option(
2855 this: ::core::option::Option<Self>,
2856 encoder: &mut ___E,
2857 out: &mut ::core::mem::MaybeUninit<
2858 ::fidl_next::wire::Box<'static, crate::wire::DirectoryUnlinkRequest<'static>>,
2859 >,
2860 _: (),
2861 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2862 if let Some(inner) = this {
2863 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2864 ::fidl_next::wire::Box::encode_present(out);
2865 } else {
2866 ::fidl_next::wire::Box::encode_absent(out);
2867 }
2868
2869 Ok(())
2870 }
2871 }
2872
2873 unsafe impl<'a, ___E>
2874 ::fidl_next::EncodeOption<
2875 ::fidl_next::wire::Box<'static, crate::wire::DirectoryUnlinkRequest<'static>>,
2876 ___E,
2877 > for &'a DirectoryUnlinkRequest
2878 where
2879 ___E: ::fidl_next::Encoder + ?Sized,
2880 &'a DirectoryUnlinkRequest:
2881 ::fidl_next::Encode<crate::wire::DirectoryUnlinkRequest<'static>, ___E>,
2882 {
2883 #[inline]
2884 fn encode_option(
2885 this: ::core::option::Option<Self>,
2886 encoder: &mut ___E,
2887 out: &mut ::core::mem::MaybeUninit<
2888 ::fidl_next::wire::Box<'static, crate::wire::DirectoryUnlinkRequest<'static>>,
2889 >,
2890 _: (),
2891 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2892 if let Some(inner) = this {
2893 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2894 ::fidl_next::wire::Box::encode_present(out);
2895 } else {
2896 ::fidl_next::wire::Box::encode_absent(out);
2897 }
2898
2899 Ok(())
2900 }
2901 }
2902
2903 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryUnlinkRequest<'de>>
2904 for DirectoryUnlinkRequest
2905 {
2906 #[inline]
2907 fn from_wire(wire: crate::wire::DirectoryUnlinkRequest<'de>) -> Self {
2908 Self {
2909 name: ::fidl_next::FromWire::from_wire(wire.name),
2910
2911 options: ::fidl_next::FromWire::from_wire(wire.options),
2912 }
2913 }
2914 }
2915
2916 impl<'de> ::fidl_next::FromWireRef<crate::wire::DirectoryUnlinkRequest<'de>>
2917 for DirectoryUnlinkRequest
2918 {
2919 #[inline]
2920 fn from_wire_ref(wire: &crate::wire::DirectoryUnlinkRequest<'de>) -> Self {
2921 Self {
2922 name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name),
2923
2924 options: ::fidl_next::FromWireRef::from_wire_ref(&wire.options),
2925 }
2926 }
2927 }
2928
2929 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2930 #[repr(C)]
2931 pub struct DirectoryUnlinkResponse {}
2932
2933 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryUnlinkResponse, ___E>
2934 for DirectoryUnlinkResponse
2935 where
2936 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2937 {
2938 #[inline]
2939 fn encode(
2940 self,
2941 encoder_: &mut ___E,
2942 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryUnlinkResponse>,
2943 _: (),
2944 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2945 ::fidl_next::munge! {
2946 let crate::wire::DirectoryUnlinkResponse {
2947
2948 _empty,
2949
2950 } = out_;
2951 }
2952
2953 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
2954
2955 Ok(())
2956 }
2957 }
2958
2959 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryUnlinkResponse, ___E>
2960 for &'a DirectoryUnlinkResponse
2961 where
2962 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2963 {
2964 #[inline]
2965 fn encode(
2966 self,
2967 encoder_: &mut ___E,
2968 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryUnlinkResponse>,
2969 _: (),
2970 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2971 ::fidl_next::munge! {
2972 let crate::wire::DirectoryUnlinkResponse {
2973
2974 _empty,
2975
2976
2977 } = out_;
2978 }
2979
2980 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
2981
2982 Ok(())
2983 }
2984 }
2985
2986 unsafe impl<___E>
2987 ::fidl_next::EncodeOption<
2988 ::fidl_next::wire::Box<'static, crate::wire::DirectoryUnlinkResponse>,
2989 ___E,
2990 > for DirectoryUnlinkResponse
2991 where
2992 ___E: ::fidl_next::Encoder + ?Sized,
2993 DirectoryUnlinkResponse: ::fidl_next::Encode<crate::wire::DirectoryUnlinkResponse, ___E>,
2994 {
2995 #[inline]
2996 fn encode_option(
2997 this: ::core::option::Option<Self>,
2998 encoder: &mut ___E,
2999 out: &mut ::core::mem::MaybeUninit<
3000 ::fidl_next::wire::Box<'static, crate::wire::DirectoryUnlinkResponse>,
3001 >,
3002 _: (),
3003 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3004 if let Some(inner) = this {
3005 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3006 ::fidl_next::wire::Box::encode_present(out);
3007 } else {
3008 ::fidl_next::wire::Box::encode_absent(out);
3009 }
3010
3011 Ok(())
3012 }
3013 }
3014
3015 unsafe impl<'a, ___E>
3016 ::fidl_next::EncodeOption<
3017 ::fidl_next::wire::Box<'static, crate::wire::DirectoryUnlinkResponse>,
3018 ___E,
3019 > for &'a DirectoryUnlinkResponse
3020 where
3021 ___E: ::fidl_next::Encoder + ?Sized,
3022 &'a DirectoryUnlinkResponse:
3023 ::fidl_next::Encode<crate::wire::DirectoryUnlinkResponse, ___E>,
3024 {
3025 #[inline]
3026 fn encode_option(
3027 this: ::core::option::Option<Self>,
3028 encoder: &mut ___E,
3029 out: &mut ::core::mem::MaybeUninit<
3030 ::fidl_next::wire::Box<'static, crate::wire::DirectoryUnlinkResponse>,
3031 >,
3032 _: (),
3033 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3034 if let Some(inner) = this {
3035 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3036 ::fidl_next::wire::Box::encode_present(out);
3037 } else {
3038 ::fidl_next::wire::Box::encode_absent(out);
3039 }
3040
3041 Ok(())
3042 }
3043 }
3044
3045 impl ::fidl_next::FromWire<crate::wire::DirectoryUnlinkResponse> for DirectoryUnlinkResponse {
3046 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3047 crate::wire::DirectoryUnlinkResponse,
3048 Self,
3049 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
3050
3051 #[inline]
3052 fn from_wire(wire: crate::wire::DirectoryUnlinkResponse) -> Self {
3053 Self {}
3054 }
3055 }
3056
3057 impl ::fidl_next::FromWireRef<crate::wire::DirectoryUnlinkResponse> for DirectoryUnlinkResponse {
3058 #[inline]
3059 fn from_wire_ref(wire: &crate::wire::DirectoryUnlinkResponse) -> Self {
3060 Self {}
3061 }
3062 }
3063
3064 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3065 #[repr(C)]
3066 pub struct DirectoryRenameResponse {}
3067
3068 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryRenameResponse, ___E>
3069 for DirectoryRenameResponse
3070 where
3071 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3072 {
3073 #[inline]
3074 fn encode(
3075 self,
3076 encoder_: &mut ___E,
3077 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRenameResponse>,
3078 _: (),
3079 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3080 ::fidl_next::munge! {
3081 let crate::wire::DirectoryRenameResponse {
3082
3083 _empty,
3084
3085 } = out_;
3086 }
3087
3088 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
3089
3090 Ok(())
3091 }
3092 }
3093
3094 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryRenameResponse, ___E>
3095 for &'a DirectoryRenameResponse
3096 where
3097 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3098 {
3099 #[inline]
3100 fn encode(
3101 self,
3102 encoder_: &mut ___E,
3103 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRenameResponse>,
3104 _: (),
3105 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3106 ::fidl_next::munge! {
3107 let crate::wire::DirectoryRenameResponse {
3108
3109 _empty,
3110
3111
3112 } = out_;
3113 }
3114
3115 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
3116
3117 Ok(())
3118 }
3119 }
3120
3121 unsafe impl<___E>
3122 ::fidl_next::EncodeOption<
3123 ::fidl_next::wire::Box<'static, crate::wire::DirectoryRenameResponse>,
3124 ___E,
3125 > for DirectoryRenameResponse
3126 where
3127 ___E: ::fidl_next::Encoder + ?Sized,
3128 DirectoryRenameResponse: ::fidl_next::Encode<crate::wire::DirectoryRenameResponse, ___E>,
3129 {
3130 #[inline]
3131 fn encode_option(
3132 this: ::core::option::Option<Self>,
3133 encoder: &mut ___E,
3134 out: &mut ::core::mem::MaybeUninit<
3135 ::fidl_next::wire::Box<'static, crate::wire::DirectoryRenameResponse>,
3136 >,
3137 _: (),
3138 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3139 if let Some(inner) = this {
3140 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3141 ::fidl_next::wire::Box::encode_present(out);
3142 } else {
3143 ::fidl_next::wire::Box::encode_absent(out);
3144 }
3145
3146 Ok(())
3147 }
3148 }
3149
3150 unsafe impl<'a, ___E>
3151 ::fidl_next::EncodeOption<
3152 ::fidl_next::wire::Box<'static, crate::wire::DirectoryRenameResponse>,
3153 ___E,
3154 > for &'a DirectoryRenameResponse
3155 where
3156 ___E: ::fidl_next::Encoder + ?Sized,
3157 &'a DirectoryRenameResponse:
3158 ::fidl_next::Encode<crate::wire::DirectoryRenameResponse, ___E>,
3159 {
3160 #[inline]
3161 fn encode_option(
3162 this: ::core::option::Option<Self>,
3163 encoder: &mut ___E,
3164 out: &mut ::core::mem::MaybeUninit<
3165 ::fidl_next::wire::Box<'static, crate::wire::DirectoryRenameResponse>,
3166 >,
3167 _: (),
3168 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3169 if let Some(inner) = this {
3170 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3171 ::fidl_next::wire::Box::encode_present(out);
3172 } else {
3173 ::fidl_next::wire::Box::encode_absent(out);
3174 }
3175
3176 Ok(())
3177 }
3178 }
3179
3180 impl ::fidl_next::FromWire<crate::wire::DirectoryRenameResponse> for DirectoryRenameResponse {
3181 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3182 crate::wire::DirectoryRenameResponse,
3183 Self,
3184 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
3185
3186 #[inline]
3187 fn from_wire(wire: crate::wire::DirectoryRenameResponse) -> Self {
3188 Self {}
3189 }
3190 }
3191
3192 impl ::fidl_next::FromWireRef<crate::wire::DirectoryRenameResponse> for DirectoryRenameResponse {
3193 #[inline]
3194 fn from_wire_ref(wire: &crate::wire::DirectoryRenameResponse) -> Self {
3195 Self {}
3196 }
3197 }
3198
3199 ::fidl_next::bitflags::bitflags! {
3200 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct WatchMask: u32 {
3201 #[doc = " Used by `Directory.Watch`. Requests transmission of `WatchEvent.DELETED`.\n"]const DELETED = 1;
3202 #[doc = " Used by `Directory.Watch`. Requests transmission of `WatchEvent.ADDED`.\n"]const ADDED = 2;
3203 #[doc = " Used by `Directory.Watch`. Requests transmission of `WatchEvent.REMOVED`.\n"]const REMOVED = 4;
3204 #[doc = " Used by `Directory.Watch`. Requests transmission of `WatchEvent.EXISTING`.\n"]const EXISTING = 8;
3205 #[doc = " Used by `Directory.Watch`. Requests transmission of `WatchEvent.IDLE`.\n"]const IDLE = 16;
3206
3207 }
3208 }
3209
3210 unsafe impl<___E> ::fidl_next::Encode<crate::wire::WatchMask, ___E> for WatchMask
3211 where
3212 ___E: ?Sized,
3213 {
3214 #[inline]
3215 fn encode(
3216 self,
3217 encoder: &mut ___E,
3218 out: &mut ::core::mem::MaybeUninit<crate::wire::WatchMask>,
3219 _: (),
3220 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3221 ::fidl_next::Encode::encode(&self, encoder, out, ())
3222 }
3223 }
3224
3225 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WatchMask, ___E> for &'a WatchMask
3226 where
3227 ___E: ?Sized,
3228 {
3229 #[inline]
3230 fn encode(
3231 self,
3232 _: &mut ___E,
3233 out: &mut ::core::mem::MaybeUninit<crate::wire::WatchMask>,
3234 _: (),
3235 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3236 ::fidl_next::munge!(let crate::wire::WatchMask { value } = out);
3237
3238 if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
3239 return Err(::fidl_next::EncodeError::InvalidStrictBits);
3240 }
3241
3242 let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
3243 Ok(())
3244 }
3245 }
3246
3247 impl ::core::convert::From<crate::wire::WatchMask> for WatchMask {
3248 fn from(wire: crate::wire::WatchMask) -> Self {
3249 Self::from_bits_retain(u32::from(wire.value))
3250 }
3251 }
3252
3253 impl ::fidl_next::FromWire<crate::wire::WatchMask> for WatchMask {
3254 #[inline]
3255 fn from_wire(wire: crate::wire::WatchMask) -> Self {
3256 Self::from(wire)
3257 }
3258 }
3259
3260 impl ::fidl_next::FromWireRef<crate::wire::WatchMask> for WatchMask {
3261 #[inline]
3262 fn from_wire_ref(wire: &crate::wire::WatchMask) -> Self {
3263 Self::from(*wire)
3264 }
3265 }
3266
3267 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3268 #[repr(C)]
3269 pub struct DirectoryWatchResponse {
3270 pub s: i32,
3271 }
3272
3273 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryWatchResponse, ___E>
3274 for DirectoryWatchResponse
3275 where
3276 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3277 {
3278 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3279 Self,
3280 crate::wire::DirectoryWatchResponse,
3281 > = unsafe {
3282 ::fidl_next::CopyOptimization::enable_if(
3283 true
3284
3285 && <
3286 i32 as ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>
3287 >::COPY_OPTIMIZATION.is_enabled()
3288
3289 )
3290 };
3291
3292 #[inline]
3293 fn encode(
3294 self,
3295 encoder_: &mut ___E,
3296 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchResponse>,
3297 _: (),
3298 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3299 ::fidl_next::munge! {
3300 let crate::wire::DirectoryWatchResponse {
3301 s,
3302
3303 } = out_;
3304 }
3305
3306 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
3307
3308 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
3309
3310 Ok(())
3311 }
3312 }
3313
3314 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryWatchResponse, ___E>
3315 for &'a DirectoryWatchResponse
3316 where
3317 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3318 {
3319 #[inline]
3320 fn encode(
3321 self,
3322 encoder_: &mut ___E,
3323 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchResponse>,
3324 _: (),
3325 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3326 ::fidl_next::munge! {
3327 let crate::wire::DirectoryWatchResponse {
3328
3329 s,
3330
3331 } = out_;
3332 }
3333
3334 ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
3335
3336 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
3337
3338 Ok(())
3339 }
3340 }
3341
3342 unsafe impl<___E>
3343 ::fidl_next::EncodeOption<
3344 ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchResponse>,
3345 ___E,
3346 > for DirectoryWatchResponse
3347 where
3348 ___E: ::fidl_next::Encoder + ?Sized,
3349 DirectoryWatchResponse: ::fidl_next::Encode<crate::wire::DirectoryWatchResponse, ___E>,
3350 {
3351 #[inline]
3352 fn encode_option(
3353 this: ::core::option::Option<Self>,
3354 encoder: &mut ___E,
3355 out: &mut ::core::mem::MaybeUninit<
3356 ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchResponse>,
3357 >,
3358 _: (),
3359 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3360 if let Some(inner) = this {
3361 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3362 ::fidl_next::wire::Box::encode_present(out);
3363 } else {
3364 ::fidl_next::wire::Box::encode_absent(out);
3365 }
3366
3367 Ok(())
3368 }
3369 }
3370
3371 unsafe impl<'a, ___E>
3372 ::fidl_next::EncodeOption<
3373 ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchResponse>,
3374 ___E,
3375 > for &'a DirectoryWatchResponse
3376 where
3377 ___E: ::fidl_next::Encoder + ?Sized,
3378 &'a DirectoryWatchResponse: ::fidl_next::Encode<crate::wire::DirectoryWatchResponse, ___E>,
3379 {
3380 #[inline]
3381 fn encode_option(
3382 this: ::core::option::Option<Self>,
3383 encoder: &mut ___E,
3384 out: &mut ::core::mem::MaybeUninit<
3385 ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchResponse>,
3386 >,
3387 _: (),
3388 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3389 if let Some(inner) = this {
3390 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3391 ::fidl_next::wire::Box::encode_present(out);
3392 } else {
3393 ::fidl_next::wire::Box::encode_absent(out);
3394 }
3395
3396 Ok(())
3397 }
3398 }
3399
3400 impl ::fidl_next::FromWire<crate::wire::DirectoryWatchResponse> for DirectoryWatchResponse {
3401 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3402 crate::wire::DirectoryWatchResponse,
3403 Self,
3404 > = unsafe {
3405 ::fidl_next::CopyOptimization::enable_if(
3406 true && <i32 as ::fidl_next::FromWire<::fidl_next::wire::Int32>>::COPY_OPTIMIZATION
3407 .is_enabled(),
3408 )
3409 };
3410
3411 #[inline]
3412 fn from_wire(wire: crate::wire::DirectoryWatchResponse) -> Self {
3413 Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
3414 }
3415 }
3416
3417 impl ::fidl_next::FromWireRef<crate::wire::DirectoryWatchResponse> for DirectoryWatchResponse {
3418 #[inline]
3419 fn from_wire_ref(wire: &crate::wire::DirectoryWatchResponse) -> Self {
3420 Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
3421 }
3422 }
3423
3424 pub type SymlinkTarget = ::std::vec::Vec<u8>;
3425
3426 #[doc = " The name of an extended attribute. It can not contain any null bytes. Other\n than that and the maximum size, no particular structure is imposed on the\n name.\n"]
3427 pub type ExtendedAttributeName = ::std::vec::Vec<u8>;
3428
3429 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3430 pub struct NodeGetExtendedAttributeRequest {
3431 pub name: ::std::vec::Vec<u8>,
3432 }
3433
3434 unsafe impl<___E>
3435 ::fidl_next::Encode<crate::wire::NodeGetExtendedAttributeRequest<'static>, ___E>
3436 for NodeGetExtendedAttributeRequest
3437 where
3438 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3439 ___E: ::fidl_next::Encoder,
3440 {
3441 #[inline]
3442 fn encode(
3443 self,
3444 encoder_: &mut ___E,
3445 out_: &mut ::core::mem::MaybeUninit<
3446 crate::wire::NodeGetExtendedAttributeRequest<'static>,
3447 >,
3448 _: (),
3449 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3450 ::fidl_next::munge! {
3451 let crate::wire::NodeGetExtendedAttributeRequest {
3452 name,
3453
3454 } = out_;
3455 }
3456
3457 ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
3458
3459 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
3460 ::fidl_next::Constrained::validate(_field, (255, ()))?;
3461
3462 Ok(())
3463 }
3464 }
3465
3466 unsafe impl<'a, ___E>
3467 ::fidl_next::Encode<crate::wire::NodeGetExtendedAttributeRequest<'static>, ___E>
3468 for &'a NodeGetExtendedAttributeRequest
3469 where
3470 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3471 ___E: ::fidl_next::Encoder,
3472 {
3473 #[inline]
3474 fn encode(
3475 self,
3476 encoder_: &mut ___E,
3477 out_: &mut ::core::mem::MaybeUninit<
3478 crate::wire::NodeGetExtendedAttributeRequest<'static>,
3479 >,
3480 _: (),
3481 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3482 ::fidl_next::munge! {
3483 let crate::wire::NodeGetExtendedAttributeRequest {
3484
3485 name,
3486
3487 } = out_;
3488 }
3489
3490 ::fidl_next::Encode::encode(&self.name, encoder_, name, (255, ()))?;
3491
3492 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
3493 ::fidl_next::Constrained::validate(_field, (255, ()))?;
3494
3495 Ok(())
3496 }
3497 }
3498
3499 unsafe impl<___E>
3500 ::fidl_next::EncodeOption<
3501 ::fidl_next::wire::Box<'static, crate::wire::NodeGetExtendedAttributeRequest<'static>>,
3502 ___E,
3503 > for NodeGetExtendedAttributeRequest
3504 where
3505 ___E: ::fidl_next::Encoder + ?Sized,
3506 NodeGetExtendedAttributeRequest:
3507 ::fidl_next::Encode<crate::wire::NodeGetExtendedAttributeRequest<'static>, ___E>,
3508 {
3509 #[inline]
3510 fn encode_option(
3511 this: ::core::option::Option<Self>,
3512 encoder: &mut ___E,
3513 out: &mut ::core::mem::MaybeUninit<
3514 ::fidl_next::wire::Box<
3515 'static,
3516 crate::wire::NodeGetExtendedAttributeRequest<'static>,
3517 >,
3518 >,
3519 _: (),
3520 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3521 if let Some(inner) = this {
3522 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3523 ::fidl_next::wire::Box::encode_present(out);
3524 } else {
3525 ::fidl_next::wire::Box::encode_absent(out);
3526 }
3527
3528 Ok(())
3529 }
3530 }
3531
3532 unsafe impl<'a, ___E>
3533 ::fidl_next::EncodeOption<
3534 ::fidl_next::wire::Box<'static, crate::wire::NodeGetExtendedAttributeRequest<'static>>,
3535 ___E,
3536 > for &'a NodeGetExtendedAttributeRequest
3537 where
3538 ___E: ::fidl_next::Encoder + ?Sized,
3539 &'a NodeGetExtendedAttributeRequest:
3540 ::fidl_next::Encode<crate::wire::NodeGetExtendedAttributeRequest<'static>, ___E>,
3541 {
3542 #[inline]
3543 fn encode_option(
3544 this: ::core::option::Option<Self>,
3545 encoder: &mut ___E,
3546 out: &mut ::core::mem::MaybeUninit<
3547 ::fidl_next::wire::Box<
3548 'static,
3549 crate::wire::NodeGetExtendedAttributeRequest<'static>,
3550 >,
3551 >,
3552 _: (),
3553 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3554 if let Some(inner) = this {
3555 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3556 ::fidl_next::wire::Box::encode_present(out);
3557 } else {
3558 ::fidl_next::wire::Box::encode_absent(out);
3559 }
3560
3561 Ok(())
3562 }
3563 }
3564
3565 impl<'de> ::fidl_next::FromWire<crate::wire::NodeGetExtendedAttributeRequest<'de>>
3566 for NodeGetExtendedAttributeRequest
3567 {
3568 #[inline]
3569 fn from_wire(wire: crate::wire::NodeGetExtendedAttributeRequest<'de>) -> Self {
3570 Self { name: ::fidl_next::FromWire::from_wire(wire.name) }
3571 }
3572 }
3573
3574 impl<'de> ::fidl_next::FromWireRef<crate::wire::NodeGetExtendedAttributeRequest<'de>>
3575 for NodeGetExtendedAttributeRequest
3576 {
3577 #[inline]
3578 fn from_wire_ref(wire: &crate::wire::NodeGetExtendedAttributeRequest<'de>) -> Self {
3579 Self { name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name) }
3580 }
3581 }
3582
3583 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3584 #[repr(u32)]
3585 pub enum SetExtendedAttributeMode {
3586 Set = 1,
3587 Create = 2,
3588 Replace = 3,
3589 }
3590 impl ::core::convert::TryFrom<u32> for SetExtendedAttributeMode {
3591 type Error = ::fidl_next::UnknownStrictEnumMemberError;
3592 fn try_from(
3593 value: u32,
3594 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
3595 match value {
3596 1 => Ok(Self::Set),
3597 2 => Ok(Self::Create),
3598 3 => Ok(Self::Replace),
3599
3600 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
3601 }
3602 }
3603 }
3604
3605 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SetExtendedAttributeMode, ___E>
3606 for SetExtendedAttributeMode
3607 where
3608 ___E: ?Sized,
3609 {
3610 #[inline]
3611 fn encode(
3612 self,
3613 encoder: &mut ___E,
3614 out: &mut ::core::mem::MaybeUninit<crate::wire::SetExtendedAttributeMode>,
3615 _: (),
3616 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3617 ::fidl_next::Encode::encode(&self, encoder, out, ())
3618 }
3619 }
3620
3621 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SetExtendedAttributeMode, ___E>
3622 for &'a SetExtendedAttributeMode
3623 where
3624 ___E: ?Sized,
3625 {
3626 #[inline]
3627 fn encode(
3628 self,
3629 encoder: &mut ___E,
3630 out: &mut ::core::mem::MaybeUninit<crate::wire::SetExtendedAttributeMode>,
3631 _: (),
3632 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3633 ::fidl_next::munge!(let crate::wire::SetExtendedAttributeMode { value } = out);
3634 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
3635 SetExtendedAttributeMode::Set => 1,
3636
3637 SetExtendedAttributeMode::Create => 2,
3638
3639 SetExtendedAttributeMode::Replace => 3,
3640 }));
3641
3642 Ok(())
3643 }
3644 }
3645
3646 impl ::core::convert::From<crate::wire::SetExtendedAttributeMode> for SetExtendedAttributeMode {
3647 fn from(wire: crate::wire::SetExtendedAttributeMode) -> Self {
3648 match u32::from(wire.value) {
3649 1 => Self::Set,
3650
3651 2 => Self::Create,
3652
3653 3 => Self::Replace,
3654
3655 _ => unsafe { ::core::hint::unreachable_unchecked() },
3656 }
3657 }
3658 }
3659
3660 impl ::fidl_next::FromWire<crate::wire::SetExtendedAttributeMode> for SetExtendedAttributeMode {
3661 #[inline]
3662 fn from_wire(wire: crate::wire::SetExtendedAttributeMode) -> Self {
3663 Self::from(wire)
3664 }
3665 }
3666
3667 impl ::fidl_next::FromWireRef<crate::wire::SetExtendedAttributeMode> for SetExtendedAttributeMode {
3668 #[inline]
3669 fn from_wire_ref(wire: &crate::wire::SetExtendedAttributeMode) -> Self {
3670 Self::from(*wire)
3671 }
3672 }
3673
3674 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3675 #[repr(C)]
3676 pub struct NodeSetExtendedAttributeResponse {}
3677
3678 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeResponse, ___E>
3679 for NodeSetExtendedAttributeResponse
3680 where
3681 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3682 {
3683 #[inline]
3684 fn encode(
3685 self,
3686 encoder_: &mut ___E,
3687 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeSetExtendedAttributeResponse>,
3688 _: (),
3689 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3690 ::fidl_next::munge! {
3691 let crate::wire::NodeSetExtendedAttributeResponse {
3692
3693 _empty,
3694
3695 } = out_;
3696 }
3697
3698 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
3699
3700 Ok(())
3701 }
3702 }
3703
3704 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeResponse, ___E>
3705 for &'a NodeSetExtendedAttributeResponse
3706 where
3707 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3708 {
3709 #[inline]
3710 fn encode(
3711 self,
3712 encoder_: &mut ___E,
3713 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeSetExtendedAttributeResponse>,
3714 _: (),
3715 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3716 ::fidl_next::munge! {
3717 let crate::wire::NodeSetExtendedAttributeResponse {
3718
3719 _empty,
3720
3721
3722 } = out_;
3723 }
3724
3725 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
3726
3727 Ok(())
3728 }
3729 }
3730
3731 unsafe impl<___E>
3732 ::fidl_next::EncodeOption<
3733 ::fidl_next::wire::Box<'static, crate::wire::NodeSetExtendedAttributeResponse>,
3734 ___E,
3735 > for NodeSetExtendedAttributeResponse
3736 where
3737 ___E: ::fidl_next::Encoder + ?Sized,
3738 NodeSetExtendedAttributeResponse:
3739 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeResponse, ___E>,
3740 {
3741 #[inline]
3742 fn encode_option(
3743 this: ::core::option::Option<Self>,
3744 encoder: &mut ___E,
3745 out: &mut ::core::mem::MaybeUninit<
3746 ::fidl_next::wire::Box<'static, crate::wire::NodeSetExtendedAttributeResponse>,
3747 >,
3748 _: (),
3749 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3750 if let Some(inner) = this {
3751 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3752 ::fidl_next::wire::Box::encode_present(out);
3753 } else {
3754 ::fidl_next::wire::Box::encode_absent(out);
3755 }
3756
3757 Ok(())
3758 }
3759 }
3760
3761 unsafe impl<'a, ___E>
3762 ::fidl_next::EncodeOption<
3763 ::fidl_next::wire::Box<'static, crate::wire::NodeSetExtendedAttributeResponse>,
3764 ___E,
3765 > for &'a NodeSetExtendedAttributeResponse
3766 where
3767 ___E: ::fidl_next::Encoder + ?Sized,
3768 &'a NodeSetExtendedAttributeResponse:
3769 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeResponse, ___E>,
3770 {
3771 #[inline]
3772 fn encode_option(
3773 this: ::core::option::Option<Self>,
3774 encoder: &mut ___E,
3775 out: &mut ::core::mem::MaybeUninit<
3776 ::fidl_next::wire::Box<'static, crate::wire::NodeSetExtendedAttributeResponse>,
3777 >,
3778 _: (),
3779 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3780 if let Some(inner) = this {
3781 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3782 ::fidl_next::wire::Box::encode_present(out);
3783 } else {
3784 ::fidl_next::wire::Box::encode_absent(out);
3785 }
3786
3787 Ok(())
3788 }
3789 }
3790
3791 impl ::fidl_next::FromWire<crate::wire::NodeSetExtendedAttributeResponse>
3792 for NodeSetExtendedAttributeResponse
3793 {
3794 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3795 crate::wire::NodeSetExtendedAttributeResponse,
3796 Self,
3797 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
3798
3799 #[inline]
3800 fn from_wire(wire: crate::wire::NodeSetExtendedAttributeResponse) -> Self {
3801 Self {}
3802 }
3803 }
3804
3805 impl ::fidl_next::FromWireRef<crate::wire::NodeSetExtendedAttributeResponse>
3806 for NodeSetExtendedAttributeResponse
3807 {
3808 #[inline]
3809 fn from_wire_ref(wire: &crate::wire::NodeSetExtendedAttributeResponse) -> Self {
3810 Self {}
3811 }
3812 }
3813
3814 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3815 pub struct NodeRemoveExtendedAttributeRequest {
3816 pub name: ::std::vec::Vec<u8>,
3817 }
3818
3819 unsafe impl<___E>
3820 ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeRequest<'static>, ___E>
3821 for NodeRemoveExtendedAttributeRequest
3822 where
3823 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3824 ___E: ::fidl_next::Encoder,
3825 {
3826 #[inline]
3827 fn encode(
3828 self,
3829 encoder_: &mut ___E,
3830 out_: &mut ::core::mem::MaybeUninit<
3831 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
3832 >,
3833 _: (),
3834 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3835 ::fidl_next::munge! {
3836 let crate::wire::NodeRemoveExtendedAttributeRequest {
3837 name,
3838
3839 } = out_;
3840 }
3841
3842 ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
3843
3844 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
3845 ::fidl_next::Constrained::validate(_field, (255, ()))?;
3846
3847 Ok(())
3848 }
3849 }
3850
3851 unsafe impl<'a, ___E>
3852 ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeRequest<'static>, ___E>
3853 for &'a NodeRemoveExtendedAttributeRequest
3854 where
3855 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3856 ___E: ::fidl_next::Encoder,
3857 {
3858 #[inline]
3859 fn encode(
3860 self,
3861 encoder_: &mut ___E,
3862 out_: &mut ::core::mem::MaybeUninit<
3863 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
3864 >,
3865 _: (),
3866 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3867 ::fidl_next::munge! {
3868 let crate::wire::NodeRemoveExtendedAttributeRequest {
3869
3870 name,
3871
3872 } = out_;
3873 }
3874
3875 ::fidl_next::Encode::encode(&self.name, encoder_, name, (255, ()))?;
3876
3877 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
3878 ::fidl_next::Constrained::validate(_field, (255, ()))?;
3879
3880 Ok(())
3881 }
3882 }
3883
3884 unsafe impl<___E>
3885 ::fidl_next::EncodeOption<
3886 ::fidl_next::wire::Box<
3887 'static,
3888 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
3889 >,
3890 ___E,
3891 > for NodeRemoveExtendedAttributeRequest
3892 where
3893 ___E: ::fidl_next::Encoder + ?Sized,
3894 NodeRemoveExtendedAttributeRequest:
3895 ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeRequest<'static>, ___E>,
3896 {
3897 #[inline]
3898 fn encode_option(
3899 this: ::core::option::Option<Self>,
3900 encoder: &mut ___E,
3901 out: &mut ::core::mem::MaybeUninit<
3902 ::fidl_next::wire::Box<
3903 'static,
3904 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
3905 >,
3906 >,
3907 _: (),
3908 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3909 if let Some(inner) = this {
3910 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3911 ::fidl_next::wire::Box::encode_present(out);
3912 } else {
3913 ::fidl_next::wire::Box::encode_absent(out);
3914 }
3915
3916 Ok(())
3917 }
3918 }
3919
3920 unsafe impl<'a, ___E>
3921 ::fidl_next::EncodeOption<
3922 ::fidl_next::wire::Box<
3923 'static,
3924 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
3925 >,
3926 ___E,
3927 > for &'a NodeRemoveExtendedAttributeRequest
3928 where
3929 ___E: ::fidl_next::Encoder + ?Sized,
3930 &'a NodeRemoveExtendedAttributeRequest:
3931 ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeRequest<'static>, ___E>,
3932 {
3933 #[inline]
3934 fn encode_option(
3935 this: ::core::option::Option<Self>,
3936 encoder: &mut ___E,
3937 out: &mut ::core::mem::MaybeUninit<
3938 ::fidl_next::wire::Box<
3939 'static,
3940 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
3941 >,
3942 >,
3943 _: (),
3944 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3945 if let Some(inner) = this {
3946 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3947 ::fidl_next::wire::Box::encode_present(out);
3948 } else {
3949 ::fidl_next::wire::Box::encode_absent(out);
3950 }
3951
3952 Ok(())
3953 }
3954 }
3955
3956 impl<'de> ::fidl_next::FromWire<crate::wire::NodeRemoveExtendedAttributeRequest<'de>>
3957 for NodeRemoveExtendedAttributeRequest
3958 {
3959 #[inline]
3960 fn from_wire(wire: crate::wire::NodeRemoveExtendedAttributeRequest<'de>) -> Self {
3961 Self { name: ::fidl_next::FromWire::from_wire(wire.name) }
3962 }
3963 }
3964
3965 impl<'de> ::fidl_next::FromWireRef<crate::wire::NodeRemoveExtendedAttributeRequest<'de>>
3966 for NodeRemoveExtendedAttributeRequest
3967 {
3968 #[inline]
3969 fn from_wire_ref(wire: &crate::wire::NodeRemoveExtendedAttributeRequest<'de>) -> Self {
3970 Self { name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name) }
3971 }
3972 }
3973
3974 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3975 #[repr(C)]
3976 pub struct NodeRemoveExtendedAttributeResponse {}
3977
3978 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeResponse, ___E>
3979 for NodeRemoveExtendedAttributeResponse
3980 where
3981 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3982 {
3983 #[inline]
3984 fn encode(
3985 self,
3986 encoder_: &mut ___E,
3987 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeRemoveExtendedAttributeResponse>,
3988 _: (),
3989 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3990 ::fidl_next::munge! {
3991 let crate::wire::NodeRemoveExtendedAttributeResponse {
3992
3993 _empty,
3994
3995 } = out_;
3996 }
3997
3998 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
3999
4000 Ok(())
4001 }
4002 }
4003
4004 unsafe impl<'a, ___E>
4005 ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeResponse, ___E>
4006 for &'a NodeRemoveExtendedAttributeResponse
4007 where
4008 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4009 {
4010 #[inline]
4011 fn encode(
4012 self,
4013 encoder_: &mut ___E,
4014 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeRemoveExtendedAttributeResponse>,
4015 _: (),
4016 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4017 ::fidl_next::munge! {
4018 let crate::wire::NodeRemoveExtendedAttributeResponse {
4019
4020 _empty,
4021
4022
4023 } = out_;
4024 }
4025
4026 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
4027
4028 Ok(())
4029 }
4030 }
4031
4032 unsafe impl<___E>
4033 ::fidl_next::EncodeOption<
4034 ::fidl_next::wire::Box<'static, crate::wire::NodeRemoveExtendedAttributeResponse>,
4035 ___E,
4036 > for NodeRemoveExtendedAttributeResponse
4037 where
4038 ___E: ::fidl_next::Encoder + ?Sized,
4039 NodeRemoveExtendedAttributeResponse:
4040 ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeResponse, ___E>,
4041 {
4042 #[inline]
4043 fn encode_option(
4044 this: ::core::option::Option<Self>,
4045 encoder: &mut ___E,
4046 out: &mut ::core::mem::MaybeUninit<
4047 ::fidl_next::wire::Box<'static, crate::wire::NodeRemoveExtendedAttributeResponse>,
4048 >,
4049 _: (),
4050 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4051 if let Some(inner) = this {
4052 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4053 ::fidl_next::wire::Box::encode_present(out);
4054 } else {
4055 ::fidl_next::wire::Box::encode_absent(out);
4056 }
4057
4058 Ok(())
4059 }
4060 }
4061
4062 unsafe impl<'a, ___E>
4063 ::fidl_next::EncodeOption<
4064 ::fidl_next::wire::Box<'static, crate::wire::NodeRemoveExtendedAttributeResponse>,
4065 ___E,
4066 > for &'a NodeRemoveExtendedAttributeResponse
4067 where
4068 ___E: ::fidl_next::Encoder + ?Sized,
4069 &'a NodeRemoveExtendedAttributeResponse:
4070 ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeResponse, ___E>,
4071 {
4072 #[inline]
4073 fn encode_option(
4074 this: ::core::option::Option<Self>,
4075 encoder: &mut ___E,
4076 out: &mut ::core::mem::MaybeUninit<
4077 ::fidl_next::wire::Box<'static, crate::wire::NodeRemoveExtendedAttributeResponse>,
4078 >,
4079 _: (),
4080 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4081 if let Some(inner) = this {
4082 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4083 ::fidl_next::wire::Box::encode_present(out);
4084 } else {
4085 ::fidl_next::wire::Box::encode_absent(out);
4086 }
4087
4088 Ok(())
4089 }
4090 }
4091
4092 impl ::fidl_next::FromWire<crate::wire::NodeRemoveExtendedAttributeResponse>
4093 for NodeRemoveExtendedAttributeResponse
4094 {
4095 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4096 crate::wire::NodeRemoveExtendedAttributeResponse,
4097 Self,
4098 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
4099
4100 #[inline]
4101 fn from_wire(wire: crate::wire::NodeRemoveExtendedAttributeResponse) -> Self {
4102 Self {}
4103 }
4104 }
4105
4106 impl ::fidl_next::FromWireRef<crate::wire::NodeRemoveExtendedAttributeResponse>
4107 for NodeRemoveExtendedAttributeResponse
4108 {
4109 #[inline]
4110 fn from_wire_ref(wire: &crate::wire::NodeRemoveExtendedAttributeResponse) -> Self {
4111 Self {}
4112 }
4113 }
4114
4115 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4116 #[repr(C)]
4117 pub struct DirectoryCreateSymlinkResponse {}
4118
4119 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkResponse, ___E>
4120 for DirectoryCreateSymlinkResponse
4121 where
4122 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4123 {
4124 #[inline]
4125 fn encode(
4126 self,
4127 encoder_: &mut ___E,
4128 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryCreateSymlinkResponse>,
4129 _: (),
4130 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4131 ::fidl_next::munge! {
4132 let crate::wire::DirectoryCreateSymlinkResponse {
4133
4134 _empty,
4135
4136 } = out_;
4137 }
4138
4139 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
4140
4141 Ok(())
4142 }
4143 }
4144
4145 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkResponse, ___E>
4146 for &'a DirectoryCreateSymlinkResponse
4147 where
4148 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4149 {
4150 #[inline]
4151 fn encode(
4152 self,
4153 encoder_: &mut ___E,
4154 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryCreateSymlinkResponse>,
4155 _: (),
4156 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4157 ::fidl_next::munge! {
4158 let crate::wire::DirectoryCreateSymlinkResponse {
4159
4160 _empty,
4161
4162
4163 } = out_;
4164 }
4165
4166 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
4167
4168 Ok(())
4169 }
4170 }
4171
4172 unsafe impl<___E>
4173 ::fidl_next::EncodeOption<
4174 ::fidl_next::wire::Box<'static, crate::wire::DirectoryCreateSymlinkResponse>,
4175 ___E,
4176 > for DirectoryCreateSymlinkResponse
4177 where
4178 ___E: ::fidl_next::Encoder + ?Sized,
4179 DirectoryCreateSymlinkResponse:
4180 ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkResponse, ___E>,
4181 {
4182 #[inline]
4183 fn encode_option(
4184 this: ::core::option::Option<Self>,
4185 encoder: &mut ___E,
4186 out: &mut ::core::mem::MaybeUninit<
4187 ::fidl_next::wire::Box<'static, crate::wire::DirectoryCreateSymlinkResponse>,
4188 >,
4189 _: (),
4190 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4191 if let Some(inner) = this {
4192 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4193 ::fidl_next::wire::Box::encode_present(out);
4194 } else {
4195 ::fidl_next::wire::Box::encode_absent(out);
4196 }
4197
4198 Ok(())
4199 }
4200 }
4201
4202 unsafe impl<'a, ___E>
4203 ::fidl_next::EncodeOption<
4204 ::fidl_next::wire::Box<'static, crate::wire::DirectoryCreateSymlinkResponse>,
4205 ___E,
4206 > for &'a DirectoryCreateSymlinkResponse
4207 where
4208 ___E: ::fidl_next::Encoder + ?Sized,
4209 &'a DirectoryCreateSymlinkResponse:
4210 ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkResponse, ___E>,
4211 {
4212 #[inline]
4213 fn encode_option(
4214 this: ::core::option::Option<Self>,
4215 encoder: &mut ___E,
4216 out: &mut ::core::mem::MaybeUninit<
4217 ::fidl_next::wire::Box<'static, crate::wire::DirectoryCreateSymlinkResponse>,
4218 >,
4219 _: (),
4220 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4221 if let Some(inner) = this {
4222 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4223 ::fidl_next::wire::Box::encode_present(out);
4224 } else {
4225 ::fidl_next::wire::Box::encode_absent(out);
4226 }
4227
4228 Ok(())
4229 }
4230 }
4231
4232 impl ::fidl_next::FromWire<crate::wire::DirectoryCreateSymlinkResponse>
4233 for DirectoryCreateSymlinkResponse
4234 {
4235 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4236 crate::wire::DirectoryCreateSymlinkResponse,
4237 Self,
4238 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
4239
4240 #[inline]
4241 fn from_wire(wire: crate::wire::DirectoryCreateSymlinkResponse) -> Self {
4242 Self {}
4243 }
4244 }
4245
4246 impl ::fidl_next::FromWireRef<crate::wire::DirectoryCreateSymlinkResponse>
4247 for DirectoryCreateSymlinkResponse
4248 {
4249 #[inline]
4250 fn from_wire_ref(wire: &crate::wire::DirectoryCreateSymlinkResponse) -> Self {
4251 Self {}
4252 }
4253 }
4254
4255 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4256 #[repr(C)]
4257 pub struct NodeSetFlagsResponse {}
4258
4259 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeSetFlagsResponse, ___E>
4260 for NodeSetFlagsResponse
4261 where
4262 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4263 {
4264 #[inline]
4265 fn encode(
4266 self,
4267 encoder_: &mut ___E,
4268 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeSetFlagsResponse>,
4269 _: (),
4270 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4271 ::fidl_next::munge! {
4272 let crate::wire::NodeSetFlagsResponse {
4273
4274 _empty,
4275
4276 } = out_;
4277 }
4278
4279 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
4280
4281 Ok(())
4282 }
4283 }
4284
4285 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeSetFlagsResponse, ___E>
4286 for &'a NodeSetFlagsResponse
4287 where
4288 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4289 {
4290 #[inline]
4291 fn encode(
4292 self,
4293 encoder_: &mut ___E,
4294 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeSetFlagsResponse>,
4295 _: (),
4296 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4297 ::fidl_next::munge! {
4298 let crate::wire::NodeSetFlagsResponse {
4299
4300 _empty,
4301
4302
4303 } = out_;
4304 }
4305
4306 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
4307
4308 Ok(())
4309 }
4310 }
4311
4312 unsafe impl<___E>
4313 ::fidl_next::EncodeOption<
4314 ::fidl_next::wire::Box<'static, crate::wire::NodeSetFlagsResponse>,
4315 ___E,
4316 > for NodeSetFlagsResponse
4317 where
4318 ___E: ::fidl_next::Encoder + ?Sized,
4319 NodeSetFlagsResponse: ::fidl_next::Encode<crate::wire::NodeSetFlagsResponse, ___E>,
4320 {
4321 #[inline]
4322 fn encode_option(
4323 this: ::core::option::Option<Self>,
4324 encoder: &mut ___E,
4325 out: &mut ::core::mem::MaybeUninit<
4326 ::fidl_next::wire::Box<'static, crate::wire::NodeSetFlagsResponse>,
4327 >,
4328 _: (),
4329 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4330 if let Some(inner) = this {
4331 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4332 ::fidl_next::wire::Box::encode_present(out);
4333 } else {
4334 ::fidl_next::wire::Box::encode_absent(out);
4335 }
4336
4337 Ok(())
4338 }
4339 }
4340
4341 unsafe impl<'a, ___E>
4342 ::fidl_next::EncodeOption<
4343 ::fidl_next::wire::Box<'static, crate::wire::NodeSetFlagsResponse>,
4344 ___E,
4345 > for &'a NodeSetFlagsResponse
4346 where
4347 ___E: ::fidl_next::Encoder + ?Sized,
4348 &'a NodeSetFlagsResponse: ::fidl_next::Encode<crate::wire::NodeSetFlagsResponse, ___E>,
4349 {
4350 #[inline]
4351 fn encode_option(
4352 this: ::core::option::Option<Self>,
4353 encoder: &mut ___E,
4354 out: &mut ::core::mem::MaybeUninit<
4355 ::fidl_next::wire::Box<'static, crate::wire::NodeSetFlagsResponse>,
4356 >,
4357 _: (),
4358 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4359 if let Some(inner) = this {
4360 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4361 ::fidl_next::wire::Box::encode_present(out);
4362 } else {
4363 ::fidl_next::wire::Box::encode_absent(out);
4364 }
4365
4366 Ok(())
4367 }
4368 }
4369
4370 impl ::fidl_next::FromWire<crate::wire::NodeSetFlagsResponse> for NodeSetFlagsResponse {
4371 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4372 crate::wire::NodeSetFlagsResponse,
4373 Self,
4374 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
4375
4376 #[inline]
4377 fn from_wire(wire: crate::wire::NodeSetFlagsResponse) -> Self {
4378 Self {}
4379 }
4380 }
4381
4382 impl ::fidl_next::FromWireRef<crate::wire::NodeSetFlagsResponse> for NodeSetFlagsResponse {
4383 #[inline]
4384 fn from_wire_ref(wire: &crate::wire::NodeSetFlagsResponse) -> Self {
4385 Self {}
4386 }
4387 }
4388
4389 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4390 pub struct NodeDeprecatedGetAttrResponse {
4391 pub s: i32,
4392
4393 pub attributes: crate::natural::NodeAttributes,
4394 }
4395
4396 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedGetAttrResponse, ___E>
4397 for NodeDeprecatedGetAttrResponse
4398 where
4399 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4400 {
4401 #[inline]
4402 fn encode(
4403 self,
4404 encoder_: &mut ___E,
4405 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedGetAttrResponse>,
4406 _: (),
4407 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4408 ::fidl_next::munge! {
4409 let crate::wire::NodeDeprecatedGetAttrResponse {
4410 s,
4411 attributes,
4412
4413 } = out_;
4414 }
4415
4416 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
4417
4418 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
4419
4420 ::fidl_next::Encode::encode(self.attributes, encoder_, attributes, ())?;
4421
4422 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(attributes.as_mut_ptr()) };
4423
4424 Ok(())
4425 }
4426 }
4427
4428 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedGetAttrResponse, ___E>
4429 for &'a NodeDeprecatedGetAttrResponse
4430 where
4431 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4432 {
4433 #[inline]
4434 fn encode(
4435 self,
4436 encoder_: &mut ___E,
4437 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedGetAttrResponse>,
4438 _: (),
4439 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4440 ::fidl_next::munge! {
4441 let crate::wire::NodeDeprecatedGetAttrResponse {
4442
4443 s,
4444 attributes,
4445
4446 } = out_;
4447 }
4448
4449 ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
4450
4451 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
4452
4453 ::fidl_next::Encode::encode(&self.attributes, encoder_, attributes, ())?;
4454
4455 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(attributes.as_mut_ptr()) };
4456
4457 Ok(())
4458 }
4459 }
4460
4461 unsafe impl<___E>
4462 ::fidl_next::EncodeOption<
4463 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetAttrResponse>,
4464 ___E,
4465 > for NodeDeprecatedGetAttrResponse
4466 where
4467 ___E: ::fidl_next::Encoder + ?Sized,
4468 NodeDeprecatedGetAttrResponse:
4469 ::fidl_next::Encode<crate::wire::NodeDeprecatedGetAttrResponse, ___E>,
4470 {
4471 #[inline]
4472 fn encode_option(
4473 this: ::core::option::Option<Self>,
4474 encoder: &mut ___E,
4475 out: &mut ::core::mem::MaybeUninit<
4476 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetAttrResponse>,
4477 >,
4478 _: (),
4479 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4480 if let Some(inner) = this {
4481 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4482 ::fidl_next::wire::Box::encode_present(out);
4483 } else {
4484 ::fidl_next::wire::Box::encode_absent(out);
4485 }
4486
4487 Ok(())
4488 }
4489 }
4490
4491 unsafe impl<'a, ___E>
4492 ::fidl_next::EncodeOption<
4493 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetAttrResponse>,
4494 ___E,
4495 > for &'a NodeDeprecatedGetAttrResponse
4496 where
4497 ___E: ::fidl_next::Encoder + ?Sized,
4498 &'a NodeDeprecatedGetAttrResponse:
4499 ::fidl_next::Encode<crate::wire::NodeDeprecatedGetAttrResponse, ___E>,
4500 {
4501 #[inline]
4502 fn encode_option(
4503 this: ::core::option::Option<Self>,
4504 encoder: &mut ___E,
4505 out: &mut ::core::mem::MaybeUninit<
4506 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetAttrResponse>,
4507 >,
4508 _: (),
4509 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4510 if let Some(inner) = this {
4511 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4512 ::fidl_next::wire::Box::encode_present(out);
4513 } else {
4514 ::fidl_next::wire::Box::encode_absent(out);
4515 }
4516
4517 Ok(())
4518 }
4519 }
4520
4521 impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedGetAttrResponse>
4522 for NodeDeprecatedGetAttrResponse
4523 {
4524 #[inline]
4525 fn from_wire(wire: crate::wire::NodeDeprecatedGetAttrResponse) -> Self {
4526 Self {
4527 s: ::fidl_next::FromWire::from_wire(wire.s),
4528
4529 attributes: ::fidl_next::FromWire::from_wire(wire.attributes),
4530 }
4531 }
4532 }
4533
4534 impl ::fidl_next::FromWireRef<crate::wire::NodeDeprecatedGetAttrResponse>
4535 for NodeDeprecatedGetAttrResponse
4536 {
4537 #[inline]
4538 fn from_wire_ref(wire: &crate::wire::NodeDeprecatedGetAttrResponse) -> Self {
4539 Self {
4540 s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s),
4541
4542 attributes: ::fidl_next::FromWireRef::from_wire_ref(&wire.attributes),
4543 }
4544 }
4545 }
4546
4547 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4548 pub struct NodeDeprecatedSetAttrRequest {
4549 pub flags: crate::natural::NodeAttributeFlags,
4550
4551 pub attributes: crate::natural::NodeAttributes,
4552 }
4553
4554 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrRequest, ___E>
4555 for NodeDeprecatedSetAttrRequest
4556 where
4557 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4558 {
4559 #[inline]
4560 fn encode(
4561 self,
4562 encoder_: &mut ___E,
4563 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetAttrRequest>,
4564 _: (),
4565 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4566 ::fidl_next::munge! {
4567 let crate::wire::NodeDeprecatedSetAttrRequest {
4568 flags,
4569 attributes,
4570
4571 } = out_;
4572 }
4573
4574 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
4575
4576 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
4577
4578 ::fidl_next::Encode::encode(self.attributes, encoder_, attributes, ())?;
4579
4580 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(attributes.as_mut_ptr()) };
4581
4582 Ok(())
4583 }
4584 }
4585
4586 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrRequest, ___E>
4587 for &'a NodeDeprecatedSetAttrRequest
4588 where
4589 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4590 {
4591 #[inline]
4592 fn encode(
4593 self,
4594 encoder_: &mut ___E,
4595 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetAttrRequest>,
4596 _: (),
4597 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4598 ::fidl_next::munge! {
4599 let crate::wire::NodeDeprecatedSetAttrRequest {
4600
4601 flags,
4602 attributes,
4603
4604 } = out_;
4605 }
4606
4607 ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
4608
4609 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
4610
4611 ::fidl_next::Encode::encode(&self.attributes, encoder_, attributes, ())?;
4612
4613 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(attributes.as_mut_ptr()) };
4614
4615 Ok(())
4616 }
4617 }
4618
4619 unsafe impl<___E>
4620 ::fidl_next::EncodeOption<
4621 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrRequest>,
4622 ___E,
4623 > for NodeDeprecatedSetAttrRequest
4624 where
4625 ___E: ::fidl_next::Encoder + ?Sized,
4626 NodeDeprecatedSetAttrRequest:
4627 ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrRequest, ___E>,
4628 {
4629 #[inline]
4630 fn encode_option(
4631 this: ::core::option::Option<Self>,
4632 encoder: &mut ___E,
4633 out: &mut ::core::mem::MaybeUninit<
4634 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrRequest>,
4635 >,
4636 _: (),
4637 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4638 if let Some(inner) = this {
4639 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4640 ::fidl_next::wire::Box::encode_present(out);
4641 } else {
4642 ::fidl_next::wire::Box::encode_absent(out);
4643 }
4644
4645 Ok(())
4646 }
4647 }
4648
4649 unsafe impl<'a, ___E>
4650 ::fidl_next::EncodeOption<
4651 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrRequest>,
4652 ___E,
4653 > for &'a NodeDeprecatedSetAttrRequest
4654 where
4655 ___E: ::fidl_next::Encoder + ?Sized,
4656 &'a NodeDeprecatedSetAttrRequest:
4657 ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrRequest, ___E>,
4658 {
4659 #[inline]
4660 fn encode_option(
4661 this: ::core::option::Option<Self>,
4662 encoder: &mut ___E,
4663 out: &mut ::core::mem::MaybeUninit<
4664 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrRequest>,
4665 >,
4666 _: (),
4667 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4668 if let Some(inner) = this {
4669 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4670 ::fidl_next::wire::Box::encode_present(out);
4671 } else {
4672 ::fidl_next::wire::Box::encode_absent(out);
4673 }
4674
4675 Ok(())
4676 }
4677 }
4678
4679 impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedSetAttrRequest>
4680 for NodeDeprecatedSetAttrRequest
4681 {
4682 #[inline]
4683 fn from_wire(wire: crate::wire::NodeDeprecatedSetAttrRequest) -> Self {
4684 Self {
4685 flags: ::fidl_next::FromWire::from_wire(wire.flags),
4686
4687 attributes: ::fidl_next::FromWire::from_wire(wire.attributes),
4688 }
4689 }
4690 }
4691
4692 impl ::fidl_next::FromWireRef<crate::wire::NodeDeprecatedSetAttrRequest>
4693 for NodeDeprecatedSetAttrRequest
4694 {
4695 #[inline]
4696 fn from_wire_ref(wire: &crate::wire::NodeDeprecatedSetAttrRequest) -> Self {
4697 Self {
4698 flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags),
4699
4700 attributes: ::fidl_next::FromWireRef::from_wire_ref(&wire.attributes),
4701 }
4702 }
4703 }
4704
4705 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4706 #[repr(C)]
4707 pub struct NodeDeprecatedSetAttrResponse {
4708 pub s: i32,
4709 }
4710
4711 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrResponse, ___E>
4712 for NodeDeprecatedSetAttrResponse
4713 where
4714 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4715 {
4716 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4717 Self,
4718 crate::wire::NodeDeprecatedSetAttrResponse,
4719 > = unsafe {
4720 ::fidl_next::CopyOptimization::enable_if(
4721 true
4722
4723 && <
4724 i32 as ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>
4725 >::COPY_OPTIMIZATION.is_enabled()
4726
4727 )
4728 };
4729
4730 #[inline]
4731 fn encode(
4732 self,
4733 encoder_: &mut ___E,
4734 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetAttrResponse>,
4735 _: (),
4736 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4737 ::fidl_next::munge! {
4738 let crate::wire::NodeDeprecatedSetAttrResponse {
4739 s,
4740
4741 } = out_;
4742 }
4743
4744 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
4745
4746 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
4747
4748 Ok(())
4749 }
4750 }
4751
4752 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrResponse, ___E>
4753 for &'a NodeDeprecatedSetAttrResponse
4754 where
4755 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4756 {
4757 #[inline]
4758 fn encode(
4759 self,
4760 encoder_: &mut ___E,
4761 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetAttrResponse>,
4762 _: (),
4763 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4764 ::fidl_next::munge! {
4765 let crate::wire::NodeDeprecatedSetAttrResponse {
4766
4767 s,
4768
4769 } = out_;
4770 }
4771
4772 ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
4773
4774 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
4775
4776 Ok(())
4777 }
4778 }
4779
4780 unsafe impl<___E>
4781 ::fidl_next::EncodeOption<
4782 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrResponse>,
4783 ___E,
4784 > for NodeDeprecatedSetAttrResponse
4785 where
4786 ___E: ::fidl_next::Encoder + ?Sized,
4787 NodeDeprecatedSetAttrResponse:
4788 ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrResponse, ___E>,
4789 {
4790 #[inline]
4791 fn encode_option(
4792 this: ::core::option::Option<Self>,
4793 encoder: &mut ___E,
4794 out: &mut ::core::mem::MaybeUninit<
4795 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrResponse>,
4796 >,
4797 _: (),
4798 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4799 if let Some(inner) = this {
4800 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4801 ::fidl_next::wire::Box::encode_present(out);
4802 } else {
4803 ::fidl_next::wire::Box::encode_absent(out);
4804 }
4805
4806 Ok(())
4807 }
4808 }
4809
4810 unsafe impl<'a, ___E>
4811 ::fidl_next::EncodeOption<
4812 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrResponse>,
4813 ___E,
4814 > for &'a NodeDeprecatedSetAttrResponse
4815 where
4816 ___E: ::fidl_next::Encoder + ?Sized,
4817 &'a NodeDeprecatedSetAttrResponse:
4818 ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrResponse, ___E>,
4819 {
4820 #[inline]
4821 fn encode_option(
4822 this: ::core::option::Option<Self>,
4823 encoder: &mut ___E,
4824 out: &mut ::core::mem::MaybeUninit<
4825 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrResponse>,
4826 >,
4827 _: (),
4828 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4829 if let Some(inner) = this {
4830 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4831 ::fidl_next::wire::Box::encode_present(out);
4832 } else {
4833 ::fidl_next::wire::Box::encode_absent(out);
4834 }
4835
4836 Ok(())
4837 }
4838 }
4839
4840 impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedSetAttrResponse>
4841 for NodeDeprecatedSetAttrResponse
4842 {
4843 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4844 crate::wire::NodeDeprecatedSetAttrResponse,
4845 Self,
4846 > = unsafe {
4847 ::fidl_next::CopyOptimization::enable_if(
4848 true && <i32 as ::fidl_next::FromWire<::fidl_next::wire::Int32>>::COPY_OPTIMIZATION
4849 .is_enabled(),
4850 )
4851 };
4852
4853 #[inline]
4854 fn from_wire(wire: crate::wire::NodeDeprecatedSetAttrResponse) -> Self {
4855 Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
4856 }
4857 }
4858
4859 impl ::fidl_next::FromWireRef<crate::wire::NodeDeprecatedSetAttrResponse>
4860 for NodeDeprecatedSetAttrResponse
4861 {
4862 #[inline]
4863 fn from_wire_ref(wire: &crate::wire::NodeDeprecatedSetAttrResponse) -> Self {
4864 Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
4865 }
4866 }
4867
4868 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4869 #[repr(C)]
4870 pub struct NodeDeprecatedGetFlagsResponse {
4871 pub s: i32,
4872
4873 pub flags: crate::natural::OpenFlags,
4874 }
4875
4876 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedGetFlagsResponse, ___E>
4877 for NodeDeprecatedGetFlagsResponse
4878 where
4879 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4880 {
4881 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4882 Self,
4883 crate::wire::NodeDeprecatedGetFlagsResponse,
4884 > = unsafe {
4885 ::fidl_next::CopyOptimization::enable_if(
4886 true
4887
4888 && <
4889 i32 as ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>
4890 >::COPY_OPTIMIZATION.is_enabled()
4891
4892 && <
4893 crate::natural::OpenFlags as ::fidl_next::Encode<crate::wire::OpenFlags, ___E>
4894 >::COPY_OPTIMIZATION.is_enabled()
4895
4896 )
4897 };
4898
4899 #[inline]
4900 fn encode(
4901 self,
4902 encoder_: &mut ___E,
4903 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedGetFlagsResponse>,
4904 _: (),
4905 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4906 ::fidl_next::munge! {
4907 let crate::wire::NodeDeprecatedGetFlagsResponse {
4908 s,
4909 flags,
4910
4911 } = out_;
4912 }
4913
4914 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
4915
4916 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
4917
4918 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
4919
4920 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
4921
4922 Ok(())
4923 }
4924 }
4925
4926 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedGetFlagsResponse, ___E>
4927 for &'a NodeDeprecatedGetFlagsResponse
4928 where
4929 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4930 {
4931 #[inline]
4932 fn encode(
4933 self,
4934 encoder_: &mut ___E,
4935 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedGetFlagsResponse>,
4936 _: (),
4937 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4938 ::fidl_next::munge! {
4939 let crate::wire::NodeDeprecatedGetFlagsResponse {
4940
4941 s,
4942 flags,
4943
4944 } = out_;
4945 }
4946
4947 ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
4948
4949 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
4950
4951 ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
4952
4953 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
4954
4955 Ok(())
4956 }
4957 }
4958
4959 unsafe impl<___E>
4960 ::fidl_next::EncodeOption<
4961 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetFlagsResponse>,
4962 ___E,
4963 > for NodeDeprecatedGetFlagsResponse
4964 where
4965 ___E: ::fidl_next::Encoder + ?Sized,
4966 NodeDeprecatedGetFlagsResponse:
4967 ::fidl_next::Encode<crate::wire::NodeDeprecatedGetFlagsResponse, ___E>,
4968 {
4969 #[inline]
4970 fn encode_option(
4971 this: ::core::option::Option<Self>,
4972 encoder: &mut ___E,
4973 out: &mut ::core::mem::MaybeUninit<
4974 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetFlagsResponse>,
4975 >,
4976 _: (),
4977 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4978 if let Some(inner) = this {
4979 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4980 ::fidl_next::wire::Box::encode_present(out);
4981 } else {
4982 ::fidl_next::wire::Box::encode_absent(out);
4983 }
4984
4985 Ok(())
4986 }
4987 }
4988
4989 unsafe impl<'a, ___E>
4990 ::fidl_next::EncodeOption<
4991 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetFlagsResponse>,
4992 ___E,
4993 > for &'a NodeDeprecatedGetFlagsResponse
4994 where
4995 ___E: ::fidl_next::Encoder + ?Sized,
4996 &'a NodeDeprecatedGetFlagsResponse:
4997 ::fidl_next::Encode<crate::wire::NodeDeprecatedGetFlagsResponse, ___E>,
4998 {
4999 #[inline]
5000 fn encode_option(
5001 this: ::core::option::Option<Self>,
5002 encoder: &mut ___E,
5003 out: &mut ::core::mem::MaybeUninit<
5004 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetFlagsResponse>,
5005 >,
5006 _: (),
5007 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5008 if let Some(inner) = this {
5009 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5010 ::fidl_next::wire::Box::encode_present(out);
5011 } else {
5012 ::fidl_next::wire::Box::encode_absent(out);
5013 }
5014
5015 Ok(())
5016 }
5017 }
5018
5019 impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedGetFlagsResponse>
5020 for NodeDeprecatedGetFlagsResponse
5021 {
5022 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5023 crate::wire::NodeDeprecatedGetFlagsResponse,
5024 Self,
5025 > = unsafe {
5026 ::fidl_next::CopyOptimization::enable_if(
5027 true && <i32 as ::fidl_next::FromWire<::fidl_next::wire::Int32>>::COPY_OPTIMIZATION
5028 .is_enabled()
5029 && <crate::natural::OpenFlags as ::fidl_next::FromWire<
5030 crate::wire::OpenFlags,
5031 >>::COPY_OPTIMIZATION
5032 .is_enabled(),
5033 )
5034 };
5035
5036 #[inline]
5037 fn from_wire(wire: crate::wire::NodeDeprecatedGetFlagsResponse) -> Self {
5038 Self {
5039 s: ::fidl_next::FromWire::from_wire(wire.s),
5040
5041 flags: ::fidl_next::FromWire::from_wire(wire.flags),
5042 }
5043 }
5044 }
5045
5046 impl ::fidl_next::FromWireRef<crate::wire::NodeDeprecatedGetFlagsResponse>
5047 for NodeDeprecatedGetFlagsResponse
5048 {
5049 #[inline]
5050 fn from_wire_ref(wire: &crate::wire::NodeDeprecatedGetFlagsResponse) -> Self {
5051 Self {
5052 s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s),
5053
5054 flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags),
5055 }
5056 }
5057 }
5058
5059 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5060 #[repr(C)]
5061 pub struct NodeDeprecatedSetFlagsRequest {
5062 pub flags: crate::natural::OpenFlags,
5063 }
5064
5065 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsRequest, ___E>
5066 for NodeDeprecatedSetFlagsRequest
5067 where
5068 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5069 {
5070 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5071 Self,
5072 crate::wire::NodeDeprecatedSetFlagsRequest,
5073 > = unsafe {
5074 ::fidl_next::CopyOptimization::enable_if(
5075 true && <crate::natural::OpenFlags as ::fidl_next::Encode<
5076 crate::wire::OpenFlags,
5077 ___E,
5078 >>::COPY_OPTIMIZATION
5079 .is_enabled(),
5080 )
5081 };
5082
5083 #[inline]
5084 fn encode(
5085 self,
5086 encoder_: &mut ___E,
5087 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetFlagsRequest>,
5088 _: (),
5089 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5090 ::fidl_next::munge! {
5091 let crate::wire::NodeDeprecatedSetFlagsRequest {
5092 flags,
5093
5094 } = out_;
5095 }
5096
5097 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
5098
5099 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
5100
5101 Ok(())
5102 }
5103 }
5104
5105 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsRequest, ___E>
5106 for &'a NodeDeprecatedSetFlagsRequest
5107 where
5108 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5109 {
5110 #[inline]
5111 fn encode(
5112 self,
5113 encoder_: &mut ___E,
5114 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetFlagsRequest>,
5115 _: (),
5116 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5117 ::fidl_next::munge! {
5118 let crate::wire::NodeDeprecatedSetFlagsRequest {
5119
5120 flags,
5121
5122 } = out_;
5123 }
5124
5125 ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
5126
5127 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
5128
5129 Ok(())
5130 }
5131 }
5132
5133 unsafe impl<___E>
5134 ::fidl_next::EncodeOption<
5135 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsRequest>,
5136 ___E,
5137 > for NodeDeprecatedSetFlagsRequest
5138 where
5139 ___E: ::fidl_next::Encoder + ?Sized,
5140 NodeDeprecatedSetFlagsRequest:
5141 ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsRequest, ___E>,
5142 {
5143 #[inline]
5144 fn encode_option(
5145 this: ::core::option::Option<Self>,
5146 encoder: &mut ___E,
5147 out: &mut ::core::mem::MaybeUninit<
5148 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsRequest>,
5149 >,
5150 _: (),
5151 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5152 if let Some(inner) = this {
5153 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5154 ::fidl_next::wire::Box::encode_present(out);
5155 } else {
5156 ::fidl_next::wire::Box::encode_absent(out);
5157 }
5158
5159 Ok(())
5160 }
5161 }
5162
5163 unsafe impl<'a, ___E>
5164 ::fidl_next::EncodeOption<
5165 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsRequest>,
5166 ___E,
5167 > for &'a NodeDeprecatedSetFlagsRequest
5168 where
5169 ___E: ::fidl_next::Encoder + ?Sized,
5170 &'a NodeDeprecatedSetFlagsRequest:
5171 ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsRequest, ___E>,
5172 {
5173 #[inline]
5174 fn encode_option(
5175 this: ::core::option::Option<Self>,
5176 encoder: &mut ___E,
5177 out: &mut ::core::mem::MaybeUninit<
5178 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsRequest>,
5179 >,
5180 _: (),
5181 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5182 if let Some(inner) = this {
5183 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5184 ::fidl_next::wire::Box::encode_present(out);
5185 } else {
5186 ::fidl_next::wire::Box::encode_absent(out);
5187 }
5188
5189 Ok(())
5190 }
5191 }
5192
5193 impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedSetFlagsRequest>
5194 for NodeDeprecatedSetFlagsRequest
5195 {
5196 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5197 crate::wire::NodeDeprecatedSetFlagsRequest,
5198 Self,
5199 > = unsafe {
5200 ::fidl_next::CopyOptimization::enable_if(
5201 true && <crate::natural::OpenFlags as ::fidl_next::FromWire<
5202 crate::wire::OpenFlags,
5203 >>::COPY_OPTIMIZATION
5204 .is_enabled(),
5205 )
5206 };
5207
5208 #[inline]
5209 fn from_wire(wire: crate::wire::NodeDeprecatedSetFlagsRequest) -> Self {
5210 Self { flags: ::fidl_next::FromWire::from_wire(wire.flags) }
5211 }
5212 }
5213
5214 impl ::fidl_next::FromWireRef<crate::wire::NodeDeprecatedSetFlagsRequest>
5215 for NodeDeprecatedSetFlagsRequest
5216 {
5217 #[inline]
5218 fn from_wire_ref(wire: &crate::wire::NodeDeprecatedSetFlagsRequest) -> Self {
5219 Self { flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags) }
5220 }
5221 }
5222
5223 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5224 #[repr(C)]
5225 pub struct NodeDeprecatedSetFlagsResponse {
5226 pub s: i32,
5227 }
5228
5229 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsResponse, ___E>
5230 for NodeDeprecatedSetFlagsResponse
5231 where
5232 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5233 {
5234 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5235 Self,
5236 crate::wire::NodeDeprecatedSetFlagsResponse,
5237 > = unsafe {
5238 ::fidl_next::CopyOptimization::enable_if(
5239 true
5240
5241 && <
5242 i32 as ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>
5243 >::COPY_OPTIMIZATION.is_enabled()
5244
5245 )
5246 };
5247
5248 #[inline]
5249 fn encode(
5250 self,
5251 encoder_: &mut ___E,
5252 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetFlagsResponse>,
5253 _: (),
5254 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5255 ::fidl_next::munge! {
5256 let crate::wire::NodeDeprecatedSetFlagsResponse {
5257 s,
5258
5259 } = out_;
5260 }
5261
5262 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
5263
5264 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
5265
5266 Ok(())
5267 }
5268 }
5269
5270 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsResponse, ___E>
5271 for &'a NodeDeprecatedSetFlagsResponse
5272 where
5273 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5274 {
5275 #[inline]
5276 fn encode(
5277 self,
5278 encoder_: &mut ___E,
5279 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetFlagsResponse>,
5280 _: (),
5281 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5282 ::fidl_next::munge! {
5283 let crate::wire::NodeDeprecatedSetFlagsResponse {
5284
5285 s,
5286
5287 } = out_;
5288 }
5289
5290 ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
5291
5292 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
5293
5294 Ok(())
5295 }
5296 }
5297
5298 unsafe impl<___E>
5299 ::fidl_next::EncodeOption<
5300 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsResponse>,
5301 ___E,
5302 > for NodeDeprecatedSetFlagsResponse
5303 where
5304 ___E: ::fidl_next::Encoder + ?Sized,
5305 NodeDeprecatedSetFlagsResponse:
5306 ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsResponse, ___E>,
5307 {
5308 #[inline]
5309 fn encode_option(
5310 this: ::core::option::Option<Self>,
5311 encoder: &mut ___E,
5312 out: &mut ::core::mem::MaybeUninit<
5313 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsResponse>,
5314 >,
5315 _: (),
5316 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5317 if let Some(inner) = this {
5318 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5319 ::fidl_next::wire::Box::encode_present(out);
5320 } else {
5321 ::fidl_next::wire::Box::encode_absent(out);
5322 }
5323
5324 Ok(())
5325 }
5326 }
5327
5328 unsafe impl<'a, ___E>
5329 ::fidl_next::EncodeOption<
5330 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsResponse>,
5331 ___E,
5332 > for &'a NodeDeprecatedSetFlagsResponse
5333 where
5334 ___E: ::fidl_next::Encoder + ?Sized,
5335 &'a NodeDeprecatedSetFlagsResponse:
5336 ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsResponse, ___E>,
5337 {
5338 #[inline]
5339 fn encode_option(
5340 this: ::core::option::Option<Self>,
5341 encoder: &mut ___E,
5342 out: &mut ::core::mem::MaybeUninit<
5343 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsResponse>,
5344 >,
5345 _: (),
5346 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5347 if let Some(inner) = this {
5348 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5349 ::fidl_next::wire::Box::encode_present(out);
5350 } else {
5351 ::fidl_next::wire::Box::encode_absent(out);
5352 }
5353
5354 Ok(())
5355 }
5356 }
5357
5358 impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedSetFlagsResponse>
5359 for NodeDeprecatedSetFlagsResponse
5360 {
5361 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5362 crate::wire::NodeDeprecatedSetFlagsResponse,
5363 Self,
5364 > = unsafe {
5365 ::fidl_next::CopyOptimization::enable_if(
5366 true && <i32 as ::fidl_next::FromWire<::fidl_next::wire::Int32>>::COPY_OPTIMIZATION
5367 .is_enabled(),
5368 )
5369 };
5370
5371 #[inline]
5372 fn from_wire(wire: crate::wire::NodeDeprecatedSetFlagsResponse) -> Self {
5373 Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
5374 }
5375 }
5376
5377 impl ::fidl_next::FromWireRef<crate::wire::NodeDeprecatedSetFlagsResponse>
5378 for NodeDeprecatedSetFlagsResponse
5379 {
5380 #[inline]
5381 fn from_wire_ref(wire: &crate::wire::NodeDeprecatedSetFlagsResponse) -> Self {
5382 Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
5383 }
5384 }
5385
5386 ::fidl_next::bitflags::bitflags! {
5387 #[doc = " Flags used to specify how a node should be opened. Note that ranges of bits are reserved\n for specific use cases:\n * Bits 1-16: Permission flags `PERM_*` (e.g. [`Flags.PERM_READ_BYTES`]).\n * Bits 17-32: POSIX compatibile `O_*` flags (e.g. [`Flags.FILE_TRUNCATE`] or `O_TRUNC`).\n * Bits 33-64: Fuchsia-specific flags.\n"]#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct Flags: u64 {
5388 #[doc = " Allows opening child nodes with [`PROTOCOL_SERVICE`].\n"]const PERM_CONNECT = 1;
5389 #[doc = " Read byte contents of a file.\n"]const PERM_READ_BYTES = 2;
5390 #[doc = " Write byte contents to a file.\n"]const PERM_WRITE_BYTES = 4;
5391 #[doc = " Execute byte contents of a file.\n"]const PERM_EXECUTE = 8;
5392 #[doc = " Get/query attributes of a node.\n"]const PERM_GET_ATTRIBUTES = 16;
5393 #[doc = " Set/update attributes of a node.\n"]const PERM_UPDATE_ATTRIBUTES = 32;
5394 #[doc = " Enumerate (list) directory entries.\n"]const PERM_ENUMERATE = 64;
5395 #[doc = " Allow opening a child node with a node protocol. Must be specified with PERM_ENUMERATE\n otherwise requests will fail with `ZX_ERR_INVALID_ARGS`.\n"]const PERM_TRAVERSE = 128;
5396 #[doc = " Modify directory entries (create/rename/link/unlink). Must be specified with\n PERM_ENUMERATE otherwise requests will fail with `ZX_ERR_INVALID_ARGS`.\n"]const PERM_MODIFY_DIRECTORY = 256;
5397 #[doc = " Inherit write permissions when available (PERM_WRITE_BYTES, PERM_UPDATE_ATTRIBUTES,\n PERM_MODIFY_DIRECTORY, /// PERM_ENUMERATE). Servers must ensure this flag is removed\n if the parent connection lacks any of these rights. See [`INHERITED_WRITE_PERMISSIONS`]\n for the exact set of permissions that will be inherited.\n"]const PERM_INHERIT_WRITE = 8192;
5398 #[doc = " Inherit execute permission when available (PERM_EXECUTE).\n Servers must ensure this flag is removed if the parent connection lacks PERM_EXECUTE.\n"]const PERM_INHERIT_EXECUTE = 16384;
5399 #[doc = " Connect to the underlying protocol if this is a service node. The caller must determine the\n correct protocol to use (e.g. based on path). Unless used with [`PROTOCOL_NODE`], specifying\n other flags with the request will fail with `ZX_ERR_INVALID_ARGS`.\n"]const PROTOCOL_SERVICE = 4294967296;
5400 #[doc = " Connect to the underlying node. Takes precedence over other protocols. If other `PROTOCOL_*`\n are specified, they will be used to validate the target node type. Requests will fail with\n `ZX_ERR_INVALID_ARGS` if flags other than `PROTOCOL_*` and [`FLAG_SEND_REPRESENTATION`] are\n specified. Equivalent to POSIX `O_PATH`.\n"]const PROTOCOL_NODE = 4194304;
5401 #[doc = " Caller accepts [`fuchsia.io/Directory`] protocol. Equivalent to POSIX `O_DIRECTORY`.\n"]const PROTOCOL_DIRECTORY = 524288;
5402 #[doc = " Caller accepts [`fuchsia.io/File`] protocol.\n"]const PROTOCOL_FILE = 8589934592;
5403 #[doc = " Caller accepts [`fuchsia.io/Symlink`] protocol.\n"]const PROTOCOL_SYMLINK = 17179869184;
5404 #[doc = " Caller requests a [`fuchsia.io/Node.OnRepresentation`] event on success.\n"]const FLAG_SEND_REPRESENTATION = 1099511627776;
5405 #[doc = " Create a new object if one doesn\'t exist, otherwise open an existing object. If set, a\n single `PROTOCOL_*` flag must be set indicating the type of object to create. Equivalent\n to POSIX `O_CREAT`.\n"]const FLAG_MAYBE_CREATE = 65536;
5406 #[doc = " Create a new object if one doesn\'t exist, otherwise fail the request with\n `ZX_ERR_ALREADY_EXISTS`. If set, a single `PROTOCOL_*` flag must be set indicating the type\n of object to create. Takes precedence over [`FLAG_MAYBE_CREATE`]. Equivalent to POSIX\n `O_EXCL`.\n"]const FLAG_MUST_CREATE = 131072;
5407 #[doc = " Create a new unnamed temporary object. The object is temporary until it is linked to the\n filesystem. If specified with `FLAG_TEMPORARY_AS_NOT_LINKABLE`, then the created object is\n not linkable. If this flag is set:\n * `path` specified in [`fuchsia.io/Directory.Open`] refers to the path of the directory\n which the new object will be created in,\n * A `PROTOCOL_*` flag is set to indicate the type of object to be created. Currently, this\n is only supported when specified with `PROTOCOL_FILE`, in which case, it is equivalent\n to Linux `O_TMPFILE`.\n * `FLAG_MAYBE_CREATE` will be ignored.\n"]const FLAG_CREATE_AS_UNNAMED_TEMPORARY = 34359738368;
5408 #[doc = " Open the file in append mode. The seek pointer will be moved to end-of-file (EOF)\n before all writes. Equivalent to POSIX `O_APPEND`.\n"]const FILE_APPEND = 1048576;
5409 #[doc = " Truncate the file to zero length upon opening it. Equivalent to POSIX `O_TRUNC`.\n"]const FILE_TRUNCATE = 262144;
5410 const _ = !0;
5411 }
5412 }
5413
5414 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Flags, ___E> for Flags
5415 where
5416 ___E: ?Sized,
5417 {
5418 #[inline]
5419 fn encode(
5420 self,
5421 encoder: &mut ___E,
5422 out: &mut ::core::mem::MaybeUninit<crate::wire::Flags>,
5423 _: (),
5424 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5425 ::fidl_next::Encode::encode(&self, encoder, out, ())
5426 }
5427 }
5428
5429 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Flags, ___E> for &'a Flags
5430 where
5431 ___E: ?Sized,
5432 {
5433 #[inline]
5434 fn encode(
5435 self,
5436 _: &mut ___E,
5437 out: &mut ::core::mem::MaybeUninit<crate::wire::Flags>,
5438 _: (),
5439 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5440 ::fidl_next::munge!(let crate::wire::Flags { value } = out);
5441
5442 let _ = value.write(::fidl_next::wire::Uint64::from(self.bits()));
5443 Ok(())
5444 }
5445 }
5446
5447 impl ::core::convert::From<crate::wire::Flags> for Flags {
5448 fn from(wire: crate::wire::Flags) -> Self {
5449 Self::from_bits_retain(u64::from(wire.value))
5450 }
5451 }
5452
5453 impl ::fidl_next::FromWire<crate::wire::Flags> for Flags {
5454 #[inline]
5455 fn from_wire(wire: crate::wire::Flags) -> Self {
5456 Self::from(wire)
5457 }
5458 }
5459
5460 impl ::fidl_next::FromWireRef<crate::wire::Flags> for Flags {
5461 #[inline]
5462 fn from_wire_ref(wire: &crate::wire::Flags) -> Self {
5463 Self::from(*wire)
5464 }
5465 }
5466
5467 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5468 #[repr(C)]
5469 pub struct NodeGetFlagsResponse {
5470 pub flags: crate::natural::Flags,
5471 }
5472
5473 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeGetFlagsResponse, ___E>
5474 for NodeGetFlagsResponse
5475 where
5476 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5477 {
5478 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5479 Self,
5480 crate::wire::NodeGetFlagsResponse,
5481 > = unsafe {
5482 ::fidl_next::CopyOptimization::enable_if(
5483 true
5484
5485 && <
5486 crate::natural::Flags as ::fidl_next::Encode<crate::wire::Flags, ___E>
5487 >::COPY_OPTIMIZATION.is_enabled()
5488
5489 )
5490 };
5491
5492 #[inline]
5493 fn encode(
5494 self,
5495 encoder_: &mut ___E,
5496 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetFlagsResponse>,
5497 _: (),
5498 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5499 ::fidl_next::munge! {
5500 let crate::wire::NodeGetFlagsResponse {
5501 flags,
5502
5503 } = out_;
5504 }
5505
5506 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
5507
5508 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
5509
5510 Ok(())
5511 }
5512 }
5513
5514 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeGetFlagsResponse, ___E>
5515 for &'a NodeGetFlagsResponse
5516 where
5517 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5518 {
5519 #[inline]
5520 fn encode(
5521 self,
5522 encoder_: &mut ___E,
5523 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetFlagsResponse>,
5524 _: (),
5525 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5526 ::fidl_next::munge! {
5527 let crate::wire::NodeGetFlagsResponse {
5528
5529 flags,
5530
5531 } = out_;
5532 }
5533
5534 ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
5535
5536 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
5537
5538 Ok(())
5539 }
5540 }
5541
5542 unsafe impl<___E>
5543 ::fidl_next::EncodeOption<
5544 ::fidl_next::wire::Box<'static, crate::wire::NodeGetFlagsResponse>,
5545 ___E,
5546 > for NodeGetFlagsResponse
5547 where
5548 ___E: ::fidl_next::Encoder + ?Sized,
5549 NodeGetFlagsResponse: ::fidl_next::Encode<crate::wire::NodeGetFlagsResponse, ___E>,
5550 {
5551 #[inline]
5552 fn encode_option(
5553 this: ::core::option::Option<Self>,
5554 encoder: &mut ___E,
5555 out: &mut ::core::mem::MaybeUninit<
5556 ::fidl_next::wire::Box<'static, crate::wire::NodeGetFlagsResponse>,
5557 >,
5558 _: (),
5559 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5560 if let Some(inner) = this {
5561 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5562 ::fidl_next::wire::Box::encode_present(out);
5563 } else {
5564 ::fidl_next::wire::Box::encode_absent(out);
5565 }
5566
5567 Ok(())
5568 }
5569 }
5570
5571 unsafe impl<'a, ___E>
5572 ::fidl_next::EncodeOption<
5573 ::fidl_next::wire::Box<'static, crate::wire::NodeGetFlagsResponse>,
5574 ___E,
5575 > for &'a NodeGetFlagsResponse
5576 where
5577 ___E: ::fidl_next::Encoder + ?Sized,
5578 &'a NodeGetFlagsResponse: ::fidl_next::Encode<crate::wire::NodeGetFlagsResponse, ___E>,
5579 {
5580 #[inline]
5581 fn encode_option(
5582 this: ::core::option::Option<Self>,
5583 encoder: &mut ___E,
5584 out: &mut ::core::mem::MaybeUninit<
5585 ::fidl_next::wire::Box<'static, crate::wire::NodeGetFlagsResponse>,
5586 >,
5587 _: (),
5588 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5589 if let Some(inner) = this {
5590 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5591 ::fidl_next::wire::Box::encode_present(out);
5592 } else {
5593 ::fidl_next::wire::Box::encode_absent(out);
5594 }
5595
5596 Ok(())
5597 }
5598 }
5599
5600 impl ::fidl_next::FromWire<crate::wire::NodeGetFlagsResponse> for NodeGetFlagsResponse {
5601 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5602 crate::wire::NodeGetFlagsResponse,
5603 Self,
5604 > = unsafe {
5605 ::fidl_next::CopyOptimization::enable_if(
5606 true
5607
5608 && <
5609 crate::natural::Flags as ::fidl_next::FromWire<crate::wire::Flags>
5610 >::COPY_OPTIMIZATION.is_enabled()
5611
5612 )
5613 };
5614
5615 #[inline]
5616 fn from_wire(wire: crate::wire::NodeGetFlagsResponse) -> Self {
5617 Self { flags: ::fidl_next::FromWire::from_wire(wire.flags) }
5618 }
5619 }
5620
5621 impl ::fidl_next::FromWireRef<crate::wire::NodeGetFlagsResponse> for NodeGetFlagsResponse {
5622 #[inline]
5623 fn from_wire_ref(wire: &crate::wire::NodeGetFlagsResponse) -> Self {
5624 Self { flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags) }
5625 }
5626 }
5627
5628 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5629 #[repr(C)]
5630 pub struct NodeSetFlagsRequest {
5631 pub flags: crate::natural::Flags,
5632 }
5633
5634 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeSetFlagsRequest, ___E>
5635 for NodeSetFlagsRequest
5636 where
5637 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5638 {
5639 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5640 Self,
5641 crate::wire::NodeSetFlagsRequest,
5642 > = unsafe {
5643 ::fidl_next::CopyOptimization::enable_if(
5644 true
5645
5646 && <
5647 crate::natural::Flags as ::fidl_next::Encode<crate::wire::Flags, ___E>
5648 >::COPY_OPTIMIZATION.is_enabled()
5649
5650 )
5651 };
5652
5653 #[inline]
5654 fn encode(
5655 self,
5656 encoder_: &mut ___E,
5657 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeSetFlagsRequest>,
5658 _: (),
5659 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5660 ::fidl_next::munge! {
5661 let crate::wire::NodeSetFlagsRequest {
5662 flags,
5663
5664 } = out_;
5665 }
5666
5667 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
5668
5669 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
5670
5671 Ok(())
5672 }
5673 }
5674
5675 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeSetFlagsRequest, ___E>
5676 for &'a NodeSetFlagsRequest
5677 where
5678 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5679 {
5680 #[inline]
5681 fn encode(
5682 self,
5683 encoder_: &mut ___E,
5684 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeSetFlagsRequest>,
5685 _: (),
5686 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5687 ::fidl_next::munge! {
5688 let crate::wire::NodeSetFlagsRequest {
5689
5690 flags,
5691
5692 } = out_;
5693 }
5694
5695 ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
5696
5697 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
5698
5699 Ok(())
5700 }
5701 }
5702
5703 unsafe impl<___E>
5704 ::fidl_next::EncodeOption<
5705 ::fidl_next::wire::Box<'static, crate::wire::NodeSetFlagsRequest>,
5706 ___E,
5707 > for NodeSetFlagsRequest
5708 where
5709 ___E: ::fidl_next::Encoder + ?Sized,
5710 NodeSetFlagsRequest: ::fidl_next::Encode<crate::wire::NodeSetFlagsRequest, ___E>,
5711 {
5712 #[inline]
5713 fn encode_option(
5714 this: ::core::option::Option<Self>,
5715 encoder: &mut ___E,
5716 out: &mut ::core::mem::MaybeUninit<
5717 ::fidl_next::wire::Box<'static, crate::wire::NodeSetFlagsRequest>,
5718 >,
5719 _: (),
5720 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5721 if let Some(inner) = this {
5722 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5723 ::fidl_next::wire::Box::encode_present(out);
5724 } else {
5725 ::fidl_next::wire::Box::encode_absent(out);
5726 }
5727
5728 Ok(())
5729 }
5730 }
5731
5732 unsafe impl<'a, ___E>
5733 ::fidl_next::EncodeOption<
5734 ::fidl_next::wire::Box<'static, crate::wire::NodeSetFlagsRequest>,
5735 ___E,
5736 > for &'a NodeSetFlagsRequest
5737 where
5738 ___E: ::fidl_next::Encoder + ?Sized,
5739 &'a NodeSetFlagsRequest: ::fidl_next::Encode<crate::wire::NodeSetFlagsRequest, ___E>,
5740 {
5741 #[inline]
5742 fn encode_option(
5743 this: ::core::option::Option<Self>,
5744 encoder: &mut ___E,
5745 out: &mut ::core::mem::MaybeUninit<
5746 ::fidl_next::wire::Box<'static, crate::wire::NodeSetFlagsRequest>,
5747 >,
5748 _: (),
5749 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5750 if let Some(inner) = this {
5751 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5752 ::fidl_next::wire::Box::encode_present(out);
5753 } else {
5754 ::fidl_next::wire::Box::encode_absent(out);
5755 }
5756
5757 Ok(())
5758 }
5759 }
5760
5761 impl ::fidl_next::FromWire<crate::wire::NodeSetFlagsRequest> for NodeSetFlagsRequest {
5762 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5763 crate::wire::NodeSetFlagsRequest,
5764 Self,
5765 > = unsafe {
5766 ::fidl_next::CopyOptimization::enable_if(
5767 true
5768
5769 && <
5770 crate::natural::Flags as ::fidl_next::FromWire<crate::wire::Flags>
5771 >::COPY_OPTIMIZATION.is_enabled()
5772
5773 )
5774 };
5775
5776 #[inline]
5777 fn from_wire(wire: crate::wire::NodeSetFlagsRequest) -> Self {
5778 Self { flags: ::fidl_next::FromWire::from_wire(wire.flags) }
5779 }
5780 }
5781
5782 impl ::fidl_next::FromWireRef<crate::wire::NodeSetFlagsRequest> for NodeSetFlagsRequest {
5783 #[inline]
5784 fn from_wire_ref(wire: &crate::wire::NodeSetFlagsRequest) -> Self {
5785 Self { flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags) }
5786 }
5787 }
5788
5789 #[doc = " Used in places where empty structs are needed, such as empty union members, to avoid creating\n new struct types.\n"]
5790 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5791 #[repr(C)]
5792 pub struct EmptyStruct {}
5793
5794 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EmptyStruct, ___E> for EmptyStruct
5795 where
5796 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5797 {
5798 #[inline]
5799 fn encode(
5800 self,
5801 encoder_: &mut ___E,
5802 out_: &mut ::core::mem::MaybeUninit<crate::wire::EmptyStruct>,
5803 _: (),
5804 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5805 ::fidl_next::munge! {
5806 let crate::wire::EmptyStruct {
5807
5808 _empty,
5809
5810 } = out_;
5811 }
5812
5813 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
5814
5815 Ok(())
5816 }
5817 }
5818
5819 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::EmptyStruct, ___E> for &'a EmptyStruct
5820 where
5821 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5822 {
5823 #[inline]
5824 fn encode(
5825 self,
5826 encoder_: &mut ___E,
5827 out_: &mut ::core::mem::MaybeUninit<crate::wire::EmptyStruct>,
5828 _: (),
5829 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5830 ::fidl_next::munge! {
5831 let crate::wire::EmptyStruct {
5832
5833 _empty,
5834
5835
5836 } = out_;
5837 }
5838
5839 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
5840
5841 Ok(())
5842 }
5843 }
5844
5845 unsafe impl<___E>
5846 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::EmptyStruct>, ___E>
5847 for EmptyStruct
5848 where
5849 ___E: ::fidl_next::Encoder + ?Sized,
5850 EmptyStruct: ::fidl_next::Encode<crate::wire::EmptyStruct, ___E>,
5851 {
5852 #[inline]
5853 fn encode_option(
5854 this: ::core::option::Option<Self>,
5855 encoder: &mut ___E,
5856 out: &mut ::core::mem::MaybeUninit<
5857 ::fidl_next::wire::Box<'static, crate::wire::EmptyStruct>,
5858 >,
5859 _: (),
5860 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5861 if let Some(inner) = this {
5862 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5863 ::fidl_next::wire::Box::encode_present(out);
5864 } else {
5865 ::fidl_next::wire::Box::encode_absent(out);
5866 }
5867
5868 Ok(())
5869 }
5870 }
5871
5872 unsafe impl<'a, ___E>
5873 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::EmptyStruct>, ___E>
5874 for &'a EmptyStruct
5875 where
5876 ___E: ::fidl_next::Encoder + ?Sized,
5877 &'a EmptyStruct: ::fidl_next::Encode<crate::wire::EmptyStruct, ___E>,
5878 {
5879 #[inline]
5880 fn encode_option(
5881 this: ::core::option::Option<Self>,
5882 encoder: &mut ___E,
5883 out: &mut ::core::mem::MaybeUninit<
5884 ::fidl_next::wire::Box<'static, crate::wire::EmptyStruct>,
5885 >,
5886 _: (),
5887 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5888 if let Some(inner) = this {
5889 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5890 ::fidl_next::wire::Box::encode_present(out);
5891 } else {
5892 ::fidl_next::wire::Box::encode_absent(out);
5893 }
5894
5895 Ok(())
5896 }
5897 }
5898
5899 impl ::fidl_next::FromWire<crate::wire::EmptyStruct> for EmptyStruct {
5900 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::EmptyStruct, Self> =
5901 unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
5902
5903 #[inline]
5904 fn from_wire(wire: crate::wire::EmptyStruct) -> Self {
5905 Self {}
5906 }
5907 }
5908
5909 impl ::fidl_next::FromWireRef<crate::wire::EmptyStruct> for EmptyStruct {
5910 #[inline]
5911 fn from_wire_ref(wire: &crate::wire::EmptyStruct) -> Self {
5912 Self {}
5913 }
5914 }
5915
5916 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5917 pub enum SelinuxContext {
5918 Data(::std::vec::Vec<u8>),
5919
5920 UseExtendedAttributes(crate::natural::EmptyStruct),
5921
5922 UnknownOrdinal_(u64),
5923 }
5924
5925 impl SelinuxContext {
5926 pub fn is_unknown(&self) -> bool {
5927 #[allow(unreachable_patterns)]
5928 match self {
5929 Self::UnknownOrdinal_(_) => true,
5930 _ => false,
5931 }
5932 }
5933 }
5934
5935 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SelinuxContext<'static>, ___E> for SelinuxContext
5936 where
5937 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5938 ___E: ::fidl_next::Encoder,
5939 {
5940 #[inline]
5941 fn encode(
5942 self,
5943 encoder: &mut ___E,
5944 out: &mut ::core::mem::MaybeUninit<crate::wire::SelinuxContext<'static>>,
5945 _: (),
5946 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5947 ::fidl_next::munge!(let crate::wire::SelinuxContext { raw, _phantom: _ } = out);
5948
5949 match self {
5950 Self::Data(value) => ::fidl_next::wire::Union::encode_as::<
5951 ___E,
5952 ::fidl_next::wire::Vector<'static, u8>,
5953 >(value, 1, encoder, raw, (256, ()))?,
5954
5955 Self::UseExtendedAttributes(value) => ::fidl_next::wire::Union::encode_as::<
5956 ___E,
5957 crate::wire::EmptyStruct,
5958 >(value, 2, encoder, raw, ())?,
5959
5960 Self::UnknownOrdinal_(ordinal) => {
5961 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
5962 }
5963 }
5964
5965 Ok(())
5966 }
5967 }
5968
5969 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SelinuxContext<'static>, ___E>
5970 for &'a SelinuxContext
5971 where
5972 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5973 ___E: ::fidl_next::Encoder,
5974 {
5975 #[inline]
5976 fn encode(
5977 self,
5978 encoder: &mut ___E,
5979 out: &mut ::core::mem::MaybeUninit<crate::wire::SelinuxContext<'static>>,
5980 _: (),
5981 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5982 ::fidl_next::munge!(let crate::wire::SelinuxContext { raw, _phantom: _ } = out);
5983
5984 match self {
5985 SelinuxContext::Data(value) => ::fidl_next::wire::Union::encode_as::<
5986 ___E,
5987 ::fidl_next::wire::Vector<'static, u8>,
5988 >(value, 1, encoder, raw, (256, ()))?,
5989
5990 SelinuxContext::UseExtendedAttributes(value) => {
5991 ::fidl_next::wire::Union::encode_as::<___E, crate::wire::EmptyStruct>(
5992 value,
5993 2,
5994 encoder,
5995 raw,
5996 (),
5997 )?
5998 }
5999
6000 SelinuxContext::UnknownOrdinal_(ordinal) => {
6001 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize));
6002 }
6003 }
6004
6005 Ok(())
6006 }
6007 }
6008
6009 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::SelinuxContext<'static>, ___E>
6010 for SelinuxContext
6011 where
6012 ___E: ?Sized,
6013 SelinuxContext: ::fidl_next::Encode<crate::wire::SelinuxContext<'static>, ___E>,
6014 {
6015 #[inline]
6016 fn encode_option(
6017 this: ::core::option::Option<Self>,
6018 encoder: &mut ___E,
6019 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::SelinuxContext<'static>>,
6020 _: (),
6021 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6022 ::fidl_next::munge!(let crate::wire_optional::SelinuxContext { raw, _phantom: _ } = &mut *out);
6023
6024 if let Some(inner) = this {
6025 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
6026 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
6027 } else {
6028 ::fidl_next::wire::Union::encode_absent(raw);
6029 }
6030
6031 Ok(())
6032 }
6033 }
6034
6035 unsafe impl<'a, ___E>
6036 ::fidl_next::EncodeOption<crate::wire_optional::SelinuxContext<'static>, ___E>
6037 for &'a SelinuxContext
6038 where
6039 ___E: ?Sized,
6040 &'a SelinuxContext: ::fidl_next::Encode<crate::wire::SelinuxContext<'static>, ___E>,
6041 {
6042 #[inline]
6043 fn encode_option(
6044 this: ::core::option::Option<Self>,
6045 encoder: &mut ___E,
6046 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::SelinuxContext<'static>>,
6047 _: (),
6048 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6049 ::fidl_next::munge!(let crate::wire_optional::SelinuxContext { raw, _phantom: _ } = &mut *out);
6050
6051 if let Some(inner) = this {
6052 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
6053 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
6054 } else {
6055 ::fidl_next::wire::Union::encode_absent(raw);
6056 }
6057
6058 Ok(())
6059 }
6060 }
6061
6062 impl<'de> ::fidl_next::FromWire<crate::wire::SelinuxContext<'de>> for SelinuxContext {
6063 #[inline]
6064 fn from_wire(wire: crate::wire::SelinuxContext<'de>) -> Self {
6065 let wire = ::core::mem::ManuallyDrop::new(wire);
6066 match wire.raw.ordinal() {
6067 1 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
6068 wire.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
6069 })),
6070
6071 2 => Self::UseExtendedAttributes(::fidl_next::FromWire::from_wire(unsafe {
6072 wire.raw.get().read_unchecked::<crate::wire::EmptyStruct>()
6073 })),
6074
6075 ord => return Self::UnknownOrdinal_(ord as u64),
6076 }
6077 }
6078 }
6079
6080 impl<'de> ::fidl_next::FromWireRef<crate::wire::SelinuxContext<'de>> for SelinuxContext {
6081 #[inline]
6082 fn from_wire_ref(wire: &crate::wire::SelinuxContext<'de>) -> Self {
6083 match wire.raw.ordinal() {
6084 1 => Self::Data(::fidl_next::FromWireRef::from_wire_ref(unsafe {
6085 wire.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
6086 })),
6087
6088 2 => Self::UseExtendedAttributes(::fidl_next::FromWireRef::from_wire_ref(unsafe {
6089 wire.raw.get().deref_unchecked::<crate::wire::EmptyStruct>()
6090 })),
6091
6092 ord => return Self::UnknownOrdinal_(ord as u64),
6093 }
6094 }
6095 }
6096
6097 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::SelinuxContext<'de>>
6098 for SelinuxContext
6099 {
6100 #[inline]
6101 fn from_wire_option(
6102 wire: crate::wire_optional::SelinuxContext<'de>,
6103 ) -> ::core::option::Option<Self> {
6104 if let Some(inner) = wire.into_option() {
6105 Some(::fidl_next::FromWire::from_wire(inner))
6106 } else {
6107 None
6108 }
6109 }
6110 }
6111
6112 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::SelinuxContext<'de>>
6113 for Box<SelinuxContext>
6114 {
6115 #[inline]
6116 fn from_wire_option(
6117 wire: crate::wire_optional::SelinuxContext<'de>,
6118 ) -> ::core::option::Option<Self> {
6119 <SelinuxContext as ::fidl_next::FromWireOption<
6120 crate::wire_optional::SelinuxContext<'de>,
6121 >>::from_wire_option(wire)
6122 .map(Box::new)
6123 }
6124 }
6125
6126 impl<'de> ::fidl_next::FromWireOptionRef<crate::wire_optional::SelinuxContext<'de>>
6127 for Box<SelinuxContext>
6128 {
6129 #[inline]
6130 fn from_wire_option_ref(
6131 wire: &crate::wire_optional::SelinuxContext<'de>,
6132 ) -> ::core::option::Option<Self> {
6133 if let Some(inner) = wire.as_ref() {
6134 Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
6135 } else {
6136 None
6137 }
6138 }
6139 }
6140
6141 #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6142 pub struct MutableNodeAttributes {
6143 pub creation_time: ::core::option::Option<u64>,
6144
6145 pub modification_time: ::core::option::Option<u64>,
6146
6147 pub mode: ::core::option::Option<u32>,
6148
6149 pub uid: ::core::option::Option<u32>,
6150
6151 pub gid: ::core::option::Option<u32>,
6152
6153 pub rdev: ::core::option::Option<u64>,
6154
6155 pub access_time: ::core::option::Option<u64>,
6156
6157 pub casefold: ::core::option::Option<bool>,
6158
6159 pub selinux_context: ::core::option::Option<crate::natural::SelinuxContext>,
6160
6161 pub wrapping_key_id: ::core::option::Option<[u8; 16]>,
6162 }
6163
6164 impl MutableNodeAttributes {
6165 fn __max_ordinal(&self) -> usize {
6166 if self.wrapping_key_id.is_some() {
6167 return 10;
6168 }
6169
6170 if self.selinux_context.is_some() {
6171 return 9;
6172 }
6173
6174 if self.casefold.is_some() {
6175 return 8;
6176 }
6177
6178 if self.access_time.is_some() {
6179 return 7;
6180 }
6181
6182 if self.rdev.is_some() {
6183 return 6;
6184 }
6185
6186 if self.gid.is_some() {
6187 return 5;
6188 }
6189
6190 if self.uid.is_some() {
6191 return 4;
6192 }
6193
6194 if self.mode.is_some() {
6195 return 3;
6196 }
6197
6198 if self.modification_time.is_some() {
6199 return 2;
6200 }
6201
6202 if self.creation_time.is_some() {
6203 return 1;
6204 }
6205
6206 0
6207 }
6208 }
6209
6210 unsafe impl<___E> ::fidl_next::Encode<crate::wire::MutableNodeAttributes<'static>, ___E>
6211 for MutableNodeAttributes
6212 where
6213 ___E: ::fidl_next::Encoder + ?Sized,
6214 {
6215 #[inline]
6216 fn encode(
6217 mut self,
6218 encoder: &mut ___E,
6219 out: &mut ::core::mem::MaybeUninit<crate::wire::MutableNodeAttributes<'static>>,
6220 _: (),
6221 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6222 ::fidl_next::munge!(let crate::wire::MutableNodeAttributes { table } = out);
6223
6224 let max_ord = self.__max_ordinal();
6225
6226 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6227 ::fidl_next::Wire::zero_padding(&mut out);
6228
6229 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6230 ::fidl_next::wire::Envelope,
6231 >(encoder, max_ord);
6232
6233 for i in 1..=max_ord {
6234 match i {
6235 10 => {
6236 if let Some(value) = self.wrapping_key_id.take() {
6237 ::fidl_next::wire::Envelope::encode_value::<[u8; 16], ___E>(
6238 value,
6239 preallocated.encoder,
6240 &mut out,
6241 (),
6242 )?;
6243 } else {
6244 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6245 }
6246 }
6247
6248 9 => {
6249 if let Some(value) = self.selinux_context.take() {
6250 ::fidl_next::wire::Envelope::encode_value::<
6251 crate::wire::SelinuxContext<'static>,
6252 ___E,
6253 >(
6254 value, preallocated.encoder, &mut out, ()
6255 )?;
6256 } else {
6257 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6258 }
6259 }
6260
6261 8 => {
6262 if let Some(value) = self.casefold.take() {
6263 ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
6264 value,
6265 preallocated.encoder,
6266 &mut out,
6267 (),
6268 )?;
6269 } else {
6270 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6271 }
6272 }
6273
6274 7 => {
6275 if let Some(value) = self.access_time.take() {
6276 ::fidl_next::wire::Envelope::encode_value::<
6277 ::fidl_next::wire::Uint64,
6278 ___E,
6279 >(
6280 value, preallocated.encoder, &mut out, ()
6281 )?;
6282 } else {
6283 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6284 }
6285 }
6286
6287 6 => {
6288 if let Some(value) = self.rdev.take() {
6289 ::fidl_next::wire::Envelope::encode_value::<
6290 ::fidl_next::wire::Uint64,
6291 ___E,
6292 >(
6293 value, preallocated.encoder, &mut out, ()
6294 )?;
6295 } else {
6296 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6297 }
6298 }
6299
6300 5 => {
6301 if let Some(value) = self.gid.take() {
6302 ::fidl_next::wire::Envelope::encode_value::<
6303 ::fidl_next::wire::Uint32,
6304 ___E,
6305 >(
6306 value, preallocated.encoder, &mut out, ()
6307 )?;
6308 } else {
6309 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6310 }
6311 }
6312
6313 4 => {
6314 if let Some(value) = self.uid.take() {
6315 ::fidl_next::wire::Envelope::encode_value::<
6316 ::fidl_next::wire::Uint32,
6317 ___E,
6318 >(
6319 value, preallocated.encoder, &mut out, ()
6320 )?;
6321 } else {
6322 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6323 }
6324 }
6325
6326 3 => {
6327 if let Some(value) = self.mode.take() {
6328 ::fidl_next::wire::Envelope::encode_value::<
6329 ::fidl_next::wire::Uint32,
6330 ___E,
6331 >(
6332 value, preallocated.encoder, &mut out, ()
6333 )?;
6334 } else {
6335 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6336 }
6337 }
6338
6339 2 => {
6340 if let Some(value) = self.modification_time.take() {
6341 ::fidl_next::wire::Envelope::encode_value::<
6342 ::fidl_next::wire::Uint64,
6343 ___E,
6344 >(
6345 value, preallocated.encoder, &mut out, ()
6346 )?;
6347 } else {
6348 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6349 }
6350 }
6351
6352 1 => {
6353 if let Some(value) = self.creation_time.take() {
6354 ::fidl_next::wire::Envelope::encode_value::<
6355 ::fidl_next::wire::Uint64,
6356 ___E,
6357 >(
6358 value, preallocated.encoder, &mut out, ()
6359 )?;
6360 } else {
6361 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6362 }
6363 }
6364
6365 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6366 }
6367 unsafe {
6368 preallocated.write_next(out.assume_init_ref());
6369 }
6370 }
6371
6372 ::fidl_next::wire::Table::encode_len(table, max_ord);
6373
6374 Ok(())
6375 }
6376 }
6377
6378 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::MutableNodeAttributes<'static>, ___E>
6379 for &'a MutableNodeAttributes
6380 where
6381 ___E: ::fidl_next::Encoder + ?Sized,
6382 {
6383 #[inline]
6384 fn encode(
6385 self,
6386 encoder: &mut ___E,
6387 out: &mut ::core::mem::MaybeUninit<crate::wire::MutableNodeAttributes<'static>>,
6388 _: (),
6389 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6390 ::fidl_next::munge!(let crate::wire::MutableNodeAttributes { table } = out);
6391
6392 let max_ord = self.__max_ordinal();
6393
6394 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6395 ::fidl_next::Wire::zero_padding(&mut out);
6396
6397 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6398 ::fidl_next::wire::Envelope,
6399 >(encoder, max_ord);
6400
6401 for i in 1..=max_ord {
6402 match i {
6403 10 => {
6404 if let Some(value) = &self.wrapping_key_id {
6405 ::fidl_next::wire::Envelope::encode_value::<[u8; 16], ___E>(
6406 value,
6407 preallocated.encoder,
6408 &mut out,
6409 (),
6410 )?;
6411 } else {
6412 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6413 }
6414 }
6415
6416 9 => {
6417 if let Some(value) = &self.selinux_context {
6418 ::fidl_next::wire::Envelope::encode_value::<
6419 crate::wire::SelinuxContext<'static>,
6420 ___E,
6421 >(
6422 value, preallocated.encoder, &mut out, ()
6423 )?;
6424 } else {
6425 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6426 }
6427 }
6428
6429 8 => {
6430 if let Some(value) = &self.casefold {
6431 ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
6432 value,
6433 preallocated.encoder,
6434 &mut out,
6435 (),
6436 )?;
6437 } else {
6438 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6439 }
6440 }
6441
6442 7 => {
6443 if let Some(value) = &self.access_time {
6444 ::fidl_next::wire::Envelope::encode_value::<
6445 ::fidl_next::wire::Uint64,
6446 ___E,
6447 >(
6448 value, preallocated.encoder, &mut out, ()
6449 )?;
6450 } else {
6451 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6452 }
6453 }
6454
6455 6 => {
6456 if let Some(value) = &self.rdev {
6457 ::fidl_next::wire::Envelope::encode_value::<
6458 ::fidl_next::wire::Uint64,
6459 ___E,
6460 >(
6461 value, preallocated.encoder, &mut out, ()
6462 )?;
6463 } else {
6464 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6465 }
6466 }
6467
6468 5 => {
6469 if let Some(value) = &self.gid {
6470 ::fidl_next::wire::Envelope::encode_value::<
6471 ::fidl_next::wire::Uint32,
6472 ___E,
6473 >(
6474 value, preallocated.encoder, &mut out, ()
6475 )?;
6476 } else {
6477 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6478 }
6479 }
6480
6481 4 => {
6482 if let Some(value) = &self.uid {
6483 ::fidl_next::wire::Envelope::encode_value::<
6484 ::fidl_next::wire::Uint32,
6485 ___E,
6486 >(
6487 value, preallocated.encoder, &mut out, ()
6488 )?;
6489 } else {
6490 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6491 }
6492 }
6493
6494 3 => {
6495 if let Some(value) = &self.mode {
6496 ::fidl_next::wire::Envelope::encode_value::<
6497 ::fidl_next::wire::Uint32,
6498 ___E,
6499 >(
6500 value, preallocated.encoder, &mut out, ()
6501 )?;
6502 } else {
6503 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6504 }
6505 }
6506
6507 2 => {
6508 if let Some(value) = &self.modification_time {
6509 ::fidl_next::wire::Envelope::encode_value::<
6510 ::fidl_next::wire::Uint64,
6511 ___E,
6512 >(
6513 value, preallocated.encoder, &mut out, ()
6514 )?;
6515 } else {
6516 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6517 }
6518 }
6519
6520 1 => {
6521 if let Some(value) = &self.creation_time {
6522 ::fidl_next::wire::Envelope::encode_value::<
6523 ::fidl_next::wire::Uint64,
6524 ___E,
6525 >(
6526 value, preallocated.encoder, &mut out, ()
6527 )?;
6528 } else {
6529 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6530 }
6531 }
6532
6533 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6534 }
6535 unsafe {
6536 preallocated.write_next(out.assume_init_ref());
6537 }
6538 }
6539
6540 ::fidl_next::wire::Table::encode_len(table, max_ord);
6541
6542 Ok(())
6543 }
6544 }
6545
6546 impl<'de> ::fidl_next::FromWire<crate::wire::MutableNodeAttributes<'de>> for MutableNodeAttributes {
6547 #[inline]
6548 fn from_wire(wire_: crate::wire::MutableNodeAttributes<'de>) -> Self {
6549 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
6550
6551 let creation_time = wire_.table.get(1);
6552
6553 let modification_time = wire_.table.get(2);
6554
6555 let mode = wire_.table.get(3);
6556
6557 let uid = wire_.table.get(4);
6558
6559 let gid = wire_.table.get(5);
6560
6561 let rdev = wire_.table.get(6);
6562
6563 let access_time = wire_.table.get(7);
6564
6565 let casefold = wire_.table.get(8);
6566
6567 let selinux_context = wire_.table.get(9);
6568
6569 let wrapping_key_id = wire_.table.get(10);
6570
6571 Self {
6572 creation_time: creation_time.map(|envelope| {
6573 ::fidl_next::FromWire::from_wire(unsafe {
6574 envelope.read_unchecked::<::fidl_next::wire::Uint64>()
6575 })
6576 }),
6577
6578 modification_time: modification_time.map(|envelope| {
6579 ::fidl_next::FromWire::from_wire(unsafe {
6580 envelope.read_unchecked::<::fidl_next::wire::Uint64>()
6581 })
6582 }),
6583
6584 mode: mode.map(|envelope| {
6585 ::fidl_next::FromWire::from_wire(unsafe {
6586 envelope.read_unchecked::<::fidl_next::wire::Uint32>()
6587 })
6588 }),
6589
6590 uid: uid.map(|envelope| {
6591 ::fidl_next::FromWire::from_wire(unsafe {
6592 envelope.read_unchecked::<::fidl_next::wire::Uint32>()
6593 })
6594 }),
6595
6596 gid: gid.map(|envelope| {
6597 ::fidl_next::FromWire::from_wire(unsafe {
6598 envelope.read_unchecked::<::fidl_next::wire::Uint32>()
6599 })
6600 }),
6601
6602 rdev: rdev.map(|envelope| {
6603 ::fidl_next::FromWire::from_wire(unsafe {
6604 envelope.read_unchecked::<::fidl_next::wire::Uint64>()
6605 })
6606 }),
6607
6608 access_time: access_time.map(|envelope| {
6609 ::fidl_next::FromWire::from_wire(unsafe {
6610 envelope.read_unchecked::<::fidl_next::wire::Uint64>()
6611 })
6612 }),
6613
6614 casefold: casefold.map(|envelope| {
6615 ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
6616 }),
6617
6618 selinux_context: selinux_context.map(|envelope| {
6619 ::fidl_next::FromWire::from_wire(unsafe {
6620 envelope.read_unchecked::<crate::wire::SelinuxContext<'de>>()
6621 })
6622 }),
6623
6624 wrapping_key_id: wrapping_key_id.map(|envelope| {
6625 ::fidl_next::FromWire::from_wire(unsafe {
6626 envelope.read_unchecked::<[u8; 16]>()
6627 })
6628 }),
6629 }
6630 }
6631 }
6632
6633 impl<'de> ::fidl_next::FromWireRef<crate::wire::MutableNodeAttributes<'de>>
6634 for MutableNodeAttributes
6635 {
6636 #[inline]
6637 fn from_wire_ref(wire: &crate::wire::MutableNodeAttributes<'de>) -> Self {
6638 Self {
6639 creation_time: wire.table.get(1).map(|envelope| {
6640 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6641 envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
6642 })
6643 }),
6644
6645 modification_time: wire.table.get(2).map(|envelope| {
6646 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6647 envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
6648 })
6649 }),
6650
6651 mode: wire.table.get(3).map(|envelope| {
6652 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6653 envelope.deref_unchecked::<::fidl_next::wire::Uint32>()
6654 })
6655 }),
6656
6657 uid: wire.table.get(4).map(|envelope| {
6658 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6659 envelope.deref_unchecked::<::fidl_next::wire::Uint32>()
6660 })
6661 }),
6662
6663 gid: wire.table.get(5).map(|envelope| {
6664 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6665 envelope.deref_unchecked::<::fidl_next::wire::Uint32>()
6666 })
6667 }),
6668
6669 rdev: wire.table.get(6).map(|envelope| {
6670 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6671 envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
6672 })
6673 }),
6674
6675 access_time: wire.table.get(7).map(|envelope| {
6676 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6677 envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
6678 })
6679 }),
6680
6681 casefold: wire.table.get(8).map(|envelope| {
6682 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6683 envelope.deref_unchecked::<bool>()
6684 })
6685 }),
6686
6687 selinux_context: wire.table.get(9).map(|envelope| {
6688 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6689 envelope.deref_unchecked::<crate::wire::SelinuxContext<'de>>()
6690 })
6691 }),
6692
6693 wrapping_key_id: wire.table.get(10).map(|envelope| {
6694 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6695 envelope.deref_unchecked::<[u8; 16]>()
6696 })
6697 }),
6698 }
6699 }
6700 }
6701
6702 ::fidl_next::bitflags::bitflags! {
6703 #[doc = " A node may have multiple supported representations when opening, even though\n it may have a fixed underlying identity.\n\n Today, a file is accessed via the [`File`] protocol, and sends a\n [`Representation.FileInfo`] when opened with `GET_REPRESENTATION`. However,\n in the future we might introduce a more sophisticated `FileV2` protocol, or\n a more efficient `SuperFastFile` backed by a specialized kernel object. New\n clients can request the more advanced representations by specifying the\n corresponding bits in [`NodeProtocolKinds`], whereas existing clients would\n continue to talk to the node via the old representation.\n\n [`NodeProtocolKinds`] enables forward-compatibility through a form of protocol\n negotiation.\n\n The elements have one-to-one correspondence with the members of\n [`Representation`].\n"]#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct NodeProtocolKinds: u64 {
6704 #[doc = " The connector representation of a node.\n\n The connection will speak either [`Node`] or the target protocol,\n depending on the flags used during opening.\n"]const CONNECTOR = 1;
6705 #[doc = " The directory representation of a node.\n\n The connection will speak the [`Directory`] protocol.\n"]const DIRECTORY = 2;
6706 #[doc = " The file representation of a node.\n\n The connection will speak the [`File`] protocol.\n"]const FILE = 4;
6707 #[doc = " The symlink representation of a node.\n\n The connection will speak the [`Symlink`] protocol.\n"]const SYMLINK = 8;
6708 const _ = !0;
6709 }
6710 }
6711
6712 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeProtocolKinds, ___E> for NodeProtocolKinds
6713 where
6714 ___E: ?Sized,
6715 {
6716 #[inline]
6717 fn encode(
6718 self,
6719 encoder: &mut ___E,
6720 out: &mut ::core::mem::MaybeUninit<crate::wire::NodeProtocolKinds>,
6721 _: (),
6722 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6723 ::fidl_next::Encode::encode(&self, encoder, out, ())
6724 }
6725 }
6726
6727 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeProtocolKinds, ___E>
6728 for &'a NodeProtocolKinds
6729 where
6730 ___E: ?Sized,
6731 {
6732 #[inline]
6733 fn encode(
6734 self,
6735 _: &mut ___E,
6736 out: &mut ::core::mem::MaybeUninit<crate::wire::NodeProtocolKinds>,
6737 _: (),
6738 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6739 ::fidl_next::munge!(let crate::wire::NodeProtocolKinds { value } = out);
6740
6741 let _ = value.write(::fidl_next::wire::Uint64::from(self.bits()));
6742 Ok(())
6743 }
6744 }
6745
6746 impl ::core::convert::From<crate::wire::NodeProtocolKinds> for NodeProtocolKinds {
6747 fn from(wire: crate::wire::NodeProtocolKinds) -> Self {
6748 Self::from_bits_retain(u64::from(wire.value))
6749 }
6750 }
6751
6752 impl ::fidl_next::FromWire<crate::wire::NodeProtocolKinds> for NodeProtocolKinds {
6753 #[inline]
6754 fn from_wire(wire: crate::wire::NodeProtocolKinds) -> Self {
6755 Self::from(wire)
6756 }
6757 }
6758
6759 impl ::fidl_next::FromWireRef<crate::wire::NodeProtocolKinds> for NodeProtocolKinds {
6760 #[inline]
6761 fn from_wire_ref(wire: &crate::wire::NodeProtocolKinds) -> Self {
6762 Self::from(*wire)
6763 }
6764 }
6765
6766 #[doc = " Denotes which hash algorithm is used to build the merkle tree for\n fsverity-enabled files.\n"]
6767 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6768 #[repr(u8)]
6769 pub enum HashAlgorithm {
6770 Sha256 = 1,
6771 Sha512 = 2,
6772 UnknownOrdinal_(u8) = 3,
6773 }
6774 impl ::std::convert::From<u8> for HashAlgorithm {
6775 fn from(value: u8) -> Self {
6776 match value {
6777 1 => Self::Sha256,
6778 2 => Self::Sha512,
6779
6780 _ => Self::UnknownOrdinal_(value),
6781 }
6782 }
6783 }
6784
6785 unsafe impl<___E> ::fidl_next::Encode<crate::wire::HashAlgorithm, ___E> for HashAlgorithm
6786 where
6787 ___E: ?Sized,
6788 {
6789 #[inline]
6790 fn encode(
6791 self,
6792 encoder: &mut ___E,
6793 out: &mut ::core::mem::MaybeUninit<crate::wire::HashAlgorithm>,
6794 _: (),
6795 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6796 ::fidl_next::Encode::encode(&self, encoder, out, ())
6797 }
6798 }
6799
6800 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::HashAlgorithm, ___E> for &'a HashAlgorithm
6801 where
6802 ___E: ?Sized,
6803 {
6804 #[inline]
6805 fn encode(
6806 self,
6807 encoder: &mut ___E,
6808 out: &mut ::core::mem::MaybeUninit<crate::wire::HashAlgorithm>,
6809 _: (),
6810 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6811 ::fidl_next::munge!(let crate::wire::HashAlgorithm { value } = out);
6812 let _ = value.write(u8::from(match *self {
6813 HashAlgorithm::Sha256 => 1,
6814
6815 HashAlgorithm::Sha512 => 2,
6816
6817 HashAlgorithm::UnknownOrdinal_(value) => value,
6818 }));
6819
6820 Ok(())
6821 }
6822 }
6823
6824 impl ::core::convert::From<crate::wire::HashAlgorithm> for HashAlgorithm {
6825 fn from(wire: crate::wire::HashAlgorithm) -> Self {
6826 match u8::from(wire.value) {
6827 1 => Self::Sha256,
6828
6829 2 => Self::Sha512,
6830
6831 value => Self::UnknownOrdinal_(value),
6832 }
6833 }
6834 }
6835
6836 impl ::fidl_next::FromWire<crate::wire::HashAlgorithm> for HashAlgorithm {
6837 #[inline]
6838 fn from_wire(wire: crate::wire::HashAlgorithm) -> Self {
6839 Self::from(wire)
6840 }
6841 }
6842
6843 impl ::fidl_next::FromWireRef<crate::wire::HashAlgorithm> for HashAlgorithm {
6844 #[inline]
6845 fn from_wire_ref(wire: &crate::wire::HashAlgorithm) -> Self {
6846 Self::from(*wire)
6847 }
6848 }
6849
6850 #[doc = " Set of options used to enable verity on a file.\n"]
6851 #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6852 pub struct VerificationOptions {
6853 pub hash_algorithm: ::core::option::Option<crate::natural::HashAlgorithm>,
6854
6855 pub salt: ::core::option::Option<::std::vec::Vec<u8>>,
6856 }
6857
6858 impl VerificationOptions {
6859 fn __max_ordinal(&self) -> usize {
6860 if self.salt.is_some() {
6861 return 2;
6862 }
6863
6864 if self.hash_algorithm.is_some() {
6865 return 1;
6866 }
6867
6868 0
6869 }
6870 }
6871
6872 unsafe impl<___E> ::fidl_next::Encode<crate::wire::VerificationOptions<'static>, ___E>
6873 for VerificationOptions
6874 where
6875 ___E: ::fidl_next::Encoder + ?Sized,
6876 {
6877 #[inline]
6878 fn encode(
6879 mut self,
6880 encoder: &mut ___E,
6881 out: &mut ::core::mem::MaybeUninit<crate::wire::VerificationOptions<'static>>,
6882 _: (),
6883 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6884 ::fidl_next::munge!(let crate::wire::VerificationOptions { table } = out);
6885
6886 let max_ord = self.__max_ordinal();
6887
6888 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6889 ::fidl_next::Wire::zero_padding(&mut out);
6890
6891 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6892 ::fidl_next::wire::Envelope,
6893 >(encoder, max_ord);
6894
6895 for i in 1..=max_ord {
6896 match i {
6897 2 => {
6898 if let Some(value) = self.salt.take() {
6899 ::fidl_next::wire::Envelope::encode_value::<
6900 ::fidl_next::wire::Vector<'static, u8>,
6901 ___E,
6902 >(
6903 value, preallocated.encoder, &mut out, (32, ())
6904 )?;
6905 } else {
6906 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6907 }
6908 }
6909
6910 1 => {
6911 if let Some(value) = self.hash_algorithm.take() {
6912 ::fidl_next::wire::Envelope::encode_value::<
6913 crate::wire::HashAlgorithm,
6914 ___E,
6915 >(
6916 value, preallocated.encoder, &mut out, ()
6917 )?;
6918 } else {
6919 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6920 }
6921 }
6922
6923 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6924 }
6925 unsafe {
6926 preallocated.write_next(out.assume_init_ref());
6927 }
6928 }
6929
6930 ::fidl_next::wire::Table::encode_len(table, max_ord);
6931
6932 Ok(())
6933 }
6934 }
6935
6936 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::VerificationOptions<'static>, ___E>
6937 for &'a VerificationOptions
6938 where
6939 ___E: ::fidl_next::Encoder + ?Sized,
6940 {
6941 #[inline]
6942 fn encode(
6943 self,
6944 encoder: &mut ___E,
6945 out: &mut ::core::mem::MaybeUninit<crate::wire::VerificationOptions<'static>>,
6946 _: (),
6947 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6948 ::fidl_next::munge!(let crate::wire::VerificationOptions { table } = out);
6949
6950 let max_ord = self.__max_ordinal();
6951
6952 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6953 ::fidl_next::Wire::zero_padding(&mut out);
6954
6955 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6956 ::fidl_next::wire::Envelope,
6957 >(encoder, max_ord);
6958
6959 for i in 1..=max_ord {
6960 match i {
6961 2 => {
6962 if let Some(value) = &self.salt {
6963 ::fidl_next::wire::Envelope::encode_value::<
6964 ::fidl_next::wire::Vector<'static, u8>,
6965 ___E,
6966 >(
6967 value, preallocated.encoder, &mut out, (32, ())
6968 )?;
6969 } else {
6970 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6971 }
6972 }
6973
6974 1 => {
6975 if let Some(value) = &self.hash_algorithm {
6976 ::fidl_next::wire::Envelope::encode_value::<
6977 crate::wire::HashAlgorithm,
6978 ___E,
6979 >(
6980 value, preallocated.encoder, &mut out, ()
6981 )?;
6982 } else {
6983 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6984 }
6985 }
6986
6987 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6988 }
6989 unsafe {
6990 preallocated.write_next(out.assume_init_ref());
6991 }
6992 }
6993
6994 ::fidl_next::wire::Table::encode_len(table, max_ord);
6995
6996 Ok(())
6997 }
6998 }
6999
7000 impl<'de> ::fidl_next::FromWire<crate::wire::VerificationOptions<'de>> for VerificationOptions {
7001 #[inline]
7002 fn from_wire(wire_: crate::wire::VerificationOptions<'de>) -> Self {
7003 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
7004
7005 let hash_algorithm = wire_.table.get(1);
7006
7007 let salt = wire_.table.get(2);
7008
7009 Self {
7010 hash_algorithm: hash_algorithm.map(|envelope| {
7011 ::fidl_next::FromWire::from_wire(unsafe {
7012 envelope.read_unchecked::<crate::wire::HashAlgorithm>()
7013 })
7014 }),
7015
7016 salt: salt.map(|envelope| {
7017 ::fidl_next::FromWire::from_wire(unsafe {
7018 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
7019 })
7020 }),
7021 }
7022 }
7023 }
7024
7025 impl<'de> ::fidl_next::FromWireRef<crate::wire::VerificationOptions<'de>> for VerificationOptions {
7026 #[inline]
7027 fn from_wire_ref(wire: &crate::wire::VerificationOptions<'de>) -> Self {
7028 Self {
7029 hash_algorithm: wire.table.get(1).map(|envelope| {
7030 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
7031 envelope.deref_unchecked::<crate::wire::HashAlgorithm>()
7032 })
7033 }),
7034
7035 salt: wire.table.get(2).map(|envelope| {
7036 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
7037 envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
7038 })
7039 }),
7040 }
7041 }
7042 }
7043
7044 #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7045 pub struct ImmutableNodeAttributes {
7046 pub protocols: ::core::option::Option<crate::natural::NodeProtocolKinds>,
7047
7048 pub abilities: ::core::option::Option<crate::natural::Operations>,
7049
7050 pub content_size: ::core::option::Option<u64>,
7051
7052 pub storage_size: ::core::option::Option<u64>,
7053
7054 pub link_count: ::core::option::Option<u64>,
7055
7056 pub id: ::core::option::Option<u64>,
7057
7058 pub change_time: ::core::option::Option<u64>,
7059
7060 pub options: ::core::option::Option<crate::natural::VerificationOptions>,
7061
7062 pub root_hash: ::core::option::Option<::std::vec::Vec<u8>>,
7063
7064 pub verity_enabled: ::core::option::Option<bool>,
7065 }
7066
7067 impl ImmutableNodeAttributes {
7068 fn __max_ordinal(&self) -> usize {
7069 if self.verity_enabled.is_some() {
7070 return 10;
7071 }
7072
7073 if self.root_hash.is_some() {
7074 return 9;
7075 }
7076
7077 if self.options.is_some() {
7078 return 8;
7079 }
7080
7081 if self.change_time.is_some() {
7082 return 7;
7083 }
7084
7085 if self.id.is_some() {
7086 return 6;
7087 }
7088
7089 if self.link_count.is_some() {
7090 return 5;
7091 }
7092
7093 if self.storage_size.is_some() {
7094 return 4;
7095 }
7096
7097 if self.content_size.is_some() {
7098 return 3;
7099 }
7100
7101 if self.abilities.is_some() {
7102 return 2;
7103 }
7104
7105 if self.protocols.is_some() {
7106 return 1;
7107 }
7108
7109 0
7110 }
7111 }
7112
7113 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ImmutableNodeAttributes<'static>, ___E>
7114 for ImmutableNodeAttributes
7115 where
7116 ___E: ::fidl_next::Encoder + ?Sized,
7117 {
7118 #[inline]
7119 fn encode(
7120 mut self,
7121 encoder: &mut ___E,
7122 out: &mut ::core::mem::MaybeUninit<crate::wire::ImmutableNodeAttributes<'static>>,
7123 _: (),
7124 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7125 ::fidl_next::munge!(let crate::wire::ImmutableNodeAttributes { table } = out);
7126
7127 let max_ord = self.__max_ordinal();
7128
7129 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
7130 ::fidl_next::Wire::zero_padding(&mut out);
7131
7132 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
7133 ::fidl_next::wire::Envelope,
7134 >(encoder, max_ord);
7135
7136 for i in 1..=max_ord {
7137 match i {
7138 10 => {
7139 if let Some(value) = self.verity_enabled.take() {
7140 ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
7141 value,
7142 preallocated.encoder,
7143 &mut out,
7144 (),
7145 )?;
7146 } else {
7147 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7148 }
7149 }
7150
7151 9 => {
7152 if let Some(value) = self.root_hash.take() {
7153 ::fidl_next::wire::Envelope::encode_value::<
7154 ::fidl_next::wire::Vector<'static, u8>,
7155 ___E,
7156 >(
7157 value, preallocated.encoder, &mut out, (64, ())
7158 )?;
7159 } else {
7160 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7161 }
7162 }
7163
7164 8 => {
7165 if let Some(value) = self.options.take() {
7166 ::fidl_next::wire::Envelope::encode_value::<
7167 crate::wire::VerificationOptions<'static>,
7168 ___E,
7169 >(
7170 value, preallocated.encoder, &mut out, ()
7171 )?;
7172 } else {
7173 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7174 }
7175 }
7176
7177 7 => {
7178 if let Some(value) = self.change_time.take() {
7179 ::fidl_next::wire::Envelope::encode_value::<
7180 ::fidl_next::wire::Uint64,
7181 ___E,
7182 >(
7183 value, preallocated.encoder, &mut out, ()
7184 )?;
7185 } else {
7186 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7187 }
7188 }
7189
7190 6 => {
7191 if let Some(value) = self.id.take() {
7192 ::fidl_next::wire::Envelope::encode_value::<
7193 ::fidl_next::wire::Uint64,
7194 ___E,
7195 >(
7196 value, preallocated.encoder, &mut out, ()
7197 )?;
7198 } else {
7199 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7200 }
7201 }
7202
7203 5 => {
7204 if let Some(value) = self.link_count.take() {
7205 ::fidl_next::wire::Envelope::encode_value::<
7206 ::fidl_next::wire::Uint64,
7207 ___E,
7208 >(
7209 value, preallocated.encoder, &mut out, ()
7210 )?;
7211 } else {
7212 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7213 }
7214 }
7215
7216 4 => {
7217 if let Some(value) = self.storage_size.take() {
7218 ::fidl_next::wire::Envelope::encode_value::<
7219 ::fidl_next::wire::Uint64,
7220 ___E,
7221 >(
7222 value, preallocated.encoder, &mut out, ()
7223 )?;
7224 } else {
7225 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7226 }
7227 }
7228
7229 3 => {
7230 if let Some(value) = self.content_size.take() {
7231 ::fidl_next::wire::Envelope::encode_value::<
7232 ::fidl_next::wire::Uint64,
7233 ___E,
7234 >(
7235 value, preallocated.encoder, &mut out, ()
7236 )?;
7237 } else {
7238 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7239 }
7240 }
7241
7242 2 => {
7243 if let Some(value) = self.abilities.take() {
7244 ::fidl_next::wire::Envelope::encode_value::<
7245 crate::wire::Operations,
7246 ___E,
7247 >(
7248 value, preallocated.encoder, &mut out, ()
7249 )?;
7250 } else {
7251 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7252 }
7253 }
7254
7255 1 => {
7256 if let Some(value) = self.protocols.take() {
7257 ::fidl_next::wire::Envelope::encode_value::<
7258 crate::wire::NodeProtocolKinds,
7259 ___E,
7260 >(
7261 value, preallocated.encoder, &mut out, ()
7262 )?;
7263 } else {
7264 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7265 }
7266 }
7267
7268 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
7269 }
7270 unsafe {
7271 preallocated.write_next(out.assume_init_ref());
7272 }
7273 }
7274
7275 ::fidl_next::wire::Table::encode_len(table, max_ord);
7276
7277 Ok(())
7278 }
7279 }
7280
7281 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ImmutableNodeAttributes<'static>, ___E>
7282 for &'a ImmutableNodeAttributes
7283 where
7284 ___E: ::fidl_next::Encoder + ?Sized,
7285 {
7286 #[inline]
7287 fn encode(
7288 self,
7289 encoder: &mut ___E,
7290 out: &mut ::core::mem::MaybeUninit<crate::wire::ImmutableNodeAttributes<'static>>,
7291 _: (),
7292 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7293 ::fidl_next::munge!(let crate::wire::ImmutableNodeAttributes { table } = out);
7294
7295 let max_ord = self.__max_ordinal();
7296
7297 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
7298 ::fidl_next::Wire::zero_padding(&mut out);
7299
7300 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
7301 ::fidl_next::wire::Envelope,
7302 >(encoder, max_ord);
7303
7304 for i in 1..=max_ord {
7305 match i {
7306 10 => {
7307 if let Some(value) = &self.verity_enabled {
7308 ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
7309 value,
7310 preallocated.encoder,
7311 &mut out,
7312 (),
7313 )?;
7314 } else {
7315 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7316 }
7317 }
7318
7319 9 => {
7320 if let Some(value) = &self.root_hash {
7321 ::fidl_next::wire::Envelope::encode_value::<
7322 ::fidl_next::wire::Vector<'static, u8>,
7323 ___E,
7324 >(
7325 value, preallocated.encoder, &mut out, (64, ())
7326 )?;
7327 } else {
7328 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7329 }
7330 }
7331
7332 8 => {
7333 if let Some(value) = &self.options {
7334 ::fidl_next::wire::Envelope::encode_value::<
7335 crate::wire::VerificationOptions<'static>,
7336 ___E,
7337 >(
7338 value, preallocated.encoder, &mut out, ()
7339 )?;
7340 } else {
7341 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7342 }
7343 }
7344
7345 7 => {
7346 if let Some(value) = &self.change_time {
7347 ::fidl_next::wire::Envelope::encode_value::<
7348 ::fidl_next::wire::Uint64,
7349 ___E,
7350 >(
7351 value, preallocated.encoder, &mut out, ()
7352 )?;
7353 } else {
7354 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7355 }
7356 }
7357
7358 6 => {
7359 if let Some(value) = &self.id {
7360 ::fidl_next::wire::Envelope::encode_value::<
7361 ::fidl_next::wire::Uint64,
7362 ___E,
7363 >(
7364 value, preallocated.encoder, &mut out, ()
7365 )?;
7366 } else {
7367 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7368 }
7369 }
7370
7371 5 => {
7372 if let Some(value) = &self.link_count {
7373 ::fidl_next::wire::Envelope::encode_value::<
7374 ::fidl_next::wire::Uint64,
7375 ___E,
7376 >(
7377 value, preallocated.encoder, &mut out, ()
7378 )?;
7379 } else {
7380 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7381 }
7382 }
7383
7384 4 => {
7385 if let Some(value) = &self.storage_size {
7386 ::fidl_next::wire::Envelope::encode_value::<
7387 ::fidl_next::wire::Uint64,
7388 ___E,
7389 >(
7390 value, preallocated.encoder, &mut out, ()
7391 )?;
7392 } else {
7393 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7394 }
7395 }
7396
7397 3 => {
7398 if let Some(value) = &self.content_size {
7399 ::fidl_next::wire::Envelope::encode_value::<
7400 ::fidl_next::wire::Uint64,
7401 ___E,
7402 >(
7403 value, preallocated.encoder, &mut out, ()
7404 )?;
7405 } else {
7406 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7407 }
7408 }
7409
7410 2 => {
7411 if let Some(value) = &self.abilities {
7412 ::fidl_next::wire::Envelope::encode_value::<
7413 crate::wire::Operations,
7414 ___E,
7415 >(
7416 value, preallocated.encoder, &mut out, ()
7417 )?;
7418 } else {
7419 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7420 }
7421 }
7422
7423 1 => {
7424 if let Some(value) = &self.protocols {
7425 ::fidl_next::wire::Envelope::encode_value::<
7426 crate::wire::NodeProtocolKinds,
7427 ___E,
7428 >(
7429 value, preallocated.encoder, &mut out, ()
7430 )?;
7431 } else {
7432 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7433 }
7434 }
7435
7436 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
7437 }
7438 unsafe {
7439 preallocated.write_next(out.assume_init_ref());
7440 }
7441 }
7442
7443 ::fidl_next::wire::Table::encode_len(table, max_ord);
7444
7445 Ok(())
7446 }
7447 }
7448
7449 impl<'de> ::fidl_next::FromWire<crate::wire::ImmutableNodeAttributes<'de>>
7450 for ImmutableNodeAttributes
7451 {
7452 #[inline]
7453 fn from_wire(wire_: crate::wire::ImmutableNodeAttributes<'de>) -> Self {
7454 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
7455
7456 let protocols = wire_.table.get(1);
7457
7458 let abilities = wire_.table.get(2);
7459
7460 let content_size = wire_.table.get(3);
7461
7462 let storage_size = wire_.table.get(4);
7463
7464 let link_count = wire_.table.get(5);
7465
7466 let id = wire_.table.get(6);
7467
7468 let change_time = wire_.table.get(7);
7469
7470 let options = wire_.table.get(8);
7471
7472 let root_hash = wire_.table.get(9);
7473
7474 let verity_enabled = wire_.table.get(10);
7475
7476 Self {
7477 protocols: protocols.map(|envelope| {
7478 ::fidl_next::FromWire::from_wire(unsafe {
7479 envelope.read_unchecked::<crate::wire::NodeProtocolKinds>()
7480 })
7481 }),
7482
7483 abilities: abilities.map(|envelope| {
7484 ::fidl_next::FromWire::from_wire(unsafe {
7485 envelope.read_unchecked::<crate::wire::Operations>()
7486 })
7487 }),
7488
7489 content_size: content_size.map(|envelope| {
7490 ::fidl_next::FromWire::from_wire(unsafe {
7491 envelope.read_unchecked::<::fidl_next::wire::Uint64>()
7492 })
7493 }),
7494
7495 storage_size: storage_size.map(|envelope| {
7496 ::fidl_next::FromWire::from_wire(unsafe {
7497 envelope.read_unchecked::<::fidl_next::wire::Uint64>()
7498 })
7499 }),
7500
7501 link_count: link_count.map(|envelope| {
7502 ::fidl_next::FromWire::from_wire(unsafe {
7503 envelope.read_unchecked::<::fidl_next::wire::Uint64>()
7504 })
7505 }),
7506
7507 id: id.map(|envelope| {
7508 ::fidl_next::FromWire::from_wire(unsafe {
7509 envelope.read_unchecked::<::fidl_next::wire::Uint64>()
7510 })
7511 }),
7512
7513 change_time: change_time.map(|envelope| {
7514 ::fidl_next::FromWire::from_wire(unsafe {
7515 envelope.read_unchecked::<::fidl_next::wire::Uint64>()
7516 })
7517 }),
7518
7519 options: options.map(|envelope| {
7520 ::fidl_next::FromWire::from_wire(unsafe {
7521 envelope.read_unchecked::<crate::wire::VerificationOptions<'de>>()
7522 })
7523 }),
7524
7525 root_hash: root_hash.map(|envelope| {
7526 ::fidl_next::FromWire::from_wire(unsafe {
7527 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
7528 })
7529 }),
7530
7531 verity_enabled: verity_enabled.map(|envelope| {
7532 ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
7533 }),
7534 }
7535 }
7536 }
7537
7538 impl<'de> ::fidl_next::FromWireRef<crate::wire::ImmutableNodeAttributes<'de>>
7539 for ImmutableNodeAttributes
7540 {
7541 #[inline]
7542 fn from_wire_ref(wire: &crate::wire::ImmutableNodeAttributes<'de>) -> Self {
7543 Self {
7544 protocols: wire.table.get(1).map(|envelope| {
7545 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
7546 envelope.deref_unchecked::<crate::wire::NodeProtocolKinds>()
7547 })
7548 }),
7549
7550 abilities: wire.table.get(2).map(|envelope| {
7551 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
7552 envelope.deref_unchecked::<crate::wire::Operations>()
7553 })
7554 }),
7555
7556 content_size: wire.table.get(3).map(|envelope| {
7557 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
7558 envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
7559 })
7560 }),
7561
7562 storage_size: wire.table.get(4).map(|envelope| {
7563 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
7564 envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
7565 })
7566 }),
7567
7568 link_count: wire.table.get(5).map(|envelope| {
7569 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
7570 envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
7571 })
7572 }),
7573
7574 id: wire.table.get(6).map(|envelope| {
7575 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
7576 envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
7577 })
7578 }),
7579
7580 change_time: wire.table.get(7).map(|envelope| {
7581 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
7582 envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
7583 })
7584 }),
7585
7586 options: wire.table.get(8).map(|envelope| {
7587 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
7588 envelope.deref_unchecked::<crate::wire::VerificationOptions<'de>>()
7589 })
7590 }),
7591
7592 root_hash: wire.table.get(9).map(|envelope| {
7593 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
7594 envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
7595 })
7596 }),
7597
7598 verity_enabled: wire.table.get(10).map(|envelope| {
7599 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
7600 envelope.deref_unchecked::<bool>()
7601 })
7602 }),
7603 }
7604 }
7605 }
7606
7607 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7608 pub struct NodeAttributes2 {
7609 pub mutable_attributes: crate::natural::MutableNodeAttributes,
7610
7611 pub immutable_attributes: crate::natural::ImmutableNodeAttributes,
7612 }
7613
7614 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeAttributes2<'static>, ___E>
7615 for NodeAttributes2
7616 where
7617 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7618 ___E: ::fidl_next::Encoder,
7619 {
7620 #[inline]
7621 fn encode(
7622 self,
7623 encoder_: &mut ___E,
7624 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributes2<'static>>,
7625 _: (),
7626 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7627 ::fidl_next::munge! {
7628 let crate::wire::NodeAttributes2 {
7629 mutable_attributes,
7630 immutable_attributes,
7631
7632 } = out_;
7633 }
7634
7635 ::fidl_next::Encode::encode(self.mutable_attributes, encoder_, mutable_attributes, ())?;
7636
7637 let mut _field =
7638 unsafe { ::fidl_next::Slot::new_unchecked(mutable_attributes.as_mut_ptr()) };
7639
7640 ::fidl_next::Encode::encode(
7641 self.immutable_attributes,
7642 encoder_,
7643 immutable_attributes,
7644 (),
7645 )?;
7646
7647 let mut _field =
7648 unsafe { ::fidl_next::Slot::new_unchecked(immutable_attributes.as_mut_ptr()) };
7649
7650 Ok(())
7651 }
7652 }
7653
7654 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeAttributes2<'static>, ___E>
7655 for &'a NodeAttributes2
7656 where
7657 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7658 ___E: ::fidl_next::Encoder,
7659 {
7660 #[inline]
7661 fn encode(
7662 self,
7663 encoder_: &mut ___E,
7664 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributes2<'static>>,
7665 _: (),
7666 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7667 ::fidl_next::munge! {
7668 let crate::wire::NodeAttributes2 {
7669
7670 mutable_attributes,
7671 immutable_attributes,
7672
7673 } = out_;
7674 }
7675
7676 ::fidl_next::Encode::encode(
7677 &self.mutable_attributes,
7678 encoder_,
7679 mutable_attributes,
7680 (),
7681 )?;
7682
7683 let mut _field =
7684 unsafe { ::fidl_next::Slot::new_unchecked(mutable_attributes.as_mut_ptr()) };
7685
7686 ::fidl_next::Encode::encode(
7687 &self.immutable_attributes,
7688 encoder_,
7689 immutable_attributes,
7690 (),
7691 )?;
7692
7693 let mut _field =
7694 unsafe { ::fidl_next::Slot::new_unchecked(immutable_attributes.as_mut_ptr()) };
7695
7696 Ok(())
7697 }
7698 }
7699
7700 unsafe impl<___E>
7701 ::fidl_next::EncodeOption<
7702 ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes2<'static>>,
7703 ___E,
7704 > for NodeAttributes2
7705 where
7706 ___E: ::fidl_next::Encoder + ?Sized,
7707 NodeAttributes2: ::fidl_next::Encode<crate::wire::NodeAttributes2<'static>, ___E>,
7708 {
7709 #[inline]
7710 fn encode_option(
7711 this: ::core::option::Option<Self>,
7712 encoder: &mut ___E,
7713 out: &mut ::core::mem::MaybeUninit<
7714 ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes2<'static>>,
7715 >,
7716 _: (),
7717 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7718 if let Some(inner) = this {
7719 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7720 ::fidl_next::wire::Box::encode_present(out);
7721 } else {
7722 ::fidl_next::wire::Box::encode_absent(out);
7723 }
7724
7725 Ok(())
7726 }
7727 }
7728
7729 unsafe impl<'a, ___E>
7730 ::fidl_next::EncodeOption<
7731 ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes2<'static>>,
7732 ___E,
7733 > for &'a NodeAttributes2
7734 where
7735 ___E: ::fidl_next::Encoder + ?Sized,
7736 &'a NodeAttributes2: ::fidl_next::Encode<crate::wire::NodeAttributes2<'static>, ___E>,
7737 {
7738 #[inline]
7739 fn encode_option(
7740 this: ::core::option::Option<Self>,
7741 encoder: &mut ___E,
7742 out: &mut ::core::mem::MaybeUninit<
7743 ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes2<'static>>,
7744 >,
7745 _: (),
7746 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7747 if let Some(inner) = this {
7748 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7749 ::fidl_next::wire::Box::encode_present(out);
7750 } else {
7751 ::fidl_next::wire::Box::encode_absent(out);
7752 }
7753
7754 Ok(())
7755 }
7756 }
7757
7758 impl<'de> ::fidl_next::FromWire<crate::wire::NodeAttributes2<'de>> for NodeAttributes2 {
7759 #[inline]
7760 fn from_wire(wire: crate::wire::NodeAttributes2<'de>) -> Self {
7761 Self {
7762 mutable_attributes: ::fidl_next::FromWire::from_wire(wire.mutable_attributes),
7763
7764 immutable_attributes: ::fidl_next::FromWire::from_wire(wire.immutable_attributes),
7765 }
7766 }
7767 }
7768
7769 impl<'de> ::fidl_next::FromWireRef<crate::wire::NodeAttributes2<'de>> for NodeAttributes2 {
7770 #[inline]
7771 fn from_wire_ref(wire: &crate::wire::NodeAttributes2<'de>) -> Self {
7772 Self {
7773 mutable_attributes: ::fidl_next::FromWireRef::from_wire_ref(
7774 &wire.mutable_attributes,
7775 ),
7776
7777 immutable_attributes: ::fidl_next::FromWireRef::from_wire_ref(
7778 &wire.immutable_attributes,
7779 ),
7780 }
7781 }
7782 }
7783
7784 #[doc = " Information that describes the target node.\n"]
7785 #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7786 pub struct NodeInfo {
7787 pub attributes: ::core::option::Option<crate::natural::NodeAttributes2>,
7788 }
7789
7790 impl NodeInfo {
7791 fn __max_ordinal(&self) -> usize {
7792 if self.attributes.is_some() {
7793 return 1;
7794 }
7795
7796 0
7797 }
7798 }
7799
7800 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeInfo<'static>, ___E> for NodeInfo
7801 where
7802 ___E: ::fidl_next::Encoder + ?Sized,
7803 {
7804 #[inline]
7805 fn encode(
7806 mut self,
7807 encoder: &mut ___E,
7808 out: &mut ::core::mem::MaybeUninit<crate::wire::NodeInfo<'static>>,
7809 _: (),
7810 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7811 ::fidl_next::munge!(let crate::wire::NodeInfo { table } = out);
7812
7813 let max_ord = self.__max_ordinal();
7814
7815 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
7816 ::fidl_next::Wire::zero_padding(&mut out);
7817
7818 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
7819 ::fidl_next::wire::Envelope,
7820 >(encoder, max_ord);
7821
7822 for i in 1..=max_ord {
7823 match i {
7824 1 => {
7825 if let Some(value) = self.attributes.take() {
7826 ::fidl_next::wire::Envelope::encode_value::<
7827 crate::wire::NodeAttributes2<'static>,
7828 ___E,
7829 >(
7830 value, preallocated.encoder, &mut out, ()
7831 )?;
7832 } else {
7833 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7834 }
7835 }
7836
7837 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
7838 }
7839 unsafe {
7840 preallocated.write_next(out.assume_init_ref());
7841 }
7842 }
7843
7844 ::fidl_next::wire::Table::encode_len(table, max_ord);
7845
7846 Ok(())
7847 }
7848 }
7849
7850 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeInfo<'static>, ___E> for &'a NodeInfo
7851 where
7852 ___E: ::fidl_next::Encoder + ?Sized,
7853 {
7854 #[inline]
7855 fn encode(
7856 self,
7857 encoder: &mut ___E,
7858 out: &mut ::core::mem::MaybeUninit<crate::wire::NodeInfo<'static>>,
7859 _: (),
7860 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7861 ::fidl_next::munge!(let crate::wire::NodeInfo { table } = out);
7862
7863 let max_ord = self.__max_ordinal();
7864
7865 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
7866 ::fidl_next::Wire::zero_padding(&mut out);
7867
7868 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
7869 ::fidl_next::wire::Envelope,
7870 >(encoder, max_ord);
7871
7872 for i in 1..=max_ord {
7873 match i {
7874 1 => {
7875 if let Some(value) = &self.attributes {
7876 ::fidl_next::wire::Envelope::encode_value::<
7877 crate::wire::NodeAttributes2<'static>,
7878 ___E,
7879 >(
7880 value, preallocated.encoder, &mut out, ()
7881 )?;
7882 } else {
7883 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7884 }
7885 }
7886
7887 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
7888 }
7889 unsafe {
7890 preallocated.write_next(out.assume_init_ref());
7891 }
7892 }
7893
7894 ::fidl_next::wire::Table::encode_len(table, max_ord);
7895
7896 Ok(())
7897 }
7898 }
7899
7900 impl<'de> ::fidl_next::FromWire<crate::wire::NodeInfo<'de>> for NodeInfo {
7901 #[inline]
7902 fn from_wire(wire_: crate::wire::NodeInfo<'de>) -> Self {
7903 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
7904
7905 let attributes = wire_.table.get(1);
7906
7907 Self {
7908 attributes: attributes.map(|envelope| {
7909 ::fidl_next::FromWire::from_wire(unsafe {
7910 envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
7911 })
7912 }),
7913 }
7914 }
7915 }
7916
7917 impl<'de> ::fidl_next::FromWireRef<crate::wire::NodeInfo<'de>> for NodeInfo {
7918 #[inline]
7919 fn from_wire_ref(wire: &crate::wire::NodeInfo<'de>) -> Self {
7920 Self {
7921 attributes: wire.table.get(1).map(|envelope| {
7922 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
7923 envelope.deref_unchecked::<crate::wire::NodeAttributes2<'de>>()
7924 })
7925 }),
7926 }
7927 }
7928 }
7929
7930 #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7931 pub struct DirectoryInfo {
7932 pub attributes: ::core::option::Option<crate::natural::NodeAttributes2>,
7933 }
7934
7935 impl DirectoryInfo {
7936 fn __max_ordinal(&self) -> usize {
7937 if self.attributes.is_some() {
7938 return 1;
7939 }
7940
7941 0
7942 }
7943 }
7944
7945 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryInfo<'static>, ___E> for DirectoryInfo
7946 where
7947 ___E: ::fidl_next::Encoder + ?Sized,
7948 {
7949 #[inline]
7950 fn encode(
7951 mut self,
7952 encoder: &mut ___E,
7953 out: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryInfo<'static>>,
7954 _: (),
7955 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7956 ::fidl_next::munge!(let crate::wire::DirectoryInfo { table } = out);
7957
7958 let max_ord = self.__max_ordinal();
7959
7960 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
7961 ::fidl_next::Wire::zero_padding(&mut out);
7962
7963 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
7964 ::fidl_next::wire::Envelope,
7965 >(encoder, max_ord);
7966
7967 for i in 1..=max_ord {
7968 match i {
7969 1 => {
7970 if let Some(value) = self.attributes.take() {
7971 ::fidl_next::wire::Envelope::encode_value::<
7972 crate::wire::NodeAttributes2<'static>,
7973 ___E,
7974 >(
7975 value, preallocated.encoder, &mut out, ()
7976 )?;
7977 } else {
7978 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7979 }
7980 }
7981
7982 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
7983 }
7984 unsafe {
7985 preallocated.write_next(out.assume_init_ref());
7986 }
7987 }
7988
7989 ::fidl_next::wire::Table::encode_len(table, max_ord);
7990
7991 Ok(())
7992 }
7993 }
7994
7995 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryInfo<'static>, ___E>
7996 for &'a DirectoryInfo
7997 where
7998 ___E: ::fidl_next::Encoder + ?Sized,
7999 {
8000 #[inline]
8001 fn encode(
8002 self,
8003 encoder: &mut ___E,
8004 out: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryInfo<'static>>,
8005 _: (),
8006 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8007 ::fidl_next::munge!(let crate::wire::DirectoryInfo { table } = out);
8008
8009 let max_ord = self.__max_ordinal();
8010
8011 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
8012 ::fidl_next::Wire::zero_padding(&mut out);
8013
8014 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
8015 ::fidl_next::wire::Envelope,
8016 >(encoder, max_ord);
8017
8018 for i in 1..=max_ord {
8019 match i {
8020 1 => {
8021 if let Some(value) = &self.attributes {
8022 ::fidl_next::wire::Envelope::encode_value::<
8023 crate::wire::NodeAttributes2<'static>,
8024 ___E,
8025 >(
8026 value, preallocated.encoder, &mut out, ()
8027 )?;
8028 } else {
8029 ::fidl_next::wire::Envelope::encode_zero(&mut out)
8030 }
8031 }
8032
8033 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
8034 }
8035 unsafe {
8036 preallocated.write_next(out.assume_init_ref());
8037 }
8038 }
8039
8040 ::fidl_next::wire::Table::encode_len(table, max_ord);
8041
8042 Ok(())
8043 }
8044 }
8045
8046 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryInfo<'de>> for DirectoryInfo {
8047 #[inline]
8048 fn from_wire(wire_: crate::wire::DirectoryInfo<'de>) -> Self {
8049 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
8050
8051 let attributes = wire_.table.get(1);
8052
8053 Self {
8054 attributes: attributes.map(|envelope| {
8055 ::fidl_next::FromWire::from_wire(unsafe {
8056 envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
8057 })
8058 }),
8059 }
8060 }
8061 }
8062
8063 impl<'de> ::fidl_next::FromWireRef<crate::wire::DirectoryInfo<'de>> for DirectoryInfo {
8064 #[inline]
8065 fn from_wire_ref(wire: &crate::wire::DirectoryInfo<'de>) -> Self {
8066 Self {
8067 attributes: wire.table.get(1).map(|envelope| {
8068 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
8069 envelope.deref_unchecked::<crate::wire::NodeAttributes2<'de>>()
8070 })
8071 }),
8072 }
8073 }
8074 }
8075
8076 #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8077 pub struct SymlinkInfo {
8078 pub target: ::core::option::Option<::std::vec::Vec<u8>>,
8079
8080 pub attributes: ::core::option::Option<crate::natural::NodeAttributes2>,
8081 }
8082
8083 impl SymlinkInfo {
8084 fn __max_ordinal(&self) -> usize {
8085 if self.attributes.is_some() {
8086 return 2;
8087 }
8088
8089 if self.target.is_some() {
8090 return 1;
8091 }
8092
8093 0
8094 }
8095 }
8096
8097 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SymlinkInfo<'static>, ___E> for SymlinkInfo
8098 where
8099 ___E: ::fidl_next::Encoder + ?Sized,
8100 {
8101 #[inline]
8102 fn encode(
8103 mut self,
8104 encoder: &mut ___E,
8105 out: &mut ::core::mem::MaybeUninit<crate::wire::SymlinkInfo<'static>>,
8106 _: (),
8107 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8108 ::fidl_next::munge!(let crate::wire::SymlinkInfo { table } = out);
8109
8110 let max_ord = self.__max_ordinal();
8111
8112 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
8113 ::fidl_next::Wire::zero_padding(&mut out);
8114
8115 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
8116 ::fidl_next::wire::Envelope,
8117 >(encoder, max_ord);
8118
8119 for i in 1..=max_ord {
8120 match i {
8121 2 => {
8122 if let Some(value) = self.attributes.take() {
8123 ::fidl_next::wire::Envelope::encode_value::<
8124 crate::wire::NodeAttributes2<'static>,
8125 ___E,
8126 >(
8127 value, preallocated.encoder, &mut out, ()
8128 )?;
8129 } else {
8130 ::fidl_next::wire::Envelope::encode_zero(&mut out)
8131 }
8132 }
8133
8134 1 => {
8135 if let Some(value) = self.target.take() {
8136 ::fidl_next::wire::Envelope::encode_value::<
8137 ::fidl_next::wire::Vector<'static, u8>,
8138 ___E,
8139 >(
8140 value, preallocated.encoder, &mut out, (4095, ())
8141 )?;
8142 } else {
8143 ::fidl_next::wire::Envelope::encode_zero(&mut out)
8144 }
8145 }
8146
8147 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
8148 }
8149 unsafe {
8150 preallocated.write_next(out.assume_init_ref());
8151 }
8152 }
8153
8154 ::fidl_next::wire::Table::encode_len(table, max_ord);
8155
8156 Ok(())
8157 }
8158 }
8159
8160 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SymlinkInfo<'static>, ___E>
8161 for &'a SymlinkInfo
8162 where
8163 ___E: ::fidl_next::Encoder + ?Sized,
8164 {
8165 #[inline]
8166 fn encode(
8167 self,
8168 encoder: &mut ___E,
8169 out: &mut ::core::mem::MaybeUninit<crate::wire::SymlinkInfo<'static>>,
8170 _: (),
8171 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8172 ::fidl_next::munge!(let crate::wire::SymlinkInfo { table } = out);
8173
8174 let max_ord = self.__max_ordinal();
8175
8176 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
8177 ::fidl_next::Wire::zero_padding(&mut out);
8178
8179 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
8180 ::fidl_next::wire::Envelope,
8181 >(encoder, max_ord);
8182
8183 for i in 1..=max_ord {
8184 match i {
8185 2 => {
8186 if let Some(value) = &self.attributes {
8187 ::fidl_next::wire::Envelope::encode_value::<
8188 crate::wire::NodeAttributes2<'static>,
8189 ___E,
8190 >(
8191 value, preallocated.encoder, &mut out, ()
8192 )?;
8193 } else {
8194 ::fidl_next::wire::Envelope::encode_zero(&mut out)
8195 }
8196 }
8197
8198 1 => {
8199 if let Some(value) = &self.target {
8200 ::fidl_next::wire::Envelope::encode_value::<
8201 ::fidl_next::wire::Vector<'static, u8>,
8202 ___E,
8203 >(
8204 value, preallocated.encoder, &mut out, (4095, ())
8205 )?;
8206 } else {
8207 ::fidl_next::wire::Envelope::encode_zero(&mut out)
8208 }
8209 }
8210
8211 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
8212 }
8213 unsafe {
8214 preallocated.write_next(out.assume_init_ref());
8215 }
8216 }
8217
8218 ::fidl_next::wire::Table::encode_len(table, max_ord);
8219
8220 Ok(())
8221 }
8222 }
8223
8224 impl<'de> ::fidl_next::FromWire<crate::wire::SymlinkInfo<'de>> for SymlinkInfo {
8225 #[inline]
8226 fn from_wire(wire_: crate::wire::SymlinkInfo<'de>) -> Self {
8227 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
8228
8229 let target = wire_.table.get(1);
8230
8231 let attributes = wire_.table.get(2);
8232
8233 Self {
8234 target: target.map(|envelope| {
8235 ::fidl_next::FromWire::from_wire(unsafe {
8236 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
8237 })
8238 }),
8239
8240 attributes: attributes.map(|envelope| {
8241 ::fidl_next::FromWire::from_wire(unsafe {
8242 envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
8243 })
8244 }),
8245 }
8246 }
8247 }
8248
8249 impl<'de> ::fidl_next::FromWireRef<crate::wire::SymlinkInfo<'de>> for SymlinkInfo {
8250 #[inline]
8251 fn from_wire_ref(wire: &crate::wire::SymlinkInfo<'de>) -> Self {
8252 Self {
8253 target: wire.table.get(1).map(|envelope| {
8254 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
8255 envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
8256 })
8257 }),
8258
8259 attributes: wire.table.get(2).map(|envelope| {
8260 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
8261 envelope.deref_unchecked::<crate::wire::NodeAttributes2<'de>>()
8262 })
8263 }),
8264 }
8265 }
8266 }
8267
8268 ::fidl_next::bitflags::bitflags! {
8269 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct NodeAttributesQuery: u64 {
8270 #[doc = " Requests [`NodeAttributes.protocols`].\n"]const PROTOCOLS = 1;
8271 #[doc = " Requests [`NodeAttributes.abilities`].\n"]const ABILITIES = 2;
8272 #[doc = " Requests [`NodeAttributes.content_size`].\n"]const CONTENT_SIZE = 4;
8273 #[doc = " Requests [`NodeAttributes.storage_size`].\n"]const STORAGE_SIZE = 8;
8274 #[doc = " Requests [`NodeAttributes.link_count`].\n"]const LINK_COUNT = 16;
8275 #[doc = " Requests [`NodeAttributes.id`].\n"]const ID = 32;
8276 #[doc = " Requests [`NodeAttributes.creation_time`].\n"]const CREATION_TIME = 64;
8277 #[doc = " Requests [`NodeAttributes.modification_time`].\n"]const MODIFICATION_TIME = 128;
8278 #[doc = " Posix attributes.\n"]const MODE = 256;
8279 const UID = 512;
8280 const GID = 1024;
8281 const RDEV = 2048;
8282 const ACCESS_TIME = 4096;
8283 const CHANGE_TIME = 8192;
8284 #[doc = " Verity attributes.\n"]const OPTIONS = 16384;
8285 const ROOT_HASH = 32768;
8286 const VERITY_ENABLED = 65536;
8287 #[doc = " Casefold (case-insensitive filename) support.\n When true, file lookups will be case-insensitive but case-preserving. i.e. \"Foo\" will\n be stored verbatim but can be opened as \"foo\", \"fOO\", etc. Casefolding is done in\n accordance to the Unicode 12 NFD normalization and casefolding standard.\n"]const CASEFOLD = 131072;
8288 #[doc = " Requests [`MutableNodeAttributes.selinux_context`]. See that field for more detail.\n"]const SELINUX_CONTEXT = 262144;
8289 #[doc = " fscrypt attribute.\n"]const WRAPPING_KEY_ID = 524288;
8290 #[doc = " When this is queried in [`fuchsia.io/Node.GetAttributes`], it indicates to the filesystem\n that this node has been accessed and is pending an access time update given that any one of\n the following conditions are met:\n * current_access_time <= current_modification_time\n * current_access_time <= current_change_time\n * current_access_time < current_time - duration(1 day)\n\n If any of the above conditions are met, `access_time` is updated to the current time before\n any queried node attributes are returned.\n\n This is compatible with Linux relatime mount.\n\n The rationale behind adding this `NodeAttributesQuery` is that some filesystems, e.g. Fxfs,\n are unable to identify when a file access has occured and thus update the access time. We\n allow for clients to communicate to the underlying filesystem that a file access has\n occurred and that it awaits for an update to access time.\n\n WARNING: If this is queried without a prior file access, as long as the above conditions\n are met, the node\'s access time will be updated. Not all filesystems will support this. The\n query will be ignored if the filesystem does not support this.\n"]const PENDING_ACCESS_TIME_UPDATE = 1048576;
8291 const _ = !0;
8292 }
8293 }
8294
8295 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeAttributesQuery, ___E>
8296 for NodeAttributesQuery
8297 where
8298 ___E: ?Sized,
8299 {
8300 #[inline]
8301 fn encode(
8302 self,
8303 encoder: &mut ___E,
8304 out: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributesQuery>,
8305 _: (),
8306 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8307 ::fidl_next::Encode::encode(&self, encoder, out, ())
8308 }
8309 }
8310
8311 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeAttributesQuery, ___E>
8312 for &'a NodeAttributesQuery
8313 where
8314 ___E: ?Sized,
8315 {
8316 #[inline]
8317 fn encode(
8318 self,
8319 _: &mut ___E,
8320 out: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributesQuery>,
8321 _: (),
8322 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8323 ::fidl_next::munge!(let crate::wire::NodeAttributesQuery { value } = out);
8324
8325 let _ = value.write(::fidl_next::wire::Uint64::from(self.bits()));
8326 Ok(())
8327 }
8328 }
8329
8330 impl ::core::convert::From<crate::wire::NodeAttributesQuery> for NodeAttributesQuery {
8331 fn from(wire: crate::wire::NodeAttributesQuery) -> Self {
8332 Self::from_bits_retain(u64::from(wire.value))
8333 }
8334 }
8335
8336 impl ::fidl_next::FromWire<crate::wire::NodeAttributesQuery> for NodeAttributesQuery {
8337 #[inline]
8338 fn from_wire(wire: crate::wire::NodeAttributesQuery) -> Self {
8339 Self::from(wire)
8340 }
8341 }
8342
8343 impl ::fidl_next::FromWireRef<crate::wire::NodeAttributesQuery> for NodeAttributesQuery {
8344 #[inline]
8345 fn from_wire_ref(wire: &crate::wire::NodeAttributesQuery) -> Self {
8346 Self::from(*wire)
8347 }
8348 }
8349
8350 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8351 #[repr(C)]
8352 pub struct NodeGetAttributesRequest {
8353 pub query: crate::natural::NodeAttributesQuery,
8354 }
8355
8356 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeGetAttributesRequest, ___E>
8357 for NodeGetAttributesRequest
8358 where
8359 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8360 {
8361 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
8362 Self,
8363 crate::wire::NodeGetAttributesRequest,
8364 > = unsafe {
8365 ::fidl_next::CopyOptimization::enable_if(
8366 true && <crate::natural::NodeAttributesQuery as ::fidl_next::Encode<
8367 crate::wire::NodeAttributesQuery,
8368 ___E,
8369 >>::COPY_OPTIMIZATION
8370 .is_enabled(),
8371 )
8372 };
8373
8374 #[inline]
8375 fn encode(
8376 self,
8377 encoder_: &mut ___E,
8378 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetAttributesRequest>,
8379 _: (),
8380 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8381 ::fidl_next::munge! {
8382 let crate::wire::NodeGetAttributesRequest {
8383 query,
8384
8385 } = out_;
8386 }
8387
8388 ::fidl_next::Encode::encode(self.query, encoder_, query, ())?;
8389
8390 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(query.as_mut_ptr()) };
8391
8392 Ok(())
8393 }
8394 }
8395
8396 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeGetAttributesRequest, ___E>
8397 for &'a NodeGetAttributesRequest
8398 where
8399 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8400 {
8401 #[inline]
8402 fn encode(
8403 self,
8404 encoder_: &mut ___E,
8405 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetAttributesRequest>,
8406 _: (),
8407 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8408 ::fidl_next::munge! {
8409 let crate::wire::NodeGetAttributesRequest {
8410
8411 query,
8412
8413 } = out_;
8414 }
8415
8416 ::fidl_next::Encode::encode(&self.query, encoder_, query, ())?;
8417
8418 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(query.as_mut_ptr()) };
8419
8420 Ok(())
8421 }
8422 }
8423
8424 unsafe impl<___E>
8425 ::fidl_next::EncodeOption<
8426 ::fidl_next::wire::Box<'static, crate::wire::NodeGetAttributesRequest>,
8427 ___E,
8428 > for NodeGetAttributesRequest
8429 where
8430 ___E: ::fidl_next::Encoder + ?Sized,
8431 NodeGetAttributesRequest: ::fidl_next::Encode<crate::wire::NodeGetAttributesRequest, ___E>,
8432 {
8433 #[inline]
8434 fn encode_option(
8435 this: ::core::option::Option<Self>,
8436 encoder: &mut ___E,
8437 out: &mut ::core::mem::MaybeUninit<
8438 ::fidl_next::wire::Box<'static, crate::wire::NodeGetAttributesRequest>,
8439 >,
8440 _: (),
8441 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8442 if let Some(inner) = this {
8443 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8444 ::fidl_next::wire::Box::encode_present(out);
8445 } else {
8446 ::fidl_next::wire::Box::encode_absent(out);
8447 }
8448
8449 Ok(())
8450 }
8451 }
8452
8453 unsafe impl<'a, ___E>
8454 ::fidl_next::EncodeOption<
8455 ::fidl_next::wire::Box<'static, crate::wire::NodeGetAttributesRequest>,
8456 ___E,
8457 > for &'a NodeGetAttributesRequest
8458 where
8459 ___E: ::fidl_next::Encoder + ?Sized,
8460 &'a NodeGetAttributesRequest:
8461 ::fidl_next::Encode<crate::wire::NodeGetAttributesRequest, ___E>,
8462 {
8463 #[inline]
8464 fn encode_option(
8465 this: ::core::option::Option<Self>,
8466 encoder: &mut ___E,
8467 out: &mut ::core::mem::MaybeUninit<
8468 ::fidl_next::wire::Box<'static, crate::wire::NodeGetAttributesRequest>,
8469 >,
8470 _: (),
8471 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8472 if let Some(inner) = this {
8473 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8474 ::fidl_next::wire::Box::encode_present(out);
8475 } else {
8476 ::fidl_next::wire::Box::encode_absent(out);
8477 }
8478
8479 Ok(())
8480 }
8481 }
8482
8483 impl ::fidl_next::FromWire<crate::wire::NodeGetAttributesRequest> for NodeGetAttributesRequest {
8484 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
8485 crate::wire::NodeGetAttributesRequest,
8486 Self,
8487 > = unsafe {
8488 ::fidl_next::CopyOptimization::enable_if(
8489 true && <crate::natural::NodeAttributesQuery as ::fidl_next::FromWire<
8490 crate::wire::NodeAttributesQuery,
8491 >>::COPY_OPTIMIZATION
8492 .is_enabled(),
8493 )
8494 };
8495
8496 #[inline]
8497 fn from_wire(wire: crate::wire::NodeGetAttributesRequest) -> Self {
8498 Self { query: ::fidl_next::FromWire::from_wire(wire.query) }
8499 }
8500 }
8501
8502 impl ::fidl_next::FromWireRef<crate::wire::NodeGetAttributesRequest> for NodeGetAttributesRequest {
8503 #[inline]
8504 fn from_wire_ref(wire: &crate::wire::NodeGetAttributesRequest) -> Self {
8505 Self { query: ::fidl_next::FromWireRef::from_wire_ref(&wire.query) }
8506 }
8507 }
8508
8509 #[doc = " Options which can be used when opening nodes. Unlike [`Flags`], these options are designed for\n specific use cases (e.g. to reduce round-trip latency when requesting attributes).\n"]
8510 #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8511 pub struct Options {
8512 pub attributes: ::core::option::Option<crate::natural::NodeAttributesQuery>,
8513
8514 pub create_attributes: ::core::option::Option<crate::natural::MutableNodeAttributes>,
8515 }
8516
8517 impl Options {
8518 fn __max_ordinal(&self) -> usize {
8519 if self.create_attributes.is_some() {
8520 return 2;
8521 }
8522
8523 if self.attributes.is_some() {
8524 return 1;
8525 }
8526
8527 0
8528 }
8529 }
8530
8531 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Options<'static>, ___E> for Options
8532 where
8533 ___E: ::fidl_next::Encoder + ?Sized,
8534 {
8535 #[inline]
8536 fn encode(
8537 mut self,
8538 encoder: &mut ___E,
8539 out: &mut ::core::mem::MaybeUninit<crate::wire::Options<'static>>,
8540 _: (),
8541 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8542 ::fidl_next::munge!(let crate::wire::Options { table } = out);
8543
8544 let max_ord = self.__max_ordinal();
8545
8546 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
8547 ::fidl_next::Wire::zero_padding(&mut out);
8548
8549 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
8550 ::fidl_next::wire::Envelope,
8551 >(encoder, max_ord);
8552
8553 for i in 1..=max_ord {
8554 match i {
8555 2 => {
8556 if let Some(value) = self.create_attributes.take() {
8557 ::fidl_next::wire::Envelope::encode_value::<
8558 crate::wire::MutableNodeAttributes<'static>,
8559 ___E,
8560 >(
8561 value, preallocated.encoder, &mut out, ()
8562 )?;
8563 } else {
8564 ::fidl_next::wire::Envelope::encode_zero(&mut out)
8565 }
8566 }
8567
8568 1 => {
8569 if let Some(value) = self.attributes.take() {
8570 ::fidl_next::wire::Envelope::encode_value::<
8571 crate::wire::NodeAttributesQuery,
8572 ___E,
8573 >(
8574 value, preallocated.encoder, &mut out, ()
8575 )?;
8576 } else {
8577 ::fidl_next::wire::Envelope::encode_zero(&mut out)
8578 }
8579 }
8580
8581 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
8582 }
8583 unsafe {
8584 preallocated.write_next(out.assume_init_ref());
8585 }
8586 }
8587
8588 ::fidl_next::wire::Table::encode_len(table, max_ord);
8589
8590 Ok(())
8591 }
8592 }
8593
8594 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Options<'static>, ___E> for &'a Options
8595 where
8596 ___E: ::fidl_next::Encoder + ?Sized,
8597 {
8598 #[inline]
8599 fn encode(
8600 self,
8601 encoder: &mut ___E,
8602 out: &mut ::core::mem::MaybeUninit<crate::wire::Options<'static>>,
8603 _: (),
8604 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8605 ::fidl_next::munge!(let crate::wire::Options { table } = out);
8606
8607 let max_ord = self.__max_ordinal();
8608
8609 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
8610 ::fidl_next::Wire::zero_padding(&mut out);
8611
8612 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
8613 ::fidl_next::wire::Envelope,
8614 >(encoder, max_ord);
8615
8616 for i in 1..=max_ord {
8617 match i {
8618 2 => {
8619 if let Some(value) = &self.create_attributes {
8620 ::fidl_next::wire::Envelope::encode_value::<
8621 crate::wire::MutableNodeAttributes<'static>,
8622 ___E,
8623 >(
8624 value, preallocated.encoder, &mut out, ()
8625 )?;
8626 } else {
8627 ::fidl_next::wire::Envelope::encode_zero(&mut out)
8628 }
8629 }
8630
8631 1 => {
8632 if let Some(value) = &self.attributes {
8633 ::fidl_next::wire::Envelope::encode_value::<
8634 crate::wire::NodeAttributesQuery,
8635 ___E,
8636 >(
8637 value, preallocated.encoder, &mut out, ()
8638 )?;
8639 } else {
8640 ::fidl_next::wire::Envelope::encode_zero(&mut out)
8641 }
8642 }
8643
8644 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
8645 }
8646 unsafe {
8647 preallocated.write_next(out.assume_init_ref());
8648 }
8649 }
8650
8651 ::fidl_next::wire::Table::encode_len(table, max_ord);
8652
8653 Ok(())
8654 }
8655 }
8656
8657 impl<'de> ::fidl_next::FromWire<crate::wire::Options<'de>> for Options {
8658 #[inline]
8659 fn from_wire(wire_: crate::wire::Options<'de>) -> Self {
8660 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
8661
8662 let attributes = wire_.table.get(1);
8663
8664 let create_attributes = wire_.table.get(2);
8665
8666 Self {
8667 attributes: attributes.map(|envelope| {
8668 ::fidl_next::FromWire::from_wire(unsafe {
8669 envelope.read_unchecked::<crate::wire::NodeAttributesQuery>()
8670 })
8671 }),
8672
8673 create_attributes: create_attributes.map(|envelope| {
8674 ::fidl_next::FromWire::from_wire(unsafe {
8675 envelope.read_unchecked::<crate::wire::MutableNodeAttributes<'de>>()
8676 })
8677 }),
8678 }
8679 }
8680 }
8681
8682 impl<'de> ::fidl_next::FromWireRef<crate::wire::Options<'de>> for Options {
8683 #[inline]
8684 fn from_wire_ref(wire: &crate::wire::Options<'de>) -> Self {
8685 Self {
8686 attributes: wire.table.get(1).map(|envelope| {
8687 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
8688 envelope.deref_unchecked::<crate::wire::NodeAttributesQuery>()
8689 })
8690 }),
8691
8692 create_attributes: wire.table.get(2).map(|envelope| {
8693 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
8694 envelope.deref_unchecked::<crate::wire::MutableNodeAttributes<'de>>()
8695 })
8696 }),
8697 }
8698 }
8699 }
8700
8701 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8702 #[repr(C)]
8703 pub struct DirectoryObject {}
8704
8705 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryObject, ___E> for DirectoryObject
8706 where
8707 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8708 {
8709 #[inline]
8710 fn encode(
8711 self,
8712 encoder_: &mut ___E,
8713 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryObject>,
8714 _: (),
8715 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8716 ::fidl_next::munge! {
8717 let crate::wire::DirectoryObject {
8718
8719 _empty,
8720
8721 } = out_;
8722 }
8723
8724 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
8725
8726 Ok(())
8727 }
8728 }
8729
8730 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryObject, ___E>
8731 for &'a DirectoryObject
8732 where
8733 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8734 {
8735 #[inline]
8736 fn encode(
8737 self,
8738 encoder_: &mut ___E,
8739 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryObject>,
8740 _: (),
8741 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8742 ::fidl_next::munge! {
8743 let crate::wire::DirectoryObject {
8744
8745 _empty,
8746
8747
8748 } = out_;
8749 }
8750
8751 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
8752
8753 Ok(())
8754 }
8755 }
8756
8757 unsafe impl<___E>
8758 ::fidl_next::EncodeOption<
8759 ::fidl_next::wire::Box<'static, crate::wire::DirectoryObject>,
8760 ___E,
8761 > for DirectoryObject
8762 where
8763 ___E: ::fidl_next::Encoder + ?Sized,
8764 DirectoryObject: ::fidl_next::Encode<crate::wire::DirectoryObject, ___E>,
8765 {
8766 #[inline]
8767 fn encode_option(
8768 this: ::core::option::Option<Self>,
8769 encoder: &mut ___E,
8770 out: &mut ::core::mem::MaybeUninit<
8771 ::fidl_next::wire::Box<'static, crate::wire::DirectoryObject>,
8772 >,
8773 _: (),
8774 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8775 if let Some(inner) = this {
8776 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8777 ::fidl_next::wire::Box::encode_present(out);
8778 } else {
8779 ::fidl_next::wire::Box::encode_absent(out);
8780 }
8781
8782 Ok(())
8783 }
8784 }
8785
8786 unsafe impl<'a, ___E>
8787 ::fidl_next::EncodeOption<
8788 ::fidl_next::wire::Box<'static, crate::wire::DirectoryObject>,
8789 ___E,
8790 > for &'a DirectoryObject
8791 where
8792 ___E: ::fidl_next::Encoder + ?Sized,
8793 &'a DirectoryObject: ::fidl_next::Encode<crate::wire::DirectoryObject, ___E>,
8794 {
8795 #[inline]
8796 fn encode_option(
8797 this: ::core::option::Option<Self>,
8798 encoder: &mut ___E,
8799 out: &mut ::core::mem::MaybeUninit<
8800 ::fidl_next::wire::Box<'static, crate::wire::DirectoryObject>,
8801 >,
8802 _: (),
8803 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8804 if let Some(inner) = this {
8805 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8806 ::fidl_next::wire::Box::encode_present(out);
8807 } else {
8808 ::fidl_next::wire::Box::encode_absent(out);
8809 }
8810
8811 Ok(())
8812 }
8813 }
8814
8815 impl ::fidl_next::FromWire<crate::wire::DirectoryObject> for DirectoryObject {
8816 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::DirectoryObject, Self> =
8817 unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
8818
8819 #[inline]
8820 fn from_wire(wire: crate::wire::DirectoryObject) -> Self {
8821 Self {}
8822 }
8823 }
8824
8825 impl ::fidl_next::FromWireRef<crate::wire::DirectoryObject> for DirectoryObject {
8826 #[inline]
8827 fn from_wire_ref(wire: &crate::wire::DirectoryObject) -> Self {
8828 Self {}
8829 }
8830 }
8831
8832 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8833 #[repr(u8)]
8834 pub enum DirentType {
8835 Unknown = 0,
8836 Directory = 4,
8837 BlockDevice = 6,
8838 File = 8,
8839 Symlink = 10,
8840 Service = 16,
8841 UnknownOrdinal_(u8) = 17,
8842 }
8843 impl ::std::convert::From<u8> for DirentType {
8844 fn from(value: u8) -> Self {
8845 match value {
8846 0 => Self::Unknown,
8847 4 => Self::Directory,
8848 6 => Self::BlockDevice,
8849 8 => Self::File,
8850 10 => Self::Symlink,
8851 16 => Self::Service,
8852
8853 _ => Self::UnknownOrdinal_(value),
8854 }
8855 }
8856 }
8857
8858 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirentType, ___E> for DirentType
8859 where
8860 ___E: ?Sized,
8861 {
8862 #[inline]
8863 fn encode(
8864 self,
8865 encoder: &mut ___E,
8866 out: &mut ::core::mem::MaybeUninit<crate::wire::DirentType>,
8867 _: (),
8868 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8869 ::fidl_next::Encode::encode(&self, encoder, out, ())
8870 }
8871 }
8872
8873 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirentType, ___E> for &'a DirentType
8874 where
8875 ___E: ?Sized,
8876 {
8877 #[inline]
8878 fn encode(
8879 self,
8880 encoder: &mut ___E,
8881 out: &mut ::core::mem::MaybeUninit<crate::wire::DirentType>,
8882 _: (),
8883 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8884 ::fidl_next::munge!(let crate::wire::DirentType { value } = out);
8885 let _ = value.write(u8::from(match *self {
8886 DirentType::Unknown => 0,
8887
8888 DirentType::Directory => 4,
8889
8890 DirentType::BlockDevice => 6,
8891
8892 DirentType::File => 8,
8893
8894 DirentType::Symlink => 10,
8895
8896 DirentType::Service => 16,
8897
8898 DirentType::UnknownOrdinal_(value) => value,
8899 }));
8900
8901 Ok(())
8902 }
8903 }
8904
8905 impl ::core::convert::From<crate::wire::DirentType> for DirentType {
8906 fn from(wire: crate::wire::DirentType) -> Self {
8907 match u8::from(wire.value) {
8908 0 => Self::Unknown,
8909
8910 4 => Self::Directory,
8911
8912 6 => Self::BlockDevice,
8913
8914 8 => Self::File,
8915
8916 10 => Self::Symlink,
8917
8918 16 => Self::Service,
8919
8920 value => Self::UnknownOrdinal_(value),
8921 }
8922 }
8923 }
8924
8925 impl ::fidl_next::FromWire<crate::wire::DirentType> for DirentType {
8926 #[inline]
8927 fn from_wire(wire: crate::wire::DirentType) -> Self {
8928 Self::from(wire)
8929 }
8930 }
8931
8932 impl ::fidl_next::FromWireRef<crate::wire::DirentType> for DirentType {
8933 #[inline]
8934 fn from_wire_ref(wire: &crate::wire::DirentType) -> Self {
8935 Self::from(*wire)
8936 }
8937 }
8938
8939 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8940 pub struct ExtendedAttributeIteratorGetNextResponse {
8941 pub attributes: ::std::vec::Vec<::std::vec::Vec<u8>>,
8942
8943 pub last: bool,
8944 }
8945
8946 unsafe impl<___E>
8947 ::fidl_next::Encode<crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>, ___E>
8948 for ExtendedAttributeIteratorGetNextResponse
8949 where
8950 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8951 ___E: ::fidl_next::Encoder,
8952 {
8953 #[inline]
8954 fn encode(
8955 self,
8956 encoder_: &mut ___E,
8957 out_: &mut ::core::mem::MaybeUninit<
8958 crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
8959 >,
8960 _: (),
8961 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8962 ::fidl_next::munge! {
8963 let crate::wire::ExtendedAttributeIteratorGetNextResponse {
8964 attributes,
8965 last,
8966
8967 } = out_;
8968 }
8969
8970 ::fidl_next::Encode::encode(self.attributes, encoder_, attributes, (128, (255, ())))?;
8971
8972 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(attributes.as_mut_ptr()) };
8973 ::fidl_next::Constrained::validate(_field, (128, (255, ())))?;
8974
8975 ::fidl_next::Encode::encode(self.last, encoder_, last, ())?;
8976
8977 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(last.as_mut_ptr()) };
8978
8979 Ok(())
8980 }
8981 }
8982
8983 unsafe impl<'a, ___E>
8984 ::fidl_next::Encode<crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>, ___E>
8985 for &'a ExtendedAttributeIteratorGetNextResponse
8986 where
8987 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8988 ___E: ::fidl_next::Encoder,
8989 {
8990 #[inline]
8991 fn encode(
8992 self,
8993 encoder_: &mut ___E,
8994 out_: &mut ::core::mem::MaybeUninit<
8995 crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
8996 >,
8997 _: (),
8998 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8999 ::fidl_next::munge! {
9000 let crate::wire::ExtendedAttributeIteratorGetNextResponse {
9001
9002 attributes,
9003 last,
9004
9005 } = out_;
9006 }
9007
9008 ::fidl_next::Encode::encode(&self.attributes, encoder_, attributes, (128, (255, ())))?;
9009
9010 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(attributes.as_mut_ptr()) };
9011 ::fidl_next::Constrained::validate(_field, (128, (255, ())))?;
9012
9013 ::fidl_next::Encode::encode(&self.last, encoder_, last, ())?;
9014
9015 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(last.as_mut_ptr()) };
9016
9017 Ok(())
9018 }
9019 }
9020
9021 unsafe impl<___E>
9022 ::fidl_next::EncodeOption<
9023 ::fidl_next::wire::Box<
9024 'static,
9025 crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
9026 >,
9027 ___E,
9028 > for ExtendedAttributeIteratorGetNextResponse
9029 where
9030 ___E: ::fidl_next::Encoder + ?Sized,
9031 ExtendedAttributeIteratorGetNextResponse: ::fidl_next::Encode<
9032 crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
9033 ___E,
9034 >,
9035 {
9036 #[inline]
9037 fn encode_option(
9038 this: ::core::option::Option<Self>,
9039 encoder: &mut ___E,
9040 out: &mut ::core::mem::MaybeUninit<
9041 ::fidl_next::wire::Box<
9042 'static,
9043 crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
9044 >,
9045 >,
9046 _: (),
9047 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9048 if let Some(inner) = this {
9049 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9050 ::fidl_next::wire::Box::encode_present(out);
9051 } else {
9052 ::fidl_next::wire::Box::encode_absent(out);
9053 }
9054
9055 Ok(())
9056 }
9057 }
9058
9059 unsafe impl<'a, ___E>
9060 ::fidl_next::EncodeOption<
9061 ::fidl_next::wire::Box<
9062 'static,
9063 crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
9064 >,
9065 ___E,
9066 > for &'a ExtendedAttributeIteratorGetNextResponse
9067 where
9068 ___E: ::fidl_next::Encoder + ?Sized,
9069 &'a ExtendedAttributeIteratorGetNextResponse: ::fidl_next::Encode<
9070 crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
9071 ___E,
9072 >,
9073 {
9074 #[inline]
9075 fn encode_option(
9076 this: ::core::option::Option<Self>,
9077 encoder: &mut ___E,
9078 out: &mut ::core::mem::MaybeUninit<
9079 ::fidl_next::wire::Box<
9080 'static,
9081 crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
9082 >,
9083 >,
9084 _: (),
9085 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9086 if let Some(inner) = this {
9087 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9088 ::fidl_next::wire::Box::encode_present(out);
9089 } else {
9090 ::fidl_next::wire::Box::encode_absent(out);
9091 }
9092
9093 Ok(())
9094 }
9095 }
9096
9097 impl<'de> ::fidl_next::FromWire<crate::wire::ExtendedAttributeIteratorGetNextResponse<'de>>
9098 for ExtendedAttributeIteratorGetNextResponse
9099 {
9100 #[inline]
9101 fn from_wire(wire: crate::wire::ExtendedAttributeIteratorGetNextResponse<'de>) -> Self {
9102 Self {
9103 attributes: ::fidl_next::FromWire::from_wire(wire.attributes),
9104
9105 last: ::fidl_next::FromWire::from_wire(wire.last),
9106 }
9107 }
9108 }
9109
9110 impl<'de> ::fidl_next::FromWireRef<crate::wire::ExtendedAttributeIteratorGetNextResponse<'de>>
9111 for ExtendedAttributeIteratorGetNextResponse
9112 {
9113 #[inline]
9114 fn from_wire_ref(
9115 wire: &crate::wire::ExtendedAttributeIteratorGetNextResponse<'de>,
9116 ) -> Self {
9117 Self {
9118 attributes: ::fidl_next::FromWireRef::from_wire_ref(&wire.attributes),
9119
9120 last: ::fidl_next::FromWireRef::from_wire_ref(&wire.last),
9121 }
9122 }
9123 }
9124
9125 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9126 #[repr(C)]
9127 pub struct ReadableReadRequest {
9128 pub count: u64,
9129 }
9130
9131 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ReadableReadRequest, ___E>
9132 for ReadableReadRequest
9133 where
9134 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9135 {
9136 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
9137 Self,
9138 crate::wire::ReadableReadRequest,
9139 > = unsafe {
9140 ::fidl_next::CopyOptimization::enable_if(
9141 true
9142
9143 && <
9144 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
9145 >::COPY_OPTIMIZATION.is_enabled()
9146
9147 )
9148 };
9149
9150 #[inline]
9151 fn encode(
9152 self,
9153 encoder_: &mut ___E,
9154 out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadableReadRequest>,
9155 _: (),
9156 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9157 ::fidl_next::munge! {
9158 let crate::wire::ReadableReadRequest {
9159 count,
9160
9161 } = out_;
9162 }
9163
9164 ::fidl_next::Encode::encode(self.count, encoder_, count, ())?;
9165
9166 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(count.as_mut_ptr()) };
9167
9168 Ok(())
9169 }
9170 }
9171
9172 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ReadableReadRequest, ___E>
9173 for &'a ReadableReadRequest
9174 where
9175 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9176 {
9177 #[inline]
9178 fn encode(
9179 self,
9180 encoder_: &mut ___E,
9181 out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadableReadRequest>,
9182 _: (),
9183 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9184 ::fidl_next::munge! {
9185 let crate::wire::ReadableReadRequest {
9186
9187 count,
9188
9189 } = out_;
9190 }
9191
9192 ::fidl_next::Encode::encode(&self.count, encoder_, count, ())?;
9193
9194 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(count.as_mut_ptr()) };
9195
9196 Ok(())
9197 }
9198 }
9199
9200 unsafe impl<___E>
9201 ::fidl_next::EncodeOption<
9202 ::fidl_next::wire::Box<'static, crate::wire::ReadableReadRequest>,
9203 ___E,
9204 > for ReadableReadRequest
9205 where
9206 ___E: ::fidl_next::Encoder + ?Sized,
9207 ReadableReadRequest: ::fidl_next::Encode<crate::wire::ReadableReadRequest, ___E>,
9208 {
9209 #[inline]
9210 fn encode_option(
9211 this: ::core::option::Option<Self>,
9212 encoder: &mut ___E,
9213 out: &mut ::core::mem::MaybeUninit<
9214 ::fidl_next::wire::Box<'static, crate::wire::ReadableReadRequest>,
9215 >,
9216 _: (),
9217 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9218 if let Some(inner) = this {
9219 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9220 ::fidl_next::wire::Box::encode_present(out);
9221 } else {
9222 ::fidl_next::wire::Box::encode_absent(out);
9223 }
9224
9225 Ok(())
9226 }
9227 }
9228
9229 unsafe impl<'a, ___E>
9230 ::fidl_next::EncodeOption<
9231 ::fidl_next::wire::Box<'static, crate::wire::ReadableReadRequest>,
9232 ___E,
9233 > for &'a ReadableReadRequest
9234 where
9235 ___E: ::fidl_next::Encoder + ?Sized,
9236 &'a ReadableReadRequest: ::fidl_next::Encode<crate::wire::ReadableReadRequest, ___E>,
9237 {
9238 #[inline]
9239 fn encode_option(
9240 this: ::core::option::Option<Self>,
9241 encoder: &mut ___E,
9242 out: &mut ::core::mem::MaybeUninit<
9243 ::fidl_next::wire::Box<'static, crate::wire::ReadableReadRequest>,
9244 >,
9245 _: (),
9246 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9247 if let Some(inner) = this {
9248 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9249 ::fidl_next::wire::Box::encode_present(out);
9250 } else {
9251 ::fidl_next::wire::Box::encode_absent(out);
9252 }
9253
9254 Ok(())
9255 }
9256 }
9257
9258 impl ::fidl_next::FromWire<crate::wire::ReadableReadRequest> for ReadableReadRequest {
9259 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
9260 crate::wire::ReadableReadRequest,
9261 Self,
9262 > = unsafe {
9263 ::fidl_next::CopyOptimization::enable_if(
9264 true
9265 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
9266 .is_enabled(),
9267 )
9268 };
9269
9270 #[inline]
9271 fn from_wire(wire: crate::wire::ReadableReadRequest) -> Self {
9272 Self { count: ::fidl_next::FromWire::from_wire(wire.count) }
9273 }
9274 }
9275
9276 impl ::fidl_next::FromWireRef<crate::wire::ReadableReadRequest> for ReadableReadRequest {
9277 #[inline]
9278 fn from_wire_ref(wire: &crate::wire::ReadableReadRequest) -> Self {
9279 Self { count: ::fidl_next::FromWireRef::from_wire_ref(&wire.count) }
9280 }
9281 }
9282
9283 #[doc = " The byte vector type used for read/write operations.\n"]
9284 pub type Transfer = ::std::vec::Vec<u8>;
9285
9286 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9287 pub struct ReadableReadResponse {
9288 pub data: ::std::vec::Vec<u8>,
9289 }
9290
9291 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ReadableReadResponse<'static>, ___E>
9292 for ReadableReadResponse
9293 where
9294 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9295 ___E: ::fidl_next::Encoder,
9296 {
9297 #[inline]
9298 fn encode(
9299 self,
9300 encoder_: &mut ___E,
9301 out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadableReadResponse<'static>>,
9302 _: (),
9303 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9304 ::fidl_next::munge! {
9305 let crate::wire::ReadableReadResponse {
9306 data,
9307
9308 } = out_;
9309 }
9310
9311 ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
9312
9313 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
9314 ::fidl_next::Constrained::validate(_field, (8192, ()))?;
9315
9316 Ok(())
9317 }
9318 }
9319
9320 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ReadableReadResponse<'static>, ___E>
9321 for &'a ReadableReadResponse
9322 where
9323 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9324 ___E: ::fidl_next::Encoder,
9325 {
9326 #[inline]
9327 fn encode(
9328 self,
9329 encoder_: &mut ___E,
9330 out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadableReadResponse<'static>>,
9331 _: (),
9332 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9333 ::fidl_next::munge! {
9334 let crate::wire::ReadableReadResponse {
9335
9336 data,
9337
9338 } = out_;
9339 }
9340
9341 ::fidl_next::Encode::encode(&self.data, encoder_, data, (8192, ()))?;
9342
9343 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
9344 ::fidl_next::Constrained::validate(_field, (8192, ()))?;
9345
9346 Ok(())
9347 }
9348 }
9349
9350 unsafe impl<___E>
9351 ::fidl_next::EncodeOption<
9352 ::fidl_next::wire::Box<'static, crate::wire::ReadableReadResponse<'static>>,
9353 ___E,
9354 > for ReadableReadResponse
9355 where
9356 ___E: ::fidl_next::Encoder + ?Sized,
9357 ReadableReadResponse: ::fidl_next::Encode<crate::wire::ReadableReadResponse<'static>, ___E>,
9358 {
9359 #[inline]
9360 fn encode_option(
9361 this: ::core::option::Option<Self>,
9362 encoder: &mut ___E,
9363 out: &mut ::core::mem::MaybeUninit<
9364 ::fidl_next::wire::Box<'static, crate::wire::ReadableReadResponse<'static>>,
9365 >,
9366 _: (),
9367 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9368 if let Some(inner) = this {
9369 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9370 ::fidl_next::wire::Box::encode_present(out);
9371 } else {
9372 ::fidl_next::wire::Box::encode_absent(out);
9373 }
9374
9375 Ok(())
9376 }
9377 }
9378
9379 unsafe impl<'a, ___E>
9380 ::fidl_next::EncodeOption<
9381 ::fidl_next::wire::Box<'static, crate::wire::ReadableReadResponse<'static>>,
9382 ___E,
9383 > for &'a ReadableReadResponse
9384 where
9385 ___E: ::fidl_next::Encoder + ?Sized,
9386 &'a ReadableReadResponse:
9387 ::fidl_next::Encode<crate::wire::ReadableReadResponse<'static>, ___E>,
9388 {
9389 #[inline]
9390 fn encode_option(
9391 this: ::core::option::Option<Self>,
9392 encoder: &mut ___E,
9393 out: &mut ::core::mem::MaybeUninit<
9394 ::fidl_next::wire::Box<'static, crate::wire::ReadableReadResponse<'static>>,
9395 >,
9396 _: (),
9397 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9398 if let Some(inner) = this {
9399 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9400 ::fidl_next::wire::Box::encode_present(out);
9401 } else {
9402 ::fidl_next::wire::Box::encode_absent(out);
9403 }
9404
9405 Ok(())
9406 }
9407 }
9408
9409 impl<'de> ::fidl_next::FromWire<crate::wire::ReadableReadResponse<'de>> for ReadableReadResponse {
9410 #[inline]
9411 fn from_wire(wire: crate::wire::ReadableReadResponse<'de>) -> Self {
9412 Self { data: ::fidl_next::FromWire::from_wire(wire.data) }
9413 }
9414 }
9415
9416 impl<'de> ::fidl_next::FromWireRef<crate::wire::ReadableReadResponse<'de>>
9417 for ReadableReadResponse
9418 {
9419 #[inline]
9420 fn from_wire_ref(wire: &crate::wire::ReadableReadResponse<'de>) -> Self {
9421 Self { data: ::fidl_next::FromWireRef::from_wire_ref(&wire.data) }
9422 }
9423 }
9424
9425 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9426 pub struct WritableWriteRequest {
9427 pub data: ::std::vec::Vec<u8>,
9428 }
9429
9430 unsafe impl<___E> ::fidl_next::Encode<crate::wire::WritableWriteRequest<'static>, ___E>
9431 for WritableWriteRequest
9432 where
9433 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9434 ___E: ::fidl_next::Encoder,
9435 {
9436 #[inline]
9437 fn encode(
9438 self,
9439 encoder_: &mut ___E,
9440 out_: &mut ::core::mem::MaybeUninit<crate::wire::WritableWriteRequest<'static>>,
9441 _: (),
9442 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9443 ::fidl_next::munge! {
9444 let crate::wire::WritableWriteRequest {
9445 data,
9446
9447 } = out_;
9448 }
9449
9450 ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
9451
9452 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
9453 ::fidl_next::Constrained::validate(_field, (8192, ()))?;
9454
9455 Ok(())
9456 }
9457 }
9458
9459 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WritableWriteRequest<'static>, ___E>
9460 for &'a WritableWriteRequest
9461 where
9462 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9463 ___E: ::fidl_next::Encoder,
9464 {
9465 #[inline]
9466 fn encode(
9467 self,
9468 encoder_: &mut ___E,
9469 out_: &mut ::core::mem::MaybeUninit<crate::wire::WritableWriteRequest<'static>>,
9470 _: (),
9471 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9472 ::fidl_next::munge! {
9473 let crate::wire::WritableWriteRequest {
9474
9475 data,
9476
9477 } = out_;
9478 }
9479
9480 ::fidl_next::Encode::encode(&self.data, encoder_, data, (8192, ()))?;
9481
9482 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
9483 ::fidl_next::Constrained::validate(_field, (8192, ()))?;
9484
9485 Ok(())
9486 }
9487 }
9488
9489 unsafe impl<___E>
9490 ::fidl_next::EncodeOption<
9491 ::fidl_next::wire::Box<'static, crate::wire::WritableWriteRequest<'static>>,
9492 ___E,
9493 > for WritableWriteRequest
9494 where
9495 ___E: ::fidl_next::Encoder + ?Sized,
9496 WritableWriteRequest: ::fidl_next::Encode<crate::wire::WritableWriteRequest<'static>, ___E>,
9497 {
9498 #[inline]
9499 fn encode_option(
9500 this: ::core::option::Option<Self>,
9501 encoder: &mut ___E,
9502 out: &mut ::core::mem::MaybeUninit<
9503 ::fidl_next::wire::Box<'static, crate::wire::WritableWriteRequest<'static>>,
9504 >,
9505 _: (),
9506 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9507 if let Some(inner) = this {
9508 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9509 ::fidl_next::wire::Box::encode_present(out);
9510 } else {
9511 ::fidl_next::wire::Box::encode_absent(out);
9512 }
9513
9514 Ok(())
9515 }
9516 }
9517
9518 unsafe impl<'a, ___E>
9519 ::fidl_next::EncodeOption<
9520 ::fidl_next::wire::Box<'static, crate::wire::WritableWriteRequest<'static>>,
9521 ___E,
9522 > for &'a WritableWriteRequest
9523 where
9524 ___E: ::fidl_next::Encoder + ?Sized,
9525 &'a WritableWriteRequest:
9526 ::fidl_next::Encode<crate::wire::WritableWriteRequest<'static>, ___E>,
9527 {
9528 #[inline]
9529 fn encode_option(
9530 this: ::core::option::Option<Self>,
9531 encoder: &mut ___E,
9532 out: &mut ::core::mem::MaybeUninit<
9533 ::fidl_next::wire::Box<'static, crate::wire::WritableWriteRequest<'static>>,
9534 >,
9535 _: (),
9536 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9537 if let Some(inner) = this {
9538 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9539 ::fidl_next::wire::Box::encode_present(out);
9540 } else {
9541 ::fidl_next::wire::Box::encode_absent(out);
9542 }
9543
9544 Ok(())
9545 }
9546 }
9547
9548 impl<'de> ::fidl_next::FromWire<crate::wire::WritableWriteRequest<'de>> for WritableWriteRequest {
9549 #[inline]
9550 fn from_wire(wire: crate::wire::WritableWriteRequest<'de>) -> Self {
9551 Self { data: ::fidl_next::FromWire::from_wire(wire.data) }
9552 }
9553 }
9554
9555 impl<'de> ::fidl_next::FromWireRef<crate::wire::WritableWriteRequest<'de>>
9556 for WritableWriteRequest
9557 {
9558 #[inline]
9559 fn from_wire_ref(wire: &crate::wire::WritableWriteRequest<'de>) -> Self {
9560 Self { data: ::fidl_next::FromWireRef::from_wire_ref(&wire.data) }
9561 }
9562 }
9563
9564 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9565 #[repr(C)]
9566 pub struct WritableWriteResponse {
9567 pub actual_count: u64,
9568 }
9569
9570 unsafe impl<___E> ::fidl_next::Encode<crate::wire::WritableWriteResponse, ___E>
9571 for WritableWriteResponse
9572 where
9573 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9574 {
9575 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
9576 Self,
9577 crate::wire::WritableWriteResponse,
9578 > = unsafe {
9579 ::fidl_next::CopyOptimization::enable_if(
9580 true
9581
9582 && <
9583 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
9584 >::COPY_OPTIMIZATION.is_enabled()
9585
9586 )
9587 };
9588
9589 #[inline]
9590 fn encode(
9591 self,
9592 encoder_: &mut ___E,
9593 out_: &mut ::core::mem::MaybeUninit<crate::wire::WritableWriteResponse>,
9594 _: (),
9595 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9596 ::fidl_next::munge! {
9597 let crate::wire::WritableWriteResponse {
9598 actual_count,
9599
9600 } = out_;
9601 }
9602
9603 ::fidl_next::Encode::encode(self.actual_count, encoder_, actual_count, ())?;
9604
9605 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(actual_count.as_mut_ptr()) };
9606
9607 Ok(())
9608 }
9609 }
9610
9611 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WritableWriteResponse, ___E>
9612 for &'a WritableWriteResponse
9613 where
9614 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9615 {
9616 #[inline]
9617 fn encode(
9618 self,
9619 encoder_: &mut ___E,
9620 out_: &mut ::core::mem::MaybeUninit<crate::wire::WritableWriteResponse>,
9621 _: (),
9622 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9623 ::fidl_next::munge! {
9624 let crate::wire::WritableWriteResponse {
9625
9626 actual_count,
9627
9628 } = out_;
9629 }
9630
9631 ::fidl_next::Encode::encode(&self.actual_count, encoder_, actual_count, ())?;
9632
9633 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(actual_count.as_mut_ptr()) };
9634
9635 Ok(())
9636 }
9637 }
9638
9639 unsafe impl<___E>
9640 ::fidl_next::EncodeOption<
9641 ::fidl_next::wire::Box<'static, crate::wire::WritableWriteResponse>,
9642 ___E,
9643 > for WritableWriteResponse
9644 where
9645 ___E: ::fidl_next::Encoder + ?Sized,
9646 WritableWriteResponse: ::fidl_next::Encode<crate::wire::WritableWriteResponse, ___E>,
9647 {
9648 #[inline]
9649 fn encode_option(
9650 this: ::core::option::Option<Self>,
9651 encoder: &mut ___E,
9652 out: &mut ::core::mem::MaybeUninit<
9653 ::fidl_next::wire::Box<'static, crate::wire::WritableWriteResponse>,
9654 >,
9655 _: (),
9656 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9657 if let Some(inner) = this {
9658 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9659 ::fidl_next::wire::Box::encode_present(out);
9660 } else {
9661 ::fidl_next::wire::Box::encode_absent(out);
9662 }
9663
9664 Ok(())
9665 }
9666 }
9667
9668 unsafe impl<'a, ___E>
9669 ::fidl_next::EncodeOption<
9670 ::fidl_next::wire::Box<'static, crate::wire::WritableWriteResponse>,
9671 ___E,
9672 > for &'a WritableWriteResponse
9673 where
9674 ___E: ::fidl_next::Encoder + ?Sized,
9675 &'a WritableWriteResponse: ::fidl_next::Encode<crate::wire::WritableWriteResponse, ___E>,
9676 {
9677 #[inline]
9678 fn encode_option(
9679 this: ::core::option::Option<Self>,
9680 encoder: &mut ___E,
9681 out: &mut ::core::mem::MaybeUninit<
9682 ::fidl_next::wire::Box<'static, crate::wire::WritableWriteResponse>,
9683 >,
9684 _: (),
9685 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9686 if let Some(inner) = this {
9687 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9688 ::fidl_next::wire::Box::encode_present(out);
9689 } else {
9690 ::fidl_next::wire::Box::encode_absent(out);
9691 }
9692
9693 Ok(())
9694 }
9695 }
9696
9697 impl ::fidl_next::FromWire<crate::wire::WritableWriteResponse> for WritableWriteResponse {
9698 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
9699 crate::wire::WritableWriteResponse,
9700 Self,
9701 > = unsafe {
9702 ::fidl_next::CopyOptimization::enable_if(
9703 true
9704 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
9705 .is_enabled(),
9706 )
9707 };
9708
9709 #[inline]
9710 fn from_wire(wire: crate::wire::WritableWriteResponse) -> Self {
9711 Self { actual_count: ::fidl_next::FromWire::from_wire(wire.actual_count) }
9712 }
9713 }
9714
9715 impl ::fidl_next::FromWireRef<crate::wire::WritableWriteResponse> for WritableWriteResponse {
9716 #[inline]
9717 fn from_wire_ref(wire: &crate::wire::WritableWriteResponse) -> Self {
9718 Self { actual_count: ::fidl_next::FromWireRef::from_wire_ref(&wire.actual_count) }
9719 }
9720 }
9721
9722 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9723 pub struct FileSeekRequest {
9724 pub origin: crate::natural::SeekOrigin,
9725
9726 pub offset: i64,
9727 }
9728
9729 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileSeekRequest, ___E> for FileSeekRequest
9730 where
9731 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9732 {
9733 #[inline]
9734 fn encode(
9735 self,
9736 encoder_: &mut ___E,
9737 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileSeekRequest>,
9738 _: (),
9739 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9740 ::fidl_next::munge! {
9741 let crate::wire::FileSeekRequest {
9742 origin,
9743 offset,
9744
9745 } = out_;
9746 }
9747
9748 ::fidl_next::Encode::encode(self.origin, encoder_, origin, ())?;
9749
9750 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(origin.as_mut_ptr()) };
9751
9752 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
9753
9754 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
9755
9756 Ok(())
9757 }
9758 }
9759
9760 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileSeekRequest, ___E>
9761 for &'a FileSeekRequest
9762 where
9763 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9764 {
9765 #[inline]
9766 fn encode(
9767 self,
9768 encoder_: &mut ___E,
9769 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileSeekRequest>,
9770 _: (),
9771 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9772 ::fidl_next::munge! {
9773 let crate::wire::FileSeekRequest {
9774
9775 origin,
9776 offset,
9777
9778 } = out_;
9779 }
9780
9781 ::fidl_next::Encode::encode(&self.origin, encoder_, origin, ())?;
9782
9783 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(origin.as_mut_ptr()) };
9784
9785 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
9786
9787 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
9788
9789 Ok(())
9790 }
9791 }
9792
9793 unsafe impl<___E>
9794 ::fidl_next::EncodeOption<
9795 ::fidl_next::wire::Box<'static, crate::wire::FileSeekRequest>,
9796 ___E,
9797 > for FileSeekRequest
9798 where
9799 ___E: ::fidl_next::Encoder + ?Sized,
9800 FileSeekRequest: ::fidl_next::Encode<crate::wire::FileSeekRequest, ___E>,
9801 {
9802 #[inline]
9803 fn encode_option(
9804 this: ::core::option::Option<Self>,
9805 encoder: &mut ___E,
9806 out: &mut ::core::mem::MaybeUninit<
9807 ::fidl_next::wire::Box<'static, crate::wire::FileSeekRequest>,
9808 >,
9809 _: (),
9810 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9811 if let Some(inner) = this {
9812 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9813 ::fidl_next::wire::Box::encode_present(out);
9814 } else {
9815 ::fidl_next::wire::Box::encode_absent(out);
9816 }
9817
9818 Ok(())
9819 }
9820 }
9821
9822 unsafe impl<'a, ___E>
9823 ::fidl_next::EncodeOption<
9824 ::fidl_next::wire::Box<'static, crate::wire::FileSeekRequest>,
9825 ___E,
9826 > for &'a FileSeekRequest
9827 where
9828 ___E: ::fidl_next::Encoder + ?Sized,
9829 &'a FileSeekRequest: ::fidl_next::Encode<crate::wire::FileSeekRequest, ___E>,
9830 {
9831 #[inline]
9832 fn encode_option(
9833 this: ::core::option::Option<Self>,
9834 encoder: &mut ___E,
9835 out: &mut ::core::mem::MaybeUninit<
9836 ::fidl_next::wire::Box<'static, crate::wire::FileSeekRequest>,
9837 >,
9838 _: (),
9839 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9840 if let Some(inner) = this {
9841 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9842 ::fidl_next::wire::Box::encode_present(out);
9843 } else {
9844 ::fidl_next::wire::Box::encode_absent(out);
9845 }
9846
9847 Ok(())
9848 }
9849 }
9850
9851 impl ::fidl_next::FromWire<crate::wire::FileSeekRequest> for FileSeekRequest {
9852 #[inline]
9853 fn from_wire(wire: crate::wire::FileSeekRequest) -> Self {
9854 Self {
9855 origin: ::fidl_next::FromWire::from_wire(wire.origin),
9856
9857 offset: ::fidl_next::FromWire::from_wire(wire.offset),
9858 }
9859 }
9860 }
9861
9862 impl ::fidl_next::FromWireRef<crate::wire::FileSeekRequest> for FileSeekRequest {
9863 #[inline]
9864 fn from_wire_ref(wire: &crate::wire::FileSeekRequest) -> Self {
9865 Self {
9866 origin: ::fidl_next::FromWireRef::from_wire_ref(&wire.origin),
9867
9868 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
9869 }
9870 }
9871 }
9872
9873 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9874 #[repr(C)]
9875 pub struct FileSeekResponse {
9876 pub offset_from_start: u64,
9877 }
9878
9879 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileSeekResponse, ___E> for FileSeekResponse
9880 where
9881 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9882 {
9883 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
9884 Self,
9885 crate::wire::FileSeekResponse,
9886 > = unsafe {
9887 ::fidl_next::CopyOptimization::enable_if(
9888 true
9889
9890 && <
9891 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
9892 >::COPY_OPTIMIZATION.is_enabled()
9893
9894 )
9895 };
9896
9897 #[inline]
9898 fn encode(
9899 self,
9900 encoder_: &mut ___E,
9901 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileSeekResponse>,
9902 _: (),
9903 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9904 ::fidl_next::munge! {
9905 let crate::wire::FileSeekResponse {
9906 offset_from_start,
9907
9908 } = out_;
9909 }
9910
9911 ::fidl_next::Encode::encode(self.offset_from_start, encoder_, offset_from_start, ())?;
9912
9913 let mut _field =
9914 unsafe { ::fidl_next::Slot::new_unchecked(offset_from_start.as_mut_ptr()) };
9915
9916 Ok(())
9917 }
9918 }
9919
9920 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileSeekResponse, ___E>
9921 for &'a FileSeekResponse
9922 where
9923 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9924 {
9925 #[inline]
9926 fn encode(
9927 self,
9928 encoder_: &mut ___E,
9929 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileSeekResponse>,
9930 _: (),
9931 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9932 ::fidl_next::munge! {
9933 let crate::wire::FileSeekResponse {
9934
9935 offset_from_start,
9936
9937 } = out_;
9938 }
9939
9940 ::fidl_next::Encode::encode(&self.offset_from_start, encoder_, offset_from_start, ())?;
9941
9942 let mut _field =
9943 unsafe { ::fidl_next::Slot::new_unchecked(offset_from_start.as_mut_ptr()) };
9944
9945 Ok(())
9946 }
9947 }
9948
9949 unsafe impl<___E>
9950 ::fidl_next::EncodeOption<
9951 ::fidl_next::wire::Box<'static, crate::wire::FileSeekResponse>,
9952 ___E,
9953 > for FileSeekResponse
9954 where
9955 ___E: ::fidl_next::Encoder + ?Sized,
9956 FileSeekResponse: ::fidl_next::Encode<crate::wire::FileSeekResponse, ___E>,
9957 {
9958 #[inline]
9959 fn encode_option(
9960 this: ::core::option::Option<Self>,
9961 encoder: &mut ___E,
9962 out: &mut ::core::mem::MaybeUninit<
9963 ::fidl_next::wire::Box<'static, crate::wire::FileSeekResponse>,
9964 >,
9965 _: (),
9966 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9967 if let Some(inner) = this {
9968 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9969 ::fidl_next::wire::Box::encode_present(out);
9970 } else {
9971 ::fidl_next::wire::Box::encode_absent(out);
9972 }
9973
9974 Ok(())
9975 }
9976 }
9977
9978 unsafe impl<'a, ___E>
9979 ::fidl_next::EncodeOption<
9980 ::fidl_next::wire::Box<'static, crate::wire::FileSeekResponse>,
9981 ___E,
9982 > for &'a FileSeekResponse
9983 where
9984 ___E: ::fidl_next::Encoder + ?Sized,
9985 &'a FileSeekResponse: ::fidl_next::Encode<crate::wire::FileSeekResponse, ___E>,
9986 {
9987 #[inline]
9988 fn encode_option(
9989 this: ::core::option::Option<Self>,
9990 encoder: &mut ___E,
9991 out: &mut ::core::mem::MaybeUninit<
9992 ::fidl_next::wire::Box<'static, crate::wire::FileSeekResponse>,
9993 >,
9994 _: (),
9995 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9996 if let Some(inner) = this {
9997 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9998 ::fidl_next::wire::Box::encode_present(out);
9999 } else {
10000 ::fidl_next::wire::Box::encode_absent(out);
10001 }
10002
10003 Ok(())
10004 }
10005 }
10006
10007 impl ::fidl_next::FromWire<crate::wire::FileSeekResponse> for FileSeekResponse {
10008 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
10009 crate::wire::FileSeekResponse,
10010 Self,
10011 > = unsafe {
10012 ::fidl_next::CopyOptimization::enable_if(
10013 true
10014 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
10015 .is_enabled(),
10016 )
10017 };
10018
10019 #[inline]
10020 fn from_wire(wire: crate::wire::FileSeekResponse) -> Self {
10021 Self { offset_from_start: ::fidl_next::FromWire::from_wire(wire.offset_from_start) }
10022 }
10023 }
10024
10025 impl ::fidl_next::FromWireRef<crate::wire::FileSeekResponse> for FileSeekResponse {
10026 #[inline]
10027 fn from_wire_ref(wire: &crate::wire::FileSeekResponse) -> Self {
10028 Self {
10029 offset_from_start: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset_from_start),
10030 }
10031 }
10032 }
10033
10034 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
10035 #[repr(C)]
10036 pub struct FileReadAtRequest {
10037 pub count: u64,
10038
10039 pub offset: u64,
10040 }
10041
10042 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileReadAtRequest, ___E> for FileReadAtRequest
10043 where
10044 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10045 {
10046 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
10047 Self,
10048 crate::wire::FileReadAtRequest,
10049 > = unsafe {
10050 ::fidl_next::CopyOptimization::enable_if(
10051 true
10052
10053 && <
10054 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
10055 >::COPY_OPTIMIZATION.is_enabled()
10056
10057 && <
10058 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
10059 >::COPY_OPTIMIZATION.is_enabled()
10060
10061 )
10062 };
10063
10064 #[inline]
10065 fn encode(
10066 self,
10067 encoder_: &mut ___E,
10068 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileReadAtRequest>,
10069 _: (),
10070 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10071 ::fidl_next::munge! {
10072 let crate::wire::FileReadAtRequest {
10073 count,
10074 offset,
10075
10076 } = out_;
10077 }
10078
10079 ::fidl_next::Encode::encode(self.count, encoder_, count, ())?;
10080
10081 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(count.as_mut_ptr()) };
10082
10083 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
10084
10085 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
10086
10087 Ok(())
10088 }
10089 }
10090
10091 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileReadAtRequest, ___E>
10092 for &'a FileReadAtRequest
10093 where
10094 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10095 {
10096 #[inline]
10097 fn encode(
10098 self,
10099 encoder_: &mut ___E,
10100 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileReadAtRequest>,
10101 _: (),
10102 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10103 ::fidl_next::munge! {
10104 let crate::wire::FileReadAtRequest {
10105
10106 count,
10107 offset,
10108
10109 } = out_;
10110 }
10111
10112 ::fidl_next::Encode::encode(&self.count, encoder_, count, ())?;
10113
10114 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(count.as_mut_ptr()) };
10115
10116 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
10117
10118 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
10119
10120 Ok(())
10121 }
10122 }
10123
10124 unsafe impl<___E>
10125 ::fidl_next::EncodeOption<
10126 ::fidl_next::wire::Box<'static, crate::wire::FileReadAtRequest>,
10127 ___E,
10128 > for FileReadAtRequest
10129 where
10130 ___E: ::fidl_next::Encoder + ?Sized,
10131 FileReadAtRequest: ::fidl_next::Encode<crate::wire::FileReadAtRequest, ___E>,
10132 {
10133 #[inline]
10134 fn encode_option(
10135 this: ::core::option::Option<Self>,
10136 encoder: &mut ___E,
10137 out: &mut ::core::mem::MaybeUninit<
10138 ::fidl_next::wire::Box<'static, crate::wire::FileReadAtRequest>,
10139 >,
10140 _: (),
10141 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10142 if let Some(inner) = this {
10143 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10144 ::fidl_next::wire::Box::encode_present(out);
10145 } else {
10146 ::fidl_next::wire::Box::encode_absent(out);
10147 }
10148
10149 Ok(())
10150 }
10151 }
10152
10153 unsafe impl<'a, ___E>
10154 ::fidl_next::EncodeOption<
10155 ::fidl_next::wire::Box<'static, crate::wire::FileReadAtRequest>,
10156 ___E,
10157 > for &'a FileReadAtRequest
10158 where
10159 ___E: ::fidl_next::Encoder + ?Sized,
10160 &'a FileReadAtRequest: ::fidl_next::Encode<crate::wire::FileReadAtRequest, ___E>,
10161 {
10162 #[inline]
10163 fn encode_option(
10164 this: ::core::option::Option<Self>,
10165 encoder: &mut ___E,
10166 out: &mut ::core::mem::MaybeUninit<
10167 ::fidl_next::wire::Box<'static, crate::wire::FileReadAtRequest>,
10168 >,
10169 _: (),
10170 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10171 if let Some(inner) = this {
10172 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10173 ::fidl_next::wire::Box::encode_present(out);
10174 } else {
10175 ::fidl_next::wire::Box::encode_absent(out);
10176 }
10177
10178 Ok(())
10179 }
10180 }
10181
10182 impl ::fidl_next::FromWire<crate::wire::FileReadAtRequest> for FileReadAtRequest {
10183 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
10184 crate::wire::FileReadAtRequest,
10185 Self,
10186 > = unsafe {
10187 ::fidl_next::CopyOptimization::enable_if(
10188 true
10189 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
10190 .is_enabled()
10191 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
10192 .is_enabled(),
10193 )
10194 };
10195
10196 #[inline]
10197 fn from_wire(wire: crate::wire::FileReadAtRequest) -> Self {
10198 Self {
10199 count: ::fidl_next::FromWire::from_wire(wire.count),
10200
10201 offset: ::fidl_next::FromWire::from_wire(wire.offset),
10202 }
10203 }
10204 }
10205
10206 impl ::fidl_next::FromWireRef<crate::wire::FileReadAtRequest> for FileReadAtRequest {
10207 #[inline]
10208 fn from_wire_ref(wire: &crate::wire::FileReadAtRequest) -> Self {
10209 Self {
10210 count: ::fidl_next::FromWireRef::from_wire_ref(&wire.count),
10211
10212 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
10213 }
10214 }
10215 }
10216
10217 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
10218 pub struct FileReadAtResponse {
10219 pub data: ::std::vec::Vec<u8>,
10220 }
10221
10222 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileReadAtResponse<'static>, ___E>
10223 for FileReadAtResponse
10224 where
10225 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10226 ___E: ::fidl_next::Encoder,
10227 {
10228 #[inline]
10229 fn encode(
10230 self,
10231 encoder_: &mut ___E,
10232 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileReadAtResponse<'static>>,
10233 _: (),
10234 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10235 ::fidl_next::munge! {
10236 let crate::wire::FileReadAtResponse {
10237 data,
10238
10239 } = out_;
10240 }
10241
10242 ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
10243
10244 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
10245 ::fidl_next::Constrained::validate(_field, (8192, ()))?;
10246
10247 Ok(())
10248 }
10249 }
10250
10251 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileReadAtResponse<'static>, ___E>
10252 for &'a FileReadAtResponse
10253 where
10254 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10255 ___E: ::fidl_next::Encoder,
10256 {
10257 #[inline]
10258 fn encode(
10259 self,
10260 encoder_: &mut ___E,
10261 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileReadAtResponse<'static>>,
10262 _: (),
10263 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10264 ::fidl_next::munge! {
10265 let crate::wire::FileReadAtResponse {
10266
10267 data,
10268
10269 } = out_;
10270 }
10271
10272 ::fidl_next::Encode::encode(&self.data, encoder_, data, (8192, ()))?;
10273
10274 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
10275 ::fidl_next::Constrained::validate(_field, (8192, ()))?;
10276
10277 Ok(())
10278 }
10279 }
10280
10281 unsafe impl<___E>
10282 ::fidl_next::EncodeOption<
10283 ::fidl_next::wire::Box<'static, crate::wire::FileReadAtResponse<'static>>,
10284 ___E,
10285 > for FileReadAtResponse
10286 where
10287 ___E: ::fidl_next::Encoder + ?Sized,
10288 FileReadAtResponse: ::fidl_next::Encode<crate::wire::FileReadAtResponse<'static>, ___E>,
10289 {
10290 #[inline]
10291 fn encode_option(
10292 this: ::core::option::Option<Self>,
10293 encoder: &mut ___E,
10294 out: &mut ::core::mem::MaybeUninit<
10295 ::fidl_next::wire::Box<'static, crate::wire::FileReadAtResponse<'static>>,
10296 >,
10297 _: (),
10298 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10299 if let Some(inner) = this {
10300 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10301 ::fidl_next::wire::Box::encode_present(out);
10302 } else {
10303 ::fidl_next::wire::Box::encode_absent(out);
10304 }
10305
10306 Ok(())
10307 }
10308 }
10309
10310 unsafe impl<'a, ___E>
10311 ::fidl_next::EncodeOption<
10312 ::fidl_next::wire::Box<'static, crate::wire::FileReadAtResponse<'static>>,
10313 ___E,
10314 > for &'a FileReadAtResponse
10315 where
10316 ___E: ::fidl_next::Encoder + ?Sized,
10317 &'a FileReadAtResponse: ::fidl_next::Encode<crate::wire::FileReadAtResponse<'static>, ___E>,
10318 {
10319 #[inline]
10320 fn encode_option(
10321 this: ::core::option::Option<Self>,
10322 encoder: &mut ___E,
10323 out: &mut ::core::mem::MaybeUninit<
10324 ::fidl_next::wire::Box<'static, crate::wire::FileReadAtResponse<'static>>,
10325 >,
10326 _: (),
10327 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10328 if let Some(inner) = this {
10329 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10330 ::fidl_next::wire::Box::encode_present(out);
10331 } else {
10332 ::fidl_next::wire::Box::encode_absent(out);
10333 }
10334
10335 Ok(())
10336 }
10337 }
10338
10339 impl<'de> ::fidl_next::FromWire<crate::wire::FileReadAtResponse<'de>> for FileReadAtResponse {
10340 #[inline]
10341 fn from_wire(wire: crate::wire::FileReadAtResponse<'de>) -> Self {
10342 Self { data: ::fidl_next::FromWire::from_wire(wire.data) }
10343 }
10344 }
10345
10346 impl<'de> ::fidl_next::FromWireRef<crate::wire::FileReadAtResponse<'de>> for FileReadAtResponse {
10347 #[inline]
10348 fn from_wire_ref(wire: &crate::wire::FileReadAtResponse<'de>) -> Self {
10349 Self { data: ::fidl_next::FromWireRef::from_wire_ref(&wire.data) }
10350 }
10351 }
10352
10353 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
10354 pub struct FileWriteAtRequest {
10355 pub data: ::std::vec::Vec<u8>,
10356
10357 pub offset: u64,
10358 }
10359
10360 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileWriteAtRequest<'static>, ___E>
10361 for FileWriteAtRequest
10362 where
10363 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10364 ___E: ::fidl_next::Encoder,
10365 {
10366 #[inline]
10367 fn encode(
10368 self,
10369 encoder_: &mut ___E,
10370 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileWriteAtRequest<'static>>,
10371 _: (),
10372 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10373 ::fidl_next::munge! {
10374 let crate::wire::FileWriteAtRequest {
10375 data,
10376 offset,
10377
10378 } = out_;
10379 }
10380
10381 ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
10382
10383 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
10384 ::fidl_next::Constrained::validate(_field, (8192, ()))?;
10385
10386 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
10387
10388 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
10389
10390 Ok(())
10391 }
10392 }
10393
10394 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileWriteAtRequest<'static>, ___E>
10395 for &'a FileWriteAtRequest
10396 where
10397 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10398 ___E: ::fidl_next::Encoder,
10399 {
10400 #[inline]
10401 fn encode(
10402 self,
10403 encoder_: &mut ___E,
10404 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileWriteAtRequest<'static>>,
10405 _: (),
10406 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10407 ::fidl_next::munge! {
10408 let crate::wire::FileWriteAtRequest {
10409
10410 data,
10411 offset,
10412
10413 } = out_;
10414 }
10415
10416 ::fidl_next::Encode::encode(&self.data, encoder_, data, (8192, ()))?;
10417
10418 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
10419 ::fidl_next::Constrained::validate(_field, (8192, ()))?;
10420
10421 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
10422
10423 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
10424
10425 Ok(())
10426 }
10427 }
10428
10429 unsafe impl<___E>
10430 ::fidl_next::EncodeOption<
10431 ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtRequest<'static>>,
10432 ___E,
10433 > for FileWriteAtRequest
10434 where
10435 ___E: ::fidl_next::Encoder + ?Sized,
10436 FileWriteAtRequest: ::fidl_next::Encode<crate::wire::FileWriteAtRequest<'static>, ___E>,
10437 {
10438 #[inline]
10439 fn encode_option(
10440 this: ::core::option::Option<Self>,
10441 encoder: &mut ___E,
10442 out: &mut ::core::mem::MaybeUninit<
10443 ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtRequest<'static>>,
10444 >,
10445 _: (),
10446 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10447 if let Some(inner) = this {
10448 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10449 ::fidl_next::wire::Box::encode_present(out);
10450 } else {
10451 ::fidl_next::wire::Box::encode_absent(out);
10452 }
10453
10454 Ok(())
10455 }
10456 }
10457
10458 unsafe impl<'a, ___E>
10459 ::fidl_next::EncodeOption<
10460 ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtRequest<'static>>,
10461 ___E,
10462 > for &'a FileWriteAtRequest
10463 where
10464 ___E: ::fidl_next::Encoder + ?Sized,
10465 &'a FileWriteAtRequest: ::fidl_next::Encode<crate::wire::FileWriteAtRequest<'static>, ___E>,
10466 {
10467 #[inline]
10468 fn encode_option(
10469 this: ::core::option::Option<Self>,
10470 encoder: &mut ___E,
10471 out: &mut ::core::mem::MaybeUninit<
10472 ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtRequest<'static>>,
10473 >,
10474 _: (),
10475 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10476 if let Some(inner) = this {
10477 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10478 ::fidl_next::wire::Box::encode_present(out);
10479 } else {
10480 ::fidl_next::wire::Box::encode_absent(out);
10481 }
10482
10483 Ok(())
10484 }
10485 }
10486
10487 impl<'de> ::fidl_next::FromWire<crate::wire::FileWriteAtRequest<'de>> for FileWriteAtRequest {
10488 #[inline]
10489 fn from_wire(wire: crate::wire::FileWriteAtRequest<'de>) -> Self {
10490 Self {
10491 data: ::fidl_next::FromWire::from_wire(wire.data),
10492
10493 offset: ::fidl_next::FromWire::from_wire(wire.offset),
10494 }
10495 }
10496 }
10497
10498 impl<'de> ::fidl_next::FromWireRef<crate::wire::FileWriteAtRequest<'de>> for FileWriteAtRequest {
10499 #[inline]
10500 fn from_wire_ref(wire: &crate::wire::FileWriteAtRequest<'de>) -> Self {
10501 Self {
10502 data: ::fidl_next::FromWireRef::from_wire_ref(&wire.data),
10503
10504 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
10505 }
10506 }
10507 }
10508
10509 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
10510 #[repr(C)]
10511 pub struct FileWriteAtResponse {
10512 pub actual_count: u64,
10513 }
10514
10515 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileWriteAtResponse, ___E>
10516 for FileWriteAtResponse
10517 where
10518 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10519 {
10520 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
10521 Self,
10522 crate::wire::FileWriteAtResponse,
10523 > = unsafe {
10524 ::fidl_next::CopyOptimization::enable_if(
10525 true
10526
10527 && <
10528 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
10529 >::COPY_OPTIMIZATION.is_enabled()
10530
10531 )
10532 };
10533
10534 #[inline]
10535 fn encode(
10536 self,
10537 encoder_: &mut ___E,
10538 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileWriteAtResponse>,
10539 _: (),
10540 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10541 ::fidl_next::munge! {
10542 let crate::wire::FileWriteAtResponse {
10543 actual_count,
10544
10545 } = out_;
10546 }
10547
10548 ::fidl_next::Encode::encode(self.actual_count, encoder_, actual_count, ())?;
10549
10550 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(actual_count.as_mut_ptr()) };
10551
10552 Ok(())
10553 }
10554 }
10555
10556 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileWriteAtResponse, ___E>
10557 for &'a FileWriteAtResponse
10558 where
10559 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10560 {
10561 #[inline]
10562 fn encode(
10563 self,
10564 encoder_: &mut ___E,
10565 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileWriteAtResponse>,
10566 _: (),
10567 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10568 ::fidl_next::munge! {
10569 let crate::wire::FileWriteAtResponse {
10570
10571 actual_count,
10572
10573 } = out_;
10574 }
10575
10576 ::fidl_next::Encode::encode(&self.actual_count, encoder_, actual_count, ())?;
10577
10578 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(actual_count.as_mut_ptr()) };
10579
10580 Ok(())
10581 }
10582 }
10583
10584 unsafe impl<___E>
10585 ::fidl_next::EncodeOption<
10586 ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtResponse>,
10587 ___E,
10588 > for FileWriteAtResponse
10589 where
10590 ___E: ::fidl_next::Encoder + ?Sized,
10591 FileWriteAtResponse: ::fidl_next::Encode<crate::wire::FileWriteAtResponse, ___E>,
10592 {
10593 #[inline]
10594 fn encode_option(
10595 this: ::core::option::Option<Self>,
10596 encoder: &mut ___E,
10597 out: &mut ::core::mem::MaybeUninit<
10598 ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtResponse>,
10599 >,
10600 _: (),
10601 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10602 if let Some(inner) = this {
10603 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10604 ::fidl_next::wire::Box::encode_present(out);
10605 } else {
10606 ::fidl_next::wire::Box::encode_absent(out);
10607 }
10608
10609 Ok(())
10610 }
10611 }
10612
10613 unsafe impl<'a, ___E>
10614 ::fidl_next::EncodeOption<
10615 ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtResponse>,
10616 ___E,
10617 > for &'a FileWriteAtResponse
10618 where
10619 ___E: ::fidl_next::Encoder + ?Sized,
10620 &'a FileWriteAtResponse: ::fidl_next::Encode<crate::wire::FileWriteAtResponse, ___E>,
10621 {
10622 #[inline]
10623 fn encode_option(
10624 this: ::core::option::Option<Self>,
10625 encoder: &mut ___E,
10626 out: &mut ::core::mem::MaybeUninit<
10627 ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtResponse>,
10628 >,
10629 _: (),
10630 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10631 if let Some(inner) = this {
10632 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10633 ::fidl_next::wire::Box::encode_present(out);
10634 } else {
10635 ::fidl_next::wire::Box::encode_absent(out);
10636 }
10637
10638 Ok(())
10639 }
10640 }
10641
10642 impl ::fidl_next::FromWire<crate::wire::FileWriteAtResponse> for FileWriteAtResponse {
10643 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
10644 crate::wire::FileWriteAtResponse,
10645 Self,
10646 > = unsafe {
10647 ::fidl_next::CopyOptimization::enable_if(
10648 true
10649 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
10650 .is_enabled(),
10651 )
10652 };
10653
10654 #[inline]
10655 fn from_wire(wire: crate::wire::FileWriteAtResponse) -> Self {
10656 Self { actual_count: ::fidl_next::FromWire::from_wire(wire.actual_count) }
10657 }
10658 }
10659
10660 impl ::fidl_next::FromWireRef<crate::wire::FileWriteAtResponse> for FileWriteAtResponse {
10661 #[inline]
10662 fn from_wire_ref(wire: &crate::wire::FileWriteAtResponse) -> Self {
10663 Self { actual_count: ::fidl_next::FromWireRef::from_wire_ref(&wire.actual_count) }
10664 }
10665 }
10666
10667 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
10668 #[repr(C)]
10669 pub struct FileResizeRequest {
10670 pub length: u64,
10671 }
10672
10673 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileResizeRequest, ___E> for FileResizeRequest
10674 where
10675 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10676 {
10677 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
10678 Self,
10679 crate::wire::FileResizeRequest,
10680 > = unsafe {
10681 ::fidl_next::CopyOptimization::enable_if(
10682 true
10683
10684 && <
10685 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
10686 >::COPY_OPTIMIZATION.is_enabled()
10687
10688 )
10689 };
10690
10691 #[inline]
10692 fn encode(
10693 self,
10694 encoder_: &mut ___E,
10695 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileResizeRequest>,
10696 _: (),
10697 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10698 ::fidl_next::munge! {
10699 let crate::wire::FileResizeRequest {
10700 length,
10701
10702 } = out_;
10703 }
10704
10705 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
10706
10707 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
10708
10709 Ok(())
10710 }
10711 }
10712
10713 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileResizeRequest, ___E>
10714 for &'a FileResizeRequest
10715 where
10716 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10717 {
10718 #[inline]
10719 fn encode(
10720 self,
10721 encoder_: &mut ___E,
10722 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileResizeRequest>,
10723 _: (),
10724 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10725 ::fidl_next::munge! {
10726 let crate::wire::FileResizeRequest {
10727
10728 length,
10729
10730 } = out_;
10731 }
10732
10733 ::fidl_next::Encode::encode(&self.length, encoder_, length, ())?;
10734
10735 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
10736
10737 Ok(())
10738 }
10739 }
10740
10741 unsafe impl<___E>
10742 ::fidl_next::EncodeOption<
10743 ::fidl_next::wire::Box<'static, crate::wire::FileResizeRequest>,
10744 ___E,
10745 > for FileResizeRequest
10746 where
10747 ___E: ::fidl_next::Encoder + ?Sized,
10748 FileResizeRequest: ::fidl_next::Encode<crate::wire::FileResizeRequest, ___E>,
10749 {
10750 #[inline]
10751 fn encode_option(
10752 this: ::core::option::Option<Self>,
10753 encoder: &mut ___E,
10754 out: &mut ::core::mem::MaybeUninit<
10755 ::fidl_next::wire::Box<'static, crate::wire::FileResizeRequest>,
10756 >,
10757 _: (),
10758 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10759 if let Some(inner) = this {
10760 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10761 ::fidl_next::wire::Box::encode_present(out);
10762 } else {
10763 ::fidl_next::wire::Box::encode_absent(out);
10764 }
10765
10766 Ok(())
10767 }
10768 }
10769
10770 unsafe impl<'a, ___E>
10771 ::fidl_next::EncodeOption<
10772 ::fidl_next::wire::Box<'static, crate::wire::FileResizeRequest>,
10773 ___E,
10774 > for &'a FileResizeRequest
10775 where
10776 ___E: ::fidl_next::Encoder + ?Sized,
10777 &'a FileResizeRequest: ::fidl_next::Encode<crate::wire::FileResizeRequest, ___E>,
10778 {
10779 #[inline]
10780 fn encode_option(
10781 this: ::core::option::Option<Self>,
10782 encoder: &mut ___E,
10783 out: &mut ::core::mem::MaybeUninit<
10784 ::fidl_next::wire::Box<'static, crate::wire::FileResizeRequest>,
10785 >,
10786 _: (),
10787 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10788 if let Some(inner) = this {
10789 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10790 ::fidl_next::wire::Box::encode_present(out);
10791 } else {
10792 ::fidl_next::wire::Box::encode_absent(out);
10793 }
10794
10795 Ok(())
10796 }
10797 }
10798
10799 impl ::fidl_next::FromWire<crate::wire::FileResizeRequest> for FileResizeRequest {
10800 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
10801 crate::wire::FileResizeRequest,
10802 Self,
10803 > = unsafe {
10804 ::fidl_next::CopyOptimization::enable_if(
10805 true
10806 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
10807 .is_enabled(),
10808 )
10809 };
10810
10811 #[inline]
10812 fn from_wire(wire: crate::wire::FileResizeRequest) -> Self {
10813 Self { length: ::fidl_next::FromWire::from_wire(wire.length) }
10814 }
10815 }
10816
10817 impl ::fidl_next::FromWireRef<crate::wire::FileResizeRequest> for FileResizeRequest {
10818 #[inline]
10819 fn from_wire_ref(wire: &crate::wire::FileResizeRequest) -> Self {
10820 Self { length: ::fidl_next::FromWireRef::from_wire_ref(&wire.length) }
10821 }
10822 }
10823
10824 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
10825 #[repr(C)]
10826 pub struct FileResizeResponse {}
10827
10828 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileResizeResponse, ___E> for FileResizeResponse
10829 where
10830 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10831 {
10832 #[inline]
10833 fn encode(
10834 self,
10835 encoder_: &mut ___E,
10836 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileResizeResponse>,
10837 _: (),
10838 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10839 ::fidl_next::munge! {
10840 let crate::wire::FileResizeResponse {
10841
10842 _empty,
10843
10844 } = out_;
10845 }
10846
10847 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
10848
10849 Ok(())
10850 }
10851 }
10852
10853 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileResizeResponse, ___E>
10854 for &'a FileResizeResponse
10855 where
10856 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10857 {
10858 #[inline]
10859 fn encode(
10860 self,
10861 encoder_: &mut ___E,
10862 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileResizeResponse>,
10863 _: (),
10864 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10865 ::fidl_next::munge! {
10866 let crate::wire::FileResizeResponse {
10867
10868 _empty,
10869
10870
10871 } = out_;
10872 }
10873
10874 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
10875
10876 Ok(())
10877 }
10878 }
10879
10880 unsafe impl<___E>
10881 ::fidl_next::EncodeOption<
10882 ::fidl_next::wire::Box<'static, crate::wire::FileResizeResponse>,
10883 ___E,
10884 > for FileResizeResponse
10885 where
10886 ___E: ::fidl_next::Encoder + ?Sized,
10887 FileResizeResponse: ::fidl_next::Encode<crate::wire::FileResizeResponse, ___E>,
10888 {
10889 #[inline]
10890 fn encode_option(
10891 this: ::core::option::Option<Self>,
10892 encoder: &mut ___E,
10893 out: &mut ::core::mem::MaybeUninit<
10894 ::fidl_next::wire::Box<'static, crate::wire::FileResizeResponse>,
10895 >,
10896 _: (),
10897 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10898 if let Some(inner) = this {
10899 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10900 ::fidl_next::wire::Box::encode_present(out);
10901 } else {
10902 ::fidl_next::wire::Box::encode_absent(out);
10903 }
10904
10905 Ok(())
10906 }
10907 }
10908
10909 unsafe impl<'a, ___E>
10910 ::fidl_next::EncodeOption<
10911 ::fidl_next::wire::Box<'static, crate::wire::FileResizeResponse>,
10912 ___E,
10913 > for &'a FileResizeResponse
10914 where
10915 ___E: ::fidl_next::Encoder + ?Sized,
10916 &'a FileResizeResponse: ::fidl_next::Encode<crate::wire::FileResizeResponse, ___E>,
10917 {
10918 #[inline]
10919 fn encode_option(
10920 this: ::core::option::Option<Self>,
10921 encoder: &mut ___E,
10922 out: &mut ::core::mem::MaybeUninit<
10923 ::fidl_next::wire::Box<'static, crate::wire::FileResizeResponse>,
10924 >,
10925 _: (),
10926 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10927 if let Some(inner) = this {
10928 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10929 ::fidl_next::wire::Box::encode_present(out);
10930 } else {
10931 ::fidl_next::wire::Box::encode_absent(out);
10932 }
10933
10934 Ok(())
10935 }
10936 }
10937
10938 impl ::fidl_next::FromWire<crate::wire::FileResizeResponse> for FileResizeResponse {
10939 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
10940 crate::wire::FileResizeResponse,
10941 Self,
10942 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
10943
10944 #[inline]
10945 fn from_wire(wire: crate::wire::FileResizeResponse) -> Self {
10946 Self {}
10947 }
10948 }
10949
10950 impl ::fidl_next::FromWireRef<crate::wire::FileResizeResponse> for FileResizeResponse {
10951 #[inline]
10952 fn from_wire_ref(wire: &crate::wire::FileResizeResponse) -> Self {
10953 Self {}
10954 }
10955 }
10956
10957 ::fidl_next::bitflags::bitflags! {
10958 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct VmoFlags: u32 {
10959 #[doc = " Requests that the VMO be readable.\n"]const READ = 1;
10960 #[doc = " Requests that the VMO be writable.\n"]const WRITE = 2;
10961 #[doc = " Request that the VMO be executable.\n"]const EXECUTE = 4;
10962 #[doc = " Require a copy-on-write clone of the underlying VMO. The request\n should fail if the VMO cannot be cloned. May not be supplied\n with `SHARED_BUFFER`.\n\n A private clone uses at least the guarantees of the\n `ZX_VMO_CHILD_SNAPSHOT_AT_LEAST_ON_WRITE` flag to\n `zx_vmo_create_child()`. This means that the returned VMO will\n be copy-on-write (if `WRITE` is requested) but that it may or\n may not reflect subsequent content changes to the underlying\n file. The returned VMO will not reflect size changes to the\n file. These semantics match those of the POSIX `mmap()`\n `MAP_PRIVATE` flag.\n\n In some cases, clients requiring a guaranteed snapshot of the\n file can use `SHARED_BUFFER` and then use\n `zx_vmo_create_child()` with `ZX_VMO_CHILD_SNAPSHOT`. However,\n in addition to cases where the implementation can\'t return a\n `SHARED_BUFFER`, creating a full snapshot will fail if the VMO\n is attached to the pager. Since most filesystems will use the\n paging system, the full snapshot approach should only be used in\n specific cases where the client is talking to a known server.\n"]const PRIVATE_CLONE = 65536;
10963 #[doc = " Require a VMO that provides direct access to the contents of the\n file\'s underlying VMO. The request should fail if such a VMO\n cannot be provided. May not be supplied with `PRIVATE_CLONE`.\n\n The returned VMO may not be resizable even when `WRITE` access is\n requested. In this case, [`File.Resize`] should be used to resize\n the file.\n"]const SHARED_BUFFER = 131072;
10964
10965 }
10966 }
10967
10968 unsafe impl<___E> ::fidl_next::Encode<crate::wire::VmoFlags, ___E> for VmoFlags
10969 where
10970 ___E: ?Sized,
10971 {
10972 #[inline]
10973 fn encode(
10974 self,
10975 encoder: &mut ___E,
10976 out: &mut ::core::mem::MaybeUninit<crate::wire::VmoFlags>,
10977 _: (),
10978 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10979 ::fidl_next::Encode::encode(&self, encoder, out, ())
10980 }
10981 }
10982
10983 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::VmoFlags, ___E> for &'a VmoFlags
10984 where
10985 ___E: ?Sized,
10986 {
10987 #[inline]
10988 fn encode(
10989 self,
10990 _: &mut ___E,
10991 out: &mut ::core::mem::MaybeUninit<crate::wire::VmoFlags>,
10992 _: (),
10993 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10994 ::fidl_next::munge!(let crate::wire::VmoFlags { value } = out);
10995
10996 if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
10997 return Err(::fidl_next::EncodeError::InvalidStrictBits);
10998 }
10999
11000 let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
11001 Ok(())
11002 }
11003 }
11004
11005 impl ::core::convert::From<crate::wire::VmoFlags> for VmoFlags {
11006 fn from(wire: crate::wire::VmoFlags) -> Self {
11007 Self::from_bits_retain(u32::from(wire.value))
11008 }
11009 }
11010
11011 impl ::fidl_next::FromWire<crate::wire::VmoFlags> for VmoFlags {
11012 #[inline]
11013 fn from_wire(wire: crate::wire::VmoFlags) -> Self {
11014 Self::from(wire)
11015 }
11016 }
11017
11018 impl ::fidl_next::FromWireRef<crate::wire::VmoFlags> for VmoFlags {
11019 #[inline]
11020 fn from_wire_ref(wire: &crate::wire::VmoFlags) -> Self {
11021 Self::from(*wire)
11022 }
11023 }
11024
11025 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
11026 #[repr(C)]
11027 pub struct FileGetBackingMemoryRequest {
11028 pub flags: crate::natural::VmoFlags,
11029 }
11030
11031 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryRequest, ___E>
11032 for FileGetBackingMemoryRequest
11033 where
11034 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11035 {
11036 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
11037 Self,
11038 crate::wire::FileGetBackingMemoryRequest,
11039 > = unsafe {
11040 ::fidl_next::CopyOptimization::enable_if(
11041 true && <crate::natural::VmoFlags as ::fidl_next::Encode<
11042 crate::wire::VmoFlags,
11043 ___E,
11044 >>::COPY_OPTIMIZATION
11045 .is_enabled(),
11046 )
11047 };
11048
11049 #[inline]
11050 fn encode(
11051 self,
11052 encoder_: &mut ___E,
11053 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryRequest>,
11054 _: (),
11055 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11056 ::fidl_next::munge! {
11057 let crate::wire::FileGetBackingMemoryRequest {
11058 flags,
11059
11060 } = out_;
11061 }
11062
11063 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
11064
11065 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
11066
11067 Ok(())
11068 }
11069 }
11070
11071 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryRequest, ___E>
11072 for &'a FileGetBackingMemoryRequest
11073 where
11074 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11075 {
11076 #[inline]
11077 fn encode(
11078 self,
11079 encoder_: &mut ___E,
11080 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryRequest>,
11081 _: (),
11082 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11083 ::fidl_next::munge! {
11084 let crate::wire::FileGetBackingMemoryRequest {
11085
11086 flags,
11087
11088 } = out_;
11089 }
11090
11091 ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
11092
11093 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
11094
11095 Ok(())
11096 }
11097 }
11098
11099 unsafe impl<___E>
11100 ::fidl_next::EncodeOption<
11101 ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryRequest>,
11102 ___E,
11103 > for FileGetBackingMemoryRequest
11104 where
11105 ___E: ::fidl_next::Encoder + ?Sized,
11106 FileGetBackingMemoryRequest:
11107 ::fidl_next::Encode<crate::wire::FileGetBackingMemoryRequest, ___E>,
11108 {
11109 #[inline]
11110 fn encode_option(
11111 this: ::core::option::Option<Self>,
11112 encoder: &mut ___E,
11113 out: &mut ::core::mem::MaybeUninit<
11114 ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryRequest>,
11115 >,
11116 _: (),
11117 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11118 if let Some(inner) = this {
11119 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
11120 ::fidl_next::wire::Box::encode_present(out);
11121 } else {
11122 ::fidl_next::wire::Box::encode_absent(out);
11123 }
11124
11125 Ok(())
11126 }
11127 }
11128
11129 unsafe impl<'a, ___E>
11130 ::fidl_next::EncodeOption<
11131 ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryRequest>,
11132 ___E,
11133 > for &'a FileGetBackingMemoryRequest
11134 where
11135 ___E: ::fidl_next::Encoder + ?Sized,
11136 &'a FileGetBackingMemoryRequest:
11137 ::fidl_next::Encode<crate::wire::FileGetBackingMemoryRequest, ___E>,
11138 {
11139 #[inline]
11140 fn encode_option(
11141 this: ::core::option::Option<Self>,
11142 encoder: &mut ___E,
11143 out: &mut ::core::mem::MaybeUninit<
11144 ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryRequest>,
11145 >,
11146 _: (),
11147 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11148 if let Some(inner) = this {
11149 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
11150 ::fidl_next::wire::Box::encode_present(out);
11151 } else {
11152 ::fidl_next::wire::Box::encode_absent(out);
11153 }
11154
11155 Ok(())
11156 }
11157 }
11158
11159 impl ::fidl_next::FromWire<crate::wire::FileGetBackingMemoryRequest>
11160 for FileGetBackingMemoryRequest
11161 {
11162 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
11163 crate::wire::FileGetBackingMemoryRequest,
11164 Self,
11165 > = unsafe {
11166 ::fidl_next::CopyOptimization::enable_if(
11167 true && <crate::natural::VmoFlags as ::fidl_next::FromWire<
11168 crate::wire::VmoFlags,
11169 >>::COPY_OPTIMIZATION
11170 .is_enabled(),
11171 )
11172 };
11173
11174 #[inline]
11175 fn from_wire(wire: crate::wire::FileGetBackingMemoryRequest) -> Self {
11176 Self { flags: ::fidl_next::FromWire::from_wire(wire.flags) }
11177 }
11178 }
11179
11180 impl ::fidl_next::FromWireRef<crate::wire::FileGetBackingMemoryRequest>
11181 for FileGetBackingMemoryRequest
11182 {
11183 #[inline]
11184 fn from_wire_ref(wire: &crate::wire::FileGetBackingMemoryRequest) -> Self {
11185 Self { flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags) }
11186 }
11187 }
11188
11189 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
11190 #[repr(C)]
11191 pub struct LinkableLinkIntoResponse {}
11192
11193 unsafe impl<___E> ::fidl_next::Encode<crate::wire::LinkableLinkIntoResponse, ___E>
11194 for LinkableLinkIntoResponse
11195 where
11196 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11197 {
11198 #[inline]
11199 fn encode(
11200 self,
11201 encoder_: &mut ___E,
11202 out_: &mut ::core::mem::MaybeUninit<crate::wire::LinkableLinkIntoResponse>,
11203 _: (),
11204 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11205 ::fidl_next::munge! {
11206 let crate::wire::LinkableLinkIntoResponse {
11207
11208 _empty,
11209
11210 } = out_;
11211 }
11212
11213 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
11214
11215 Ok(())
11216 }
11217 }
11218
11219 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::LinkableLinkIntoResponse, ___E>
11220 for &'a LinkableLinkIntoResponse
11221 where
11222 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11223 {
11224 #[inline]
11225 fn encode(
11226 self,
11227 encoder_: &mut ___E,
11228 out_: &mut ::core::mem::MaybeUninit<crate::wire::LinkableLinkIntoResponse>,
11229 _: (),
11230 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11231 ::fidl_next::munge! {
11232 let crate::wire::LinkableLinkIntoResponse {
11233
11234 _empty,
11235
11236
11237 } = out_;
11238 }
11239
11240 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
11241
11242 Ok(())
11243 }
11244 }
11245
11246 unsafe impl<___E>
11247 ::fidl_next::EncodeOption<
11248 ::fidl_next::wire::Box<'static, crate::wire::LinkableLinkIntoResponse>,
11249 ___E,
11250 > for LinkableLinkIntoResponse
11251 where
11252 ___E: ::fidl_next::Encoder + ?Sized,
11253 LinkableLinkIntoResponse: ::fidl_next::Encode<crate::wire::LinkableLinkIntoResponse, ___E>,
11254 {
11255 #[inline]
11256 fn encode_option(
11257 this: ::core::option::Option<Self>,
11258 encoder: &mut ___E,
11259 out: &mut ::core::mem::MaybeUninit<
11260 ::fidl_next::wire::Box<'static, crate::wire::LinkableLinkIntoResponse>,
11261 >,
11262 _: (),
11263 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11264 if let Some(inner) = this {
11265 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
11266 ::fidl_next::wire::Box::encode_present(out);
11267 } else {
11268 ::fidl_next::wire::Box::encode_absent(out);
11269 }
11270
11271 Ok(())
11272 }
11273 }
11274
11275 unsafe impl<'a, ___E>
11276 ::fidl_next::EncodeOption<
11277 ::fidl_next::wire::Box<'static, crate::wire::LinkableLinkIntoResponse>,
11278 ___E,
11279 > for &'a LinkableLinkIntoResponse
11280 where
11281 ___E: ::fidl_next::Encoder + ?Sized,
11282 &'a LinkableLinkIntoResponse:
11283 ::fidl_next::Encode<crate::wire::LinkableLinkIntoResponse, ___E>,
11284 {
11285 #[inline]
11286 fn encode_option(
11287 this: ::core::option::Option<Self>,
11288 encoder: &mut ___E,
11289 out: &mut ::core::mem::MaybeUninit<
11290 ::fidl_next::wire::Box<'static, crate::wire::LinkableLinkIntoResponse>,
11291 >,
11292 _: (),
11293 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11294 if let Some(inner) = this {
11295 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
11296 ::fidl_next::wire::Box::encode_present(out);
11297 } else {
11298 ::fidl_next::wire::Box::encode_absent(out);
11299 }
11300
11301 Ok(())
11302 }
11303 }
11304
11305 impl ::fidl_next::FromWire<crate::wire::LinkableLinkIntoResponse> for LinkableLinkIntoResponse {
11306 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
11307 crate::wire::LinkableLinkIntoResponse,
11308 Self,
11309 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
11310
11311 #[inline]
11312 fn from_wire(wire: crate::wire::LinkableLinkIntoResponse) -> Self {
11313 Self {}
11314 }
11315 }
11316
11317 impl ::fidl_next::FromWireRef<crate::wire::LinkableLinkIntoResponse> for LinkableLinkIntoResponse {
11318 #[inline]
11319 fn from_wire_ref(wire: &crate::wire::LinkableLinkIntoResponse) -> Self {
11320 Self {}
11321 }
11322 }
11323
11324 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
11325 #[repr(C)]
11326 pub struct FileAllocateResponse {}
11327
11328 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileAllocateResponse, ___E>
11329 for FileAllocateResponse
11330 where
11331 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11332 {
11333 #[inline]
11334 fn encode(
11335 self,
11336 encoder_: &mut ___E,
11337 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileAllocateResponse>,
11338 _: (),
11339 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11340 ::fidl_next::munge! {
11341 let crate::wire::FileAllocateResponse {
11342
11343 _empty,
11344
11345 } = out_;
11346 }
11347
11348 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
11349
11350 Ok(())
11351 }
11352 }
11353
11354 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileAllocateResponse, ___E>
11355 for &'a FileAllocateResponse
11356 where
11357 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11358 {
11359 #[inline]
11360 fn encode(
11361 self,
11362 encoder_: &mut ___E,
11363 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileAllocateResponse>,
11364 _: (),
11365 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11366 ::fidl_next::munge! {
11367 let crate::wire::FileAllocateResponse {
11368
11369 _empty,
11370
11371
11372 } = out_;
11373 }
11374
11375 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
11376
11377 Ok(())
11378 }
11379 }
11380
11381 unsafe impl<___E>
11382 ::fidl_next::EncodeOption<
11383 ::fidl_next::wire::Box<'static, crate::wire::FileAllocateResponse>,
11384 ___E,
11385 > for FileAllocateResponse
11386 where
11387 ___E: ::fidl_next::Encoder + ?Sized,
11388 FileAllocateResponse: ::fidl_next::Encode<crate::wire::FileAllocateResponse, ___E>,
11389 {
11390 #[inline]
11391 fn encode_option(
11392 this: ::core::option::Option<Self>,
11393 encoder: &mut ___E,
11394 out: &mut ::core::mem::MaybeUninit<
11395 ::fidl_next::wire::Box<'static, crate::wire::FileAllocateResponse>,
11396 >,
11397 _: (),
11398 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11399 if let Some(inner) = this {
11400 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
11401 ::fidl_next::wire::Box::encode_present(out);
11402 } else {
11403 ::fidl_next::wire::Box::encode_absent(out);
11404 }
11405
11406 Ok(())
11407 }
11408 }
11409
11410 unsafe impl<'a, ___E>
11411 ::fidl_next::EncodeOption<
11412 ::fidl_next::wire::Box<'static, crate::wire::FileAllocateResponse>,
11413 ___E,
11414 > for &'a FileAllocateResponse
11415 where
11416 ___E: ::fidl_next::Encoder + ?Sized,
11417 &'a FileAllocateResponse: ::fidl_next::Encode<crate::wire::FileAllocateResponse, ___E>,
11418 {
11419 #[inline]
11420 fn encode_option(
11421 this: ::core::option::Option<Self>,
11422 encoder: &mut ___E,
11423 out: &mut ::core::mem::MaybeUninit<
11424 ::fidl_next::wire::Box<'static, crate::wire::FileAllocateResponse>,
11425 >,
11426 _: (),
11427 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11428 if let Some(inner) = this {
11429 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
11430 ::fidl_next::wire::Box::encode_present(out);
11431 } else {
11432 ::fidl_next::wire::Box::encode_absent(out);
11433 }
11434
11435 Ok(())
11436 }
11437 }
11438
11439 impl ::fidl_next::FromWire<crate::wire::FileAllocateResponse> for FileAllocateResponse {
11440 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
11441 crate::wire::FileAllocateResponse,
11442 Self,
11443 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
11444
11445 #[inline]
11446 fn from_wire(wire: crate::wire::FileAllocateResponse) -> Self {
11447 Self {}
11448 }
11449 }
11450
11451 impl ::fidl_next::FromWireRef<crate::wire::FileAllocateResponse> for FileAllocateResponse {
11452 #[inline]
11453 fn from_wire_ref(wire: &crate::wire::FileAllocateResponse) -> Self {
11454 Self {}
11455 }
11456 }
11457
11458 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
11459 #[repr(C)]
11460 pub struct FileEnableVerityResponse {}
11461
11462 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileEnableVerityResponse, ___E>
11463 for FileEnableVerityResponse
11464 where
11465 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11466 {
11467 #[inline]
11468 fn encode(
11469 self,
11470 encoder_: &mut ___E,
11471 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileEnableVerityResponse>,
11472 _: (),
11473 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11474 ::fidl_next::munge! {
11475 let crate::wire::FileEnableVerityResponse {
11476
11477 _empty,
11478
11479 } = out_;
11480 }
11481
11482 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
11483
11484 Ok(())
11485 }
11486 }
11487
11488 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileEnableVerityResponse, ___E>
11489 for &'a FileEnableVerityResponse
11490 where
11491 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11492 {
11493 #[inline]
11494 fn encode(
11495 self,
11496 encoder_: &mut ___E,
11497 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileEnableVerityResponse>,
11498 _: (),
11499 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11500 ::fidl_next::munge! {
11501 let crate::wire::FileEnableVerityResponse {
11502
11503 _empty,
11504
11505
11506 } = out_;
11507 }
11508
11509 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
11510
11511 Ok(())
11512 }
11513 }
11514
11515 unsafe impl<___E>
11516 ::fidl_next::EncodeOption<
11517 ::fidl_next::wire::Box<'static, crate::wire::FileEnableVerityResponse>,
11518 ___E,
11519 > for FileEnableVerityResponse
11520 where
11521 ___E: ::fidl_next::Encoder + ?Sized,
11522 FileEnableVerityResponse: ::fidl_next::Encode<crate::wire::FileEnableVerityResponse, ___E>,
11523 {
11524 #[inline]
11525 fn encode_option(
11526 this: ::core::option::Option<Self>,
11527 encoder: &mut ___E,
11528 out: &mut ::core::mem::MaybeUninit<
11529 ::fidl_next::wire::Box<'static, crate::wire::FileEnableVerityResponse>,
11530 >,
11531 _: (),
11532 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11533 if let Some(inner) = this {
11534 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
11535 ::fidl_next::wire::Box::encode_present(out);
11536 } else {
11537 ::fidl_next::wire::Box::encode_absent(out);
11538 }
11539
11540 Ok(())
11541 }
11542 }
11543
11544 unsafe impl<'a, ___E>
11545 ::fidl_next::EncodeOption<
11546 ::fidl_next::wire::Box<'static, crate::wire::FileEnableVerityResponse>,
11547 ___E,
11548 > for &'a FileEnableVerityResponse
11549 where
11550 ___E: ::fidl_next::Encoder + ?Sized,
11551 &'a FileEnableVerityResponse:
11552 ::fidl_next::Encode<crate::wire::FileEnableVerityResponse, ___E>,
11553 {
11554 #[inline]
11555 fn encode_option(
11556 this: ::core::option::Option<Self>,
11557 encoder: &mut ___E,
11558 out: &mut ::core::mem::MaybeUninit<
11559 ::fidl_next::wire::Box<'static, crate::wire::FileEnableVerityResponse>,
11560 >,
11561 _: (),
11562 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11563 if let Some(inner) = this {
11564 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
11565 ::fidl_next::wire::Box::encode_present(out);
11566 } else {
11567 ::fidl_next::wire::Box::encode_absent(out);
11568 }
11569
11570 Ok(())
11571 }
11572 }
11573
11574 impl ::fidl_next::FromWire<crate::wire::FileEnableVerityResponse> for FileEnableVerityResponse {
11575 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
11576 crate::wire::FileEnableVerityResponse,
11577 Self,
11578 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
11579
11580 #[inline]
11581 fn from_wire(wire: crate::wire::FileEnableVerityResponse) -> Self {
11582 Self {}
11583 }
11584 }
11585
11586 impl ::fidl_next::FromWireRef<crate::wire::FileEnableVerityResponse> for FileEnableVerityResponse {
11587 #[inline]
11588 fn from_wire_ref(wire: &crate::wire::FileEnableVerityResponse) -> Self {
11589 Self {}
11590 }
11591 }
11592
11593 ::fidl_next::bitflags::bitflags! {
11594 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct FileSignal: u32 {
11595 #[doc = " Indicates the file is ready for reading.\n"]const READABLE = 16777216;
11596 #[doc = " Indicates the file is ready for writing.\n"]const WRITABLE = 33554432;
11597
11598 }
11599 }
11600
11601 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileSignal, ___E> for FileSignal
11602 where
11603 ___E: ?Sized,
11604 {
11605 #[inline]
11606 fn encode(
11607 self,
11608 encoder: &mut ___E,
11609 out: &mut ::core::mem::MaybeUninit<crate::wire::FileSignal>,
11610 _: (),
11611 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11612 ::fidl_next::Encode::encode(&self, encoder, out, ())
11613 }
11614 }
11615
11616 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileSignal, ___E> for &'a FileSignal
11617 where
11618 ___E: ?Sized,
11619 {
11620 #[inline]
11621 fn encode(
11622 self,
11623 _: &mut ___E,
11624 out: &mut ::core::mem::MaybeUninit<crate::wire::FileSignal>,
11625 _: (),
11626 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11627 ::fidl_next::munge!(let crate::wire::FileSignal { value } = out);
11628
11629 if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
11630 return Err(::fidl_next::EncodeError::InvalidStrictBits);
11631 }
11632
11633 let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
11634 Ok(())
11635 }
11636 }
11637
11638 impl ::core::convert::From<crate::wire::FileSignal> for FileSignal {
11639 fn from(wire: crate::wire::FileSignal) -> Self {
11640 Self::from_bits_retain(u32::from(wire.value))
11641 }
11642 }
11643
11644 impl ::fidl_next::FromWire<crate::wire::FileSignal> for FileSignal {
11645 #[inline]
11646 fn from_wire(wire: crate::wire::FileSignal) -> Self {
11647 Self::from(wire)
11648 }
11649 }
11650
11651 impl ::fidl_next::FromWireRef<crate::wire::FileSignal> for FileSignal {
11652 #[inline]
11653 fn from_wire_ref(wire: &crate::wire::FileSignal) -> Self {
11654 Self::from(*wire)
11655 }
11656 }
11657
11658 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
11659 #[repr(C)]
11660 pub struct FilesystemInfo {
11661 pub total_bytes: u64,
11662
11663 pub used_bytes: u64,
11664
11665 pub total_nodes: u64,
11666
11667 pub used_nodes: u64,
11668
11669 pub free_shared_pool_bytes: u64,
11670
11671 pub fs_id: u64,
11672
11673 pub block_size: u32,
11674
11675 pub max_filename_size: u32,
11676
11677 pub fs_type: u32,
11678
11679 pub padding: u32,
11680
11681 pub name: [i8; 32],
11682 }
11683
11684 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FilesystemInfo, ___E> for FilesystemInfo
11685 where
11686 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11687 {
11688 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::FilesystemInfo> = unsafe {
11689 ::fidl_next::CopyOptimization::enable_if(
11690 true
11691
11692 && <
11693 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
11694 >::COPY_OPTIMIZATION.is_enabled()
11695
11696 && <
11697 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
11698 >::COPY_OPTIMIZATION.is_enabled()
11699
11700 && <
11701 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
11702 >::COPY_OPTIMIZATION.is_enabled()
11703
11704 && <
11705 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
11706 >::COPY_OPTIMIZATION.is_enabled()
11707
11708 && <
11709 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
11710 >::COPY_OPTIMIZATION.is_enabled()
11711
11712 && <
11713 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
11714 >::COPY_OPTIMIZATION.is_enabled()
11715
11716 && <
11717 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
11718 >::COPY_OPTIMIZATION.is_enabled()
11719
11720 && <
11721 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
11722 >::COPY_OPTIMIZATION.is_enabled()
11723
11724 && <
11725 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
11726 >::COPY_OPTIMIZATION.is_enabled()
11727
11728 && <
11729 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
11730 >::COPY_OPTIMIZATION.is_enabled()
11731
11732 && <
11733 [i8; 32] as ::fidl_next::Encode<[i8; 32], ___E>
11734 >::COPY_OPTIMIZATION.is_enabled()
11735
11736 )
11737 };
11738
11739 #[inline]
11740 fn encode(
11741 self,
11742 encoder_: &mut ___E,
11743 out_: &mut ::core::mem::MaybeUninit<crate::wire::FilesystemInfo>,
11744 _: (),
11745 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11746 ::fidl_next::munge! {
11747 let crate::wire::FilesystemInfo {
11748 total_bytes,
11749 used_bytes,
11750 total_nodes,
11751 used_nodes,
11752 free_shared_pool_bytes,
11753 fs_id,
11754 block_size,
11755 max_filename_size,
11756 fs_type,
11757 padding,
11758 name,
11759
11760 } = out_;
11761 }
11762
11763 ::fidl_next::Encode::encode(self.total_bytes, encoder_, total_bytes, ())?;
11764
11765 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(total_bytes.as_mut_ptr()) };
11766
11767 ::fidl_next::Encode::encode(self.used_bytes, encoder_, used_bytes, ())?;
11768
11769 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(used_bytes.as_mut_ptr()) };
11770
11771 ::fidl_next::Encode::encode(self.total_nodes, encoder_, total_nodes, ())?;
11772
11773 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(total_nodes.as_mut_ptr()) };
11774
11775 ::fidl_next::Encode::encode(self.used_nodes, encoder_, used_nodes, ())?;
11776
11777 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(used_nodes.as_mut_ptr()) };
11778
11779 ::fidl_next::Encode::encode(
11780 self.free_shared_pool_bytes,
11781 encoder_,
11782 free_shared_pool_bytes,
11783 (),
11784 )?;
11785
11786 let mut _field =
11787 unsafe { ::fidl_next::Slot::new_unchecked(free_shared_pool_bytes.as_mut_ptr()) };
11788
11789 ::fidl_next::Encode::encode(self.fs_id, encoder_, fs_id, ())?;
11790
11791 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(fs_id.as_mut_ptr()) };
11792
11793 ::fidl_next::Encode::encode(self.block_size, encoder_, block_size, ())?;
11794
11795 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(block_size.as_mut_ptr()) };
11796
11797 ::fidl_next::Encode::encode(self.max_filename_size, encoder_, max_filename_size, ())?;
11798
11799 let mut _field =
11800 unsafe { ::fidl_next::Slot::new_unchecked(max_filename_size.as_mut_ptr()) };
11801
11802 ::fidl_next::Encode::encode(self.fs_type, encoder_, fs_type, ())?;
11803
11804 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(fs_type.as_mut_ptr()) };
11805
11806 ::fidl_next::Encode::encode(self.padding, encoder_, padding, ())?;
11807
11808 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(padding.as_mut_ptr()) };
11809
11810 ::fidl_next::Encode::encode(self.name, encoder_, name, ())?;
11811
11812 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
11813
11814 Ok(())
11815 }
11816 }
11817
11818 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FilesystemInfo, ___E> for &'a FilesystemInfo
11819 where
11820 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11821 {
11822 #[inline]
11823 fn encode(
11824 self,
11825 encoder_: &mut ___E,
11826 out_: &mut ::core::mem::MaybeUninit<crate::wire::FilesystemInfo>,
11827 _: (),
11828 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11829 ::fidl_next::munge! {
11830 let crate::wire::FilesystemInfo {
11831
11832 total_bytes,
11833 used_bytes,
11834 total_nodes,
11835 used_nodes,
11836 free_shared_pool_bytes,
11837 fs_id,
11838 block_size,
11839 max_filename_size,
11840 fs_type,
11841 padding,
11842 name,
11843
11844 } = out_;
11845 }
11846
11847 ::fidl_next::Encode::encode(&self.total_bytes, encoder_, total_bytes, ())?;
11848
11849 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(total_bytes.as_mut_ptr()) };
11850
11851 ::fidl_next::Encode::encode(&self.used_bytes, encoder_, used_bytes, ())?;
11852
11853 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(used_bytes.as_mut_ptr()) };
11854
11855 ::fidl_next::Encode::encode(&self.total_nodes, encoder_, total_nodes, ())?;
11856
11857 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(total_nodes.as_mut_ptr()) };
11858
11859 ::fidl_next::Encode::encode(&self.used_nodes, encoder_, used_nodes, ())?;
11860
11861 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(used_nodes.as_mut_ptr()) };
11862
11863 ::fidl_next::Encode::encode(
11864 &self.free_shared_pool_bytes,
11865 encoder_,
11866 free_shared_pool_bytes,
11867 (),
11868 )?;
11869
11870 let mut _field =
11871 unsafe { ::fidl_next::Slot::new_unchecked(free_shared_pool_bytes.as_mut_ptr()) };
11872
11873 ::fidl_next::Encode::encode(&self.fs_id, encoder_, fs_id, ())?;
11874
11875 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(fs_id.as_mut_ptr()) };
11876
11877 ::fidl_next::Encode::encode(&self.block_size, encoder_, block_size, ())?;
11878
11879 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(block_size.as_mut_ptr()) };
11880
11881 ::fidl_next::Encode::encode(&self.max_filename_size, encoder_, max_filename_size, ())?;
11882
11883 let mut _field =
11884 unsafe { ::fidl_next::Slot::new_unchecked(max_filename_size.as_mut_ptr()) };
11885
11886 ::fidl_next::Encode::encode(&self.fs_type, encoder_, fs_type, ())?;
11887
11888 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(fs_type.as_mut_ptr()) };
11889
11890 ::fidl_next::Encode::encode(&self.padding, encoder_, padding, ())?;
11891
11892 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(padding.as_mut_ptr()) };
11893
11894 ::fidl_next::Encode::encode(&self.name, encoder_, name, ())?;
11895
11896 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
11897
11898 Ok(())
11899 }
11900 }
11901
11902 unsafe impl<___E>
11903 ::fidl_next::EncodeOption<
11904 ::fidl_next::wire::Box<'static, crate::wire::FilesystemInfo>,
11905 ___E,
11906 > for FilesystemInfo
11907 where
11908 ___E: ::fidl_next::Encoder + ?Sized,
11909 FilesystemInfo: ::fidl_next::Encode<crate::wire::FilesystemInfo, ___E>,
11910 {
11911 #[inline]
11912 fn encode_option(
11913 this: ::core::option::Option<Self>,
11914 encoder: &mut ___E,
11915 out: &mut ::core::mem::MaybeUninit<
11916 ::fidl_next::wire::Box<'static, crate::wire::FilesystemInfo>,
11917 >,
11918 _: (),
11919 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11920 if let Some(inner) = this {
11921 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
11922 ::fidl_next::wire::Box::encode_present(out);
11923 } else {
11924 ::fidl_next::wire::Box::encode_absent(out);
11925 }
11926
11927 Ok(())
11928 }
11929 }
11930
11931 unsafe impl<'a, ___E>
11932 ::fidl_next::EncodeOption<
11933 ::fidl_next::wire::Box<'static, crate::wire::FilesystemInfo>,
11934 ___E,
11935 > for &'a FilesystemInfo
11936 where
11937 ___E: ::fidl_next::Encoder + ?Sized,
11938 &'a FilesystemInfo: ::fidl_next::Encode<crate::wire::FilesystemInfo, ___E>,
11939 {
11940 #[inline]
11941 fn encode_option(
11942 this: ::core::option::Option<Self>,
11943 encoder: &mut ___E,
11944 out: &mut ::core::mem::MaybeUninit<
11945 ::fidl_next::wire::Box<'static, crate::wire::FilesystemInfo>,
11946 >,
11947 _: (),
11948 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11949 if let Some(inner) = this {
11950 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
11951 ::fidl_next::wire::Box::encode_present(out);
11952 } else {
11953 ::fidl_next::wire::Box::encode_absent(out);
11954 }
11955
11956 Ok(())
11957 }
11958 }
11959
11960 impl ::fidl_next::FromWire<crate::wire::FilesystemInfo> for FilesystemInfo {
11961 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::FilesystemInfo, Self> = unsafe {
11962 ::fidl_next::CopyOptimization::enable_if(
11963 true
11964 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
11965 .is_enabled()
11966 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
11967 .is_enabled()
11968 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
11969 .is_enabled()
11970 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
11971 .is_enabled()
11972 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
11973 .is_enabled()
11974 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
11975 .is_enabled()
11976 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
11977 .is_enabled()
11978 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
11979 .is_enabled()
11980 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
11981 .is_enabled()
11982 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
11983 .is_enabled()
11984 && <[i8; 32] as ::fidl_next::FromWire<[i8; 32]>>::COPY_OPTIMIZATION
11985 .is_enabled(),
11986 )
11987 };
11988
11989 #[inline]
11990 fn from_wire(wire: crate::wire::FilesystemInfo) -> Self {
11991 Self {
11992 total_bytes: ::fidl_next::FromWire::from_wire(wire.total_bytes),
11993
11994 used_bytes: ::fidl_next::FromWire::from_wire(wire.used_bytes),
11995
11996 total_nodes: ::fidl_next::FromWire::from_wire(wire.total_nodes),
11997
11998 used_nodes: ::fidl_next::FromWire::from_wire(wire.used_nodes),
11999
12000 free_shared_pool_bytes: ::fidl_next::FromWire::from_wire(
12001 wire.free_shared_pool_bytes,
12002 ),
12003
12004 fs_id: ::fidl_next::FromWire::from_wire(wire.fs_id),
12005
12006 block_size: ::fidl_next::FromWire::from_wire(wire.block_size),
12007
12008 max_filename_size: ::fidl_next::FromWire::from_wire(wire.max_filename_size),
12009
12010 fs_type: ::fidl_next::FromWire::from_wire(wire.fs_type),
12011
12012 padding: ::fidl_next::FromWire::from_wire(wire.padding),
12013
12014 name: ::fidl_next::FromWire::from_wire(wire.name),
12015 }
12016 }
12017 }
12018
12019 impl ::fidl_next::FromWireRef<crate::wire::FilesystemInfo> for FilesystemInfo {
12020 #[inline]
12021 fn from_wire_ref(wire: &crate::wire::FilesystemInfo) -> Self {
12022 Self {
12023 total_bytes: ::fidl_next::FromWireRef::from_wire_ref(&wire.total_bytes),
12024
12025 used_bytes: ::fidl_next::FromWireRef::from_wire_ref(&wire.used_bytes),
12026
12027 total_nodes: ::fidl_next::FromWireRef::from_wire_ref(&wire.total_nodes),
12028
12029 used_nodes: ::fidl_next::FromWireRef::from_wire_ref(&wire.used_nodes),
12030
12031 free_shared_pool_bytes: ::fidl_next::FromWireRef::from_wire_ref(
12032 &wire.free_shared_pool_bytes,
12033 ),
12034
12035 fs_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.fs_id),
12036
12037 block_size: ::fidl_next::FromWireRef::from_wire_ref(&wire.block_size),
12038
12039 max_filename_size: ::fidl_next::FromWireRef::from_wire_ref(&wire.max_filename_size),
12040
12041 fs_type: ::fidl_next::FromWireRef::from_wire_ref(&wire.fs_type),
12042
12043 padding: ::fidl_next::FromWireRef::from_wire_ref(&wire.padding),
12044
12045 name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name),
12046 }
12047 }
12048 }
12049
12050 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
12051 #[repr(C)]
12052 pub struct Service {}
12053
12054 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Service, ___E> for Service
12055 where
12056 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12057 {
12058 #[inline]
12059 fn encode(
12060 self,
12061 encoder_: &mut ___E,
12062 out_: &mut ::core::mem::MaybeUninit<crate::wire::Service>,
12063 _: (),
12064 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12065 ::fidl_next::munge! {
12066 let crate::wire::Service {
12067
12068 _empty,
12069
12070 } = out_;
12071 }
12072
12073 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
12074
12075 Ok(())
12076 }
12077 }
12078
12079 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Service, ___E> for &'a Service
12080 where
12081 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12082 {
12083 #[inline]
12084 fn encode(
12085 self,
12086 encoder_: &mut ___E,
12087 out_: &mut ::core::mem::MaybeUninit<crate::wire::Service>,
12088 _: (),
12089 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12090 ::fidl_next::munge! {
12091 let crate::wire::Service {
12092
12093 _empty,
12094
12095
12096 } = out_;
12097 }
12098
12099 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
12100
12101 Ok(())
12102 }
12103 }
12104
12105 unsafe impl<___E>
12106 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Service>, ___E>
12107 for Service
12108 where
12109 ___E: ::fidl_next::Encoder + ?Sized,
12110 Service: ::fidl_next::Encode<crate::wire::Service, ___E>,
12111 {
12112 #[inline]
12113 fn encode_option(
12114 this: ::core::option::Option<Self>,
12115 encoder: &mut ___E,
12116 out: &mut ::core::mem::MaybeUninit<
12117 ::fidl_next::wire::Box<'static, crate::wire::Service>,
12118 >,
12119 _: (),
12120 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12121 if let Some(inner) = this {
12122 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
12123 ::fidl_next::wire::Box::encode_present(out);
12124 } else {
12125 ::fidl_next::wire::Box::encode_absent(out);
12126 }
12127
12128 Ok(())
12129 }
12130 }
12131
12132 unsafe impl<'a, ___E>
12133 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Service>, ___E>
12134 for &'a Service
12135 where
12136 ___E: ::fidl_next::Encoder + ?Sized,
12137 &'a Service: ::fidl_next::Encode<crate::wire::Service, ___E>,
12138 {
12139 #[inline]
12140 fn encode_option(
12141 this: ::core::option::Option<Self>,
12142 encoder: &mut ___E,
12143 out: &mut ::core::mem::MaybeUninit<
12144 ::fidl_next::wire::Box<'static, crate::wire::Service>,
12145 >,
12146 _: (),
12147 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12148 if let Some(inner) = this {
12149 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
12150 ::fidl_next::wire::Box::encode_present(out);
12151 } else {
12152 ::fidl_next::wire::Box::encode_absent(out);
12153 }
12154
12155 Ok(())
12156 }
12157 }
12158
12159 impl ::fidl_next::FromWire<crate::wire::Service> for Service {
12160 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::Service, Self> =
12161 unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
12162
12163 #[inline]
12164 fn from_wire(wire: crate::wire::Service) -> Self {
12165 Self {}
12166 }
12167 }
12168
12169 impl ::fidl_next::FromWireRef<crate::wire::Service> for Service {
12170 #[inline]
12171 fn from_wire_ref(wire: &crate::wire::Service) -> Self {
12172 Self {}
12173 }
12174 }
12175
12176 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
12177 pub struct SymlinkObject {
12178 pub target: ::std::vec::Vec<u8>,
12179 }
12180
12181 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SymlinkObject<'static>, ___E> for SymlinkObject
12182 where
12183 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12184 ___E: ::fidl_next::Encoder,
12185 {
12186 #[inline]
12187 fn encode(
12188 self,
12189 encoder_: &mut ___E,
12190 out_: &mut ::core::mem::MaybeUninit<crate::wire::SymlinkObject<'static>>,
12191 _: (),
12192 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12193 ::fidl_next::munge! {
12194 let crate::wire::SymlinkObject {
12195 target,
12196
12197 } = out_;
12198 }
12199
12200 ::fidl_next::Encode::encode(self.target, encoder_, target, (4095, ()))?;
12201
12202 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(target.as_mut_ptr()) };
12203 ::fidl_next::Constrained::validate(_field, (4095, ()))?;
12204
12205 Ok(())
12206 }
12207 }
12208
12209 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SymlinkObject<'static>, ___E>
12210 for &'a SymlinkObject
12211 where
12212 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12213 ___E: ::fidl_next::Encoder,
12214 {
12215 #[inline]
12216 fn encode(
12217 self,
12218 encoder_: &mut ___E,
12219 out_: &mut ::core::mem::MaybeUninit<crate::wire::SymlinkObject<'static>>,
12220 _: (),
12221 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12222 ::fidl_next::munge! {
12223 let crate::wire::SymlinkObject {
12224
12225 target,
12226
12227 } = out_;
12228 }
12229
12230 ::fidl_next::Encode::encode(&self.target, encoder_, target, (4095, ()))?;
12231
12232 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(target.as_mut_ptr()) };
12233 ::fidl_next::Constrained::validate(_field, (4095, ()))?;
12234
12235 Ok(())
12236 }
12237 }
12238
12239 unsafe impl<___E>
12240 ::fidl_next::EncodeOption<
12241 ::fidl_next::wire::Box<'static, crate::wire::SymlinkObject<'static>>,
12242 ___E,
12243 > for SymlinkObject
12244 where
12245 ___E: ::fidl_next::Encoder + ?Sized,
12246 SymlinkObject: ::fidl_next::Encode<crate::wire::SymlinkObject<'static>, ___E>,
12247 {
12248 #[inline]
12249 fn encode_option(
12250 this: ::core::option::Option<Self>,
12251 encoder: &mut ___E,
12252 out: &mut ::core::mem::MaybeUninit<
12253 ::fidl_next::wire::Box<'static, crate::wire::SymlinkObject<'static>>,
12254 >,
12255 _: (),
12256 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12257 if let Some(inner) = this {
12258 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
12259 ::fidl_next::wire::Box::encode_present(out);
12260 } else {
12261 ::fidl_next::wire::Box::encode_absent(out);
12262 }
12263
12264 Ok(())
12265 }
12266 }
12267
12268 unsafe impl<'a, ___E>
12269 ::fidl_next::EncodeOption<
12270 ::fidl_next::wire::Box<'static, crate::wire::SymlinkObject<'static>>,
12271 ___E,
12272 > for &'a SymlinkObject
12273 where
12274 ___E: ::fidl_next::Encoder + ?Sized,
12275 &'a SymlinkObject: ::fidl_next::Encode<crate::wire::SymlinkObject<'static>, ___E>,
12276 {
12277 #[inline]
12278 fn encode_option(
12279 this: ::core::option::Option<Self>,
12280 encoder: &mut ___E,
12281 out: &mut ::core::mem::MaybeUninit<
12282 ::fidl_next::wire::Box<'static, crate::wire::SymlinkObject<'static>>,
12283 >,
12284 _: (),
12285 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12286 if let Some(inner) = this {
12287 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
12288 ::fidl_next::wire::Box::encode_present(out);
12289 } else {
12290 ::fidl_next::wire::Box::encode_absent(out);
12291 }
12292
12293 Ok(())
12294 }
12295 }
12296
12297 impl<'de> ::fidl_next::FromWire<crate::wire::SymlinkObject<'de>> for SymlinkObject {
12298 #[inline]
12299 fn from_wire(wire: crate::wire::SymlinkObject<'de>) -> Self {
12300 Self { target: ::fidl_next::FromWire::from_wire(wire.target) }
12301 }
12302 }
12303
12304 impl<'de> ::fidl_next::FromWireRef<crate::wire::SymlinkObject<'de>> for SymlinkObject {
12305 #[inline]
12306 fn from_wire_ref(wire: &crate::wire::SymlinkObject<'de>) -> Self {
12307 Self { target: ::fidl_next::FromWireRef::from_wire_ref(&wire.target) }
12308 }
12309 }
12310
12311 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
12312 #[repr(u8)]
12313 pub enum WatchEvent {
12314 Deleted = 0,
12315 Added = 1,
12316 Removed = 2,
12317 Existing = 3,
12318 Idle = 4,
12319 }
12320 impl ::core::convert::TryFrom<u8> for WatchEvent {
12321 type Error = ::fidl_next::UnknownStrictEnumMemberError;
12322 fn try_from(
12323 value: u8,
12324 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
12325 match value {
12326 0 => Ok(Self::Deleted),
12327 1 => Ok(Self::Added),
12328 2 => Ok(Self::Removed),
12329 3 => Ok(Self::Existing),
12330 4 => Ok(Self::Idle),
12331
12332 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
12333 }
12334 }
12335 }
12336
12337 unsafe impl<___E> ::fidl_next::Encode<crate::wire::WatchEvent, ___E> for WatchEvent
12338 where
12339 ___E: ?Sized,
12340 {
12341 #[inline]
12342 fn encode(
12343 self,
12344 encoder: &mut ___E,
12345 out: &mut ::core::mem::MaybeUninit<crate::wire::WatchEvent>,
12346 _: (),
12347 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12348 ::fidl_next::Encode::encode(&self, encoder, out, ())
12349 }
12350 }
12351
12352 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WatchEvent, ___E> for &'a WatchEvent
12353 where
12354 ___E: ?Sized,
12355 {
12356 #[inline]
12357 fn encode(
12358 self,
12359 encoder: &mut ___E,
12360 out: &mut ::core::mem::MaybeUninit<crate::wire::WatchEvent>,
12361 _: (),
12362 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12363 ::fidl_next::munge!(let crate::wire::WatchEvent { value } = out);
12364 let _ = value.write(u8::from(match *self {
12365 WatchEvent::Deleted => 0,
12366
12367 WatchEvent::Added => 1,
12368
12369 WatchEvent::Removed => 2,
12370
12371 WatchEvent::Existing => 3,
12372
12373 WatchEvent::Idle => 4,
12374 }));
12375
12376 Ok(())
12377 }
12378 }
12379
12380 impl ::core::convert::From<crate::wire::WatchEvent> for WatchEvent {
12381 fn from(wire: crate::wire::WatchEvent) -> Self {
12382 match u8::from(wire.value) {
12383 0 => Self::Deleted,
12384
12385 1 => Self::Added,
12386
12387 2 => Self::Removed,
12388
12389 3 => Self::Existing,
12390
12391 4 => Self::Idle,
12392
12393 _ => unsafe { ::core::hint::unreachable_unchecked() },
12394 }
12395 }
12396 }
12397
12398 impl ::fidl_next::FromWire<crate::wire::WatchEvent> for WatchEvent {
12399 #[inline]
12400 fn from_wire(wire: crate::wire::WatchEvent) -> Self {
12401 Self::from(wire)
12402 }
12403 }
12404
12405 impl ::fidl_next::FromWireRef<crate::wire::WatchEvent> for WatchEvent {
12406 #[inline]
12407 fn from_wire_ref(wire: &crate::wire::WatchEvent) -> Self {
12408 Self::from(*wire)
12409 }
12410 }
12411}
12412
12413pub mod wire {
12414
12415 #[derive(Clone, Copy, Debug)]
12417 #[repr(transparent)]
12418 pub struct Operations {
12419 pub(crate) value: ::fidl_next::wire::Uint64,
12420 }
12421
12422 impl ::fidl_next::Constrained for Operations {
12423 type Constraint = ();
12424
12425 fn validate(
12426 _: ::fidl_next::Slot<'_, Self>,
12427 _: Self::Constraint,
12428 ) -> Result<(), ::fidl_next::ValidationError> {
12429 Ok(())
12430 }
12431 }
12432
12433 unsafe impl ::fidl_next::Wire for Operations {
12434 type Narrowed<'de> = Self;
12435
12436 #[inline]
12437 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
12438 }
12440 }
12441
12442 unsafe impl<___D> ::fidl_next::Decode<___D> for Operations
12443 where
12444 ___D: ?Sized,
12445 {
12446 fn decode(
12447 slot: ::fidl_next::Slot<'_, Self>,
12448 _: &mut ___D,
12449 _: (),
12450 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12451 ::fidl_next::munge!(let Self { value } = slot);
12452 let set = u64::from(*value);
12453 if set & !crate::natural::Operations::all().bits() != 0 {
12454 return Err(::fidl_next::DecodeError::InvalidBits {
12455 expected: crate::natural::Operations::all().bits() as usize,
12456 actual: set as usize,
12457 });
12458 }
12459
12460 Ok(())
12461 }
12462 }
12463
12464 impl ::core::convert::From<crate::natural::Operations> for Operations {
12465 fn from(natural: crate::natural::Operations) -> Self {
12466 Self { value: ::fidl_next::wire::Uint64::from(natural.bits()) }
12467 }
12468 }
12469
12470 impl ::fidl_next::IntoNatural for Operations {
12471 type Natural = crate::natural::Operations;
12472 }
12473
12474 pub type Abilities = crate::wire::Operations;
12476
12477 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
12479 #[repr(transparent)]
12480 pub struct SeekOrigin {
12481 pub(crate) value: ::fidl_next::wire::Uint32,
12482 }
12483
12484 impl ::fidl_next::Constrained for SeekOrigin {
12485 type Constraint = ();
12486
12487 fn validate(
12488 _: ::fidl_next::Slot<'_, Self>,
12489 _: Self::Constraint,
12490 ) -> Result<(), ::fidl_next::ValidationError> {
12491 Ok(())
12492 }
12493 }
12494
12495 unsafe impl ::fidl_next::Wire for SeekOrigin {
12496 type Narrowed<'de> = Self;
12497
12498 #[inline]
12499 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
12500 }
12502 }
12503
12504 impl SeekOrigin {
12505 pub const START: SeekOrigin = SeekOrigin { value: ::fidl_next::wire::Uint32(0) };
12506
12507 pub const CURRENT: SeekOrigin = SeekOrigin { value: ::fidl_next::wire::Uint32(1) };
12508
12509 pub const END: SeekOrigin = SeekOrigin { value: ::fidl_next::wire::Uint32(2) };
12510 }
12511
12512 unsafe impl<___D> ::fidl_next::Decode<___D> for SeekOrigin
12513 where
12514 ___D: ?Sized,
12515 {
12516 fn decode(
12517 slot: ::fidl_next::Slot<'_, Self>,
12518 _: &mut ___D,
12519 _: (),
12520 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12521 ::fidl_next::munge!(let Self { value } = slot);
12522
12523 match u32::from(*value) {
12524 0 | 1 | 2 => (),
12525 unknown => {
12526 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
12527 }
12528 }
12529
12530 Ok(())
12531 }
12532 }
12533
12534 impl ::core::convert::From<crate::natural::SeekOrigin> for SeekOrigin {
12535 fn from(natural: crate::natural::SeekOrigin) -> Self {
12536 match natural {
12537 crate::natural::SeekOrigin::Start => SeekOrigin::START,
12538
12539 crate::natural::SeekOrigin::Current => SeekOrigin::CURRENT,
12540
12541 crate::natural::SeekOrigin::End => SeekOrigin::END,
12542 }
12543 }
12544 }
12545
12546 impl ::fidl_next::IntoNatural for SeekOrigin {
12547 type Natural = crate::natural::SeekOrigin;
12548 }
12549
12550 #[derive(Clone, Debug)]
12552 #[repr(C)]
12553 pub struct AdvisoryLockRange {
12554 pub origin: crate::wire::SeekOrigin,
12555
12556 pub offset: ::fidl_next::wire::Int64,
12557
12558 pub length: ::fidl_next::wire::Int64,
12559 }
12560
12561 static_assertions::const_assert_eq!(std::mem::size_of::<AdvisoryLockRange>(), 24);
12562 static_assertions::const_assert_eq!(std::mem::align_of::<AdvisoryLockRange>(), 8);
12563
12564 static_assertions::const_assert_eq!(std::mem::offset_of!(AdvisoryLockRange, origin), 0);
12565
12566 static_assertions::const_assert_eq!(std::mem::offset_of!(AdvisoryLockRange, offset), 8);
12567
12568 static_assertions::const_assert_eq!(std::mem::offset_of!(AdvisoryLockRange, length), 16);
12569
12570 impl ::fidl_next::Constrained for AdvisoryLockRange {
12571 type Constraint = ();
12572
12573 fn validate(
12574 _: ::fidl_next::Slot<'_, Self>,
12575 _: Self::Constraint,
12576 ) -> Result<(), ::fidl_next::ValidationError> {
12577 Ok(())
12578 }
12579 }
12580
12581 unsafe impl ::fidl_next::Wire for AdvisoryLockRange {
12582 type Narrowed<'de> = AdvisoryLockRange;
12583
12584 #[inline]
12585 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12586 ::fidl_next::munge! {
12587 let Self {
12588
12589 origin,
12590 offset,
12591 length,
12592
12593 } = &mut *out_;
12594 }
12595
12596 ::fidl_next::Wire::zero_padding(origin);
12597
12598 ::fidl_next::Wire::zero_padding(offset);
12599
12600 ::fidl_next::Wire::zero_padding(length);
12601
12602 unsafe {
12603 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
12604 }
12605 }
12606 }
12607
12608 unsafe impl<___D> ::fidl_next::Decode<___D> for AdvisoryLockRange
12609 where
12610 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12611 {
12612 fn decode(
12613 slot_: ::fidl_next::Slot<'_, Self>,
12614 decoder_: &mut ___D,
12615 _: (),
12616 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12617 if slot_.as_bytes()[4..8] != [0u8; 4] {
12618 return Err(::fidl_next::DecodeError::InvalidPadding);
12619 }
12620
12621 ::fidl_next::munge! {
12622 let Self {
12623
12624 mut origin,
12625 mut offset,
12626 mut length,
12627
12628 } = slot_;
12629 }
12630
12631 let _field = origin.as_mut();
12632
12633 ::fidl_next::Decode::decode(origin.as_mut(), decoder_, ())?;
12634
12635 let _field = offset.as_mut();
12636
12637 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
12638
12639 let _field = length.as_mut();
12640
12641 ::fidl_next::Decode::decode(length.as_mut(), decoder_, ())?;
12642
12643 Ok(())
12644 }
12645 }
12646
12647 impl ::fidl_next::IntoNatural for AdvisoryLockRange {
12648 type Natural = crate::natural::AdvisoryLockRange;
12649 }
12650
12651 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
12653 #[repr(transparent)]
12654 pub struct AdvisoryLockType {
12655 pub(crate) value: ::fidl_next::wire::Uint32,
12656 }
12657
12658 impl ::fidl_next::Constrained for AdvisoryLockType {
12659 type Constraint = ();
12660
12661 fn validate(
12662 _: ::fidl_next::Slot<'_, Self>,
12663 _: Self::Constraint,
12664 ) -> Result<(), ::fidl_next::ValidationError> {
12665 Ok(())
12666 }
12667 }
12668
12669 unsafe impl ::fidl_next::Wire for AdvisoryLockType {
12670 type Narrowed<'de> = Self;
12671
12672 #[inline]
12673 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
12674 }
12676 }
12677
12678 impl AdvisoryLockType {
12679 pub const READ: AdvisoryLockType = AdvisoryLockType { value: ::fidl_next::wire::Uint32(1) };
12680
12681 pub const WRITE: AdvisoryLockType =
12682 AdvisoryLockType { value: ::fidl_next::wire::Uint32(2) };
12683
12684 pub const UNLOCK: AdvisoryLockType =
12685 AdvisoryLockType { value: ::fidl_next::wire::Uint32(3) };
12686 }
12687
12688 unsafe impl<___D> ::fidl_next::Decode<___D> for AdvisoryLockType
12689 where
12690 ___D: ?Sized,
12691 {
12692 fn decode(
12693 slot: ::fidl_next::Slot<'_, Self>,
12694 _: &mut ___D,
12695 _: (),
12696 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12697 ::fidl_next::munge!(let Self { value } = slot);
12698
12699 match u32::from(*value) {
12700 1 | 2 | 3 => (),
12701 unknown => {
12702 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
12703 }
12704 }
12705
12706 Ok(())
12707 }
12708 }
12709
12710 impl ::core::convert::From<crate::natural::AdvisoryLockType> for AdvisoryLockType {
12711 fn from(natural: crate::natural::AdvisoryLockType) -> Self {
12712 match natural {
12713 crate::natural::AdvisoryLockType::Read => AdvisoryLockType::READ,
12714
12715 crate::natural::AdvisoryLockType::Write => AdvisoryLockType::WRITE,
12716
12717 crate::natural::AdvisoryLockType::Unlock => AdvisoryLockType::UNLOCK,
12718 }
12719 }
12720 }
12721
12722 impl ::fidl_next::IntoNatural for AdvisoryLockType {
12723 type Natural = crate::natural::AdvisoryLockType;
12724 }
12725
12726 #[repr(C)]
12728 pub struct AdvisoryLockRequest<'de> {
12729 pub(crate) table: ::fidl_next::wire::Table<'de>,
12730 }
12731
12732 impl<'de> Drop for AdvisoryLockRequest<'de> {
12733 fn drop(&mut self) {
12734 let _ = self.table.get(1).map(|envelope| unsafe {
12735 envelope.read_unchecked::<crate::wire::AdvisoryLockType>()
12736 });
12737
12738 let _ = self.table.get(2).map(|envelope| unsafe {
12739 envelope.read_unchecked::<crate::wire::AdvisoryLockRange>()
12740 });
12741
12742 let _ = self.table.get(3).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });
12743 }
12744 }
12745
12746 impl ::fidl_next::Constrained for AdvisoryLockRequest<'_> {
12747 type Constraint = ();
12748
12749 fn validate(
12750 _: ::fidl_next::Slot<'_, Self>,
12751 _: Self::Constraint,
12752 ) -> Result<(), ::fidl_next::ValidationError> {
12753 Ok(())
12754 }
12755 }
12756
12757 unsafe impl ::fidl_next::Wire for AdvisoryLockRequest<'static> {
12758 type Narrowed<'de> = AdvisoryLockRequest<'de>;
12759
12760 #[inline]
12761 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
12762 ::fidl_next::munge!(let Self { table } = out);
12763 ::fidl_next::wire::Table::zero_padding(table);
12764 }
12765 }
12766
12767 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for AdvisoryLockRequest<'de>
12768 where
12769 ___D: ::fidl_next::Decoder<'de> + ?Sized,
12770 {
12771 fn decode(
12772 slot: ::fidl_next::Slot<'_, Self>,
12773 decoder: &mut ___D,
12774 _: (),
12775 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12776 ::fidl_next::munge!(let Self { table } = slot);
12777
12778 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
12779 match ordinal {
12780 0 => unsafe { ::core::hint::unreachable_unchecked() },
12781
12782 1 => {
12783 ::fidl_next::wire::Envelope::decode_as::<
12784 ___D,
12785 crate::wire::AdvisoryLockType,
12786 >(slot.as_mut(), decoder, ())?;
12787
12788 Ok(())
12789 }
12790
12791 2 => {
12792 ::fidl_next::wire::Envelope::decode_as::<
12793 ___D,
12794 crate::wire::AdvisoryLockRange,
12795 >(slot.as_mut(), decoder, ())?;
12796
12797 Ok(())
12798 }
12799
12800 3 => {
12801 ::fidl_next::wire::Envelope::decode_as::<___D, bool>(
12802 slot.as_mut(),
12803 decoder,
12804 (),
12805 )?;
12806
12807 Ok(())
12808 }
12809
12810 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
12811 }
12812 })
12813 }
12814 }
12815
12816 impl<'de> AdvisoryLockRequest<'de> {
12817 pub fn type_(&self) -> ::core::option::Option<&crate::wire::AdvisoryLockType> {
12818 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
12819 }
12820
12821 pub fn range(&self) -> ::core::option::Option<&crate::wire::AdvisoryLockRange> {
12822 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
12823 }
12824
12825 pub fn wait(&self) -> ::core::option::Option<&bool> {
12826 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
12827 }
12828 }
12829
12830 impl<'de> ::core::fmt::Debug for AdvisoryLockRequest<'de> {
12831 fn fmt(
12832 &self,
12833 f: &mut ::core::fmt::Formatter<'_>,
12834 ) -> ::core::result::Result<(), ::core::fmt::Error> {
12835 f.debug_struct("AdvisoryLockRequest")
12836 .field("type_", &self.type_())
12837 .field("range", &self.range())
12838 .field("wait", &self.wait())
12839 .finish()
12840 }
12841 }
12842
12843 impl<'de> ::fidl_next::IntoNatural for AdvisoryLockRequest<'de> {
12844 type Natural = crate::natural::AdvisoryLockRequest;
12845 }
12846
12847 #[derive(Debug)]
12849 #[repr(C)]
12850 pub struct AdvisoryLockingAdvisoryLockRequest<'de> {
12851 pub request: crate::wire::AdvisoryLockRequest<'de>,
12852 }
12853
12854 static_assertions::const_assert_eq!(
12855 std::mem::size_of::<AdvisoryLockingAdvisoryLockRequest<'_>>(),
12856 16
12857 );
12858 static_assertions::const_assert_eq!(
12859 std::mem::align_of::<AdvisoryLockingAdvisoryLockRequest<'_>>(),
12860 8
12861 );
12862
12863 static_assertions::const_assert_eq!(
12864 std::mem::offset_of!(AdvisoryLockingAdvisoryLockRequest<'_>, request),
12865 0
12866 );
12867
12868 impl ::fidl_next::Constrained for AdvisoryLockingAdvisoryLockRequest<'_> {
12869 type Constraint = ();
12870
12871 fn validate(
12872 _: ::fidl_next::Slot<'_, Self>,
12873 _: Self::Constraint,
12874 ) -> Result<(), ::fidl_next::ValidationError> {
12875 Ok(())
12876 }
12877 }
12878
12879 unsafe impl ::fidl_next::Wire for AdvisoryLockingAdvisoryLockRequest<'static> {
12880 type Narrowed<'de> = AdvisoryLockingAdvisoryLockRequest<'de>;
12881
12882 #[inline]
12883 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12884 ::fidl_next::munge! {
12885 let Self {
12886
12887 request,
12888
12889 } = &mut *out_;
12890 }
12891
12892 ::fidl_next::Wire::zero_padding(request);
12893 }
12894 }
12895
12896 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for AdvisoryLockingAdvisoryLockRequest<'de>
12897 where
12898 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12899 ___D: ::fidl_next::Decoder<'de>,
12900 {
12901 fn decode(
12902 slot_: ::fidl_next::Slot<'_, Self>,
12903 decoder_: &mut ___D,
12904 _: (),
12905 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12906 ::fidl_next::munge! {
12907 let Self {
12908
12909 mut request,
12910
12911 } = slot_;
12912 }
12913
12914 let _field = request.as_mut();
12915
12916 ::fidl_next::Decode::decode(request.as_mut(), decoder_, ())?;
12917
12918 Ok(())
12919 }
12920 }
12921
12922 impl<'de> ::fidl_next::IntoNatural for AdvisoryLockingAdvisoryLockRequest<'de> {
12923 type Natural = crate::natural::AdvisoryLockingAdvisoryLockRequest;
12924 }
12925
12926 #[derive(Clone, Debug)]
12928 #[repr(C)]
12929 pub struct AdvisoryLockingAdvisoryLockResponse {
12930 pub(crate) _empty: fidl_next::wire::EmptyStruct,
12931 }
12932
12933 static_assertions::const_assert_eq!(
12934 std::mem::size_of::<AdvisoryLockingAdvisoryLockResponse>(),
12935 1
12936 );
12937 static_assertions::const_assert_eq!(
12938 std::mem::align_of::<AdvisoryLockingAdvisoryLockResponse>(),
12939 1
12940 );
12941
12942 impl ::fidl_next::Constrained for AdvisoryLockingAdvisoryLockResponse {
12943 type Constraint = ();
12944
12945 fn validate(
12946 _: ::fidl_next::Slot<'_, Self>,
12947 _: Self::Constraint,
12948 ) -> Result<(), ::fidl_next::ValidationError> {
12949 Ok(())
12950 }
12951 }
12952
12953 unsafe impl ::fidl_next::Wire for AdvisoryLockingAdvisoryLockResponse {
12954 type Narrowed<'de> = AdvisoryLockingAdvisoryLockResponse;
12955
12956 #[inline]
12957 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12958 ::fidl_next::munge! {
12959 let Self {
12960
12961 _empty,
12962
12963
12964 } = &mut *out_;
12965 }
12966 }
12967 }
12968
12969 unsafe impl<___D> ::fidl_next::Decode<___D> for AdvisoryLockingAdvisoryLockResponse
12970 where
12971 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12972 {
12973 fn decode(
12974 slot_: ::fidl_next::Slot<'_, Self>,
12975 decoder_: &mut ___D,
12976 _: (),
12977 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12978 ::fidl_next::munge! {
12979 let Self {
12980
12981 mut _empty,
12982
12983
12984 } = slot_;
12985 }
12986
12987 if _empty.as_bytes() != &[0u8] {
12988 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
12989 }
12990
12991 Ok(())
12992 }
12993 }
12994
12995 impl ::fidl_next::IntoNatural for AdvisoryLockingAdvisoryLockResponse {
12996 type Natural = crate::natural::AdvisoryLockingAdvisoryLockResponse;
12997 }
12998
12999 #[derive(Clone, Copy, Debug)]
13001 #[repr(transparent)]
13002 pub struct AllocateMode {
13003 pub(crate) value: ::fidl_next::wire::Uint32,
13004 }
13005
13006 impl ::fidl_next::Constrained for AllocateMode {
13007 type Constraint = ();
13008
13009 fn validate(
13010 _: ::fidl_next::Slot<'_, Self>,
13011 _: Self::Constraint,
13012 ) -> Result<(), ::fidl_next::ValidationError> {
13013 Ok(())
13014 }
13015 }
13016
13017 unsafe impl ::fidl_next::Wire for AllocateMode {
13018 type Narrowed<'de> = Self;
13019
13020 #[inline]
13021 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
13022 }
13024 }
13025
13026 unsafe impl<___D> ::fidl_next::Decode<___D> for AllocateMode
13027 where
13028 ___D: ?Sized,
13029 {
13030 fn decode(
13031 slot: ::fidl_next::Slot<'_, Self>,
13032 _: &mut ___D,
13033 _: (),
13034 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13035 Ok(())
13036 }
13037 }
13038
13039 impl ::core::convert::From<crate::natural::AllocateMode> for AllocateMode {
13040 fn from(natural: crate::natural::AllocateMode) -> Self {
13041 Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
13042 }
13043 }
13044
13045 impl ::fidl_next::IntoNatural for AllocateMode {
13046 type Natural = crate::natural::AllocateMode;
13047 }
13048
13049 pub type Rights = crate::wire::Operations;
13051
13052 pub type Id = ::fidl_next::wire::Uint64;
13054
13055 #[derive(Clone, Copy, Debug)]
13057 #[repr(transparent)]
13058 pub struct OpenFlags {
13059 pub(crate) value: ::fidl_next::wire::Uint32,
13060 }
13061
13062 impl ::fidl_next::Constrained for OpenFlags {
13063 type Constraint = ();
13064
13065 fn validate(
13066 _: ::fidl_next::Slot<'_, Self>,
13067 _: Self::Constraint,
13068 ) -> Result<(), ::fidl_next::ValidationError> {
13069 Ok(())
13070 }
13071 }
13072
13073 unsafe impl ::fidl_next::Wire for OpenFlags {
13074 type Narrowed<'de> = Self;
13075
13076 #[inline]
13077 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
13078 }
13080 }
13081
13082 unsafe impl<___D> ::fidl_next::Decode<___D> for OpenFlags
13083 where
13084 ___D: ?Sized,
13085 {
13086 fn decode(
13087 slot: ::fidl_next::Slot<'_, Self>,
13088 _: &mut ___D,
13089 _: (),
13090 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13091 ::fidl_next::munge!(let Self { value } = slot);
13092 let set = u32::from(*value);
13093 if set & !crate::natural::OpenFlags::all().bits() != 0 {
13094 return Err(::fidl_next::DecodeError::InvalidBits {
13095 expected: crate::natural::OpenFlags::all().bits() as usize,
13096 actual: set as usize,
13097 });
13098 }
13099
13100 Ok(())
13101 }
13102 }
13103
13104 impl ::core::convert::From<crate::natural::OpenFlags> for OpenFlags {
13105 fn from(natural: crate::natural::OpenFlags) -> Self {
13106 Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
13107 }
13108 }
13109
13110 impl ::fidl_next::IntoNatural for OpenFlags {
13111 type Natural = crate::natural::OpenFlags;
13112 }
13113
13114 #[derive(Clone, Debug)]
13116 #[repr(C)]
13117 pub struct NodeAttributes {
13118 pub mode: ::fidl_next::wire::Uint32,
13119
13120 pub id: ::fidl_next::wire::Uint64,
13121
13122 pub content_size: ::fidl_next::wire::Uint64,
13123
13124 pub storage_size: ::fidl_next::wire::Uint64,
13125
13126 pub link_count: ::fidl_next::wire::Uint64,
13127
13128 pub creation_time: ::fidl_next::wire::Uint64,
13129
13130 pub modification_time: ::fidl_next::wire::Uint64,
13131 }
13132
13133 static_assertions::const_assert_eq!(std::mem::size_of::<NodeAttributes>(), 56);
13134 static_assertions::const_assert_eq!(std::mem::align_of::<NodeAttributes>(), 8);
13135
13136 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeAttributes, mode), 0);
13137
13138 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeAttributes, id), 8);
13139
13140 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeAttributes, content_size), 16);
13141
13142 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeAttributes, storage_size), 24);
13143
13144 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeAttributes, link_count), 32);
13145
13146 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeAttributes, creation_time), 40);
13147
13148 static_assertions::const_assert_eq!(
13149 std::mem::offset_of!(NodeAttributes, modification_time),
13150 48
13151 );
13152
13153 impl ::fidl_next::Constrained for NodeAttributes {
13154 type Constraint = ();
13155
13156 fn validate(
13157 _: ::fidl_next::Slot<'_, Self>,
13158 _: Self::Constraint,
13159 ) -> Result<(), ::fidl_next::ValidationError> {
13160 Ok(())
13161 }
13162 }
13163
13164 unsafe impl ::fidl_next::Wire for NodeAttributes {
13165 type Narrowed<'de> = NodeAttributes;
13166
13167 #[inline]
13168 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13169 ::fidl_next::munge! {
13170 let Self {
13171
13172 mode,
13173 id,
13174 content_size,
13175 storage_size,
13176 link_count,
13177 creation_time,
13178 modification_time,
13179
13180 } = &mut *out_;
13181 }
13182
13183 ::fidl_next::Wire::zero_padding(mode);
13184
13185 ::fidl_next::Wire::zero_padding(id);
13186
13187 ::fidl_next::Wire::zero_padding(content_size);
13188
13189 ::fidl_next::Wire::zero_padding(storage_size);
13190
13191 ::fidl_next::Wire::zero_padding(link_count);
13192
13193 ::fidl_next::Wire::zero_padding(creation_time);
13194
13195 ::fidl_next::Wire::zero_padding(modification_time);
13196
13197 unsafe {
13198 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
13199 }
13200 }
13201 }
13202
13203 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeAttributes
13204 where
13205 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13206 {
13207 fn decode(
13208 slot_: ::fidl_next::Slot<'_, Self>,
13209 decoder_: &mut ___D,
13210 _: (),
13211 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13212 if slot_.as_bytes()[4..8] != [0u8; 4] {
13213 return Err(::fidl_next::DecodeError::InvalidPadding);
13214 }
13215
13216 ::fidl_next::munge! {
13217 let Self {
13218
13219 mut mode,
13220 mut id,
13221 mut content_size,
13222 mut storage_size,
13223 mut link_count,
13224 mut creation_time,
13225 mut modification_time,
13226
13227 } = slot_;
13228 }
13229
13230 let _field = mode.as_mut();
13231
13232 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
13233
13234 let _field = id.as_mut();
13235
13236 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
13237
13238 let _field = content_size.as_mut();
13239
13240 ::fidl_next::Decode::decode(content_size.as_mut(), decoder_, ())?;
13241
13242 let _field = storage_size.as_mut();
13243
13244 ::fidl_next::Decode::decode(storage_size.as_mut(), decoder_, ())?;
13245
13246 let _field = link_count.as_mut();
13247
13248 ::fidl_next::Decode::decode(link_count.as_mut(), decoder_, ())?;
13249
13250 let _field = creation_time.as_mut();
13251
13252 ::fidl_next::Decode::decode(creation_time.as_mut(), decoder_, ())?;
13253
13254 let _field = modification_time.as_mut();
13255
13256 ::fidl_next::Decode::decode(modification_time.as_mut(), decoder_, ())?;
13257
13258 Ok(())
13259 }
13260 }
13261
13262 impl ::fidl_next::IntoNatural for NodeAttributes {
13263 type Natural = crate::natural::NodeAttributes;
13264 }
13265
13266 #[derive(Clone, Copy, Debug)]
13268 #[repr(transparent)]
13269 pub struct NodeAttributeFlags {
13270 pub(crate) value: ::fidl_next::wire::Uint32,
13271 }
13272
13273 impl ::fidl_next::Constrained for NodeAttributeFlags {
13274 type Constraint = ();
13275
13276 fn validate(
13277 _: ::fidl_next::Slot<'_, Self>,
13278 _: Self::Constraint,
13279 ) -> Result<(), ::fidl_next::ValidationError> {
13280 Ok(())
13281 }
13282 }
13283
13284 unsafe impl ::fidl_next::Wire for NodeAttributeFlags {
13285 type Narrowed<'de> = Self;
13286
13287 #[inline]
13288 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
13289 }
13291 }
13292
13293 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeAttributeFlags
13294 where
13295 ___D: ?Sized,
13296 {
13297 fn decode(
13298 slot: ::fidl_next::Slot<'_, Self>,
13299 _: &mut ___D,
13300 _: (),
13301 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13302 ::fidl_next::munge!(let Self { value } = slot);
13303 let set = u32::from(*value);
13304 if set & !crate::natural::NodeAttributeFlags::all().bits() != 0 {
13305 return Err(::fidl_next::DecodeError::InvalidBits {
13306 expected: crate::natural::NodeAttributeFlags::all().bits() as usize,
13307 actual: set as usize,
13308 });
13309 }
13310
13311 Ok(())
13312 }
13313 }
13314
13315 impl ::core::convert::From<crate::natural::NodeAttributeFlags> for NodeAttributeFlags {
13316 fn from(natural: crate::natural::NodeAttributeFlags) -> Self {
13317 Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
13318 }
13319 }
13320
13321 impl ::fidl_next::IntoNatural for NodeAttributeFlags {
13322 type Natural = crate::natural::NodeAttributeFlags;
13323 }
13324
13325 #[derive(Debug)]
13327 #[repr(C)]
13328 pub struct NodeQueryFilesystemResponse<'de> {
13329 pub s: ::fidl_next::wire::Int32,
13330
13331 pub info: ::fidl_next::wire::Box<'de, crate::wire::FilesystemInfo>,
13332 }
13333
13334 static_assertions::const_assert_eq!(std::mem::size_of::<NodeQueryFilesystemResponse<'_>>(), 16);
13335 static_assertions::const_assert_eq!(std::mem::align_of::<NodeQueryFilesystemResponse<'_>>(), 8);
13336
13337 static_assertions::const_assert_eq!(
13338 std::mem::offset_of!(NodeQueryFilesystemResponse<'_>, s),
13339 0
13340 );
13341
13342 static_assertions::const_assert_eq!(
13343 std::mem::offset_of!(NodeQueryFilesystemResponse<'_>, info),
13344 8
13345 );
13346
13347 impl ::fidl_next::Constrained for NodeQueryFilesystemResponse<'_> {
13348 type Constraint = ();
13349
13350 fn validate(
13351 _: ::fidl_next::Slot<'_, Self>,
13352 _: Self::Constraint,
13353 ) -> Result<(), ::fidl_next::ValidationError> {
13354 Ok(())
13355 }
13356 }
13357
13358 unsafe impl ::fidl_next::Wire for NodeQueryFilesystemResponse<'static> {
13359 type Narrowed<'de> = NodeQueryFilesystemResponse<'de>;
13360
13361 #[inline]
13362 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13363 ::fidl_next::munge! {
13364 let Self {
13365
13366 s,
13367 info,
13368
13369 } = &mut *out_;
13370 }
13371
13372 ::fidl_next::Wire::zero_padding(s);
13373
13374 ::fidl_next::Wire::zero_padding(info);
13375
13376 unsafe {
13377 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
13378 }
13379 }
13380 }
13381
13382 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeQueryFilesystemResponse<'de>
13383 where
13384 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13385 ___D: ::fidl_next::Decoder<'de>,
13386 {
13387 fn decode(
13388 slot_: ::fidl_next::Slot<'_, Self>,
13389 decoder_: &mut ___D,
13390 _: (),
13391 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13392 if slot_.as_bytes()[4..8] != [0u8; 4] {
13393 return Err(::fidl_next::DecodeError::InvalidPadding);
13394 }
13395
13396 ::fidl_next::munge! {
13397 let Self {
13398
13399 mut s,
13400 mut info,
13401
13402 } = slot_;
13403 }
13404
13405 let _field = s.as_mut();
13406
13407 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
13408
13409 let _field = info.as_mut();
13410
13411 ::fidl_next::Decode::decode(info.as_mut(), decoder_, ())?;
13412
13413 Ok(())
13414 }
13415 }
13416
13417 impl<'de> ::fidl_next::IntoNatural for NodeQueryFilesystemResponse<'de> {
13418 type Natural = crate::natural::NodeQueryFilesystemResponse;
13419 }
13420
13421 #[derive(Clone, Debug)]
13423 #[repr(C)]
13424 pub struct NodeUpdateAttributesResponse {
13425 pub(crate) _empty: fidl_next::wire::EmptyStruct,
13426 }
13427
13428 static_assertions::const_assert_eq!(std::mem::size_of::<NodeUpdateAttributesResponse>(), 1);
13429 static_assertions::const_assert_eq!(std::mem::align_of::<NodeUpdateAttributesResponse>(), 1);
13430
13431 impl ::fidl_next::Constrained for NodeUpdateAttributesResponse {
13432 type Constraint = ();
13433
13434 fn validate(
13435 _: ::fidl_next::Slot<'_, Self>,
13436 _: Self::Constraint,
13437 ) -> Result<(), ::fidl_next::ValidationError> {
13438 Ok(())
13439 }
13440 }
13441
13442 unsafe impl ::fidl_next::Wire for NodeUpdateAttributesResponse {
13443 type Narrowed<'de> = NodeUpdateAttributesResponse;
13444
13445 #[inline]
13446 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13447 ::fidl_next::munge! {
13448 let Self {
13449
13450 _empty,
13451
13452
13453 } = &mut *out_;
13454 }
13455 }
13456 }
13457
13458 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeUpdateAttributesResponse
13459 where
13460 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13461 {
13462 fn decode(
13463 slot_: ::fidl_next::Slot<'_, Self>,
13464 decoder_: &mut ___D,
13465 _: (),
13466 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13467 ::fidl_next::munge! {
13468 let Self {
13469
13470 mut _empty,
13471
13472
13473 } = slot_;
13474 }
13475
13476 if _empty.as_bytes() != &[0u8] {
13477 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
13478 }
13479
13480 Ok(())
13481 }
13482 }
13483
13484 impl ::fidl_next::IntoNatural for NodeUpdateAttributesResponse {
13485 type Natural = crate::natural::NodeUpdateAttributesResponse;
13486 }
13487
13488 #[derive(Clone, Debug)]
13490 #[repr(C)]
13491 pub struct NodeSyncResponse {
13492 pub(crate) _empty: fidl_next::wire::EmptyStruct,
13493 }
13494
13495 static_assertions::const_assert_eq!(std::mem::size_of::<NodeSyncResponse>(), 1);
13496 static_assertions::const_assert_eq!(std::mem::align_of::<NodeSyncResponse>(), 1);
13497
13498 impl ::fidl_next::Constrained for NodeSyncResponse {
13499 type Constraint = ();
13500
13501 fn validate(
13502 _: ::fidl_next::Slot<'_, Self>,
13503 _: Self::Constraint,
13504 ) -> Result<(), ::fidl_next::ValidationError> {
13505 Ok(())
13506 }
13507 }
13508
13509 unsafe impl ::fidl_next::Wire for NodeSyncResponse {
13510 type Narrowed<'de> = NodeSyncResponse;
13511
13512 #[inline]
13513 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13514 ::fidl_next::munge! {
13515 let Self {
13516
13517 _empty,
13518
13519
13520 } = &mut *out_;
13521 }
13522 }
13523 }
13524
13525 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeSyncResponse
13526 where
13527 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13528 {
13529 fn decode(
13530 slot_: ::fidl_next::Slot<'_, Self>,
13531 decoder_: &mut ___D,
13532 _: (),
13533 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13534 ::fidl_next::munge! {
13535 let Self {
13536
13537 mut _empty,
13538
13539
13540 } = slot_;
13541 }
13542
13543 if _empty.as_bytes() != &[0u8] {
13544 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
13545 }
13546
13547 Ok(())
13548 }
13549 }
13550
13551 impl ::fidl_next::IntoNatural for NodeSyncResponse {
13552 type Natural = crate::natural::NodeSyncResponse;
13553 }
13554
13555 #[derive(Clone, Copy, Debug)]
13557 #[repr(transparent)]
13558 pub struct ModeType {
13559 pub(crate) value: ::fidl_next::wire::Uint32,
13560 }
13561
13562 impl ::fidl_next::Constrained for ModeType {
13563 type Constraint = ();
13564
13565 fn validate(
13566 _: ::fidl_next::Slot<'_, Self>,
13567 _: Self::Constraint,
13568 ) -> Result<(), ::fidl_next::ValidationError> {
13569 Ok(())
13570 }
13571 }
13572
13573 unsafe impl ::fidl_next::Wire for ModeType {
13574 type Narrowed<'de> = Self;
13575
13576 #[inline]
13577 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
13578 }
13580 }
13581
13582 unsafe impl<___D> ::fidl_next::Decode<___D> for ModeType
13583 where
13584 ___D: ?Sized,
13585 {
13586 fn decode(
13587 slot: ::fidl_next::Slot<'_, Self>,
13588 _: &mut ___D,
13589 _: (),
13590 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13591 ::fidl_next::munge!(let Self { value } = slot);
13592 let set = u32::from(*value);
13593 if set & !crate::natural::ModeType::all().bits() != 0 {
13594 return Err(::fidl_next::DecodeError::InvalidBits {
13595 expected: crate::natural::ModeType::all().bits() as usize,
13596 actual: set as usize,
13597 });
13598 }
13599
13600 Ok(())
13601 }
13602 }
13603
13604 impl ::core::convert::From<crate::natural::ModeType> for ModeType {
13605 fn from(natural: crate::natural::ModeType) -> Self {
13606 Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
13607 }
13608 }
13609
13610 impl ::fidl_next::IntoNatural for ModeType {
13611 type Natural = crate::natural::ModeType;
13612 }
13613
13614 pub type Path<'de> = ::fidl_next::wire::String<'de>;
13616
13617 #[derive(Clone, Debug)]
13619 #[repr(C)]
13620 pub struct DirectoryReadDirentsRequest {
13621 pub max_bytes: ::fidl_next::wire::Uint64,
13622 }
13623
13624 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryReadDirentsRequest>(), 8);
13625 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryReadDirentsRequest>(), 8);
13626
13627 static_assertions::const_assert_eq!(
13628 std::mem::offset_of!(DirectoryReadDirentsRequest, max_bytes),
13629 0
13630 );
13631
13632 impl ::fidl_next::Constrained for DirectoryReadDirentsRequest {
13633 type Constraint = ();
13634
13635 fn validate(
13636 _: ::fidl_next::Slot<'_, Self>,
13637 _: Self::Constraint,
13638 ) -> Result<(), ::fidl_next::ValidationError> {
13639 Ok(())
13640 }
13641 }
13642
13643 unsafe impl ::fidl_next::Wire for DirectoryReadDirentsRequest {
13644 type Narrowed<'de> = DirectoryReadDirentsRequest;
13645
13646 #[inline]
13647 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13648 ::fidl_next::munge! {
13649 let Self {
13650
13651 max_bytes,
13652
13653 } = &mut *out_;
13654 }
13655
13656 ::fidl_next::Wire::zero_padding(max_bytes);
13657 }
13658 }
13659
13660 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryReadDirentsRequest
13661 where
13662 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13663 {
13664 fn decode(
13665 slot_: ::fidl_next::Slot<'_, Self>,
13666 decoder_: &mut ___D,
13667 _: (),
13668 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13669 ::fidl_next::munge! {
13670 let Self {
13671
13672 mut max_bytes,
13673
13674 } = slot_;
13675 }
13676
13677 let _field = max_bytes.as_mut();
13678
13679 ::fidl_next::Decode::decode(max_bytes.as_mut(), decoder_, ())?;
13680
13681 Ok(())
13682 }
13683 }
13684
13685 impl ::fidl_next::IntoNatural for DirectoryReadDirentsRequest {
13686 type Natural = crate::natural::DirectoryReadDirentsRequest;
13687 }
13688
13689 #[derive(Debug)]
13691 #[repr(C)]
13692 pub struct DirectoryReadDirentsResponse<'de> {
13693 pub s: ::fidl_next::wire::Int32,
13694
13695 pub dirents: ::fidl_next::wire::Vector<'de, u8>,
13696 }
13697
13698 static_assertions::const_assert_eq!(
13699 std::mem::size_of::<DirectoryReadDirentsResponse<'_>>(),
13700 24
13701 );
13702 static_assertions::const_assert_eq!(
13703 std::mem::align_of::<DirectoryReadDirentsResponse<'_>>(),
13704 8
13705 );
13706
13707 static_assertions::const_assert_eq!(
13708 std::mem::offset_of!(DirectoryReadDirentsResponse<'_>, s),
13709 0
13710 );
13711
13712 static_assertions::const_assert_eq!(
13713 std::mem::offset_of!(DirectoryReadDirentsResponse<'_>, dirents),
13714 8
13715 );
13716
13717 impl ::fidl_next::Constrained for DirectoryReadDirentsResponse<'_> {
13718 type Constraint = ();
13719
13720 fn validate(
13721 _: ::fidl_next::Slot<'_, Self>,
13722 _: Self::Constraint,
13723 ) -> Result<(), ::fidl_next::ValidationError> {
13724 Ok(())
13725 }
13726 }
13727
13728 unsafe impl ::fidl_next::Wire for DirectoryReadDirentsResponse<'static> {
13729 type Narrowed<'de> = DirectoryReadDirentsResponse<'de>;
13730
13731 #[inline]
13732 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13733 ::fidl_next::munge! {
13734 let Self {
13735
13736 s,
13737 dirents,
13738
13739 } = &mut *out_;
13740 }
13741
13742 ::fidl_next::Wire::zero_padding(s);
13743
13744 ::fidl_next::Wire::zero_padding(dirents);
13745
13746 unsafe {
13747 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
13748 }
13749 }
13750 }
13751
13752 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryReadDirentsResponse<'de>
13753 where
13754 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13755 ___D: ::fidl_next::Decoder<'de>,
13756 {
13757 fn decode(
13758 slot_: ::fidl_next::Slot<'_, Self>,
13759 decoder_: &mut ___D,
13760 _: (),
13761 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13762 if slot_.as_bytes()[4..8] != [0u8; 4] {
13763 return Err(::fidl_next::DecodeError::InvalidPadding);
13764 }
13765
13766 ::fidl_next::munge! {
13767 let Self {
13768
13769 mut s,
13770 mut dirents,
13771
13772 } = slot_;
13773 }
13774
13775 let _field = s.as_mut();
13776
13777 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
13778
13779 let _field = dirents.as_mut();
13780 ::fidl_next::Constrained::validate(_field, (8192, ()))?;
13781 ::fidl_next::Decode::decode(dirents.as_mut(), decoder_, (8192, ()))?;
13782
13783 let dirents = unsafe { dirents.deref_unchecked() };
13784
13785 if dirents.len() > 8192 {
13786 return Err(::fidl_next::DecodeError::VectorTooLong {
13787 size: dirents.len() as u64,
13788 limit: 8192,
13789 });
13790 }
13791
13792 Ok(())
13793 }
13794 }
13795
13796 impl<'de> ::fidl_next::IntoNatural for DirectoryReadDirentsResponse<'de> {
13797 type Natural = crate::natural::DirectoryReadDirentsResponse;
13798 }
13799
13800 #[derive(Clone, Debug)]
13802 #[repr(C)]
13803 pub struct DirectoryRewindResponse {
13804 pub s: ::fidl_next::wire::Int32,
13805 }
13806
13807 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryRewindResponse>(), 4);
13808 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryRewindResponse>(), 4);
13809
13810 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryRewindResponse, s), 0);
13811
13812 impl ::fidl_next::Constrained for DirectoryRewindResponse {
13813 type Constraint = ();
13814
13815 fn validate(
13816 _: ::fidl_next::Slot<'_, Self>,
13817 _: Self::Constraint,
13818 ) -> Result<(), ::fidl_next::ValidationError> {
13819 Ok(())
13820 }
13821 }
13822
13823 unsafe impl ::fidl_next::Wire for DirectoryRewindResponse {
13824 type Narrowed<'de> = DirectoryRewindResponse;
13825
13826 #[inline]
13827 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13828 ::fidl_next::munge! {
13829 let Self {
13830
13831 s,
13832
13833 } = &mut *out_;
13834 }
13835
13836 ::fidl_next::Wire::zero_padding(s);
13837 }
13838 }
13839
13840 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRewindResponse
13841 where
13842 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13843 {
13844 fn decode(
13845 slot_: ::fidl_next::Slot<'_, Self>,
13846 decoder_: &mut ___D,
13847 _: (),
13848 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13849 ::fidl_next::munge! {
13850 let Self {
13851
13852 mut s,
13853
13854 } = slot_;
13855 }
13856
13857 let _field = s.as_mut();
13858
13859 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
13860
13861 Ok(())
13862 }
13863 }
13864
13865 impl ::fidl_next::IntoNatural for DirectoryRewindResponse {
13866 type Natural = crate::natural::DirectoryRewindResponse;
13867 }
13868
13869 pub type Name<'de> = ::fidl_next::wire::String<'de>;
13871
13872 #[derive(Clone, Debug)]
13874 #[repr(C)]
13875 pub struct DirectoryLinkResponse {
13876 pub s: ::fidl_next::wire::Int32,
13877 }
13878
13879 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryLinkResponse>(), 4);
13880 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryLinkResponse>(), 4);
13881
13882 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryLinkResponse, s), 0);
13883
13884 impl ::fidl_next::Constrained for DirectoryLinkResponse {
13885 type Constraint = ();
13886
13887 fn validate(
13888 _: ::fidl_next::Slot<'_, Self>,
13889 _: Self::Constraint,
13890 ) -> Result<(), ::fidl_next::ValidationError> {
13891 Ok(())
13892 }
13893 }
13894
13895 unsafe impl ::fidl_next::Wire for DirectoryLinkResponse {
13896 type Narrowed<'de> = DirectoryLinkResponse;
13897
13898 #[inline]
13899 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13900 ::fidl_next::munge! {
13901 let Self {
13902
13903 s,
13904
13905 } = &mut *out_;
13906 }
13907
13908 ::fidl_next::Wire::zero_padding(s);
13909 }
13910 }
13911
13912 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryLinkResponse
13913 where
13914 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13915 {
13916 fn decode(
13917 slot_: ::fidl_next::Slot<'_, Self>,
13918 decoder_: &mut ___D,
13919 _: (),
13920 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13921 ::fidl_next::munge! {
13922 let Self {
13923
13924 mut s,
13925
13926 } = slot_;
13927 }
13928
13929 let _field = s.as_mut();
13930
13931 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
13932
13933 Ok(())
13934 }
13935 }
13936
13937 impl ::fidl_next::IntoNatural for DirectoryLinkResponse {
13938 type Natural = crate::natural::DirectoryLinkResponse;
13939 }
13940
13941 #[derive(Clone, Copy, Debug)]
13943 #[repr(transparent)]
13944 pub struct UnlinkFlags {
13945 pub(crate) value: ::fidl_next::wire::Uint64,
13946 }
13947
13948 impl ::fidl_next::Constrained for UnlinkFlags {
13949 type Constraint = ();
13950
13951 fn validate(
13952 _: ::fidl_next::Slot<'_, Self>,
13953 _: Self::Constraint,
13954 ) -> Result<(), ::fidl_next::ValidationError> {
13955 Ok(())
13956 }
13957 }
13958
13959 unsafe impl ::fidl_next::Wire for UnlinkFlags {
13960 type Narrowed<'de> = Self;
13961
13962 #[inline]
13963 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
13964 }
13966 }
13967
13968 unsafe impl<___D> ::fidl_next::Decode<___D> for UnlinkFlags
13969 where
13970 ___D: ?Sized,
13971 {
13972 fn decode(
13973 slot: ::fidl_next::Slot<'_, Self>,
13974 _: &mut ___D,
13975 _: (),
13976 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13977 Ok(())
13978 }
13979 }
13980
13981 impl ::core::convert::From<crate::natural::UnlinkFlags> for UnlinkFlags {
13982 fn from(natural: crate::natural::UnlinkFlags) -> Self {
13983 Self { value: ::fidl_next::wire::Uint64::from(natural.bits()) }
13984 }
13985 }
13986
13987 impl ::fidl_next::IntoNatural for UnlinkFlags {
13988 type Natural = crate::natural::UnlinkFlags;
13989 }
13990
13991 #[repr(C)]
13993 pub struct UnlinkOptions<'de> {
13994 pub(crate) table: ::fidl_next::wire::Table<'de>,
13995 }
13996
13997 impl<'de> Drop for UnlinkOptions<'de> {
13998 fn drop(&mut self) {
13999 let _ = self
14000 .table
14001 .get(1)
14002 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::UnlinkFlags>() });
14003 }
14004 }
14005
14006 impl ::fidl_next::Constrained for UnlinkOptions<'_> {
14007 type Constraint = ();
14008
14009 fn validate(
14010 _: ::fidl_next::Slot<'_, Self>,
14011 _: Self::Constraint,
14012 ) -> Result<(), ::fidl_next::ValidationError> {
14013 Ok(())
14014 }
14015 }
14016
14017 unsafe impl ::fidl_next::Wire for UnlinkOptions<'static> {
14018 type Narrowed<'de> = UnlinkOptions<'de>;
14019
14020 #[inline]
14021 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14022 ::fidl_next::munge!(let Self { table } = out);
14023 ::fidl_next::wire::Table::zero_padding(table);
14024 }
14025 }
14026
14027 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UnlinkOptions<'de>
14028 where
14029 ___D: ::fidl_next::Decoder<'de> + ?Sized,
14030 {
14031 fn decode(
14032 slot: ::fidl_next::Slot<'_, Self>,
14033 decoder: &mut ___D,
14034 _: (),
14035 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14036 ::fidl_next::munge!(let Self { table } = slot);
14037
14038 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
14039 match ordinal {
14040 0 => unsafe { ::core::hint::unreachable_unchecked() },
14041
14042 1 => {
14043 ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::UnlinkFlags>(
14044 slot.as_mut(),
14045 decoder,
14046 (),
14047 )?;
14048
14049 Ok(())
14050 }
14051
14052 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
14053 }
14054 })
14055 }
14056 }
14057
14058 impl<'de> UnlinkOptions<'de> {
14059 pub fn flags(&self) -> ::core::option::Option<&crate::wire::UnlinkFlags> {
14060 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
14061 }
14062 }
14063
14064 impl<'de> ::core::fmt::Debug for UnlinkOptions<'de> {
14065 fn fmt(
14066 &self,
14067 f: &mut ::core::fmt::Formatter<'_>,
14068 ) -> ::core::result::Result<(), ::core::fmt::Error> {
14069 f.debug_struct("UnlinkOptions").field("flags", &self.flags()).finish()
14070 }
14071 }
14072
14073 impl<'de> ::fidl_next::IntoNatural for UnlinkOptions<'de> {
14074 type Natural = crate::natural::UnlinkOptions;
14075 }
14076
14077 #[derive(Debug)]
14079 #[repr(C)]
14080 pub struct DirectoryUnlinkRequest<'de> {
14081 pub name: ::fidl_next::wire::String<'de>,
14082
14083 pub options: crate::wire::UnlinkOptions<'de>,
14084 }
14085
14086 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryUnlinkRequest<'_>>(), 32);
14087 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryUnlinkRequest<'_>>(), 8);
14088
14089 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryUnlinkRequest<'_>, name), 0);
14090
14091 static_assertions::const_assert_eq!(
14092 std::mem::offset_of!(DirectoryUnlinkRequest<'_>, options),
14093 16
14094 );
14095
14096 impl ::fidl_next::Constrained for DirectoryUnlinkRequest<'_> {
14097 type Constraint = ();
14098
14099 fn validate(
14100 _: ::fidl_next::Slot<'_, Self>,
14101 _: Self::Constraint,
14102 ) -> Result<(), ::fidl_next::ValidationError> {
14103 Ok(())
14104 }
14105 }
14106
14107 unsafe impl ::fidl_next::Wire for DirectoryUnlinkRequest<'static> {
14108 type Narrowed<'de> = DirectoryUnlinkRequest<'de>;
14109
14110 #[inline]
14111 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14112 ::fidl_next::munge! {
14113 let Self {
14114
14115 name,
14116 options,
14117
14118 } = &mut *out_;
14119 }
14120
14121 ::fidl_next::Wire::zero_padding(name);
14122
14123 ::fidl_next::Wire::zero_padding(options);
14124 }
14125 }
14126
14127 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryUnlinkRequest<'de>
14128 where
14129 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14130 ___D: ::fidl_next::Decoder<'de>,
14131 {
14132 fn decode(
14133 slot_: ::fidl_next::Slot<'_, Self>,
14134 decoder_: &mut ___D,
14135 _: (),
14136 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14137 ::fidl_next::munge! {
14138 let Self {
14139
14140 mut name,
14141 mut options,
14142
14143 } = slot_;
14144 }
14145
14146 let _field = name.as_mut();
14147 ::fidl_next::Constrained::validate(_field, 255)?;
14148 ::fidl_next::Decode::decode(name.as_mut(), decoder_, 255)?;
14149
14150 let name = unsafe { name.deref_unchecked() };
14151
14152 if name.len() > 255 {
14153 return Err(::fidl_next::DecodeError::VectorTooLong {
14154 size: name.len() as u64,
14155 limit: 255,
14156 });
14157 }
14158
14159 let _field = options.as_mut();
14160
14161 ::fidl_next::Decode::decode(options.as_mut(), decoder_, ())?;
14162
14163 Ok(())
14164 }
14165 }
14166
14167 impl<'de> ::fidl_next::IntoNatural for DirectoryUnlinkRequest<'de> {
14168 type Natural = crate::natural::DirectoryUnlinkRequest;
14169 }
14170
14171 #[derive(Clone, Debug)]
14173 #[repr(C)]
14174 pub struct DirectoryUnlinkResponse {
14175 pub(crate) _empty: fidl_next::wire::EmptyStruct,
14176 }
14177
14178 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryUnlinkResponse>(), 1);
14179 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryUnlinkResponse>(), 1);
14180
14181 impl ::fidl_next::Constrained for DirectoryUnlinkResponse {
14182 type Constraint = ();
14183
14184 fn validate(
14185 _: ::fidl_next::Slot<'_, Self>,
14186 _: Self::Constraint,
14187 ) -> Result<(), ::fidl_next::ValidationError> {
14188 Ok(())
14189 }
14190 }
14191
14192 unsafe impl ::fidl_next::Wire for DirectoryUnlinkResponse {
14193 type Narrowed<'de> = DirectoryUnlinkResponse;
14194
14195 #[inline]
14196 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14197 ::fidl_next::munge! {
14198 let Self {
14199
14200 _empty,
14201
14202
14203 } = &mut *out_;
14204 }
14205 }
14206 }
14207
14208 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryUnlinkResponse
14209 where
14210 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14211 {
14212 fn decode(
14213 slot_: ::fidl_next::Slot<'_, Self>,
14214 decoder_: &mut ___D,
14215 _: (),
14216 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14217 ::fidl_next::munge! {
14218 let Self {
14219
14220 mut _empty,
14221
14222
14223 } = slot_;
14224 }
14225
14226 if _empty.as_bytes() != &[0u8] {
14227 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
14228 }
14229
14230 Ok(())
14231 }
14232 }
14233
14234 impl ::fidl_next::IntoNatural for DirectoryUnlinkResponse {
14235 type Natural = crate::natural::DirectoryUnlinkResponse;
14236 }
14237
14238 #[derive(Clone, Debug)]
14240 #[repr(C)]
14241 pub struct DirectoryRenameResponse {
14242 pub(crate) _empty: fidl_next::wire::EmptyStruct,
14243 }
14244
14245 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryRenameResponse>(), 1);
14246 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryRenameResponse>(), 1);
14247
14248 impl ::fidl_next::Constrained for DirectoryRenameResponse {
14249 type Constraint = ();
14250
14251 fn validate(
14252 _: ::fidl_next::Slot<'_, Self>,
14253 _: Self::Constraint,
14254 ) -> Result<(), ::fidl_next::ValidationError> {
14255 Ok(())
14256 }
14257 }
14258
14259 unsafe impl ::fidl_next::Wire for DirectoryRenameResponse {
14260 type Narrowed<'de> = DirectoryRenameResponse;
14261
14262 #[inline]
14263 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14264 ::fidl_next::munge! {
14265 let Self {
14266
14267 _empty,
14268
14269
14270 } = &mut *out_;
14271 }
14272 }
14273 }
14274
14275 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRenameResponse
14276 where
14277 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14278 {
14279 fn decode(
14280 slot_: ::fidl_next::Slot<'_, Self>,
14281 decoder_: &mut ___D,
14282 _: (),
14283 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14284 ::fidl_next::munge! {
14285 let Self {
14286
14287 mut _empty,
14288
14289
14290 } = slot_;
14291 }
14292
14293 if _empty.as_bytes() != &[0u8] {
14294 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
14295 }
14296
14297 Ok(())
14298 }
14299 }
14300
14301 impl ::fidl_next::IntoNatural for DirectoryRenameResponse {
14302 type Natural = crate::natural::DirectoryRenameResponse;
14303 }
14304
14305 #[derive(Clone, Copy, Debug)]
14307 #[repr(transparent)]
14308 pub struct WatchMask {
14309 pub(crate) value: ::fidl_next::wire::Uint32,
14310 }
14311
14312 impl ::fidl_next::Constrained for WatchMask {
14313 type Constraint = ();
14314
14315 fn validate(
14316 _: ::fidl_next::Slot<'_, Self>,
14317 _: Self::Constraint,
14318 ) -> Result<(), ::fidl_next::ValidationError> {
14319 Ok(())
14320 }
14321 }
14322
14323 unsafe impl ::fidl_next::Wire for WatchMask {
14324 type Narrowed<'de> = Self;
14325
14326 #[inline]
14327 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
14328 }
14330 }
14331
14332 unsafe impl<___D> ::fidl_next::Decode<___D> for WatchMask
14333 where
14334 ___D: ?Sized,
14335 {
14336 fn decode(
14337 slot: ::fidl_next::Slot<'_, Self>,
14338 _: &mut ___D,
14339 _: (),
14340 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14341 ::fidl_next::munge!(let Self { value } = slot);
14342 let set = u32::from(*value);
14343 if set & !crate::natural::WatchMask::all().bits() != 0 {
14344 return Err(::fidl_next::DecodeError::InvalidBits {
14345 expected: crate::natural::WatchMask::all().bits() as usize,
14346 actual: set as usize,
14347 });
14348 }
14349
14350 Ok(())
14351 }
14352 }
14353
14354 impl ::core::convert::From<crate::natural::WatchMask> for WatchMask {
14355 fn from(natural: crate::natural::WatchMask) -> Self {
14356 Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
14357 }
14358 }
14359
14360 impl ::fidl_next::IntoNatural for WatchMask {
14361 type Natural = crate::natural::WatchMask;
14362 }
14363
14364 #[derive(Clone, Debug)]
14366 #[repr(C)]
14367 pub struct DirectoryWatchResponse {
14368 pub s: ::fidl_next::wire::Int32,
14369 }
14370
14371 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryWatchResponse>(), 4);
14372 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryWatchResponse>(), 4);
14373
14374 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryWatchResponse, s), 0);
14375
14376 impl ::fidl_next::Constrained for DirectoryWatchResponse {
14377 type Constraint = ();
14378
14379 fn validate(
14380 _: ::fidl_next::Slot<'_, Self>,
14381 _: Self::Constraint,
14382 ) -> Result<(), ::fidl_next::ValidationError> {
14383 Ok(())
14384 }
14385 }
14386
14387 unsafe impl ::fidl_next::Wire for DirectoryWatchResponse {
14388 type Narrowed<'de> = DirectoryWatchResponse;
14389
14390 #[inline]
14391 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14392 ::fidl_next::munge! {
14393 let Self {
14394
14395 s,
14396
14397 } = &mut *out_;
14398 }
14399
14400 ::fidl_next::Wire::zero_padding(s);
14401 }
14402 }
14403
14404 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryWatchResponse
14405 where
14406 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14407 {
14408 fn decode(
14409 slot_: ::fidl_next::Slot<'_, Self>,
14410 decoder_: &mut ___D,
14411 _: (),
14412 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14413 ::fidl_next::munge! {
14414 let Self {
14415
14416 mut s,
14417
14418 } = slot_;
14419 }
14420
14421 let _field = s.as_mut();
14422
14423 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
14424
14425 Ok(())
14426 }
14427 }
14428
14429 impl ::fidl_next::IntoNatural for DirectoryWatchResponse {
14430 type Natural = crate::natural::DirectoryWatchResponse;
14431 }
14432
14433 pub type SymlinkTarget<'de> = ::fidl_next::wire::Vector<'de, u8>;
14435
14436 pub type ExtendedAttributeName<'de> = ::fidl_next::wire::Vector<'de, u8>;
14438
14439 #[derive(Debug)]
14441 #[repr(C)]
14442 pub struct NodeGetExtendedAttributeRequest<'de> {
14443 pub name: ::fidl_next::wire::Vector<'de, u8>,
14444 }
14445
14446 static_assertions::const_assert_eq!(
14447 std::mem::size_of::<NodeGetExtendedAttributeRequest<'_>>(),
14448 16
14449 );
14450 static_assertions::const_assert_eq!(
14451 std::mem::align_of::<NodeGetExtendedAttributeRequest<'_>>(),
14452 8
14453 );
14454
14455 static_assertions::const_assert_eq!(
14456 std::mem::offset_of!(NodeGetExtendedAttributeRequest<'_>, name),
14457 0
14458 );
14459
14460 impl ::fidl_next::Constrained for NodeGetExtendedAttributeRequest<'_> {
14461 type Constraint = ();
14462
14463 fn validate(
14464 _: ::fidl_next::Slot<'_, Self>,
14465 _: Self::Constraint,
14466 ) -> Result<(), ::fidl_next::ValidationError> {
14467 Ok(())
14468 }
14469 }
14470
14471 unsafe impl ::fidl_next::Wire for NodeGetExtendedAttributeRequest<'static> {
14472 type Narrowed<'de> = NodeGetExtendedAttributeRequest<'de>;
14473
14474 #[inline]
14475 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14476 ::fidl_next::munge! {
14477 let Self {
14478
14479 name,
14480
14481 } = &mut *out_;
14482 }
14483
14484 ::fidl_next::Wire::zero_padding(name);
14485 }
14486 }
14487
14488 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeGetExtendedAttributeRequest<'de>
14489 where
14490 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14491 ___D: ::fidl_next::Decoder<'de>,
14492 {
14493 fn decode(
14494 slot_: ::fidl_next::Slot<'_, Self>,
14495 decoder_: &mut ___D,
14496 _: (),
14497 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14498 ::fidl_next::munge! {
14499 let Self {
14500
14501 mut name,
14502
14503 } = slot_;
14504 }
14505
14506 let _field = name.as_mut();
14507 ::fidl_next::Constrained::validate(_field, (255, ()))?;
14508 ::fidl_next::Decode::decode(name.as_mut(), decoder_, (255, ()))?;
14509
14510 let name = unsafe { name.deref_unchecked() };
14511
14512 if name.len() > 255 {
14513 return Err(::fidl_next::DecodeError::VectorTooLong {
14514 size: name.len() as u64,
14515 limit: 255,
14516 });
14517 }
14518
14519 Ok(())
14520 }
14521 }
14522
14523 impl<'de> ::fidl_next::IntoNatural for NodeGetExtendedAttributeRequest<'de> {
14524 type Natural = crate::natural::NodeGetExtendedAttributeRequest;
14525 }
14526
14527 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
14529 #[repr(transparent)]
14530 pub struct SetExtendedAttributeMode {
14531 pub(crate) value: ::fidl_next::wire::Uint32,
14532 }
14533
14534 impl ::fidl_next::Constrained for SetExtendedAttributeMode {
14535 type Constraint = ();
14536
14537 fn validate(
14538 _: ::fidl_next::Slot<'_, Self>,
14539 _: Self::Constraint,
14540 ) -> Result<(), ::fidl_next::ValidationError> {
14541 Ok(())
14542 }
14543 }
14544
14545 unsafe impl ::fidl_next::Wire for SetExtendedAttributeMode {
14546 type Narrowed<'de> = Self;
14547
14548 #[inline]
14549 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
14550 }
14552 }
14553
14554 impl SetExtendedAttributeMode {
14555 pub const SET: SetExtendedAttributeMode =
14556 SetExtendedAttributeMode { value: ::fidl_next::wire::Uint32(1) };
14557
14558 pub const CREATE: SetExtendedAttributeMode =
14559 SetExtendedAttributeMode { value: ::fidl_next::wire::Uint32(2) };
14560
14561 pub const REPLACE: SetExtendedAttributeMode =
14562 SetExtendedAttributeMode { value: ::fidl_next::wire::Uint32(3) };
14563 }
14564
14565 unsafe impl<___D> ::fidl_next::Decode<___D> for SetExtendedAttributeMode
14566 where
14567 ___D: ?Sized,
14568 {
14569 fn decode(
14570 slot: ::fidl_next::Slot<'_, Self>,
14571 _: &mut ___D,
14572 _: (),
14573 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14574 ::fidl_next::munge!(let Self { value } = slot);
14575
14576 match u32::from(*value) {
14577 1 | 2 | 3 => (),
14578 unknown => {
14579 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
14580 }
14581 }
14582
14583 Ok(())
14584 }
14585 }
14586
14587 impl ::core::convert::From<crate::natural::SetExtendedAttributeMode> for SetExtendedAttributeMode {
14588 fn from(natural: crate::natural::SetExtendedAttributeMode) -> Self {
14589 match natural {
14590 crate::natural::SetExtendedAttributeMode::Set => SetExtendedAttributeMode::SET,
14591
14592 crate::natural::SetExtendedAttributeMode::Create => {
14593 SetExtendedAttributeMode::CREATE
14594 }
14595
14596 crate::natural::SetExtendedAttributeMode::Replace => {
14597 SetExtendedAttributeMode::REPLACE
14598 }
14599 }
14600 }
14601 }
14602
14603 impl ::fidl_next::IntoNatural for SetExtendedAttributeMode {
14604 type Natural = crate::natural::SetExtendedAttributeMode;
14605 }
14606
14607 #[derive(Clone, Debug)]
14609 #[repr(C)]
14610 pub struct NodeSetExtendedAttributeResponse {
14611 pub(crate) _empty: fidl_next::wire::EmptyStruct,
14612 }
14613
14614 static_assertions::const_assert_eq!(std::mem::size_of::<NodeSetExtendedAttributeResponse>(), 1);
14615 static_assertions::const_assert_eq!(
14616 std::mem::align_of::<NodeSetExtendedAttributeResponse>(),
14617 1
14618 );
14619
14620 impl ::fidl_next::Constrained for NodeSetExtendedAttributeResponse {
14621 type Constraint = ();
14622
14623 fn validate(
14624 _: ::fidl_next::Slot<'_, Self>,
14625 _: Self::Constraint,
14626 ) -> Result<(), ::fidl_next::ValidationError> {
14627 Ok(())
14628 }
14629 }
14630
14631 unsafe impl ::fidl_next::Wire for NodeSetExtendedAttributeResponse {
14632 type Narrowed<'de> = NodeSetExtendedAttributeResponse;
14633
14634 #[inline]
14635 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14636 ::fidl_next::munge! {
14637 let Self {
14638
14639 _empty,
14640
14641
14642 } = &mut *out_;
14643 }
14644 }
14645 }
14646
14647 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeSetExtendedAttributeResponse
14648 where
14649 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14650 {
14651 fn decode(
14652 slot_: ::fidl_next::Slot<'_, Self>,
14653 decoder_: &mut ___D,
14654 _: (),
14655 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14656 ::fidl_next::munge! {
14657 let Self {
14658
14659 mut _empty,
14660
14661
14662 } = slot_;
14663 }
14664
14665 if _empty.as_bytes() != &[0u8] {
14666 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
14667 }
14668
14669 Ok(())
14670 }
14671 }
14672
14673 impl ::fidl_next::IntoNatural for NodeSetExtendedAttributeResponse {
14674 type Natural = crate::natural::NodeSetExtendedAttributeResponse;
14675 }
14676
14677 #[derive(Debug)]
14679 #[repr(C)]
14680 pub struct NodeRemoveExtendedAttributeRequest<'de> {
14681 pub name: ::fidl_next::wire::Vector<'de, u8>,
14682 }
14683
14684 static_assertions::const_assert_eq!(
14685 std::mem::size_of::<NodeRemoveExtendedAttributeRequest<'_>>(),
14686 16
14687 );
14688 static_assertions::const_assert_eq!(
14689 std::mem::align_of::<NodeRemoveExtendedAttributeRequest<'_>>(),
14690 8
14691 );
14692
14693 static_assertions::const_assert_eq!(
14694 std::mem::offset_of!(NodeRemoveExtendedAttributeRequest<'_>, name),
14695 0
14696 );
14697
14698 impl ::fidl_next::Constrained for NodeRemoveExtendedAttributeRequest<'_> {
14699 type Constraint = ();
14700
14701 fn validate(
14702 _: ::fidl_next::Slot<'_, Self>,
14703 _: Self::Constraint,
14704 ) -> Result<(), ::fidl_next::ValidationError> {
14705 Ok(())
14706 }
14707 }
14708
14709 unsafe impl ::fidl_next::Wire for NodeRemoveExtendedAttributeRequest<'static> {
14710 type Narrowed<'de> = NodeRemoveExtendedAttributeRequest<'de>;
14711
14712 #[inline]
14713 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14714 ::fidl_next::munge! {
14715 let Self {
14716
14717 name,
14718
14719 } = &mut *out_;
14720 }
14721
14722 ::fidl_next::Wire::zero_padding(name);
14723 }
14724 }
14725
14726 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeRemoveExtendedAttributeRequest<'de>
14727 where
14728 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14729 ___D: ::fidl_next::Decoder<'de>,
14730 {
14731 fn decode(
14732 slot_: ::fidl_next::Slot<'_, Self>,
14733 decoder_: &mut ___D,
14734 _: (),
14735 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14736 ::fidl_next::munge! {
14737 let Self {
14738
14739 mut name,
14740
14741 } = slot_;
14742 }
14743
14744 let _field = name.as_mut();
14745 ::fidl_next::Constrained::validate(_field, (255, ()))?;
14746 ::fidl_next::Decode::decode(name.as_mut(), decoder_, (255, ()))?;
14747
14748 let name = unsafe { name.deref_unchecked() };
14749
14750 if name.len() > 255 {
14751 return Err(::fidl_next::DecodeError::VectorTooLong {
14752 size: name.len() as u64,
14753 limit: 255,
14754 });
14755 }
14756
14757 Ok(())
14758 }
14759 }
14760
14761 impl<'de> ::fidl_next::IntoNatural for NodeRemoveExtendedAttributeRequest<'de> {
14762 type Natural = crate::natural::NodeRemoveExtendedAttributeRequest;
14763 }
14764
14765 #[derive(Clone, Debug)]
14767 #[repr(C)]
14768 pub struct NodeRemoveExtendedAttributeResponse {
14769 pub(crate) _empty: fidl_next::wire::EmptyStruct,
14770 }
14771
14772 static_assertions::const_assert_eq!(
14773 std::mem::size_of::<NodeRemoveExtendedAttributeResponse>(),
14774 1
14775 );
14776 static_assertions::const_assert_eq!(
14777 std::mem::align_of::<NodeRemoveExtendedAttributeResponse>(),
14778 1
14779 );
14780
14781 impl ::fidl_next::Constrained for NodeRemoveExtendedAttributeResponse {
14782 type Constraint = ();
14783
14784 fn validate(
14785 _: ::fidl_next::Slot<'_, Self>,
14786 _: Self::Constraint,
14787 ) -> Result<(), ::fidl_next::ValidationError> {
14788 Ok(())
14789 }
14790 }
14791
14792 unsafe impl ::fidl_next::Wire for NodeRemoveExtendedAttributeResponse {
14793 type Narrowed<'de> = NodeRemoveExtendedAttributeResponse;
14794
14795 #[inline]
14796 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14797 ::fidl_next::munge! {
14798 let Self {
14799
14800 _empty,
14801
14802
14803 } = &mut *out_;
14804 }
14805 }
14806 }
14807
14808 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeRemoveExtendedAttributeResponse
14809 where
14810 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14811 {
14812 fn decode(
14813 slot_: ::fidl_next::Slot<'_, Self>,
14814 decoder_: &mut ___D,
14815 _: (),
14816 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14817 ::fidl_next::munge! {
14818 let Self {
14819
14820 mut _empty,
14821
14822
14823 } = slot_;
14824 }
14825
14826 if _empty.as_bytes() != &[0u8] {
14827 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
14828 }
14829
14830 Ok(())
14831 }
14832 }
14833
14834 impl ::fidl_next::IntoNatural for NodeRemoveExtendedAttributeResponse {
14835 type Natural = crate::natural::NodeRemoveExtendedAttributeResponse;
14836 }
14837
14838 #[derive(Clone, Debug)]
14840 #[repr(C)]
14841 pub struct DirectoryCreateSymlinkResponse {
14842 pub(crate) _empty: fidl_next::wire::EmptyStruct,
14843 }
14844
14845 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryCreateSymlinkResponse>(), 1);
14846 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryCreateSymlinkResponse>(), 1);
14847
14848 impl ::fidl_next::Constrained for DirectoryCreateSymlinkResponse {
14849 type Constraint = ();
14850
14851 fn validate(
14852 _: ::fidl_next::Slot<'_, Self>,
14853 _: Self::Constraint,
14854 ) -> Result<(), ::fidl_next::ValidationError> {
14855 Ok(())
14856 }
14857 }
14858
14859 unsafe impl ::fidl_next::Wire for DirectoryCreateSymlinkResponse {
14860 type Narrowed<'de> = DirectoryCreateSymlinkResponse;
14861
14862 #[inline]
14863 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14864 ::fidl_next::munge! {
14865 let Self {
14866
14867 _empty,
14868
14869
14870 } = &mut *out_;
14871 }
14872 }
14873 }
14874
14875 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryCreateSymlinkResponse
14876 where
14877 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14878 {
14879 fn decode(
14880 slot_: ::fidl_next::Slot<'_, Self>,
14881 decoder_: &mut ___D,
14882 _: (),
14883 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14884 ::fidl_next::munge! {
14885 let Self {
14886
14887 mut _empty,
14888
14889
14890 } = slot_;
14891 }
14892
14893 if _empty.as_bytes() != &[0u8] {
14894 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
14895 }
14896
14897 Ok(())
14898 }
14899 }
14900
14901 impl ::fidl_next::IntoNatural for DirectoryCreateSymlinkResponse {
14902 type Natural = crate::natural::DirectoryCreateSymlinkResponse;
14903 }
14904
14905 #[derive(Clone, Debug)]
14907 #[repr(C)]
14908 pub struct NodeSetFlagsResponse {
14909 pub(crate) _empty: fidl_next::wire::EmptyStruct,
14910 }
14911
14912 static_assertions::const_assert_eq!(std::mem::size_of::<NodeSetFlagsResponse>(), 1);
14913 static_assertions::const_assert_eq!(std::mem::align_of::<NodeSetFlagsResponse>(), 1);
14914
14915 impl ::fidl_next::Constrained for NodeSetFlagsResponse {
14916 type Constraint = ();
14917
14918 fn validate(
14919 _: ::fidl_next::Slot<'_, Self>,
14920 _: Self::Constraint,
14921 ) -> Result<(), ::fidl_next::ValidationError> {
14922 Ok(())
14923 }
14924 }
14925
14926 unsafe impl ::fidl_next::Wire for NodeSetFlagsResponse {
14927 type Narrowed<'de> = NodeSetFlagsResponse;
14928
14929 #[inline]
14930 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14931 ::fidl_next::munge! {
14932 let Self {
14933
14934 _empty,
14935
14936
14937 } = &mut *out_;
14938 }
14939 }
14940 }
14941
14942 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeSetFlagsResponse
14943 where
14944 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14945 {
14946 fn decode(
14947 slot_: ::fidl_next::Slot<'_, Self>,
14948 decoder_: &mut ___D,
14949 _: (),
14950 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14951 ::fidl_next::munge! {
14952 let Self {
14953
14954 mut _empty,
14955
14956
14957 } = slot_;
14958 }
14959
14960 if _empty.as_bytes() != &[0u8] {
14961 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
14962 }
14963
14964 Ok(())
14965 }
14966 }
14967
14968 impl ::fidl_next::IntoNatural for NodeSetFlagsResponse {
14969 type Natural = crate::natural::NodeSetFlagsResponse;
14970 }
14971
14972 #[derive(Clone, Debug)]
14974 #[repr(C)]
14975 pub struct NodeDeprecatedGetAttrResponse {
14976 pub s: ::fidl_next::wire::Int32,
14977
14978 pub attributes: crate::wire::NodeAttributes,
14979 }
14980
14981 static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedGetAttrResponse>(), 64);
14982 static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedGetAttrResponse>(), 8);
14983
14984 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeDeprecatedGetAttrResponse, s), 0);
14985
14986 static_assertions::const_assert_eq!(
14987 std::mem::offset_of!(NodeDeprecatedGetAttrResponse, attributes),
14988 8
14989 );
14990
14991 impl ::fidl_next::Constrained for NodeDeprecatedGetAttrResponse {
14992 type Constraint = ();
14993
14994 fn validate(
14995 _: ::fidl_next::Slot<'_, Self>,
14996 _: Self::Constraint,
14997 ) -> Result<(), ::fidl_next::ValidationError> {
14998 Ok(())
14999 }
15000 }
15001
15002 unsafe impl ::fidl_next::Wire for NodeDeprecatedGetAttrResponse {
15003 type Narrowed<'de> = NodeDeprecatedGetAttrResponse;
15004
15005 #[inline]
15006 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15007 ::fidl_next::munge! {
15008 let Self {
15009
15010 s,
15011 attributes,
15012
15013 } = &mut *out_;
15014 }
15015
15016 ::fidl_next::Wire::zero_padding(s);
15017
15018 ::fidl_next::Wire::zero_padding(attributes);
15019
15020 unsafe {
15021 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
15022 }
15023 }
15024 }
15025
15026 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedGetAttrResponse
15027 where
15028 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15029 {
15030 fn decode(
15031 slot_: ::fidl_next::Slot<'_, Self>,
15032 decoder_: &mut ___D,
15033 _: (),
15034 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15035 if slot_.as_bytes()[4..8] != [0u8; 4] {
15036 return Err(::fidl_next::DecodeError::InvalidPadding);
15037 }
15038
15039 ::fidl_next::munge! {
15040 let Self {
15041
15042 mut s,
15043 mut attributes,
15044
15045 } = slot_;
15046 }
15047
15048 let _field = s.as_mut();
15049
15050 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
15051
15052 let _field = attributes.as_mut();
15053
15054 ::fidl_next::Decode::decode(attributes.as_mut(), decoder_, ())?;
15055
15056 Ok(())
15057 }
15058 }
15059
15060 impl ::fidl_next::IntoNatural for NodeDeprecatedGetAttrResponse {
15061 type Natural = crate::natural::NodeDeprecatedGetAttrResponse;
15062 }
15063
15064 #[derive(Clone, Debug)]
15066 #[repr(C)]
15067 pub struct NodeDeprecatedSetAttrRequest {
15068 pub flags: crate::wire::NodeAttributeFlags,
15069
15070 pub attributes: crate::wire::NodeAttributes,
15071 }
15072
15073 static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedSetAttrRequest>(), 64);
15074 static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedSetAttrRequest>(), 8);
15075
15076 static_assertions::const_assert_eq!(
15077 std::mem::offset_of!(NodeDeprecatedSetAttrRequest, flags),
15078 0
15079 );
15080
15081 static_assertions::const_assert_eq!(
15082 std::mem::offset_of!(NodeDeprecatedSetAttrRequest, attributes),
15083 8
15084 );
15085
15086 impl ::fidl_next::Constrained for NodeDeprecatedSetAttrRequest {
15087 type Constraint = ();
15088
15089 fn validate(
15090 _: ::fidl_next::Slot<'_, Self>,
15091 _: Self::Constraint,
15092 ) -> Result<(), ::fidl_next::ValidationError> {
15093 Ok(())
15094 }
15095 }
15096
15097 unsafe impl ::fidl_next::Wire for NodeDeprecatedSetAttrRequest {
15098 type Narrowed<'de> = NodeDeprecatedSetAttrRequest;
15099
15100 #[inline]
15101 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15102 ::fidl_next::munge! {
15103 let Self {
15104
15105 flags,
15106 attributes,
15107
15108 } = &mut *out_;
15109 }
15110
15111 ::fidl_next::Wire::zero_padding(flags);
15112
15113 ::fidl_next::Wire::zero_padding(attributes);
15114
15115 unsafe {
15116 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
15117 }
15118 }
15119 }
15120
15121 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedSetAttrRequest
15122 where
15123 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15124 {
15125 fn decode(
15126 slot_: ::fidl_next::Slot<'_, Self>,
15127 decoder_: &mut ___D,
15128 _: (),
15129 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15130 if slot_.as_bytes()[4..8] != [0u8; 4] {
15131 return Err(::fidl_next::DecodeError::InvalidPadding);
15132 }
15133
15134 ::fidl_next::munge! {
15135 let Self {
15136
15137 mut flags,
15138 mut attributes,
15139
15140 } = slot_;
15141 }
15142
15143 let _field = flags.as_mut();
15144
15145 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
15146
15147 let _field = attributes.as_mut();
15148
15149 ::fidl_next::Decode::decode(attributes.as_mut(), decoder_, ())?;
15150
15151 Ok(())
15152 }
15153 }
15154
15155 impl ::fidl_next::IntoNatural for NodeDeprecatedSetAttrRequest {
15156 type Natural = crate::natural::NodeDeprecatedSetAttrRequest;
15157 }
15158
15159 #[derive(Clone, Debug)]
15161 #[repr(C)]
15162 pub struct NodeDeprecatedSetAttrResponse {
15163 pub s: ::fidl_next::wire::Int32,
15164 }
15165
15166 static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedSetAttrResponse>(), 4);
15167 static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedSetAttrResponse>(), 4);
15168
15169 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeDeprecatedSetAttrResponse, s), 0);
15170
15171 impl ::fidl_next::Constrained for NodeDeprecatedSetAttrResponse {
15172 type Constraint = ();
15173
15174 fn validate(
15175 _: ::fidl_next::Slot<'_, Self>,
15176 _: Self::Constraint,
15177 ) -> Result<(), ::fidl_next::ValidationError> {
15178 Ok(())
15179 }
15180 }
15181
15182 unsafe impl ::fidl_next::Wire for NodeDeprecatedSetAttrResponse {
15183 type Narrowed<'de> = NodeDeprecatedSetAttrResponse;
15184
15185 #[inline]
15186 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15187 ::fidl_next::munge! {
15188 let Self {
15189
15190 s,
15191
15192 } = &mut *out_;
15193 }
15194
15195 ::fidl_next::Wire::zero_padding(s);
15196 }
15197 }
15198
15199 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedSetAttrResponse
15200 where
15201 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15202 {
15203 fn decode(
15204 slot_: ::fidl_next::Slot<'_, Self>,
15205 decoder_: &mut ___D,
15206 _: (),
15207 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15208 ::fidl_next::munge! {
15209 let Self {
15210
15211 mut s,
15212
15213 } = slot_;
15214 }
15215
15216 let _field = s.as_mut();
15217
15218 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
15219
15220 Ok(())
15221 }
15222 }
15223
15224 impl ::fidl_next::IntoNatural for NodeDeprecatedSetAttrResponse {
15225 type Natural = crate::natural::NodeDeprecatedSetAttrResponse;
15226 }
15227
15228 #[derive(Clone, Debug)]
15230 #[repr(C)]
15231 pub struct NodeDeprecatedGetFlagsResponse {
15232 pub s: ::fidl_next::wire::Int32,
15233
15234 pub flags: crate::wire::OpenFlags,
15235 }
15236
15237 static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedGetFlagsResponse>(), 8);
15238 static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedGetFlagsResponse>(), 4);
15239
15240 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeDeprecatedGetFlagsResponse, s), 0);
15241
15242 static_assertions::const_assert_eq!(
15243 std::mem::offset_of!(NodeDeprecatedGetFlagsResponse, flags),
15244 4
15245 );
15246
15247 impl ::fidl_next::Constrained for NodeDeprecatedGetFlagsResponse {
15248 type Constraint = ();
15249
15250 fn validate(
15251 _: ::fidl_next::Slot<'_, Self>,
15252 _: Self::Constraint,
15253 ) -> Result<(), ::fidl_next::ValidationError> {
15254 Ok(())
15255 }
15256 }
15257
15258 unsafe impl ::fidl_next::Wire for NodeDeprecatedGetFlagsResponse {
15259 type Narrowed<'de> = NodeDeprecatedGetFlagsResponse;
15260
15261 #[inline]
15262 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15263 ::fidl_next::munge! {
15264 let Self {
15265
15266 s,
15267 flags,
15268
15269 } = &mut *out_;
15270 }
15271
15272 ::fidl_next::Wire::zero_padding(s);
15273
15274 ::fidl_next::Wire::zero_padding(flags);
15275 }
15276 }
15277
15278 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedGetFlagsResponse
15279 where
15280 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15281 {
15282 fn decode(
15283 slot_: ::fidl_next::Slot<'_, Self>,
15284 decoder_: &mut ___D,
15285 _: (),
15286 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15287 ::fidl_next::munge! {
15288 let Self {
15289
15290 mut s,
15291 mut flags,
15292
15293 } = slot_;
15294 }
15295
15296 let _field = s.as_mut();
15297
15298 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
15299
15300 let _field = flags.as_mut();
15301
15302 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
15303
15304 Ok(())
15305 }
15306 }
15307
15308 impl ::fidl_next::IntoNatural for NodeDeprecatedGetFlagsResponse {
15309 type Natural = crate::natural::NodeDeprecatedGetFlagsResponse;
15310 }
15311
15312 #[derive(Clone, Debug)]
15314 #[repr(C)]
15315 pub struct NodeDeprecatedSetFlagsRequest {
15316 pub flags: crate::wire::OpenFlags,
15317 }
15318
15319 static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedSetFlagsRequest>(), 4);
15320 static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedSetFlagsRequest>(), 4);
15321
15322 static_assertions::const_assert_eq!(
15323 std::mem::offset_of!(NodeDeprecatedSetFlagsRequest, flags),
15324 0
15325 );
15326
15327 impl ::fidl_next::Constrained for NodeDeprecatedSetFlagsRequest {
15328 type Constraint = ();
15329
15330 fn validate(
15331 _: ::fidl_next::Slot<'_, Self>,
15332 _: Self::Constraint,
15333 ) -> Result<(), ::fidl_next::ValidationError> {
15334 Ok(())
15335 }
15336 }
15337
15338 unsafe impl ::fidl_next::Wire for NodeDeprecatedSetFlagsRequest {
15339 type Narrowed<'de> = NodeDeprecatedSetFlagsRequest;
15340
15341 #[inline]
15342 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15343 ::fidl_next::munge! {
15344 let Self {
15345
15346 flags,
15347
15348 } = &mut *out_;
15349 }
15350
15351 ::fidl_next::Wire::zero_padding(flags);
15352 }
15353 }
15354
15355 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedSetFlagsRequest
15356 where
15357 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15358 {
15359 fn decode(
15360 slot_: ::fidl_next::Slot<'_, Self>,
15361 decoder_: &mut ___D,
15362 _: (),
15363 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15364 ::fidl_next::munge! {
15365 let Self {
15366
15367 mut flags,
15368
15369 } = slot_;
15370 }
15371
15372 let _field = flags.as_mut();
15373
15374 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
15375
15376 Ok(())
15377 }
15378 }
15379
15380 impl ::fidl_next::IntoNatural for NodeDeprecatedSetFlagsRequest {
15381 type Natural = crate::natural::NodeDeprecatedSetFlagsRequest;
15382 }
15383
15384 #[derive(Clone, Debug)]
15386 #[repr(C)]
15387 pub struct NodeDeprecatedSetFlagsResponse {
15388 pub s: ::fidl_next::wire::Int32,
15389 }
15390
15391 static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedSetFlagsResponse>(), 4);
15392 static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedSetFlagsResponse>(), 4);
15393
15394 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeDeprecatedSetFlagsResponse, s), 0);
15395
15396 impl ::fidl_next::Constrained for NodeDeprecatedSetFlagsResponse {
15397 type Constraint = ();
15398
15399 fn validate(
15400 _: ::fidl_next::Slot<'_, Self>,
15401 _: Self::Constraint,
15402 ) -> Result<(), ::fidl_next::ValidationError> {
15403 Ok(())
15404 }
15405 }
15406
15407 unsafe impl ::fidl_next::Wire for NodeDeprecatedSetFlagsResponse {
15408 type Narrowed<'de> = NodeDeprecatedSetFlagsResponse;
15409
15410 #[inline]
15411 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15412 ::fidl_next::munge! {
15413 let Self {
15414
15415 s,
15416
15417 } = &mut *out_;
15418 }
15419
15420 ::fidl_next::Wire::zero_padding(s);
15421 }
15422 }
15423
15424 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedSetFlagsResponse
15425 where
15426 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15427 {
15428 fn decode(
15429 slot_: ::fidl_next::Slot<'_, Self>,
15430 decoder_: &mut ___D,
15431 _: (),
15432 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15433 ::fidl_next::munge! {
15434 let Self {
15435
15436 mut s,
15437
15438 } = slot_;
15439 }
15440
15441 let _field = s.as_mut();
15442
15443 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
15444
15445 Ok(())
15446 }
15447 }
15448
15449 impl ::fidl_next::IntoNatural for NodeDeprecatedSetFlagsResponse {
15450 type Natural = crate::natural::NodeDeprecatedSetFlagsResponse;
15451 }
15452
15453 #[derive(Clone, Copy, Debug)]
15455 #[repr(transparent)]
15456 pub struct Flags {
15457 pub(crate) value: ::fidl_next::wire::Uint64,
15458 }
15459
15460 impl ::fidl_next::Constrained for Flags {
15461 type Constraint = ();
15462
15463 fn validate(
15464 _: ::fidl_next::Slot<'_, Self>,
15465 _: Self::Constraint,
15466 ) -> Result<(), ::fidl_next::ValidationError> {
15467 Ok(())
15468 }
15469 }
15470
15471 unsafe impl ::fidl_next::Wire for Flags {
15472 type Narrowed<'de> = Self;
15473
15474 #[inline]
15475 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
15476 }
15478 }
15479
15480 unsafe impl<___D> ::fidl_next::Decode<___D> for Flags
15481 where
15482 ___D: ?Sized,
15483 {
15484 fn decode(
15485 slot: ::fidl_next::Slot<'_, Self>,
15486 _: &mut ___D,
15487 _: (),
15488 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15489 Ok(())
15490 }
15491 }
15492
15493 impl ::core::convert::From<crate::natural::Flags> for Flags {
15494 fn from(natural: crate::natural::Flags) -> Self {
15495 Self { value: ::fidl_next::wire::Uint64::from(natural.bits()) }
15496 }
15497 }
15498
15499 impl ::fidl_next::IntoNatural for Flags {
15500 type Natural = crate::natural::Flags;
15501 }
15502
15503 #[derive(Clone, Debug)]
15505 #[repr(C)]
15506 pub struct NodeGetFlagsResponse {
15507 pub flags: crate::wire::Flags,
15508 }
15509
15510 static_assertions::const_assert_eq!(std::mem::size_of::<NodeGetFlagsResponse>(), 8);
15511 static_assertions::const_assert_eq!(std::mem::align_of::<NodeGetFlagsResponse>(), 8);
15512
15513 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeGetFlagsResponse, flags), 0);
15514
15515 impl ::fidl_next::Constrained for NodeGetFlagsResponse {
15516 type Constraint = ();
15517
15518 fn validate(
15519 _: ::fidl_next::Slot<'_, Self>,
15520 _: Self::Constraint,
15521 ) -> Result<(), ::fidl_next::ValidationError> {
15522 Ok(())
15523 }
15524 }
15525
15526 unsafe impl ::fidl_next::Wire for NodeGetFlagsResponse {
15527 type Narrowed<'de> = NodeGetFlagsResponse;
15528
15529 #[inline]
15530 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15531 ::fidl_next::munge! {
15532 let Self {
15533
15534 flags,
15535
15536 } = &mut *out_;
15537 }
15538
15539 ::fidl_next::Wire::zero_padding(flags);
15540 }
15541 }
15542
15543 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeGetFlagsResponse
15544 where
15545 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15546 {
15547 fn decode(
15548 slot_: ::fidl_next::Slot<'_, Self>,
15549 decoder_: &mut ___D,
15550 _: (),
15551 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15552 ::fidl_next::munge! {
15553 let Self {
15554
15555 mut flags,
15556
15557 } = slot_;
15558 }
15559
15560 let _field = flags.as_mut();
15561
15562 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
15563
15564 Ok(())
15565 }
15566 }
15567
15568 impl ::fidl_next::IntoNatural for NodeGetFlagsResponse {
15569 type Natural = crate::natural::NodeGetFlagsResponse;
15570 }
15571
15572 #[derive(Clone, Debug)]
15574 #[repr(C)]
15575 pub struct NodeSetFlagsRequest {
15576 pub flags: crate::wire::Flags,
15577 }
15578
15579 static_assertions::const_assert_eq!(std::mem::size_of::<NodeSetFlagsRequest>(), 8);
15580 static_assertions::const_assert_eq!(std::mem::align_of::<NodeSetFlagsRequest>(), 8);
15581
15582 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeSetFlagsRequest, flags), 0);
15583
15584 impl ::fidl_next::Constrained for NodeSetFlagsRequest {
15585 type Constraint = ();
15586
15587 fn validate(
15588 _: ::fidl_next::Slot<'_, Self>,
15589 _: Self::Constraint,
15590 ) -> Result<(), ::fidl_next::ValidationError> {
15591 Ok(())
15592 }
15593 }
15594
15595 unsafe impl ::fidl_next::Wire for NodeSetFlagsRequest {
15596 type Narrowed<'de> = NodeSetFlagsRequest;
15597
15598 #[inline]
15599 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15600 ::fidl_next::munge! {
15601 let Self {
15602
15603 flags,
15604
15605 } = &mut *out_;
15606 }
15607
15608 ::fidl_next::Wire::zero_padding(flags);
15609 }
15610 }
15611
15612 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeSetFlagsRequest
15613 where
15614 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15615 {
15616 fn decode(
15617 slot_: ::fidl_next::Slot<'_, Self>,
15618 decoder_: &mut ___D,
15619 _: (),
15620 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15621 ::fidl_next::munge! {
15622 let Self {
15623
15624 mut flags,
15625
15626 } = slot_;
15627 }
15628
15629 let _field = flags.as_mut();
15630
15631 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
15632
15633 Ok(())
15634 }
15635 }
15636
15637 impl ::fidl_next::IntoNatural for NodeSetFlagsRequest {
15638 type Natural = crate::natural::NodeSetFlagsRequest;
15639 }
15640
15641 #[derive(Clone, Debug)]
15643 #[repr(C)]
15644 pub struct EmptyStruct {
15645 pub(crate) _empty: fidl_next::wire::EmptyStruct,
15646 }
15647
15648 static_assertions::const_assert_eq!(std::mem::size_of::<EmptyStruct>(), 1);
15649 static_assertions::const_assert_eq!(std::mem::align_of::<EmptyStruct>(), 1);
15650
15651 impl ::fidl_next::Constrained for EmptyStruct {
15652 type Constraint = ();
15653
15654 fn validate(
15655 _: ::fidl_next::Slot<'_, Self>,
15656 _: Self::Constraint,
15657 ) -> Result<(), ::fidl_next::ValidationError> {
15658 Ok(())
15659 }
15660 }
15661
15662 unsafe impl ::fidl_next::Wire for EmptyStruct {
15663 type Narrowed<'de> = EmptyStruct;
15664
15665 #[inline]
15666 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15667 ::fidl_next::munge! {
15668 let Self {
15669
15670 _empty,
15671
15672
15673 } = &mut *out_;
15674 }
15675 }
15676 }
15677
15678 unsafe impl<___D> ::fidl_next::Decode<___D> for EmptyStruct
15679 where
15680 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15681 {
15682 fn decode(
15683 slot_: ::fidl_next::Slot<'_, Self>,
15684 decoder_: &mut ___D,
15685 _: (),
15686 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15687 ::fidl_next::munge! {
15688 let Self {
15689
15690 mut _empty,
15691
15692
15693 } = slot_;
15694 }
15695
15696 if _empty.as_bytes() != &[0u8] {
15697 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
15698 }
15699
15700 Ok(())
15701 }
15702 }
15703
15704 impl ::fidl_next::IntoNatural for EmptyStruct {
15705 type Natural = crate::natural::EmptyStruct;
15706 }
15707
15708 #[repr(transparent)]
15710 pub struct SelinuxContext<'de> {
15711 pub(crate) raw: ::fidl_next::wire::Union,
15712 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
15713 }
15714
15715 impl<'de> Drop for SelinuxContext<'de> {
15716 fn drop(&mut self) {
15717 match self.raw.ordinal() {
15718 1 => {
15719 let _ = unsafe {
15720 self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
15721 };
15722 }
15723
15724 2 => {
15725 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::EmptyStruct>() };
15726 }
15727
15728 _ => (),
15729 }
15730 }
15731 }
15732
15733 impl ::fidl_next::Constrained for SelinuxContext<'_> {
15734 type Constraint = ();
15735
15736 fn validate(
15737 _: ::fidl_next::Slot<'_, Self>,
15738 _: Self::Constraint,
15739 ) -> Result<(), ::fidl_next::ValidationError> {
15740 Ok(())
15741 }
15742 }
15743
15744 unsafe impl ::fidl_next::Wire for SelinuxContext<'static> {
15745 type Narrowed<'de> = SelinuxContext<'de>;
15746
15747 #[inline]
15748 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
15749 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
15750 ::fidl_next::wire::Union::zero_padding(raw);
15751 }
15752 }
15753
15754 pub mod selinux_context {
15755 pub enum Ref<'de> {
15756 Data(&'de ::fidl_next::wire::Vector<'de, u8>),
15757
15758 UseExtendedAttributes(&'de crate::wire::EmptyStruct),
15759
15760 UnknownOrdinal_(u64),
15761 }
15762 }
15763
15764 impl<'de> SelinuxContext<'de> {
15765 pub fn as_ref(&self) -> crate::wire::selinux_context::Ref<'_> {
15766 match self.raw.ordinal() {
15767 1 => crate::wire::selinux_context::Ref::Data(unsafe {
15768 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
15769 }),
15770
15771 2 => crate::wire::selinux_context::Ref::UseExtendedAttributes(unsafe {
15772 self.raw.get().deref_unchecked::<crate::wire::EmptyStruct>()
15773 }),
15774
15775 unknown => crate::wire::selinux_context::Ref::UnknownOrdinal_(unknown),
15776 }
15777 }
15778 }
15779
15780 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SelinuxContext<'de>
15781 where
15782 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15783 ___D: ::fidl_next::Decoder<'de>,
15784 {
15785 fn decode(
15786 mut slot: ::fidl_next::Slot<'_, Self>,
15787 decoder: &mut ___D,
15788 _: (),
15789 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15790 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
15791 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
15792 1 => {
15793 ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
15794 raw,
15795 decoder,
15796 (256, ()),
15797 )?
15798 }
15799
15800 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::EmptyStruct>(
15801 raw,
15802 decoder,
15803 (),
15804 )?,
15805
15806 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
15807 }
15808
15809 Ok(())
15810 }
15811 }
15812
15813 impl<'de> ::core::fmt::Debug for SelinuxContext<'de> {
15814 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
15815 match self.raw.ordinal() {
15816 1 => unsafe {
15817 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>().fmt(f)
15818 },
15819 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::EmptyStruct>().fmt(f) },
15820 _ => unsafe { ::core::hint::unreachable_unchecked() },
15821 }
15822 }
15823 }
15824
15825 impl<'de> ::fidl_next::IntoNatural for SelinuxContext<'de> {
15826 type Natural = crate::natural::SelinuxContext;
15827 }
15828
15829 #[repr(C)]
15831 pub struct MutableNodeAttributes<'de> {
15832 pub(crate) table: ::fidl_next::wire::Table<'de>,
15833 }
15834
15835 impl<'de> Drop for MutableNodeAttributes<'de> {
15836 fn drop(&mut self) {
15837 let _ = self
15838 .table
15839 .get(1)
15840 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
15841
15842 let _ = self
15843 .table
15844 .get(2)
15845 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
15846
15847 let _ = self
15848 .table
15849 .get(3)
15850 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint32>() });
15851
15852 let _ = self
15853 .table
15854 .get(4)
15855 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint32>() });
15856
15857 let _ = self
15858 .table
15859 .get(5)
15860 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint32>() });
15861
15862 let _ = self
15863 .table
15864 .get(6)
15865 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
15866
15867 let _ = self
15868 .table
15869 .get(7)
15870 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
15871
15872 let _ = self.table.get(8).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });
15873
15874 let _ = self.table.get(9).map(|envelope| unsafe {
15875 envelope.read_unchecked::<crate::wire::SelinuxContext<'de>>()
15876 });
15877
15878 let _ =
15879 self.table.get(10).map(|envelope| unsafe { envelope.read_unchecked::<[u8; 16]>() });
15880 }
15881 }
15882
15883 impl ::fidl_next::Constrained for MutableNodeAttributes<'_> {
15884 type Constraint = ();
15885
15886 fn validate(
15887 _: ::fidl_next::Slot<'_, Self>,
15888 _: Self::Constraint,
15889 ) -> Result<(), ::fidl_next::ValidationError> {
15890 Ok(())
15891 }
15892 }
15893
15894 unsafe impl ::fidl_next::Wire for MutableNodeAttributes<'static> {
15895 type Narrowed<'de> = MutableNodeAttributes<'de>;
15896
15897 #[inline]
15898 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
15899 ::fidl_next::munge!(let Self { table } = out);
15900 ::fidl_next::wire::Table::zero_padding(table);
15901 }
15902 }
15903
15904 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for MutableNodeAttributes<'de>
15905 where
15906 ___D: ::fidl_next::Decoder<'de> + ?Sized,
15907 {
15908 fn decode(
15909 slot: ::fidl_next::Slot<'_, Self>,
15910 decoder: &mut ___D,
15911 _: (),
15912 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15913 ::fidl_next::munge!(let Self { table } = slot);
15914
15915 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
15916 match ordinal {
15917 0 => unsafe { ::core::hint::unreachable_unchecked() },
15918
15919 1 => {
15920 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
15921 slot.as_mut(),
15922 decoder,
15923 (),
15924 )?;
15925
15926 Ok(())
15927 }
15928
15929 2 => {
15930 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
15931 slot.as_mut(),
15932 decoder,
15933 (),
15934 )?;
15935
15936 Ok(())
15937 }
15938
15939 3 => {
15940 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint32>(
15941 slot.as_mut(),
15942 decoder,
15943 (),
15944 )?;
15945
15946 Ok(())
15947 }
15948
15949 4 => {
15950 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint32>(
15951 slot.as_mut(),
15952 decoder,
15953 (),
15954 )?;
15955
15956 Ok(())
15957 }
15958
15959 5 => {
15960 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint32>(
15961 slot.as_mut(),
15962 decoder,
15963 (),
15964 )?;
15965
15966 Ok(())
15967 }
15968
15969 6 => {
15970 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
15971 slot.as_mut(),
15972 decoder,
15973 (),
15974 )?;
15975
15976 Ok(())
15977 }
15978
15979 7 => {
15980 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
15981 slot.as_mut(),
15982 decoder,
15983 (),
15984 )?;
15985
15986 Ok(())
15987 }
15988
15989 8 => {
15990 ::fidl_next::wire::Envelope::decode_as::<___D, bool>(
15991 slot.as_mut(),
15992 decoder,
15993 (),
15994 )?;
15995
15996 Ok(())
15997 }
15998
15999 9 => {
16000 ::fidl_next::wire::Envelope::decode_as::<
16001 ___D,
16002 crate::wire::SelinuxContext<'de>,
16003 >(slot.as_mut(), decoder, ())?;
16004
16005 Ok(())
16006 }
16007
16008 10 => {
16009 ::fidl_next::wire::Envelope::decode_as::<___D, [u8; 16]>(
16010 slot.as_mut(),
16011 decoder,
16012 (),
16013 )?;
16014
16015 Ok(())
16016 }
16017
16018 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
16019 }
16020 })
16021 }
16022 }
16023
16024 impl<'de> MutableNodeAttributes<'de> {
16025 pub fn creation_time(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
16026 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
16027 }
16028
16029 pub fn modification_time(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
16030 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
16031 }
16032
16033 pub fn mode(&self) -> ::core::option::Option<&::fidl_next::wire::Uint32> {
16034 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
16035 }
16036
16037 pub fn uid(&self) -> ::core::option::Option<&::fidl_next::wire::Uint32> {
16038 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
16039 }
16040
16041 pub fn gid(&self) -> ::core::option::Option<&::fidl_next::wire::Uint32> {
16042 unsafe { Some(self.table.get(5)?.deref_unchecked()) }
16043 }
16044
16045 pub fn rdev(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
16046 unsafe { Some(self.table.get(6)?.deref_unchecked()) }
16047 }
16048
16049 pub fn access_time(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
16050 unsafe { Some(self.table.get(7)?.deref_unchecked()) }
16051 }
16052
16053 pub fn casefold(&self) -> ::core::option::Option<&bool> {
16054 unsafe { Some(self.table.get(8)?.deref_unchecked()) }
16055 }
16056
16057 pub fn selinux_context(&self) -> ::core::option::Option<&crate::wire::SelinuxContext<'de>> {
16058 unsafe { Some(self.table.get(9)?.deref_unchecked()) }
16059 }
16060
16061 pub fn wrapping_key_id(&self) -> ::core::option::Option<&[u8; 16]> {
16062 unsafe { Some(self.table.get(10)?.deref_unchecked()) }
16063 }
16064 }
16065
16066 impl<'de> ::core::fmt::Debug for MutableNodeAttributes<'de> {
16067 fn fmt(
16068 &self,
16069 f: &mut ::core::fmt::Formatter<'_>,
16070 ) -> ::core::result::Result<(), ::core::fmt::Error> {
16071 f.debug_struct("MutableNodeAttributes")
16072 .field("creation_time", &self.creation_time())
16073 .field("modification_time", &self.modification_time())
16074 .field("mode", &self.mode())
16075 .field("uid", &self.uid())
16076 .field("gid", &self.gid())
16077 .field("rdev", &self.rdev())
16078 .field("access_time", &self.access_time())
16079 .field("casefold", &self.casefold())
16080 .field("selinux_context", &self.selinux_context())
16081 .field("wrapping_key_id", &self.wrapping_key_id())
16082 .finish()
16083 }
16084 }
16085
16086 impl<'de> ::fidl_next::IntoNatural for MutableNodeAttributes<'de> {
16087 type Natural = crate::natural::MutableNodeAttributes;
16088 }
16089
16090 #[derive(Clone, Copy, Debug)]
16092 #[repr(transparent)]
16093 pub struct NodeProtocolKinds {
16094 pub(crate) value: ::fidl_next::wire::Uint64,
16095 }
16096
16097 impl ::fidl_next::Constrained for NodeProtocolKinds {
16098 type Constraint = ();
16099
16100 fn validate(
16101 _: ::fidl_next::Slot<'_, Self>,
16102 _: Self::Constraint,
16103 ) -> Result<(), ::fidl_next::ValidationError> {
16104 Ok(())
16105 }
16106 }
16107
16108 unsafe impl ::fidl_next::Wire for NodeProtocolKinds {
16109 type Narrowed<'de> = Self;
16110
16111 #[inline]
16112 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
16113 }
16115 }
16116
16117 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeProtocolKinds
16118 where
16119 ___D: ?Sized,
16120 {
16121 fn decode(
16122 slot: ::fidl_next::Slot<'_, Self>,
16123 _: &mut ___D,
16124 _: (),
16125 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16126 Ok(())
16127 }
16128 }
16129
16130 impl ::core::convert::From<crate::natural::NodeProtocolKinds> for NodeProtocolKinds {
16131 fn from(natural: crate::natural::NodeProtocolKinds) -> Self {
16132 Self { value: ::fidl_next::wire::Uint64::from(natural.bits()) }
16133 }
16134 }
16135
16136 impl ::fidl_next::IntoNatural for NodeProtocolKinds {
16137 type Natural = crate::natural::NodeProtocolKinds;
16138 }
16139
16140 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
16142 #[repr(transparent)]
16143 pub struct HashAlgorithm {
16144 pub(crate) value: u8,
16145 }
16146
16147 impl ::fidl_next::Constrained for HashAlgorithm {
16148 type Constraint = ();
16149
16150 fn validate(
16151 _: ::fidl_next::Slot<'_, Self>,
16152 _: Self::Constraint,
16153 ) -> Result<(), ::fidl_next::ValidationError> {
16154 Ok(())
16155 }
16156 }
16157
16158 unsafe impl ::fidl_next::Wire for HashAlgorithm {
16159 type Narrowed<'de> = Self;
16160
16161 #[inline]
16162 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
16163 }
16165 }
16166
16167 impl HashAlgorithm {
16168 pub const SHA256: HashAlgorithm = HashAlgorithm { value: 1 };
16169
16170 pub const SHA512: HashAlgorithm = HashAlgorithm { value: 2 };
16171 }
16172
16173 unsafe impl<___D> ::fidl_next::Decode<___D> for HashAlgorithm
16174 where
16175 ___D: ?Sized,
16176 {
16177 fn decode(
16178 slot: ::fidl_next::Slot<'_, Self>,
16179 _: &mut ___D,
16180 _: (),
16181 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16182 Ok(())
16183 }
16184 }
16185
16186 impl ::core::convert::From<crate::natural::HashAlgorithm> for HashAlgorithm {
16187 fn from(natural: crate::natural::HashAlgorithm) -> Self {
16188 match natural {
16189 crate::natural::HashAlgorithm::Sha256 => HashAlgorithm::SHA256,
16190
16191 crate::natural::HashAlgorithm::Sha512 => HashAlgorithm::SHA512,
16192
16193 crate::natural::HashAlgorithm::UnknownOrdinal_(value) => {
16194 HashAlgorithm { value: u8::from(value) }
16195 }
16196 }
16197 }
16198 }
16199
16200 impl ::fidl_next::IntoNatural for HashAlgorithm {
16201 type Natural = crate::natural::HashAlgorithm;
16202 }
16203
16204 #[repr(C)]
16206 pub struct VerificationOptions<'de> {
16207 pub(crate) table: ::fidl_next::wire::Table<'de>,
16208 }
16209
16210 impl<'de> Drop for VerificationOptions<'de> {
16211 fn drop(&mut self) {
16212 let _ = self
16213 .table
16214 .get(1)
16215 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::HashAlgorithm>() });
16216
16217 let _ = self.table.get(2).map(|envelope| unsafe {
16218 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
16219 });
16220 }
16221 }
16222
16223 impl ::fidl_next::Constrained for VerificationOptions<'_> {
16224 type Constraint = ();
16225
16226 fn validate(
16227 _: ::fidl_next::Slot<'_, Self>,
16228 _: Self::Constraint,
16229 ) -> Result<(), ::fidl_next::ValidationError> {
16230 Ok(())
16231 }
16232 }
16233
16234 unsafe impl ::fidl_next::Wire for VerificationOptions<'static> {
16235 type Narrowed<'de> = VerificationOptions<'de>;
16236
16237 #[inline]
16238 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
16239 ::fidl_next::munge!(let Self { table } = out);
16240 ::fidl_next::wire::Table::zero_padding(table);
16241 }
16242 }
16243
16244 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for VerificationOptions<'de>
16245 where
16246 ___D: ::fidl_next::Decoder<'de> + ?Sized,
16247 {
16248 fn decode(
16249 slot: ::fidl_next::Slot<'_, Self>,
16250 decoder: &mut ___D,
16251 _: (),
16252 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16253 ::fidl_next::munge!(let Self { table } = slot);
16254
16255 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
16256 match ordinal {
16257 0 => unsafe { ::core::hint::unreachable_unchecked() },
16258
16259 1 => {
16260 ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::HashAlgorithm>(
16261 slot.as_mut(),
16262 decoder,
16263 (),
16264 )?;
16265
16266 Ok(())
16267 }
16268
16269 2 => {
16270 ::fidl_next::wire::Envelope::decode_as::<
16271 ___D,
16272 ::fidl_next::wire::Vector<'de, u8>,
16273 >(slot.as_mut(), decoder, (32, ()))?;
16274
16275 let value = unsafe {
16276 slot.deref_unchecked()
16277 .deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
16278 };
16279
16280 if value.len() > 32 {
16281 return Err(::fidl_next::DecodeError::VectorTooLong {
16282 size: value.len() as u64,
16283 limit: 32,
16284 });
16285 }
16286
16287 Ok(())
16288 }
16289
16290 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
16291 }
16292 })
16293 }
16294 }
16295
16296 impl<'de> VerificationOptions<'de> {
16297 pub fn hash_algorithm(&self) -> ::core::option::Option<&crate::wire::HashAlgorithm> {
16298 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
16299 }
16300
16301 pub fn salt(&self) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, u8>> {
16302 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
16303 }
16304 }
16305
16306 impl<'de> ::core::fmt::Debug for VerificationOptions<'de> {
16307 fn fmt(
16308 &self,
16309 f: &mut ::core::fmt::Formatter<'_>,
16310 ) -> ::core::result::Result<(), ::core::fmt::Error> {
16311 f.debug_struct("VerificationOptions")
16312 .field("hash_algorithm", &self.hash_algorithm())
16313 .field("salt", &self.salt())
16314 .finish()
16315 }
16316 }
16317
16318 impl<'de> ::fidl_next::IntoNatural for VerificationOptions<'de> {
16319 type Natural = crate::natural::VerificationOptions;
16320 }
16321
16322 #[repr(C)]
16324 pub struct ImmutableNodeAttributes<'de> {
16325 pub(crate) table: ::fidl_next::wire::Table<'de>,
16326 }
16327
16328 impl<'de> Drop for ImmutableNodeAttributes<'de> {
16329 fn drop(&mut self) {
16330 let _ = self.table.get(1).map(|envelope| unsafe {
16331 envelope.read_unchecked::<crate::wire::NodeProtocolKinds>()
16332 });
16333
16334 let _ = self
16335 .table
16336 .get(2)
16337 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Operations>() });
16338
16339 let _ = self
16340 .table
16341 .get(3)
16342 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
16343
16344 let _ = self
16345 .table
16346 .get(4)
16347 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
16348
16349 let _ = self
16350 .table
16351 .get(5)
16352 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
16353
16354 let _ = self
16355 .table
16356 .get(6)
16357 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
16358
16359 let _ = self
16360 .table
16361 .get(7)
16362 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
16363
16364 let _ = self.table.get(8).map(|envelope| unsafe {
16365 envelope.read_unchecked::<crate::wire::VerificationOptions<'de>>()
16366 });
16367
16368 let _ = self.table.get(9).map(|envelope| unsafe {
16369 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
16370 });
16371
16372 let _ = self.table.get(10).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });
16373 }
16374 }
16375
16376 impl ::fidl_next::Constrained for ImmutableNodeAttributes<'_> {
16377 type Constraint = ();
16378
16379 fn validate(
16380 _: ::fidl_next::Slot<'_, Self>,
16381 _: Self::Constraint,
16382 ) -> Result<(), ::fidl_next::ValidationError> {
16383 Ok(())
16384 }
16385 }
16386
16387 unsafe impl ::fidl_next::Wire for ImmutableNodeAttributes<'static> {
16388 type Narrowed<'de> = ImmutableNodeAttributes<'de>;
16389
16390 #[inline]
16391 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
16392 ::fidl_next::munge!(let Self { table } = out);
16393 ::fidl_next::wire::Table::zero_padding(table);
16394 }
16395 }
16396
16397 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ImmutableNodeAttributes<'de>
16398 where
16399 ___D: ::fidl_next::Decoder<'de> + ?Sized,
16400 {
16401 fn decode(
16402 slot: ::fidl_next::Slot<'_, Self>,
16403 decoder: &mut ___D,
16404 _: (),
16405 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16406 ::fidl_next::munge!(let Self { table } = slot);
16407
16408 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
16409 match ordinal {
16410 0 => unsafe { ::core::hint::unreachable_unchecked() },
16411
16412 1 => {
16413 ::fidl_next::wire::Envelope::decode_as::<
16414 ___D,
16415 crate::wire::NodeProtocolKinds,
16416 >(slot.as_mut(), decoder, ())?;
16417
16418 Ok(())
16419 }
16420
16421 2 => {
16422 ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Operations>(
16423 slot.as_mut(),
16424 decoder,
16425 (),
16426 )?;
16427
16428 Ok(())
16429 }
16430
16431 3 => {
16432 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
16433 slot.as_mut(),
16434 decoder,
16435 (),
16436 )?;
16437
16438 Ok(())
16439 }
16440
16441 4 => {
16442 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
16443 slot.as_mut(),
16444 decoder,
16445 (),
16446 )?;
16447
16448 Ok(())
16449 }
16450
16451 5 => {
16452 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
16453 slot.as_mut(),
16454 decoder,
16455 (),
16456 )?;
16457
16458 Ok(())
16459 }
16460
16461 6 => {
16462 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
16463 slot.as_mut(),
16464 decoder,
16465 (),
16466 )?;
16467
16468 Ok(())
16469 }
16470
16471 7 => {
16472 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
16473 slot.as_mut(),
16474 decoder,
16475 (),
16476 )?;
16477
16478 Ok(())
16479 }
16480
16481 8 => {
16482 ::fidl_next::wire::Envelope::decode_as::<
16483 ___D,
16484 crate::wire::VerificationOptions<'de>,
16485 >(slot.as_mut(), decoder, ())?;
16486
16487 Ok(())
16488 }
16489
16490 9 => {
16491 ::fidl_next::wire::Envelope::decode_as::<
16492 ___D,
16493 ::fidl_next::wire::Vector<'de, u8>,
16494 >(slot.as_mut(), decoder, (64, ()))?;
16495
16496 let value = unsafe {
16497 slot.deref_unchecked()
16498 .deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
16499 };
16500
16501 if value.len() > 64 {
16502 return Err(::fidl_next::DecodeError::VectorTooLong {
16503 size: value.len() as u64,
16504 limit: 64,
16505 });
16506 }
16507
16508 Ok(())
16509 }
16510
16511 10 => {
16512 ::fidl_next::wire::Envelope::decode_as::<___D, bool>(
16513 slot.as_mut(),
16514 decoder,
16515 (),
16516 )?;
16517
16518 Ok(())
16519 }
16520
16521 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
16522 }
16523 })
16524 }
16525 }
16526
16527 impl<'de> ImmutableNodeAttributes<'de> {
16528 pub fn protocols(&self) -> ::core::option::Option<&crate::wire::NodeProtocolKinds> {
16529 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
16530 }
16531
16532 pub fn abilities(&self) -> ::core::option::Option<&crate::wire::Operations> {
16533 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
16534 }
16535
16536 pub fn content_size(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
16537 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
16538 }
16539
16540 pub fn storage_size(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
16541 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
16542 }
16543
16544 pub fn link_count(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
16545 unsafe { Some(self.table.get(5)?.deref_unchecked()) }
16546 }
16547
16548 pub fn id(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
16549 unsafe { Some(self.table.get(6)?.deref_unchecked()) }
16550 }
16551
16552 pub fn change_time(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
16553 unsafe { Some(self.table.get(7)?.deref_unchecked()) }
16554 }
16555
16556 pub fn options(&self) -> ::core::option::Option<&crate::wire::VerificationOptions<'de>> {
16557 unsafe { Some(self.table.get(8)?.deref_unchecked()) }
16558 }
16559
16560 pub fn root_hash(&self) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, u8>> {
16561 unsafe { Some(self.table.get(9)?.deref_unchecked()) }
16562 }
16563
16564 pub fn verity_enabled(&self) -> ::core::option::Option<&bool> {
16565 unsafe { Some(self.table.get(10)?.deref_unchecked()) }
16566 }
16567 }
16568
16569 impl<'de> ::core::fmt::Debug for ImmutableNodeAttributes<'de> {
16570 fn fmt(
16571 &self,
16572 f: &mut ::core::fmt::Formatter<'_>,
16573 ) -> ::core::result::Result<(), ::core::fmt::Error> {
16574 f.debug_struct("ImmutableNodeAttributes")
16575 .field("protocols", &self.protocols())
16576 .field("abilities", &self.abilities())
16577 .field("content_size", &self.content_size())
16578 .field("storage_size", &self.storage_size())
16579 .field("link_count", &self.link_count())
16580 .field("id", &self.id())
16581 .field("change_time", &self.change_time())
16582 .field("options", &self.options())
16583 .field("root_hash", &self.root_hash())
16584 .field("verity_enabled", &self.verity_enabled())
16585 .finish()
16586 }
16587 }
16588
16589 impl<'de> ::fidl_next::IntoNatural for ImmutableNodeAttributes<'de> {
16590 type Natural = crate::natural::ImmutableNodeAttributes;
16591 }
16592
16593 #[derive(Debug)]
16595 #[repr(C)]
16596 pub struct NodeAttributes2<'de> {
16597 pub mutable_attributes: crate::wire::MutableNodeAttributes<'de>,
16598
16599 pub immutable_attributes: crate::wire::ImmutableNodeAttributes<'de>,
16600 }
16601
16602 static_assertions::const_assert_eq!(std::mem::size_of::<NodeAttributes2<'_>>(), 32);
16603 static_assertions::const_assert_eq!(std::mem::align_of::<NodeAttributes2<'_>>(), 8);
16604
16605 static_assertions::const_assert_eq!(
16606 std::mem::offset_of!(NodeAttributes2<'_>, mutable_attributes),
16607 0
16608 );
16609
16610 static_assertions::const_assert_eq!(
16611 std::mem::offset_of!(NodeAttributes2<'_>, immutable_attributes),
16612 16
16613 );
16614
16615 impl ::fidl_next::Constrained for NodeAttributes2<'_> {
16616 type Constraint = ();
16617
16618 fn validate(
16619 _: ::fidl_next::Slot<'_, Self>,
16620 _: Self::Constraint,
16621 ) -> Result<(), ::fidl_next::ValidationError> {
16622 Ok(())
16623 }
16624 }
16625
16626 unsafe impl ::fidl_next::Wire for NodeAttributes2<'static> {
16627 type Narrowed<'de> = NodeAttributes2<'de>;
16628
16629 #[inline]
16630 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
16631 ::fidl_next::munge! {
16632 let Self {
16633
16634 mutable_attributes,
16635 immutable_attributes,
16636
16637 } = &mut *out_;
16638 }
16639
16640 ::fidl_next::Wire::zero_padding(mutable_attributes);
16641
16642 ::fidl_next::Wire::zero_padding(immutable_attributes);
16643 }
16644 }
16645
16646 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeAttributes2<'de>
16647 where
16648 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
16649 ___D: ::fidl_next::Decoder<'de>,
16650 {
16651 fn decode(
16652 slot_: ::fidl_next::Slot<'_, Self>,
16653 decoder_: &mut ___D,
16654 _: (),
16655 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16656 ::fidl_next::munge! {
16657 let Self {
16658
16659 mut mutable_attributes,
16660 mut immutable_attributes,
16661
16662 } = slot_;
16663 }
16664
16665 let _field = mutable_attributes.as_mut();
16666
16667 ::fidl_next::Decode::decode(mutable_attributes.as_mut(), decoder_, ())?;
16668
16669 let _field = immutable_attributes.as_mut();
16670
16671 ::fidl_next::Decode::decode(immutable_attributes.as_mut(), decoder_, ())?;
16672
16673 Ok(())
16674 }
16675 }
16676
16677 impl<'de> ::fidl_next::IntoNatural for NodeAttributes2<'de> {
16678 type Natural = crate::natural::NodeAttributes2;
16679 }
16680
16681 #[repr(C)]
16683 pub struct NodeInfo<'de> {
16684 pub(crate) table: ::fidl_next::wire::Table<'de>,
16685 }
16686
16687 impl<'de> Drop for NodeInfo<'de> {
16688 fn drop(&mut self) {
16689 let _ = self.table.get(1).map(|envelope| unsafe {
16690 envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
16691 });
16692 }
16693 }
16694
16695 impl ::fidl_next::Constrained for NodeInfo<'_> {
16696 type Constraint = ();
16697
16698 fn validate(
16699 _: ::fidl_next::Slot<'_, Self>,
16700 _: Self::Constraint,
16701 ) -> Result<(), ::fidl_next::ValidationError> {
16702 Ok(())
16703 }
16704 }
16705
16706 unsafe impl ::fidl_next::Wire for NodeInfo<'static> {
16707 type Narrowed<'de> = NodeInfo<'de>;
16708
16709 #[inline]
16710 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
16711 ::fidl_next::munge!(let Self { table } = out);
16712 ::fidl_next::wire::Table::zero_padding(table);
16713 }
16714 }
16715
16716 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeInfo<'de>
16717 where
16718 ___D: ::fidl_next::Decoder<'de> + ?Sized,
16719 {
16720 fn decode(
16721 slot: ::fidl_next::Slot<'_, Self>,
16722 decoder: &mut ___D,
16723 _: (),
16724 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16725 ::fidl_next::munge!(let Self { table } = slot);
16726
16727 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
16728 match ordinal {
16729 0 => unsafe { ::core::hint::unreachable_unchecked() },
16730
16731 1 => {
16732 ::fidl_next::wire::Envelope::decode_as::<
16733 ___D,
16734 crate::wire::NodeAttributes2<'de>,
16735 >(slot.as_mut(), decoder, ())?;
16736
16737 Ok(())
16738 }
16739
16740 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
16741 }
16742 })
16743 }
16744 }
16745
16746 impl<'de> NodeInfo<'de> {
16747 pub fn attributes(&self) -> ::core::option::Option<&crate::wire::NodeAttributes2<'de>> {
16748 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
16749 }
16750 }
16751
16752 impl<'de> ::core::fmt::Debug for NodeInfo<'de> {
16753 fn fmt(
16754 &self,
16755 f: &mut ::core::fmt::Formatter<'_>,
16756 ) -> ::core::result::Result<(), ::core::fmt::Error> {
16757 f.debug_struct("NodeInfo").field("attributes", &self.attributes()).finish()
16758 }
16759 }
16760
16761 impl<'de> ::fidl_next::IntoNatural for NodeInfo<'de> {
16762 type Natural = crate::natural::NodeInfo;
16763 }
16764
16765 #[repr(C)]
16767 pub struct DirectoryInfo<'de> {
16768 pub(crate) table: ::fidl_next::wire::Table<'de>,
16769 }
16770
16771 impl<'de> Drop for DirectoryInfo<'de> {
16772 fn drop(&mut self) {
16773 let _ = self.table.get(1).map(|envelope| unsafe {
16774 envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
16775 });
16776 }
16777 }
16778
16779 impl ::fidl_next::Constrained for DirectoryInfo<'_> {
16780 type Constraint = ();
16781
16782 fn validate(
16783 _: ::fidl_next::Slot<'_, Self>,
16784 _: Self::Constraint,
16785 ) -> Result<(), ::fidl_next::ValidationError> {
16786 Ok(())
16787 }
16788 }
16789
16790 unsafe impl ::fidl_next::Wire for DirectoryInfo<'static> {
16791 type Narrowed<'de> = DirectoryInfo<'de>;
16792
16793 #[inline]
16794 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
16795 ::fidl_next::munge!(let Self { table } = out);
16796 ::fidl_next::wire::Table::zero_padding(table);
16797 }
16798 }
16799
16800 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryInfo<'de>
16801 where
16802 ___D: ::fidl_next::Decoder<'de> + ?Sized,
16803 {
16804 fn decode(
16805 slot: ::fidl_next::Slot<'_, Self>,
16806 decoder: &mut ___D,
16807 _: (),
16808 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16809 ::fidl_next::munge!(let Self { table } = slot);
16810
16811 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
16812 match ordinal {
16813 0 => unsafe { ::core::hint::unreachable_unchecked() },
16814
16815 1 => {
16816 ::fidl_next::wire::Envelope::decode_as::<
16817 ___D,
16818 crate::wire::NodeAttributes2<'de>,
16819 >(slot.as_mut(), decoder, ())?;
16820
16821 Ok(())
16822 }
16823
16824 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
16825 }
16826 })
16827 }
16828 }
16829
16830 impl<'de> DirectoryInfo<'de> {
16831 pub fn attributes(&self) -> ::core::option::Option<&crate::wire::NodeAttributes2<'de>> {
16832 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
16833 }
16834 }
16835
16836 impl<'de> ::core::fmt::Debug for DirectoryInfo<'de> {
16837 fn fmt(
16838 &self,
16839 f: &mut ::core::fmt::Formatter<'_>,
16840 ) -> ::core::result::Result<(), ::core::fmt::Error> {
16841 f.debug_struct("DirectoryInfo").field("attributes", &self.attributes()).finish()
16842 }
16843 }
16844
16845 impl<'de> ::fidl_next::IntoNatural for DirectoryInfo<'de> {
16846 type Natural = crate::natural::DirectoryInfo;
16847 }
16848
16849 #[repr(C)]
16851 pub struct SymlinkInfo<'de> {
16852 pub(crate) table: ::fidl_next::wire::Table<'de>,
16853 }
16854
16855 impl<'de> Drop for SymlinkInfo<'de> {
16856 fn drop(&mut self) {
16857 let _ = self.table.get(1).map(|envelope| unsafe {
16858 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
16859 });
16860
16861 let _ = self.table.get(2).map(|envelope| unsafe {
16862 envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
16863 });
16864 }
16865 }
16866
16867 impl ::fidl_next::Constrained for SymlinkInfo<'_> {
16868 type Constraint = ();
16869
16870 fn validate(
16871 _: ::fidl_next::Slot<'_, Self>,
16872 _: Self::Constraint,
16873 ) -> Result<(), ::fidl_next::ValidationError> {
16874 Ok(())
16875 }
16876 }
16877
16878 unsafe impl ::fidl_next::Wire for SymlinkInfo<'static> {
16879 type Narrowed<'de> = SymlinkInfo<'de>;
16880
16881 #[inline]
16882 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
16883 ::fidl_next::munge!(let Self { table } = out);
16884 ::fidl_next::wire::Table::zero_padding(table);
16885 }
16886 }
16887
16888 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SymlinkInfo<'de>
16889 where
16890 ___D: ::fidl_next::Decoder<'de> + ?Sized,
16891 {
16892 fn decode(
16893 slot: ::fidl_next::Slot<'_, Self>,
16894 decoder: &mut ___D,
16895 _: (),
16896 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16897 ::fidl_next::munge!(let Self { table } = slot);
16898
16899 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
16900 match ordinal {
16901 0 => unsafe { ::core::hint::unreachable_unchecked() },
16902
16903 1 => {
16904 ::fidl_next::wire::Envelope::decode_as::<
16905 ___D,
16906 ::fidl_next::wire::Vector<'de, u8>,
16907 >(slot.as_mut(), decoder, (4095, ()))?;
16908
16909 let value = unsafe {
16910 slot.deref_unchecked()
16911 .deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
16912 };
16913
16914 if value.len() > 4095 {
16915 return Err(::fidl_next::DecodeError::VectorTooLong {
16916 size: value.len() as u64,
16917 limit: 4095,
16918 });
16919 }
16920
16921 Ok(())
16922 }
16923
16924 2 => {
16925 ::fidl_next::wire::Envelope::decode_as::<
16926 ___D,
16927 crate::wire::NodeAttributes2<'de>,
16928 >(slot.as_mut(), decoder, ())?;
16929
16930 Ok(())
16931 }
16932
16933 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
16934 }
16935 })
16936 }
16937 }
16938
16939 impl<'de> SymlinkInfo<'de> {
16940 pub fn target(&self) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, u8>> {
16941 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
16942 }
16943
16944 pub fn attributes(&self) -> ::core::option::Option<&crate::wire::NodeAttributes2<'de>> {
16945 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
16946 }
16947 }
16948
16949 impl<'de> ::core::fmt::Debug for SymlinkInfo<'de> {
16950 fn fmt(
16951 &self,
16952 f: &mut ::core::fmt::Formatter<'_>,
16953 ) -> ::core::result::Result<(), ::core::fmt::Error> {
16954 f.debug_struct("SymlinkInfo")
16955 .field("target", &self.target())
16956 .field("attributes", &self.attributes())
16957 .finish()
16958 }
16959 }
16960
16961 impl<'de> ::fidl_next::IntoNatural for SymlinkInfo<'de> {
16962 type Natural = crate::natural::SymlinkInfo;
16963 }
16964
16965 #[derive(Clone, Copy, Debug)]
16967 #[repr(transparent)]
16968 pub struct NodeAttributesQuery {
16969 pub(crate) value: ::fidl_next::wire::Uint64,
16970 }
16971
16972 impl ::fidl_next::Constrained for NodeAttributesQuery {
16973 type Constraint = ();
16974
16975 fn validate(
16976 _: ::fidl_next::Slot<'_, Self>,
16977 _: Self::Constraint,
16978 ) -> Result<(), ::fidl_next::ValidationError> {
16979 Ok(())
16980 }
16981 }
16982
16983 unsafe impl ::fidl_next::Wire for NodeAttributesQuery {
16984 type Narrowed<'de> = Self;
16985
16986 #[inline]
16987 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
16988 }
16990 }
16991
16992 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeAttributesQuery
16993 where
16994 ___D: ?Sized,
16995 {
16996 fn decode(
16997 slot: ::fidl_next::Slot<'_, Self>,
16998 _: &mut ___D,
16999 _: (),
17000 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17001 Ok(())
17002 }
17003 }
17004
17005 impl ::core::convert::From<crate::natural::NodeAttributesQuery> for NodeAttributesQuery {
17006 fn from(natural: crate::natural::NodeAttributesQuery) -> Self {
17007 Self { value: ::fidl_next::wire::Uint64::from(natural.bits()) }
17008 }
17009 }
17010
17011 impl ::fidl_next::IntoNatural for NodeAttributesQuery {
17012 type Natural = crate::natural::NodeAttributesQuery;
17013 }
17014
17015 #[derive(Clone, Debug)]
17017 #[repr(C)]
17018 pub struct NodeGetAttributesRequest {
17019 pub query: crate::wire::NodeAttributesQuery,
17020 }
17021
17022 static_assertions::const_assert_eq!(std::mem::size_of::<NodeGetAttributesRequest>(), 8);
17023 static_assertions::const_assert_eq!(std::mem::align_of::<NodeGetAttributesRequest>(), 8);
17024
17025 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeGetAttributesRequest, query), 0);
17026
17027 impl ::fidl_next::Constrained for NodeGetAttributesRequest {
17028 type Constraint = ();
17029
17030 fn validate(
17031 _: ::fidl_next::Slot<'_, Self>,
17032 _: Self::Constraint,
17033 ) -> Result<(), ::fidl_next::ValidationError> {
17034 Ok(())
17035 }
17036 }
17037
17038 unsafe impl ::fidl_next::Wire for NodeGetAttributesRequest {
17039 type Narrowed<'de> = NodeGetAttributesRequest;
17040
17041 #[inline]
17042 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
17043 ::fidl_next::munge! {
17044 let Self {
17045
17046 query,
17047
17048 } = &mut *out_;
17049 }
17050
17051 ::fidl_next::Wire::zero_padding(query);
17052 }
17053 }
17054
17055 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeGetAttributesRequest
17056 where
17057 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
17058 {
17059 fn decode(
17060 slot_: ::fidl_next::Slot<'_, Self>,
17061 decoder_: &mut ___D,
17062 _: (),
17063 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17064 ::fidl_next::munge! {
17065 let Self {
17066
17067 mut query,
17068
17069 } = slot_;
17070 }
17071
17072 let _field = query.as_mut();
17073
17074 ::fidl_next::Decode::decode(query.as_mut(), decoder_, ())?;
17075
17076 Ok(())
17077 }
17078 }
17079
17080 impl ::fidl_next::IntoNatural for NodeGetAttributesRequest {
17081 type Natural = crate::natural::NodeGetAttributesRequest;
17082 }
17083
17084 #[repr(C)]
17086 pub struct Options<'de> {
17087 pub(crate) table: ::fidl_next::wire::Table<'de>,
17088 }
17089
17090 impl<'de> Drop for Options<'de> {
17091 fn drop(&mut self) {
17092 let _ = self.table.get(1).map(|envelope| unsafe {
17093 envelope.read_unchecked::<crate::wire::NodeAttributesQuery>()
17094 });
17095
17096 let _ = self.table.get(2).map(|envelope| unsafe {
17097 envelope.read_unchecked::<crate::wire::MutableNodeAttributes<'de>>()
17098 });
17099 }
17100 }
17101
17102 impl ::fidl_next::Constrained for Options<'_> {
17103 type Constraint = ();
17104
17105 fn validate(
17106 _: ::fidl_next::Slot<'_, Self>,
17107 _: Self::Constraint,
17108 ) -> Result<(), ::fidl_next::ValidationError> {
17109 Ok(())
17110 }
17111 }
17112
17113 unsafe impl ::fidl_next::Wire for Options<'static> {
17114 type Narrowed<'de> = Options<'de>;
17115
17116 #[inline]
17117 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
17118 ::fidl_next::munge!(let Self { table } = out);
17119 ::fidl_next::wire::Table::zero_padding(table);
17120 }
17121 }
17122
17123 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Options<'de>
17124 where
17125 ___D: ::fidl_next::Decoder<'de> + ?Sized,
17126 {
17127 fn decode(
17128 slot: ::fidl_next::Slot<'_, Self>,
17129 decoder: &mut ___D,
17130 _: (),
17131 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17132 ::fidl_next::munge!(let Self { table } = slot);
17133
17134 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
17135 match ordinal {
17136 0 => unsafe { ::core::hint::unreachable_unchecked() },
17137
17138 1 => {
17139 ::fidl_next::wire::Envelope::decode_as::<
17140 ___D,
17141 crate::wire::NodeAttributesQuery,
17142 >(slot.as_mut(), decoder, ())?;
17143
17144 Ok(())
17145 }
17146
17147 2 => {
17148 ::fidl_next::wire::Envelope::decode_as::<
17149 ___D,
17150 crate::wire::MutableNodeAttributes<'de>,
17151 >(slot.as_mut(), decoder, ())?;
17152
17153 Ok(())
17154 }
17155
17156 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
17157 }
17158 })
17159 }
17160 }
17161
17162 impl<'de> Options<'de> {
17163 pub fn attributes(&self) -> ::core::option::Option<&crate::wire::NodeAttributesQuery> {
17164 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
17165 }
17166
17167 pub fn create_attributes(
17168 &self,
17169 ) -> ::core::option::Option<&crate::wire::MutableNodeAttributes<'de>> {
17170 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
17171 }
17172 }
17173
17174 impl<'de> ::core::fmt::Debug for Options<'de> {
17175 fn fmt(
17176 &self,
17177 f: &mut ::core::fmt::Formatter<'_>,
17178 ) -> ::core::result::Result<(), ::core::fmt::Error> {
17179 f.debug_struct("Options")
17180 .field("attributes", &self.attributes())
17181 .field("create_attributes", &self.create_attributes())
17182 .finish()
17183 }
17184 }
17185
17186 impl<'de> ::fidl_next::IntoNatural for Options<'de> {
17187 type Natural = crate::natural::Options;
17188 }
17189
17190 #[derive(Clone, Debug)]
17192 #[repr(C)]
17193 pub struct DirectoryObject {
17194 pub(crate) _empty: fidl_next::wire::EmptyStruct,
17195 }
17196
17197 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryObject>(), 1);
17198 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryObject>(), 1);
17199
17200 impl ::fidl_next::Constrained for DirectoryObject {
17201 type Constraint = ();
17202
17203 fn validate(
17204 _: ::fidl_next::Slot<'_, Self>,
17205 _: Self::Constraint,
17206 ) -> Result<(), ::fidl_next::ValidationError> {
17207 Ok(())
17208 }
17209 }
17210
17211 unsafe impl ::fidl_next::Wire for DirectoryObject {
17212 type Narrowed<'de> = DirectoryObject;
17213
17214 #[inline]
17215 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
17216 ::fidl_next::munge! {
17217 let Self {
17218
17219 _empty,
17220
17221
17222 } = &mut *out_;
17223 }
17224 }
17225 }
17226
17227 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryObject
17228 where
17229 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
17230 {
17231 fn decode(
17232 slot_: ::fidl_next::Slot<'_, Self>,
17233 decoder_: &mut ___D,
17234 _: (),
17235 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17236 ::fidl_next::munge! {
17237 let Self {
17238
17239 mut _empty,
17240
17241
17242 } = slot_;
17243 }
17244
17245 if _empty.as_bytes() != &[0u8] {
17246 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
17247 }
17248
17249 Ok(())
17250 }
17251 }
17252
17253 impl ::fidl_next::IntoNatural for DirectoryObject {
17254 type Natural = crate::natural::DirectoryObject;
17255 }
17256
17257 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
17259 #[repr(transparent)]
17260 pub struct DirentType {
17261 pub(crate) value: u8,
17262 }
17263
17264 impl ::fidl_next::Constrained for DirentType {
17265 type Constraint = ();
17266
17267 fn validate(
17268 _: ::fidl_next::Slot<'_, Self>,
17269 _: Self::Constraint,
17270 ) -> Result<(), ::fidl_next::ValidationError> {
17271 Ok(())
17272 }
17273 }
17274
17275 unsafe impl ::fidl_next::Wire for DirentType {
17276 type Narrowed<'de> = Self;
17277
17278 #[inline]
17279 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
17280 }
17282 }
17283
17284 impl DirentType {
17285 pub const UNKNOWN: DirentType = DirentType { value: 0 };
17286
17287 pub const DIRECTORY: DirentType = DirentType { value: 4 };
17288
17289 pub const BLOCK_DEVICE: DirentType = DirentType { value: 6 };
17290
17291 pub const FILE: DirentType = DirentType { value: 8 };
17292
17293 pub const SYMLINK: DirentType = DirentType { value: 10 };
17294
17295 pub const SERVICE: DirentType = DirentType { value: 16 };
17296 }
17297
17298 unsafe impl<___D> ::fidl_next::Decode<___D> for DirentType
17299 where
17300 ___D: ?Sized,
17301 {
17302 fn decode(
17303 slot: ::fidl_next::Slot<'_, Self>,
17304 _: &mut ___D,
17305 _: (),
17306 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17307 Ok(())
17308 }
17309 }
17310
17311 impl ::core::convert::From<crate::natural::DirentType> for DirentType {
17312 fn from(natural: crate::natural::DirentType) -> Self {
17313 match natural {
17314 crate::natural::DirentType::Unknown => DirentType::UNKNOWN,
17315
17316 crate::natural::DirentType::Directory => DirentType::DIRECTORY,
17317
17318 crate::natural::DirentType::BlockDevice => DirentType::BLOCK_DEVICE,
17319
17320 crate::natural::DirentType::File => DirentType::FILE,
17321
17322 crate::natural::DirentType::Symlink => DirentType::SYMLINK,
17323
17324 crate::natural::DirentType::Service => DirentType::SERVICE,
17325
17326 crate::natural::DirentType::UnknownOrdinal_(value) => {
17327 DirentType { value: u8::from(value) }
17328 }
17329 }
17330 }
17331 }
17332
17333 impl ::fidl_next::IntoNatural for DirentType {
17334 type Natural = crate::natural::DirentType;
17335 }
17336
17337 #[derive(Debug)]
17339 #[repr(C)]
17340 pub struct ExtendedAttributeIteratorGetNextResponse<'de> {
17341 pub attributes: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Vector<'de, u8>>,
17342
17343 pub last: bool,
17344 }
17345
17346 static_assertions::const_assert_eq!(
17347 std::mem::size_of::<ExtendedAttributeIteratorGetNextResponse<'_>>(),
17348 24
17349 );
17350 static_assertions::const_assert_eq!(
17351 std::mem::align_of::<ExtendedAttributeIteratorGetNextResponse<'_>>(),
17352 8
17353 );
17354
17355 static_assertions::const_assert_eq!(
17356 std::mem::offset_of!(ExtendedAttributeIteratorGetNextResponse<'_>, attributes),
17357 0
17358 );
17359
17360 static_assertions::const_assert_eq!(
17361 std::mem::offset_of!(ExtendedAttributeIteratorGetNextResponse<'_>, last),
17362 16
17363 );
17364
17365 impl ::fidl_next::Constrained for ExtendedAttributeIteratorGetNextResponse<'_> {
17366 type Constraint = ();
17367
17368 fn validate(
17369 _: ::fidl_next::Slot<'_, Self>,
17370 _: Self::Constraint,
17371 ) -> Result<(), ::fidl_next::ValidationError> {
17372 Ok(())
17373 }
17374 }
17375
17376 unsafe impl ::fidl_next::Wire for ExtendedAttributeIteratorGetNextResponse<'static> {
17377 type Narrowed<'de> = ExtendedAttributeIteratorGetNextResponse<'de>;
17378
17379 #[inline]
17380 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
17381 ::fidl_next::munge! {
17382 let Self {
17383
17384 attributes,
17385 last,
17386
17387 } = &mut *out_;
17388 }
17389
17390 ::fidl_next::Wire::zero_padding(attributes);
17391
17392 ::fidl_next::Wire::zero_padding(last);
17393
17394 unsafe {
17395 out_.as_mut_ptr().cast::<u8>().add(17).write_bytes(0, 7);
17396 }
17397 }
17398 }
17399
17400 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExtendedAttributeIteratorGetNextResponse<'de>
17401 where
17402 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
17403 ___D: ::fidl_next::Decoder<'de>,
17404 {
17405 fn decode(
17406 slot_: ::fidl_next::Slot<'_, Self>,
17407 decoder_: &mut ___D,
17408 _: (),
17409 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17410 if slot_.as_bytes()[17..24] != [0u8; 7] {
17411 return Err(::fidl_next::DecodeError::InvalidPadding);
17412 }
17413
17414 ::fidl_next::munge! {
17415 let Self {
17416
17417 mut attributes,
17418 mut last,
17419
17420 } = slot_;
17421 }
17422
17423 let _field = attributes.as_mut();
17424 ::fidl_next::Constrained::validate(_field, (128, (255, ())))?;
17425 ::fidl_next::Decode::decode(attributes.as_mut(), decoder_, (128, (255, ())))?;
17426
17427 let attributes = unsafe { attributes.deref_unchecked() };
17428
17429 if attributes.len() > 128 {
17430 return Err(::fidl_next::DecodeError::VectorTooLong {
17431 size: attributes.len() as u64,
17432 limit: 128,
17433 });
17434 }
17435
17436 let _field = last.as_mut();
17437
17438 ::fidl_next::Decode::decode(last.as_mut(), decoder_, ())?;
17439
17440 Ok(())
17441 }
17442 }
17443
17444 impl<'de> ::fidl_next::IntoNatural for ExtendedAttributeIteratorGetNextResponse<'de> {
17445 type Natural = crate::natural::ExtendedAttributeIteratorGetNextResponse;
17446 }
17447
17448 #[derive(Clone, Debug)]
17450 #[repr(C)]
17451 pub struct ReadableReadRequest {
17452 pub count: ::fidl_next::wire::Uint64,
17453 }
17454
17455 static_assertions::const_assert_eq!(std::mem::size_of::<ReadableReadRequest>(), 8);
17456 static_assertions::const_assert_eq!(std::mem::align_of::<ReadableReadRequest>(), 8);
17457
17458 static_assertions::const_assert_eq!(std::mem::offset_of!(ReadableReadRequest, count), 0);
17459
17460 impl ::fidl_next::Constrained for ReadableReadRequest {
17461 type Constraint = ();
17462
17463 fn validate(
17464 _: ::fidl_next::Slot<'_, Self>,
17465 _: Self::Constraint,
17466 ) -> Result<(), ::fidl_next::ValidationError> {
17467 Ok(())
17468 }
17469 }
17470
17471 unsafe impl ::fidl_next::Wire for ReadableReadRequest {
17472 type Narrowed<'de> = ReadableReadRequest;
17473
17474 #[inline]
17475 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
17476 ::fidl_next::munge! {
17477 let Self {
17478
17479 count,
17480
17481 } = &mut *out_;
17482 }
17483
17484 ::fidl_next::Wire::zero_padding(count);
17485 }
17486 }
17487
17488 unsafe impl<___D> ::fidl_next::Decode<___D> for ReadableReadRequest
17489 where
17490 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
17491 {
17492 fn decode(
17493 slot_: ::fidl_next::Slot<'_, Self>,
17494 decoder_: &mut ___D,
17495 _: (),
17496 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17497 ::fidl_next::munge! {
17498 let Self {
17499
17500 mut count,
17501
17502 } = slot_;
17503 }
17504
17505 let _field = count.as_mut();
17506
17507 ::fidl_next::Decode::decode(count.as_mut(), decoder_, ())?;
17508
17509 Ok(())
17510 }
17511 }
17512
17513 impl ::fidl_next::IntoNatural for ReadableReadRequest {
17514 type Natural = crate::natural::ReadableReadRequest;
17515 }
17516
17517 pub type Transfer<'de> = ::fidl_next::wire::Vector<'de, u8>;
17519
17520 #[derive(Debug)]
17522 #[repr(C)]
17523 pub struct ReadableReadResponse<'de> {
17524 pub data: ::fidl_next::wire::Vector<'de, u8>,
17525 }
17526
17527 static_assertions::const_assert_eq!(std::mem::size_of::<ReadableReadResponse<'_>>(), 16);
17528 static_assertions::const_assert_eq!(std::mem::align_of::<ReadableReadResponse<'_>>(), 8);
17529
17530 static_assertions::const_assert_eq!(std::mem::offset_of!(ReadableReadResponse<'_>, data), 0);
17531
17532 impl ::fidl_next::Constrained for ReadableReadResponse<'_> {
17533 type Constraint = ();
17534
17535 fn validate(
17536 _: ::fidl_next::Slot<'_, Self>,
17537 _: Self::Constraint,
17538 ) -> Result<(), ::fidl_next::ValidationError> {
17539 Ok(())
17540 }
17541 }
17542
17543 unsafe impl ::fidl_next::Wire for ReadableReadResponse<'static> {
17544 type Narrowed<'de> = ReadableReadResponse<'de>;
17545
17546 #[inline]
17547 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
17548 ::fidl_next::munge! {
17549 let Self {
17550
17551 data,
17552
17553 } = &mut *out_;
17554 }
17555
17556 ::fidl_next::Wire::zero_padding(data);
17557 }
17558 }
17559
17560 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ReadableReadResponse<'de>
17561 where
17562 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
17563 ___D: ::fidl_next::Decoder<'de>,
17564 {
17565 fn decode(
17566 slot_: ::fidl_next::Slot<'_, Self>,
17567 decoder_: &mut ___D,
17568 _: (),
17569 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17570 ::fidl_next::munge! {
17571 let Self {
17572
17573 mut data,
17574
17575 } = slot_;
17576 }
17577
17578 let _field = data.as_mut();
17579 ::fidl_next::Constrained::validate(_field, (8192, ()))?;
17580 ::fidl_next::Decode::decode(data.as_mut(), decoder_, (8192, ()))?;
17581
17582 let data = unsafe { data.deref_unchecked() };
17583
17584 if data.len() > 8192 {
17585 return Err(::fidl_next::DecodeError::VectorTooLong {
17586 size: data.len() as u64,
17587 limit: 8192,
17588 });
17589 }
17590
17591 Ok(())
17592 }
17593 }
17594
17595 impl<'de> ::fidl_next::IntoNatural for ReadableReadResponse<'de> {
17596 type Natural = crate::natural::ReadableReadResponse;
17597 }
17598
17599 #[derive(Debug)]
17601 #[repr(C)]
17602 pub struct WritableWriteRequest<'de> {
17603 pub data: ::fidl_next::wire::Vector<'de, u8>,
17604 }
17605
17606 static_assertions::const_assert_eq!(std::mem::size_of::<WritableWriteRequest<'_>>(), 16);
17607 static_assertions::const_assert_eq!(std::mem::align_of::<WritableWriteRequest<'_>>(), 8);
17608
17609 static_assertions::const_assert_eq!(std::mem::offset_of!(WritableWriteRequest<'_>, data), 0);
17610
17611 impl ::fidl_next::Constrained for WritableWriteRequest<'_> {
17612 type Constraint = ();
17613
17614 fn validate(
17615 _: ::fidl_next::Slot<'_, Self>,
17616 _: Self::Constraint,
17617 ) -> Result<(), ::fidl_next::ValidationError> {
17618 Ok(())
17619 }
17620 }
17621
17622 unsafe impl ::fidl_next::Wire for WritableWriteRequest<'static> {
17623 type Narrowed<'de> = WritableWriteRequest<'de>;
17624
17625 #[inline]
17626 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
17627 ::fidl_next::munge! {
17628 let Self {
17629
17630 data,
17631
17632 } = &mut *out_;
17633 }
17634
17635 ::fidl_next::Wire::zero_padding(data);
17636 }
17637 }
17638
17639 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for WritableWriteRequest<'de>
17640 where
17641 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
17642 ___D: ::fidl_next::Decoder<'de>,
17643 {
17644 fn decode(
17645 slot_: ::fidl_next::Slot<'_, Self>,
17646 decoder_: &mut ___D,
17647 _: (),
17648 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17649 ::fidl_next::munge! {
17650 let Self {
17651
17652 mut data,
17653
17654 } = slot_;
17655 }
17656
17657 let _field = data.as_mut();
17658 ::fidl_next::Constrained::validate(_field, (8192, ()))?;
17659 ::fidl_next::Decode::decode(data.as_mut(), decoder_, (8192, ()))?;
17660
17661 let data = unsafe { data.deref_unchecked() };
17662
17663 if data.len() > 8192 {
17664 return Err(::fidl_next::DecodeError::VectorTooLong {
17665 size: data.len() as u64,
17666 limit: 8192,
17667 });
17668 }
17669
17670 Ok(())
17671 }
17672 }
17673
17674 impl<'de> ::fidl_next::IntoNatural for WritableWriteRequest<'de> {
17675 type Natural = crate::natural::WritableWriteRequest;
17676 }
17677
17678 #[derive(Clone, Debug)]
17680 #[repr(C)]
17681 pub struct WritableWriteResponse {
17682 pub actual_count: ::fidl_next::wire::Uint64,
17683 }
17684
17685 static_assertions::const_assert_eq!(std::mem::size_of::<WritableWriteResponse>(), 8);
17686 static_assertions::const_assert_eq!(std::mem::align_of::<WritableWriteResponse>(), 8);
17687
17688 static_assertions::const_assert_eq!(
17689 std::mem::offset_of!(WritableWriteResponse, actual_count),
17690 0
17691 );
17692
17693 impl ::fidl_next::Constrained for WritableWriteResponse {
17694 type Constraint = ();
17695
17696 fn validate(
17697 _: ::fidl_next::Slot<'_, Self>,
17698 _: Self::Constraint,
17699 ) -> Result<(), ::fidl_next::ValidationError> {
17700 Ok(())
17701 }
17702 }
17703
17704 unsafe impl ::fidl_next::Wire for WritableWriteResponse {
17705 type Narrowed<'de> = WritableWriteResponse;
17706
17707 #[inline]
17708 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
17709 ::fidl_next::munge! {
17710 let Self {
17711
17712 actual_count,
17713
17714 } = &mut *out_;
17715 }
17716
17717 ::fidl_next::Wire::zero_padding(actual_count);
17718 }
17719 }
17720
17721 unsafe impl<___D> ::fidl_next::Decode<___D> for WritableWriteResponse
17722 where
17723 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
17724 {
17725 fn decode(
17726 slot_: ::fidl_next::Slot<'_, Self>,
17727 decoder_: &mut ___D,
17728 _: (),
17729 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17730 ::fidl_next::munge! {
17731 let Self {
17732
17733 mut actual_count,
17734
17735 } = slot_;
17736 }
17737
17738 let _field = actual_count.as_mut();
17739
17740 ::fidl_next::Decode::decode(actual_count.as_mut(), decoder_, ())?;
17741
17742 Ok(())
17743 }
17744 }
17745
17746 impl ::fidl_next::IntoNatural for WritableWriteResponse {
17747 type Natural = crate::natural::WritableWriteResponse;
17748 }
17749
17750 #[derive(Clone, Debug)]
17752 #[repr(C)]
17753 pub struct FileSeekRequest {
17754 pub origin: crate::wire::SeekOrigin,
17755
17756 pub offset: ::fidl_next::wire::Int64,
17757 }
17758
17759 static_assertions::const_assert_eq!(std::mem::size_of::<FileSeekRequest>(), 16);
17760 static_assertions::const_assert_eq!(std::mem::align_of::<FileSeekRequest>(), 8);
17761
17762 static_assertions::const_assert_eq!(std::mem::offset_of!(FileSeekRequest, origin), 0);
17763
17764 static_assertions::const_assert_eq!(std::mem::offset_of!(FileSeekRequest, offset), 8);
17765
17766 impl ::fidl_next::Constrained for FileSeekRequest {
17767 type Constraint = ();
17768
17769 fn validate(
17770 _: ::fidl_next::Slot<'_, Self>,
17771 _: Self::Constraint,
17772 ) -> Result<(), ::fidl_next::ValidationError> {
17773 Ok(())
17774 }
17775 }
17776
17777 unsafe impl ::fidl_next::Wire for FileSeekRequest {
17778 type Narrowed<'de> = FileSeekRequest;
17779
17780 #[inline]
17781 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
17782 ::fidl_next::munge! {
17783 let Self {
17784
17785 origin,
17786 offset,
17787
17788 } = &mut *out_;
17789 }
17790
17791 ::fidl_next::Wire::zero_padding(origin);
17792
17793 ::fidl_next::Wire::zero_padding(offset);
17794
17795 unsafe {
17796 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
17797 }
17798 }
17799 }
17800
17801 unsafe impl<___D> ::fidl_next::Decode<___D> for FileSeekRequest
17802 where
17803 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
17804 {
17805 fn decode(
17806 slot_: ::fidl_next::Slot<'_, Self>,
17807 decoder_: &mut ___D,
17808 _: (),
17809 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17810 if slot_.as_bytes()[4..8] != [0u8; 4] {
17811 return Err(::fidl_next::DecodeError::InvalidPadding);
17812 }
17813
17814 ::fidl_next::munge! {
17815 let Self {
17816
17817 mut origin,
17818 mut offset,
17819
17820 } = slot_;
17821 }
17822
17823 let _field = origin.as_mut();
17824
17825 ::fidl_next::Decode::decode(origin.as_mut(), decoder_, ())?;
17826
17827 let _field = offset.as_mut();
17828
17829 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
17830
17831 Ok(())
17832 }
17833 }
17834
17835 impl ::fidl_next::IntoNatural for FileSeekRequest {
17836 type Natural = crate::natural::FileSeekRequest;
17837 }
17838
17839 #[derive(Clone, Debug)]
17841 #[repr(C)]
17842 pub struct FileSeekResponse {
17843 pub offset_from_start: ::fidl_next::wire::Uint64,
17844 }
17845
17846 static_assertions::const_assert_eq!(std::mem::size_of::<FileSeekResponse>(), 8);
17847 static_assertions::const_assert_eq!(std::mem::align_of::<FileSeekResponse>(), 8);
17848
17849 static_assertions::const_assert_eq!(
17850 std::mem::offset_of!(FileSeekResponse, offset_from_start),
17851 0
17852 );
17853
17854 impl ::fidl_next::Constrained for FileSeekResponse {
17855 type Constraint = ();
17856
17857 fn validate(
17858 _: ::fidl_next::Slot<'_, Self>,
17859 _: Self::Constraint,
17860 ) -> Result<(), ::fidl_next::ValidationError> {
17861 Ok(())
17862 }
17863 }
17864
17865 unsafe impl ::fidl_next::Wire for FileSeekResponse {
17866 type Narrowed<'de> = FileSeekResponse;
17867
17868 #[inline]
17869 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
17870 ::fidl_next::munge! {
17871 let Self {
17872
17873 offset_from_start,
17874
17875 } = &mut *out_;
17876 }
17877
17878 ::fidl_next::Wire::zero_padding(offset_from_start);
17879 }
17880 }
17881
17882 unsafe impl<___D> ::fidl_next::Decode<___D> for FileSeekResponse
17883 where
17884 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
17885 {
17886 fn decode(
17887 slot_: ::fidl_next::Slot<'_, Self>,
17888 decoder_: &mut ___D,
17889 _: (),
17890 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17891 ::fidl_next::munge! {
17892 let Self {
17893
17894 mut offset_from_start,
17895
17896 } = slot_;
17897 }
17898
17899 let _field = offset_from_start.as_mut();
17900
17901 ::fidl_next::Decode::decode(offset_from_start.as_mut(), decoder_, ())?;
17902
17903 Ok(())
17904 }
17905 }
17906
17907 impl ::fidl_next::IntoNatural for FileSeekResponse {
17908 type Natural = crate::natural::FileSeekResponse;
17909 }
17910
17911 #[derive(Clone, Debug)]
17913 #[repr(C)]
17914 pub struct FileReadAtRequest {
17915 pub count: ::fidl_next::wire::Uint64,
17916
17917 pub offset: ::fidl_next::wire::Uint64,
17918 }
17919
17920 static_assertions::const_assert_eq!(std::mem::size_of::<FileReadAtRequest>(), 16);
17921 static_assertions::const_assert_eq!(std::mem::align_of::<FileReadAtRequest>(), 8);
17922
17923 static_assertions::const_assert_eq!(std::mem::offset_of!(FileReadAtRequest, count), 0);
17924
17925 static_assertions::const_assert_eq!(std::mem::offset_of!(FileReadAtRequest, offset), 8);
17926
17927 impl ::fidl_next::Constrained for FileReadAtRequest {
17928 type Constraint = ();
17929
17930 fn validate(
17931 _: ::fidl_next::Slot<'_, Self>,
17932 _: Self::Constraint,
17933 ) -> Result<(), ::fidl_next::ValidationError> {
17934 Ok(())
17935 }
17936 }
17937
17938 unsafe impl ::fidl_next::Wire for FileReadAtRequest {
17939 type Narrowed<'de> = FileReadAtRequest;
17940
17941 #[inline]
17942 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
17943 ::fidl_next::munge! {
17944 let Self {
17945
17946 count,
17947 offset,
17948
17949 } = &mut *out_;
17950 }
17951
17952 ::fidl_next::Wire::zero_padding(count);
17953
17954 ::fidl_next::Wire::zero_padding(offset);
17955 }
17956 }
17957
17958 unsafe impl<___D> ::fidl_next::Decode<___D> for FileReadAtRequest
17959 where
17960 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
17961 {
17962 fn decode(
17963 slot_: ::fidl_next::Slot<'_, Self>,
17964 decoder_: &mut ___D,
17965 _: (),
17966 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17967 ::fidl_next::munge! {
17968 let Self {
17969
17970 mut count,
17971 mut offset,
17972
17973 } = slot_;
17974 }
17975
17976 let _field = count.as_mut();
17977
17978 ::fidl_next::Decode::decode(count.as_mut(), decoder_, ())?;
17979
17980 let _field = offset.as_mut();
17981
17982 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
17983
17984 Ok(())
17985 }
17986 }
17987
17988 impl ::fidl_next::IntoNatural for FileReadAtRequest {
17989 type Natural = crate::natural::FileReadAtRequest;
17990 }
17991
17992 #[derive(Debug)]
17994 #[repr(C)]
17995 pub struct FileReadAtResponse<'de> {
17996 pub data: ::fidl_next::wire::Vector<'de, u8>,
17997 }
17998
17999 static_assertions::const_assert_eq!(std::mem::size_of::<FileReadAtResponse<'_>>(), 16);
18000 static_assertions::const_assert_eq!(std::mem::align_of::<FileReadAtResponse<'_>>(), 8);
18001
18002 static_assertions::const_assert_eq!(std::mem::offset_of!(FileReadAtResponse<'_>, data), 0);
18003
18004 impl ::fidl_next::Constrained for FileReadAtResponse<'_> {
18005 type Constraint = ();
18006
18007 fn validate(
18008 _: ::fidl_next::Slot<'_, Self>,
18009 _: Self::Constraint,
18010 ) -> Result<(), ::fidl_next::ValidationError> {
18011 Ok(())
18012 }
18013 }
18014
18015 unsafe impl ::fidl_next::Wire for FileReadAtResponse<'static> {
18016 type Narrowed<'de> = FileReadAtResponse<'de>;
18017
18018 #[inline]
18019 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
18020 ::fidl_next::munge! {
18021 let Self {
18022
18023 data,
18024
18025 } = &mut *out_;
18026 }
18027
18028 ::fidl_next::Wire::zero_padding(data);
18029 }
18030 }
18031
18032 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for FileReadAtResponse<'de>
18033 where
18034 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
18035 ___D: ::fidl_next::Decoder<'de>,
18036 {
18037 fn decode(
18038 slot_: ::fidl_next::Slot<'_, Self>,
18039 decoder_: &mut ___D,
18040 _: (),
18041 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
18042 ::fidl_next::munge! {
18043 let Self {
18044
18045 mut data,
18046
18047 } = slot_;
18048 }
18049
18050 let _field = data.as_mut();
18051 ::fidl_next::Constrained::validate(_field, (8192, ()))?;
18052 ::fidl_next::Decode::decode(data.as_mut(), decoder_, (8192, ()))?;
18053
18054 let data = unsafe { data.deref_unchecked() };
18055
18056 if data.len() > 8192 {
18057 return Err(::fidl_next::DecodeError::VectorTooLong {
18058 size: data.len() as u64,
18059 limit: 8192,
18060 });
18061 }
18062
18063 Ok(())
18064 }
18065 }
18066
18067 impl<'de> ::fidl_next::IntoNatural for FileReadAtResponse<'de> {
18068 type Natural = crate::natural::FileReadAtResponse;
18069 }
18070
18071 #[derive(Debug)]
18073 #[repr(C)]
18074 pub struct FileWriteAtRequest<'de> {
18075 pub data: ::fidl_next::wire::Vector<'de, u8>,
18076
18077 pub offset: ::fidl_next::wire::Uint64,
18078 }
18079
18080 static_assertions::const_assert_eq!(std::mem::size_of::<FileWriteAtRequest<'_>>(), 24);
18081 static_assertions::const_assert_eq!(std::mem::align_of::<FileWriteAtRequest<'_>>(), 8);
18082
18083 static_assertions::const_assert_eq!(std::mem::offset_of!(FileWriteAtRequest<'_>, data), 0);
18084
18085 static_assertions::const_assert_eq!(std::mem::offset_of!(FileWriteAtRequest<'_>, offset), 16);
18086
18087 impl ::fidl_next::Constrained for FileWriteAtRequest<'_> {
18088 type Constraint = ();
18089
18090 fn validate(
18091 _: ::fidl_next::Slot<'_, Self>,
18092 _: Self::Constraint,
18093 ) -> Result<(), ::fidl_next::ValidationError> {
18094 Ok(())
18095 }
18096 }
18097
18098 unsafe impl ::fidl_next::Wire for FileWriteAtRequest<'static> {
18099 type Narrowed<'de> = FileWriteAtRequest<'de>;
18100
18101 #[inline]
18102 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
18103 ::fidl_next::munge! {
18104 let Self {
18105
18106 data,
18107 offset,
18108
18109 } = &mut *out_;
18110 }
18111
18112 ::fidl_next::Wire::zero_padding(data);
18113
18114 ::fidl_next::Wire::zero_padding(offset);
18115 }
18116 }
18117
18118 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for FileWriteAtRequest<'de>
18119 where
18120 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
18121 ___D: ::fidl_next::Decoder<'de>,
18122 {
18123 fn decode(
18124 slot_: ::fidl_next::Slot<'_, Self>,
18125 decoder_: &mut ___D,
18126 _: (),
18127 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
18128 ::fidl_next::munge! {
18129 let Self {
18130
18131 mut data,
18132 mut offset,
18133
18134 } = slot_;
18135 }
18136
18137 let _field = data.as_mut();
18138 ::fidl_next::Constrained::validate(_field, (8192, ()))?;
18139 ::fidl_next::Decode::decode(data.as_mut(), decoder_, (8192, ()))?;
18140
18141 let data = unsafe { data.deref_unchecked() };
18142
18143 if data.len() > 8192 {
18144 return Err(::fidl_next::DecodeError::VectorTooLong {
18145 size: data.len() as u64,
18146 limit: 8192,
18147 });
18148 }
18149
18150 let _field = offset.as_mut();
18151
18152 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
18153
18154 Ok(())
18155 }
18156 }
18157
18158 impl<'de> ::fidl_next::IntoNatural for FileWriteAtRequest<'de> {
18159 type Natural = crate::natural::FileWriteAtRequest;
18160 }
18161
18162 #[derive(Clone, Debug)]
18164 #[repr(C)]
18165 pub struct FileWriteAtResponse {
18166 pub actual_count: ::fidl_next::wire::Uint64,
18167 }
18168
18169 static_assertions::const_assert_eq!(std::mem::size_of::<FileWriteAtResponse>(), 8);
18170 static_assertions::const_assert_eq!(std::mem::align_of::<FileWriteAtResponse>(), 8);
18171
18172 static_assertions::const_assert_eq!(std::mem::offset_of!(FileWriteAtResponse, actual_count), 0);
18173
18174 impl ::fidl_next::Constrained for FileWriteAtResponse {
18175 type Constraint = ();
18176
18177 fn validate(
18178 _: ::fidl_next::Slot<'_, Self>,
18179 _: Self::Constraint,
18180 ) -> Result<(), ::fidl_next::ValidationError> {
18181 Ok(())
18182 }
18183 }
18184
18185 unsafe impl ::fidl_next::Wire for FileWriteAtResponse {
18186 type Narrowed<'de> = FileWriteAtResponse;
18187
18188 #[inline]
18189 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
18190 ::fidl_next::munge! {
18191 let Self {
18192
18193 actual_count,
18194
18195 } = &mut *out_;
18196 }
18197
18198 ::fidl_next::Wire::zero_padding(actual_count);
18199 }
18200 }
18201
18202 unsafe impl<___D> ::fidl_next::Decode<___D> for FileWriteAtResponse
18203 where
18204 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
18205 {
18206 fn decode(
18207 slot_: ::fidl_next::Slot<'_, Self>,
18208 decoder_: &mut ___D,
18209 _: (),
18210 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
18211 ::fidl_next::munge! {
18212 let Self {
18213
18214 mut actual_count,
18215
18216 } = slot_;
18217 }
18218
18219 let _field = actual_count.as_mut();
18220
18221 ::fidl_next::Decode::decode(actual_count.as_mut(), decoder_, ())?;
18222
18223 Ok(())
18224 }
18225 }
18226
18227 impl ::fidl_next::IntoNatural for FileWriteAtResponse {
18228 type Natural = crate::natural::FileWriteAtResponse;
18229 }
18230
18231 #[derive(Clone, Debug)]
18233 #[repr(C)]
18234 pub struct FileResizeRequest {
18235 pub length: ::fidl_next::wire::Uint64,
18236 }
18237
18238 static_assertions::const_assert_eq!(std::mem::size_of::<FileResizeRequest>(), 8);
18239 static_assertions::const_assert_eq!(std::mem::align_of::<FileResizeRequest>(), 8);
18240
18241 static_assertions::const_assert_eq!(std::mem::offset_of!(FileResizeRequest, length), 0);
18242
18243 impl ::fidl_next::Constrained for FileResizeRequest {
18244 type Constraint = ();
18245
18246 fn validate(
18247 _: ::fidl_next::Slot<'_, Self>,
18248 _: Self::Constraint,
18249 ) -> Result<(), ::fidl_next::ValidationError> {
18250 Ok(())
18251 }
18252 }
18253
18254 unsafe impl ::fidl_next::Wire for FileResizeRequest {
18255 type Narrowed<'de> = FileResizeRequest;
18256
18257 #[inline]
18258 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
18259 ::fidl_next::munge! {
18260 let Self {
18261
18262 length,
18263
18264 } = &mut *out_;
18265 }
18266
18267 ::fidl_next::Wire::zero_padding(length);
18268 }
18269 }
18270
18271 unsafe impl<___D> ::fidl_next::Decode<___D> for FileResizeRequest
18272 where
18273 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
18274 {
18275 fn decode(
18276 slot_: ::fidl_next::Slot<'_, Self>,
18277 decoder_: &mut ___D,
18278 _: (),
18279 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
18280 ::fidl_next::munge! {
18281 let Self {
18282
18283 mut length,
18284
18285 } = slot_;
18286 }
18287
18288 let _field = length.as_mut();
18289
18290 ::fidl_next::Decode::decode(length.as_mut(), decoder_, ())?;
18291
18292 Ok(())
18293 }
18294 }
18295
18296 impl ::fidl_next::IntoNatural for FileResizeRequest {
18297 type Natural = crate::natural::FileResizeRequest;
18298 }
18299
18300 #[derive(Clone, Debug)]
18302 #[repr(C)]
18303 pub struct FileResizeResponse {
18304 pub(crate) _empty: fidl_next::wire::EmptyStruct,
18305 }
18306
18307 static_assertions::const_assert_eq!(std::mem::size_of::<FileResizeResponse>(), 1);
18308 static_assertions::const_assert_eq!(std::mem::align_of::<FileResizeResponse>(), 1);
18309
18310 impl ::fidl_next::Constrained for FileResizeResponse {
18311 type Constraint = ();
18312
18313 fn validate(
18314 _: ::fidl_next::Slot<'_, Self>,
18315 _: Self::Constraint,
18316 ) -> Result<(), ::fidl_next::ValidationError> {
18317 Ok(())
18318 }
18319 }
18320
18321 unsafe impl ::fidl_next::Wire for FileResizeResponse {
18322 type Narrowed<'de> = FileResizeResponse;
18323
18324 #[inline]
18325 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
18326 ::fidl_next::munge! {
18327 let Self {
18328
18329 _empty,
18330
18331
18332 } = &mut *out_;
18333 }
18334 }
18335 }
18336
18337 unsafe impl<___D> ::fidl_next::Decode<___D> for FileResizeResponse
18338 where
18339 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
18340 {
18341 fn decode(
18342 slot_: ::fidl_next::Slot<'_, Self>,
18343 decoder_: &mut ___D,
18344 _: (),
18345 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
18346 ::fidl_next::munge! {
18347 let Self {
18348
18349 mut _empty,
18350
18351
18352 } = slot_;
18353 }
18354
18355 if _empty.as_bytes() != &[0u8] {
18356 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
18357 }
18358
18359 Ok(())
18360 }
18361 }
18362
18363 impl ::fidl_next::IntoNatural for FileResizeResponse {
18364 type Natural = crate::natural::FileResizeResponse;
18365 }
18366
18367 #[derive(Clone, Copy, Debug)]
18369 #[repr(transparent)]
18370 pub struct VmoFlags {
18371 pub(crate) value: ::fidl_next::wire::Uint32,
18372 }
18373
18374 impl ::fidl_next::Constrained for VmoFlags {
18375 type Constraint = ();
18376
18377 fn validate(
18378 _: ::fidl_next::Slot<'_, Self>,
18379 _: Self::Constraint,
18380 ) -> Result<(), ::fidl_next::ValidationError> {
18381 Ok(())
18382 }
18383 }
18384
18385 unsafe impl ::fidl_next::Wire for VmoFlags {
18386 type Narrowed<'de> = Self;
18387
18388 #[inline]
18389 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
18390 }
18392 }
18393
18394 unsafe impl<___D> ::fidl_next::Decode<___D> for VmoFlags
18395 where
18396 ___D: ?Sized,
18397 {
18398 fn decode(
18399 slot: ::fidl_next::Slot<'_, Self>,
18400 _: &mut ___D,
18401 _: (),
18402 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
18403 ::fidl_next::munge!(let Self { value } = slot);
18404 let set = u32::from(*value);
18405 if set & !crate::natural::VmoFlags::all().bits() != 0 {
18406 return Err(::fidl_next::DecodeError::InvalidBits {
18407 expected: crate::natural::VmoFlags::all().bits() as usize,
18408 actual: set as usize,
18409 });
18410 }
18411
18412 Ok(())
18413 }
18414 }
18415
18416 impl ::core::convert::From<crate::natural::VmoFlags> for VmoFlags {
18417 fn from(natural: crate::natural::VmoFlags) -> Self {
18418 Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
18419 }
18420 }
18421
18422 impl ::fidl_next::IntoNatural for VmoFlags {
18423 type Natural = crate::natural::VmoFlags;
18424 }
18425
18426 #[derive(Clone, Debug)]
18428 #[repr(C)]
18429 pub struct FileGetBackingMemoryRequest {
18430 pub flags: crate::wire::VmoFlags,
18431 }
18432
18433 static_assertions::const_assert_eq!(std::mem::size_of::<FileGetBackingMemoryRequest>(), 4);
18434 static_assertions::const_assert_eq!(std::mem::align_of::<FileGetBackingMemoryRequest>(), 4);
18435
18436 static_assertions::const_assert_eq!(
18437 std::mem::offset_of!(FileGetBackingMemoryRequest, flags),
18438 0
18439 );
18440
18441 impl ::fidl_next::Constrained for FileGetBackingMemoryRequest {
18442 type Constraint = ();
18443
18444 fn validate(
18445 _: ::fidl_next::Slot<'_, Self>,
18446 _: Self::Constraint,
18447 ) -> Result<(), ::fidl_next::ValidationError> {
18448 Ok(())
18449 }
18450 }
18451
18452 unsafe impl ::fidl_next::Wire for FileGetBackingMemoryRequest {
18453 type Narrowed<'de> = FileGetBackingMemoryRequest;
18454
18455 #[inline]
18456 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
18457 ::fidl_next::munge! {
18458 let Self {
18459
18460 flags,
18461
18462 } = &mut *out_;
18463 }
18464
18465 ::fidl_next::Wire::zero_padding(flags);
18466 }
18467 }
18468
18469 unsafe impl<___D> ::fidl_next::Decode<___D> for FileGetBackingMemoryRequest
18470 where
18471 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
18472 {
18473 fn decode(
18474 slot_: ::fidl_next::Slot<'_, Self>,
18475 decoder_: &mut ___D,
18476 _: (),
18477 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
18478 ::fidl_next::munge! {
18479 let Self {
18480
18481 mut flags,
18482
18483 } = slot_;
18484 }
18485
18486 let _field = flags.as_mut();
18487
18488 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
18489
18490 Ok(())
18491 }
18492 }
18493
18494 impl ::fidl_next::IntoNatural for FileGetBackingMemoryRequest {
18495 type Natural = crate::natural::FileGetBackingMemoryRequest;
18496 }
18497
18498 #[derive(Clone, Debug)]
18500 #[repr(C)]
18501 pub struct LinkableLinkIntoResponse {
18502 pub(crate) _empty: fidl_next::wire::EmptyStruct,
18503 }
18504
18505 static_assertions::const_assert_eq!(std::mem::size_of::<LinkableLinkIntoResponse>(), 1);
18506 static_assertions::const_assert_eq!(std::mem::align_of::<LinkableLinkIntoResponse>(), 1);
18507
18508 impl ::fidl_next::Constrained for LinkableLinkIntoResponse {
18509 type Constraint = ();
18510
18511 fn validate(
18512 _: ::fidl_next::Slot<'_, Self>,
18513 _: Self::Constraint,
18514 ) -> Result<(), ::fidl_next::ValidationError> {
18515 Ok(())
18516 }
18517 }
18518
18519 unsafe impl ::fidl_next::Wire for LinkableLinkIntoResponse {
18520 type Narrowed<'de> = LinkableLinkIntoResponse;
18521
18522 #[inline]
18523 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
18524 ::fidl_next::munge! {
18525 let Self {
18526
18527 _empty,
18528
18529
18530 } = &mut *out_;
18531 }
18532 }
18533 }
18534
18535 unsafe impl<___D> ::fidl_next::Decode<___D> for LinkableLinkIntoResponse
18536 where
18537 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
18538 {
18539 fn decode(
18540 slot_: ::fidl_next::Slot<'_, Self>,
18541 decoder_: &mut ___D,
18542 _: (),
18543 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
18544 ::fidl_next::munge! {
18545 let Self {
18546
18547 mut _empty,
18548
18549
18550 } = slot_;
18551 }
18552
18553 if _empty.as_bytes() != &[0u8] {
18554 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
18555 }
18556
18557 Ok(())
18558 }
18559 }
18560
18561 impl ::fidl_next::IntoNatural for LinkableLinkIntoResponse {
18562 type Natural = crate::natural::LinkableLinkIntoResponse;
18563 }
18564
18565 #[derive(Clone, Debug)]
18567 #[repr(C)]
18568 pub struct FileAllocateResponse {
18569 pub(crate) _empty: fidl_next::wire::EmptyStruct,
18570 }
18571
18572 static_assertions::const_assert_eq!(std::mem::size_of::<FileAllocateResponse>(), 1);
18573 static_assertions::const_assert_eq!(std::mem::align_of::<FileAllocateResponse>(), 1);
18574
18575 impl ::fidl_next::Constrained for FileAllocateResponse {
18576 type Constraint = ();
18577
18578 fn validate(
18579 _: ::fidl_next::Slot<'_, Self>,
18580 _: Self::Constraint,
18581 ) -> Result<(), ::fidl_next::ValidationError> {
18582 Ok(())
18583 }
18584 }
18585
18586 unsafe impl ::fidl_next::Wire for FileAllocateResponse {
18587 type Narrowed<'de> = FileAllocateResponse;
18588
18589 #[inline]
18590 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
18591 ::fidl_next::munge! {
18592 let Self {
18593
18594 _empty,
18595
18596
18597 } = &mut *out_;
18598 }
18599 }
18600 }
18601
18602 unsafe impl<___D> ::fidl_next::Decode<___D> for FileAllocateResponse
18603 where
18604 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
18605 {
18606 fn decode(
18607 slot_: ::fidl_next::Slot<'_, Self>,
18608 decoder_: &mut ___D,
18609 _: (),
18610 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
18611 ::fidl_next::munge! {
18612 let Self {
18613
18614 mut _empty,
18615
18616
18617 } = slot_;
18618 }
18619
18620 if _empty.as_bytes() != &[0u8] {
18621 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
18622 }
18623
18624 Ok(())
18625 }
18626 }
18627
18628 impl ::fidl_next::IntoNatural for FileAllocateResponse {
18629 type Natural = crate::natural::FileAllocateResponse;
18630 }
18631
18632 #[derive(Clone, Debug)]
18634 #[repr(C)]
18635 pub struct FileEnableVerityResponse {
18636 pub(crate) _empty: fidl_next::wire::EmptyStruct,
18637 }
18638
18639 static_assertions::const_assert_eq!(std::mem::size_of::<FileEnableVerityResponse>(), 1);
18640 static_assertions::const_assert_eq!(std::mem::align_of::<FileEnableVerityResponse>(), 1);
18641
18642 impl ::fidl_next::Constrained for FileEnableVerityResponse {
18643 type Constraint = ();
18644
18645 fn validate(
18646 _: ::fidl_next::Slot<'_, Self>,
18647 _: Self::Constraint,
18648 ) -> Result<(), ::fidl_next::ValidationError> {
18649 Ok(())
18650 }
18651 }
18652
18653 unsafe impl ::fidl_next::Wire for FileEnableVerityResponse {
18654 type Narrowed<'de> = FileEnableVerityResponse;
18655
18656 #[inline]
18657 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
18658 ::fidl_next::munge! {
18659 let Self {
18660
18661 _empty,
18662
18663
18664 } = &mut *out_;
18665 }
18666 }
18667 }
18668
18669 unsafe impl<___D> ::fidl_next::Decode<___D> for FileEnableVerityResponse
18670 where
18671 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
18672 {
18673 fn decode(
18674 slot_: ::fidl_next::Slot<'_, Self>,
18675 decoder_: &mut ___D,
18676 _: (),
18677 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
18678 ::fidl_next::munge! {
18679 let Self {
18680
18681 mut _empty,
18682
18683
18684 } = slot_;
18685 }
18686
18687 if _empty.as_bytes() != &[0u8] {
18688 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
18689 }
18690
18691 Ok(())
18692 }
18693 }
18694
18695 impl ::fidl_next::IntoNatural for FileEnableVerityResponse {
18696 type Natural = crate::natural::FileEnableVerityResponse;
18697 }
18698
18699 #[derive(Clone, Copy, Debug)]
18701 #[repr(transparent)]
18702 pub struct FileSignal {
18703 pub(crate) value: ::fidl_next::wire::Uint32,
18704 }
18705
18706 impl ::fidl_next::Constrained for FileSignal {
18707 type Constraint = ();
18708
18709 fn validate(
18710 _: ::fidl_next::Slot<'_, Self>,
18711 _: Self::Constraint,
18712 ) -> Result<(), ::fidl_next::ValidationError> {
18713 Ok(())
18714 }
18715 }
18716
18717 unsafe impl ::fidl_next::Wire for FileSignal {
18718 type Narrowed<'de> = Self;
18719
18720 #[inline]
18721 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
18722 }
18724 }
18725
18726 unsafe impl<___D> ::fidl_next::Decode<___D> for FileSignal
18727 where
18728 ___D: ?Sized,
18729 {
18730 fn decode(
18731 slot: ::fidl_next::Slot<'_, Self>,
18732 _: &mut ___D,
18733 _: (),
18734 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
18735 ::fidl_next::munge!(let Self { value } = slot);
18736 let set = u32::from(*value);
18737 if set & !crate::natural::FileSignal::all().bits() != 0 {
18738 return Err(::fidl_next::DecodeError::InvalidBits {
18739 expected: crate::natural::FileSignal::all().bits() as usize,
18740 actual: set as usize,
18741 });
18742 }
18743
18744 Ok(())
18745 }
18746 }
18747
18748 impl ::core::convert::From<crate::natural::FileSignal> for FileSignal {
18749 fn from(natural: crate::natural::FileSignal) -> Self {
18750 Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
18751 }
18752 }
18753
18754 impl ::fidl_next::IntoNatural for FileSignal {
18755 type Natural = crate::natural::FileSignal;
18756 }
18757
18758 #[derive(Clone, Debug)]
18760 #[repr(C)]
18761 pub struct FilesystemInfo {
18762 pub total_bytes: ::fidl_next::wire::Uint64,
18763
18764 pub used_bytes: ::fidl_next::wire::Uint64,
18765
18766 pub total_nodes: ::fidl_next::wire::Uint64,
18767
18768 pub used_nodes: ::fidl_next::wire::Uint64,
18769
18770 pub free_shared_pool_bytes: ::fidl_next::wire::Uint64,
18771
18772 pub fs_id: ::fidl_next::wire::Uint64,
18773
18774 pub block_size: ::fidl_next::wire::Uint32,
18775
18776 pub max_filename_size: ::fidl_next::wire::Uint32,
18777
18778 pub fs_type: ::fidl_next::wire::Uint32,
18779
18780 pub padding: ::fidl_next::wire::Uint32,
18781
18782 pub name: [i8; 32],
18783 }
18784
18785 static_assertions::const_assert_eq!(std::mem::size_of::<FilesystemInfo>(), 96);
18786 static_assertions::const_assert_eq!(std::mem::align_of::<FilesystemInfo>(), 8);
18787
18788 static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, total_bytes), 0);
18789
18790 static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, used_bytes), 8);
18791
18792 static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, total_nodes), 16);
18793
18794 static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, used_nodes), 24);
18795
18796 static_assertions::const_assert_eq!(
18797 std::mem::offset_of!(FilesystemInfo, free_shared_pool_bytes),
18798 32
18799 );
18800
18801 static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, fs_id), 40);
18802
18803 static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, block_size), 48);
18804
18805 static_assertions::const_assert_eq!(
18806 std::mem::offset_of!(FilesystemInfo, max_filename_size),
18807 52
18808 );
18809
18810 static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, fs_type), 56);
18811
18812 static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, padding), 60);
18813
18814 static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, name), 64);
18815
18816 impl ::fidl_next::Constrained for FilesystemInfo {
18817 type Constraint = ();
18818
18819 fn validate(
18820 _: ::fidl_next::Slot<'_, Self>,
18821 _: Self::Constraint,
18822 ) -> Result<(), ::fidl_next::ValidationError> {
18823 Ok(())
18824 }
18825 }
18826
18827 unsafe impl ::fidl_next::Wire for FilesystemInfo {
18828 type Narrowed<'de> = FilesystemInfo;
18829
18830 #[inline]
18831 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
18832 ::fidl_next::munge! {
18833 let Self {
18834
18835 total_bytes,
18836 used_bytes,
18837 total_nodes,
18838 used_nodes,
18839 free_shared_pool_bytes,
18840 fs_id,
18841 block_size,
18842 max_filename_size,
18843 fs_type,
18844 padding,
18845 name,
18846
18847 } = &mut *out_;
18848 }
18849
18850 ::fidl_next::Wire::zero_padding(total_bytes);
18851
18852 ::fidl_next::Wire::zero_padding(used_bytes);
18853
18854 ::fidl_next::Wire::zero_padding(total_nodes);
18855
18856 ::fidl_next::Wire::zero_padding(used_nodes);
18857
18858 ::fidl_next::Wire::zero_padding(free_shared_pool_bytes);
18859
18860 ::fidl_next::Wire::zero_padding(fs_id);
18861
18862 ::fidl_next::Wire::zero_padding(block_size);
18863
18864 ::fidl_next::Wire::zero_padding(max_filename_size);
18865
18866 ::fidl_next::Wire::zero_padding(fs_type);
18867
18868 ::fidl_next::Wire::zero_padding(padding);
18869
18870 ::fidl_next::Wire::zero_padding(name);
18871 }
18872 }
18873
18874 unsafe impl<___D> ::fidl_next::Decode<___D> for FilesystemInfo
18875 where
18876 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
18877 {
18878 fn decode(
18879 slot_: ::fidl_next::Slot<'_, Self>,
18880 decoder_: &mut ___D,
18881 _: (),
18882 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
18883 ::fidl_next::munge! {
18884 let Self {
18885
18886 mut total_bytes,
18887 mut used_bytes,
18888 mut total_nodes,
18889 mut used_nodes,
18890 mut free_shared_pool_bytes,
18891 mut fs_id,
18892 mut block_size,
18893 mut max_filename_size,
18894 mut fs_type,
18895 mut padding,
18896 mut name,
18897
18898 } = slot_;
18899 }
18900
18901 let _field = total_bytes.as_mut();
18902
18903 ::fidl_next::Decode::decode(total_bytes.as_mut(), decoder_, ())?;
18904
18905 let _field = used_bytes.as_mut();
18906
18907 ::fidl_next::Decode::decode(used_bytes.as_mut(), decoder_, ())?;
18908
18909 let _field = total_nodes.as_mut();
18910
18911 ::fidl_next::Decode::decode(total_nodes.as_mut(), decoder_, ())?;
18912
18913 let _field = used_nodes.as_mut();
18914
18915 ::fidl_next::Decode::decode(used_nodes.as_mut(), decoder_, ())?;
18916
18917 let _field = free_shared_pool_bytes.as_mut();
18918
18919 ::fidl_next::Decode::decode(free_shared_pool_bytes.as_mut(), decoder_, ())?;
18920
18921 let _field = fs_id.as_mut();
18922
18923 ::fidl_next::Decode::decode(fs_id.as_mut(), decoder_, ())?;
18924
18925 let _field = block_size.as_mut();
18926
18927 ::fidl_next::Decode::decode(block_size.as_mut(), decoder_, ())?;
18928
18929 let _field = max_filename_size.as_mut();
18930
18931 ::fidl_next::Decode::decode(max_filename_size.as_mut(), decoder_, ())?;
18932
18933 let _field = fs_type.as_mut();
18934
18935 ::fidl_next::Decode::decode(fs_type.as_mut(), decoder_, ())?;
18936
18937 let _field = padding.as_mut();
18938
18939 ::fidl_next::Decode::decode(padding.as_mut(), decoder_, ())?;
18940
18941 let _field = name.as_mut();
18942
18943 ::fidl_next::Decode::decode(name.as_mut(), decoder_, ())?;
18944
18945 Ok(())
18946 }
18947 }
18948
18949 impl ::fidl_next::IntoNatural for FilesystemInfo {
18950 type Natural = crate::natural::FilesystemInfo;
18951 }
18952
18953 #[derive(Clone, Debug)]
18955 #[repr(C)]
18956 pub struct Service {
18957 pub(crate) _empty: fidl_next::wire::EmptyStruct,
18958 }
18959
18960 static_assertions::const_assert_eq!(std::mem::size_of::<Service>(), 1);
18961 static_assertions::const_assert_eq!(std::mem::align_of::<Service>(), 1);
18962
18963 impl ::fidl_next::Constrained for Service {
18964 type Constraint = ();
18965
18966 fn validate(
18967 _: ::fidl_next::Slot<'_, Self>,
18968 _: Self::Constraint,
18969 ) -> Result<(), ::fidl_next::ValidationError> {
18970 Ok(())
18971 }
18972 }
18973
18974 unsafe impl ::fidl_next::Wire for Service {
18975 type Narrowed<'de> = Service;
18976
18977 #[inline]
18978 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
18979 ::fidl_next::munge! {
18980 let Self {
18981
18982 _empty,
18983
18984
18985 } = &mut *out_;
18986 }
18987 }
18988 }
18989
18990 unsafe impl<___D> ::fidl_next::Decode<___D> for Service
18991 where
18992 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
18993 {
18994 fn decode(
18995 slot_: ::fidl_next::Slot<'_, Self>,
18996 decoder_: &mut ___D,
18997 _: (),
18998 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
18999 ::fidl_next::munge! {
19000 let Self {
19001
19002 mut _empty,
19003
19004
19005 } = slot_;
19006 }
19007
19008 if _empty.as_bytes() != &[0u8] {
19009 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
19010 }
19011
19012 Ok(())
19013 }
19014 }
19015
19016 impl ::fidl_next::IntoNatural for Service {
19017 type Natural = crate::natural::Service;
19018 }
19019
19020 #[derive(Debug)]
19022 #[repr(C)]
19023 pub struct SymlinkObject<'de> {
19024 pub target: ::fidl_next::wire::Vector<'de, u8>,
19025 }
19026
19027 static_assertions::const_assert_eq!(std::mem::size_of::<SymlinkObject<'_>>(), 16);
19028 static_assertions::const_assert_eq!(std::mem::align_of::<SymlinkObject<'_>>(), 8);
19029
19030 static_assertions::const_assert_eq!(std::mem::offset_of!(SymlinkObject<'_>, target), 0);
19031
19032 impl ::fidl_next::Constrained for SymlinkObject<'_> {
19033 type Constraint = ();
19034
19035 fn validate(
19036 _: ::fidl_next::Slot<'_, Self>,
19037 _: Self::Constraint,
19038 ) -> Result<(), ::fidl_next::ValidationError> {
19039 Ok(())
19040 }
19041 }
19042
19043 unsafe impl ::fidl_next::Wire for SymlinkObject<'static> {
19044 type Narrowed<'de> = SymlinkObject<'de>;
19045
19046 #[inline]
19047 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
19048 ::fidl_next::munge! {
19049 let Self {
19050
19051 target,
19052
19053 } = &mut *out_;
19054 }
19055
19056 ::fidl_next::Wire::zero_padding(target);
19057 }
19058 }
19059
19060 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SymlinkObject<'de>
19061 where
19062 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
19063 ___D: ::fidl_next::Decoder<'de>,
19064 {
19065 fn decode(
19066 slot_: ::fidl_next::Slot<'_, Self>,
19067 decoder_: &mut ___D,
19068 _: (),
19069 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
19070 ::fidl_next::munge! {
19071 let Self {
19072
19073 mut target,
19074
19075 } = slot_;
19076 }
19077
19078 let _field = target.as_mut();
19079 ::fidl_next::Constrained::validate(_field, (4095, ()))?;
19080 ::fidl_next::Decode::decode(target.as_mut(), decoder_, (4095, ()))?;
19081
19082 let target = unsafe { target.deref_unchecked() };
19083
19084 if target.len() > 4095 {
19085 return Err(::fidl_next::DecodeError::VectorTooLong {
19086 size: target.len() as u64,
19087 limit: 4095,
19088 });
19089 }
19090
19091 Ok(())
19092 }
19093 }
19094
19095 impl<'de> ::fidl_next::IntoNatural for SymlinkObject<'de> {
19096 type Natural = crate::natural::SymlinkObject;
19097 }
19098
19099 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
19101 #[repr(transparent)]
19102 pub struct WatchEvent {
19103 pub(crate) value: u8,
19104 }
19105
19106 impl ::fidl_next::Constrained for WatchEvent {
19107 type Constraint = ();
19108
19109 fn validate(
19110 _: ::fidl_next::Slot<'_, Self>,
19111 _: Self::Constraint,
19112 ) -> Result<(), ::fidl_next::ValidationError> {
19113 Ok(())
19114 }
19115 }
19116
19117 unsafe impl ::fidl_next::Wire for WatchEvent {
19118 type Narrowed<'de> = Self;
19119
19120 #[inline]
19121 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
19122 }
19124 }
19125
19126 impl WatchEvent {
19127 pub const DELETED: WatchEvent = WatchEvent { value: 0 };
19128
19129 pub const ADDED: WatchEvent = WatchEvent { value: 1 };
19130
19131 pub const REMOVED: WatchEvent = WatchEvent { value: 2 };
19132
19133 pub const EXISTING: WatchEvent = WatchEvent { value: 3 };
19134
19135 pub const IDLE: WatchEvent = WatchEvent { value: 4 };
19136 }
19137
19138 unsafe impl<___D> ::fidl_next::Decode<___D> for WatchEvent
19139 where
19140 ___D: ?Sized,
19141 {
19142 fn decode(
19143 slot: ::fidl_next::Slot<'_, Self>,
19144 _: &mut ___D,
19145 _: (),
19146 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
19147 ::fidl_next::munge!(let Self { value } = slot);
19148
19149 match u8::from(*value) {
19150 0 | 1 | 2 | 3 | 4 => (),
19151 unknown => {
19152 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
19153 }
19154 }
19155
19156 Ok(())
19157 }
19158 }
19159
19160 impl ::core::convert::From<crate::natural::WatchEvent> for WatchEvent {
19161 fn from(natural: crate::natural::WatchEvent) -> Self {
19162 match natural {
19163 crate::natural::WatchEvent::Deleted => WatchEvent::DELETED,
19164
19165 crate::natural::WatchEvent::Added => WatchEvent::ADDED,
19166
19167 crate::natural::WatchEvent::Removed => WatchEvent::REMOVED,
19168
19169 crate::natural::WatchEvent::Existing => WatchEvent::EXISTING,
19170
19171 crate::natural::WatchEvent::Idle => WatchEvent::IDLE,
19172 }
19173 }
19174 }
19175
19176 impl ::fidl_next::IntoNatural for WatchEvent {
19177 type Natural = crate::natural::WatchEvent;
19178 }
19179}
19180
19181pub mod wire_optional {
19182
19183 #[repr(transparent)]
19184 pub struct SelinuxContext<'de> {
19185 pub(crate) raw: ::fidl_next::wire::Union,
19186 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
19187 }
19188
19189 impl ::fidl_next::Constrained for SelinuxContext<'_> {
19190 type Constraint = ();
19191
19192 fn validate(
19193 _: ::fidl_next::Slot<'_, Self>,
19194 _: Self::Constraint,
19195 ) -> Result<(), ::fidl_next::ValidationError> {
19196 Ok(())
19197 }
19198 }
19199
19200 unsafe impl ::fidl_next::Wire for SelinuxContext<'static> {
19201 type Narrowed<'de> = SelinuxContext<'de>;
19202
19203 #[inline]
19204 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
19205 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
19206 ::fidl_next::wire::Union::zero_padding(raw);
19207 }
19208 }
19209
19210 impl<'de> SelinuxContext<'de> {
19211 pub fn is_some(&self) -> bool {
19212 self.raw.is_some()
19213 }
19214
19215 pub fn is_none(&self) -> bool {
19216 self.raw.is_none()
19217 }
19218
19219 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::SelinuxContext<'de>> {
19220 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
19221 }
19222
19223 pub fn into_option(self) -> ::core::option::Option<crate::wire::SelinuxContext<'de>> {
19224 if self.is_some() {
19225 Some(crate::wire::SelinuxContext {
19226 raw: self.raw,
19227 _phantom: ::core::marker::PhantomData,
19228 })
19229 } else {
19230 None
19231 }
19232 }
19233 }
19234
19235 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SelinuxContext<'de>
19236 where
19237 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
19238 ___D: ::fidl_next::Decoder<'de>,
19239 {
19240 fn decode(
19241 mut slot: ::fidl_next::Slot<'_, Self>,
19242 decoder: &mut ___D,
19243 _: (),
19244 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
19245 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
19246 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
19247 1 => {
19248 ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
19249 raw,
19250 decoder,
19251 (256, ()),
19252 )?
19253 }
19254
19255 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::EmptyStruct>(
19256 raw,
19257 decoder,
19258 (),
19259 )?,
19260
19261 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
19262 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
19263 }
19264
19265 Ok(())
19266 }
19267 }
19268
19269 impl<'de> ::core::fmt::Debug for SelinuxContext<'de> {
19270 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
19271 self.as_ref().fmt(f)
19272 }
19273 }
19274
19275 impl<'de> ::fidl_next::IntoNatural for SelinuxContext<'de> {
19276 type Natural = ::core::option::Option<crate::natural::SelinuxContext>;
19277 }
19278}
19279
19280pub mod generic {
19281
19282 pub struct AdvisoryLockRange<T0, T1, T2> {
19283 pub origin: T0,
19284
19285 pub offset: T1,
19286
19287 pub length: T2,
19288 }
19289
19290 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::AdvisoryLockRange, ___E>
19291 for AdvisoryLockRange<T0, T1, T2>
19292 where
19293 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19294 T0: ::fidl_next::Encode<crate::wire::SeekOrigin, ___E>,
19295 T1: ::fidl_next::Encode<::fidl_next::wire::Int64, ___E>,
19296 T2: ::fidl_next::Encode<::fidl_next::wire::Int64, ___E>,
19297 {
19298 #[inline]
19299 fn encode(
19300 self,
19301 encoder_: &mut ___E,
19302 out_: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockRange>,
19303 _: (),
19304 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19305 ::fidl_next::munge! {
19306 let crate::wire::AdvisoryLockRange {
19307
19308 origin,
19309 offset,
19310 length,
19311
19312 } = out_;
19313 }
19314
19315 ::fidl_next::Encode::encode(self.origin, encoder_, origin, ())?;
19316
19317 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
19318
19319 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
19320
19321 Ok(())
19322 }
19323 }
19324
19325 pub struct AdvisoryLockingAdvisoryLockRequest<T0> {
19326 pub request: T0,
19327 }
19328
19329 unsafe impl<___E, T0>
19330 ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>, ___E>
19331 for AdvisoryLockingAdvisoryLockRequest<T0>
19332 where
19333 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19334 ___E: ::fidl_next::Encoder,
19335 T0: ::fidl_next::Encode<crate::wire::AdvisoryLockRequest<'static>, ___E>,
19336 {
19337 #[inline]
19338 fn encode(
19339 self,
19340 encoder_: &mut ___E,
19341 out_: &mut ::core::mem::MaybeUninit<
19342 crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
19343 >,
19344 _: (),
19345 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19346 ::fidl_next::munge! {
19347 let crate::wire::AdvisoryLockingAdvisoryLockRequest {
19348
19349 request,
19350
19351 } = out_;
19352 }
19353
19354 ::fidl_next::Encode::encode(self.request, encoder_, request, ())?;
19355
19356 Ok(())
19357 }
19358 }
19359
19360 pub struct NodeAttributes<T0, T1, T2, T3, T4, T5, T6> {
19361 pub mode: T0,
19362
19363 pub id: T1,
19364
19365 pub content_size: T2,
19366
19367 pub storage_size: T3,
19368
19369 pub link_count: T4,
19370
19371 pub creation_time: T5,
19372
19373 pub modification_time: T6,
19374 }
19375
19376 unsafe impl<___E, T0, T1, T2, T3, T4, T5, T6>
19377 ::fidl_next::Encode<crate::wire::NodeAttributes, ___E>
19378 for NodeAttributes<T0, T1, T2, T3, T4, T5, T6>
19379 where
19380 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19381 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
19382 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
19383 T2: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
19384 T3: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
19385 T4: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
19386 T5: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
19387 T6: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
19388 {
19389 #[inline]
19390 fn encode(
19391 self,
19392 encoder_: &mut ___E,
19393 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributes>,
19394 _: (),
19395 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19396 ::fidl_next::munge! {
19397 let crate::wire::NodeAttributes {
19398
19399 mode,
19400 id,
19401 content_size,
19402 storage_size,
19403 link_count,
19404 creation_time,
19405 modification_time,
19406
19407 } = out_;
19408 }
19409
19410 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
19411
19412 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
19413
19414 ::fidl_next::Encode::encode(self.content_size, encoder_, content_size, ())?;
19415
19416 ::fidl_next::Encode::encode(self.storage_size, encoder_, storage_size, ())?;
19417
19418 ::fidl_next::Encode::encode(self.link_count, encoder_, link_count, ())?;
19419
19420 ::fidl_next::Encode::encode(self.creation_time, encoder_, creation_time, ())?;
19421
19422 ::fidl_next::Encode::encode(self.modification_time, encoder_, modification_time, ())?;
19423
19424 Ok(())
19425 }
19426 }
19427
19428 pub struct NodeQueryFilesystemResponse<T0, T1> {
19429 pub s: T0,
19430
19431 pub info: T1,
19432 }
19433
19434 unsafe impl<___E, T0, T1>
19435 ::fidl_next::Encode<crate::wire::NodeQueryFilesystemResponse<'static>, ___E>
19436 for NodeQueryFilesystemResponse<T0, T1>
19437 where
19438 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19439 ___E: ::fidl_next::Encoder,
19440 T0: ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>,
19441 T1: ::fidl_next::Encode<::fidl_next::wire::Box<'static, crate::wire::FilesystemInfo>, ___E>,
19442 {
19443 #[inline]
19444 fn encode(
19445 self,
19446 encoder_: &mut ___E,
19447 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeQueryFilesystemResponse<'static>>,
19448 _: (),
19449 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19450 ::fidl_next::munge! {
19451 let crate::wire::NodeQueryFilesystemResponse {
19452
19453 s,
19454 info,
19455
19456 } = out_;
19457 }
19458
19459 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
19460
19461 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
19462
19463 Ok(())
19464 }
19465 }
19466
19467 pub struct DirectoryReadDirentsRequest<T0> {
19468 pub max_bytes: T0,
19469 }
19470
19471 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirectoryReadDirentsRequest, ___E>
19472 for DirectoryReadDirentsRequest<T0>
19473 where
19474 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19475 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
19476 {
19477 #[inline]
19478 fn encode(
19479 self,
19480 encoder_: &mut ___E,
19481 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryReadDirentsRequest>,
19482 _: (),
19483 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19484 ::fidl_next::munge! {
19485 let crate::wire::DirectoryReadDirentsRequest {
19486
19487 max_bytes,
19488
19489 } = out_;
19490 }
19491
19492 ::fidl_next::Encode::encode(self.max_bytes, encoder_, max_bytes, ())?;
19493
19494 Ok(())
19495 }
19496 }
19497
19498 pub struct DirectoryReadDirentsResponse<T0, T1> {
19499 pub s: T0,
19500
19501 pub dirents: T1,
19502 }
19503
19504 unsafe impl<___E, T0, T1>
19505 ::fidl_next::Encode<crate::wire::DirectoryReadDirentsResponse<'static>, ___E>
19506 for DirectoryReadDirentsResponse<T0, T1>
19507 where
19508 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19509 ___E: ::fidl_next::Encoder,
19510 T0: ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>,
19511 T1: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
19512 {
19513 #[inline]
19514 fn encode(
19515 self,
19516 encoder_: &mut ___E,
19517 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryReadDirentsResponse<'static>>,
19518 _: (),
19519 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19520 ::fidl_next::munge! {
19521 let crate::wire::DirectoryReadDirentsResponse {
19522
19523 s,
19524 dirents,
19525
19526 } = out_;
19527 }
19528
19529 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
19530
19531 ::fidl_next::Encode::encode(self.dirents, encoder_, dirents, (8192, ()))?;
19532
19533 Ok(())
19534 }
19535 }
19536
19537 pub struct DirectoryRewindResponse<T0> {
19538 pub s: T0,
19539 }
19540
19541 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirectoryRewindResponse, ___E>
19542 for DirectoryRewindResponse<T0>
19543 where
19544 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19545 T0: ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>,
19546 {
19547 #[inline]
19548 fn encode(
19549 self,
19550 encoder_: &mut ___E,
19551 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRewindResponse>,
19552 _: (),
19553 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19554 ::fidl_next::munge! {
19555 let crate::wire::DirectoryRewindResponse {
19556
19557 s,
19558
19559 } = out_;
19560 }
19561
19562 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
19563
19564 Ok(())
19565 }
19566 }
19567
19568 pub struct DirectoryLinkResponse<T0> {
19569 pub s: T0,
19570 }
19571
19572 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirectoryLinkResponse, ___E>
19573 for DirectoryLinkResponse<T0>
19574 where
19575 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19576 T0: ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>,
19577 {
19578 #[inline]
19579 fn encode(
19580 self,
19581 encoder_: &mut ___E,
19582 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkResponse>,
19583 _: (),
19584 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19585 ::fidl_next::munge! {
19586 let crate::wire::DirectoryLinkResponse {
19587
19588 s,
19589
19590 } = out_;
19591 }
19592
19593 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
19594
19595 Ok(())
19596 }
19597 }
19598
19599 pub struct DirectoryUnlinkRequest<T0, T1> {
19600 pub name: T0,
19601
19602 pub options: T1,
19603 }
19604
19605 unsafe impl<___E, T0, T1>
19606 ::fidl_next::Encode<crate::wire::DirectoryUnlinkRequest<'static>, ___E>
19607 for DirectoryUnlinkRequest<T0, T1>
19608 where
19609 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19610 ___E: ::fidl_next::Encoder,
19611 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
19612 T1: ::fidl_next::Encode<crate::wire::UnlinkOptions<'static>, ___E>,
19613 {
19614 #[inline]
19615 fn encode(
19616 self,
19617 encoder_: &mut ___E,
19618 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryUnlinkRequest<'static>>,
19619 _: (),
19620 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19621 ::fidl_next::munge! {
19622 let crate::wire::DirectoryUnlinkRequest {
19623
19624 name,
19625 options,
19626
19627 } = out_;
19628 }
19629
19630 ::fidl_next::Encode::encode(self.name, encoder_, name, 255)?;
19631
19632 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
19633
19634 Ok(())
19635 }
19636 }
19637
19638 pub struct DirectoryWatchResponse<T0> {
19639 pub s: T0,
19640 }
19641
19642 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirectoryWatchResponse, ___E>
19643 for DirectoryWatchResponse<T0>
19644 where
19645 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19646 T0: ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>,
19647 {
19648 #[inline]
19649 fn encode(
19650 self,
19651 encoder_: &mut ___E,
19652 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchResponse>,
19653 _: (),
19654 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19655 ::fidl_next::munge! {
19656 let crate::wire::DirectoryWatchResponse {
19657
19658 s,
19659
19660 } = out_;
19661 }
19662
19663 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
19664
19665 Ok(())
19666 }
19667 }
19668
19669 pub struct NodeGetExtendedAttributeRequest<T0> {
19670 pub name: T0,
19671 }
19672
19673 unsafe impl<___E, T0>
19674 ::fidl_next::Encode<crate::wire::NodeGetExtendedAttributeRequest<'static>, ___E>
19675 for NodeGetExtendedAttributeRequest<T0>
19676 where
19677 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19678 ___E: ::fidl_next::Encoder,
19679 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
19680 {
19681 #[inline]
19682 fn encode(
19683 self,
19684 encoder_: &mut ___E,
19685 out_: &mut ::core::mem::MaybeUninit<
19686 crate::wire::NodeGetExtendedAttributeRequest<'static>,
19687 >,
19688 _: (),
19689 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19690 ::fidl_next::munge! {
19691 let crate::wire::NodeGetExtendedAttributeRequest {
19692
19693 name,
19694
19695 } = out_;
19696 }
19697
19698 ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
19699
19700 Ok(())
19701 }
19702 }
19703
19704 pub struct NodeRemoveExtendedAttributeRequest<T0> {
19705 pub name: T0,
19706 }
19707
19708 unsafe impl<___E, T0>
19709 ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeRequest<'static>, ___E>
19710 for NodeRemoveExtendedAttributeRequest<T0>
19711 where
19712 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19713 ___E: ::fidl_next::Encoder,
19714 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
19715 {
19716 #[inline]
19717 fn encode(
19718 self,
19719 encoder_: &mut ___E,
19720 out_: &mut ::core::mem::MaybeUninit<
19721 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
19722 >,
19723 _: (),
19724 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19725 ::fidl_next::munge! {
19726 let crate::wire::NodeRemoveExtendedAttributeRequest {
19727
19728 name,
19729
19730 } = out_;
19731 }
19732
19733 ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
19734
19735 Ok(())
19736 }
19737 }
19738
19739 pub struct NodeDeprecatedGetAttrResponse<T0, T1> {
19740 pub s: T0,
19741
19742 pub attributes: T1,
19743 }
19744
19745 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeDeprecatedGetAttrResponse, ___E>
19746 for NodeDeprecatedGetAttrResponse<T0, T1>
19747 where
19748 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19749 T0: ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>,
19750 T1: ::fidl_next::Encode<crate::wire::NodeAttributes, ___E>,
19751 {
19752 #[inline]
19753 fn encode(
19754 self,
19755 encoder_: &mut ___E,
19756 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedGetAttrResponse>,
19757 _: (),
19758 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19759 ::fidl_next::munge! {
19760 let crate::wire::NodeDeprecatedGetAttrResponse {
19761
19762 s,
19763 attributes,
19764
19765 } = out_;
19766 }
19767
19768 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
19769
19770 ::fidl_next::Encode::encode(self.attributes, encoder_, attributes, ())?;
19771
19772 Ok(())
19773 }
19774 }
19775
19776 pub struct NodeDeprecatedSetAttrRequest<T0, T1> {
19777 pub flags: T0,
19778
19779 pub attributes: T1,
19780 }
19781
19782 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrRequest, ___E>
19783 for NodeDeprecatedSetAttrRequest<T0, T1>
19784 where
19785 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19786 T0: ::fidl_next::Encode<crate::wire::NodeAttributeFlags, ___E>,
19787 T1: ::fidl_next::Encode<crate::wire::NodeAttributes, ___E>,
19788 {
19789 #[inline]
19790 fn encode(
19791 self,
19792 encoder_: &mut ___E,
19793 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetAttrRequest>,
19794 _: (),
19795 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19796 ::fidl_next::munge! {
19797 let crate::wire::NodeDeprecatedSetAttrRequest {
19798
19799 flags,
19800 attributes,
19801
19802 } = out_;
19803 }
19804
19805 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
19806
19807 ::fidl_next::Encode::encode(self.attributes, encoder_, attributes, ())?;
19808
19809 Ok(())
19810 }
19811 }
19812
19813 pub struct NodeDeprecatedSetAttrResponse<T0> {
19814 pub s: T0,
19815 }
19816
19817 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrResponse, ___E>
19818 for NodeDeprecatedSetAttrResponse<T0>
19819 where
19820 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19821 T0: ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>,
19822 {
19823 #[inline]
19824 fn encode(
19825 self,
19826 encoder_: &mut ___E,
19827 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetAttrResponse>,
19828 _: (),
19829 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19830 ::fidl_next::munge! {
19831 let crate::wire::NodeDeprecatedSetAttrResponse {
19832
19833 s,
19834
19835 } = out_;
19836 }
19837
19838 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
19839
19840 Ok(())
19841 }
19842 }
19843
19844 pub struct NodeDeprecatedGetFlagsResponse<T0, T1> {
19845 pub s: T0,
19846
19847 pub flags: T1,
19848 }
19849
19850 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeDeprecatedGetFlagsResponse, ___E>
19851 for NodeDeprecatedGetFlagsResponse<T0, T1>
19852 where
19853 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19854 T0: ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>,
19855 T1: ::fidl_next::Encode<crate::wire::OpenFlags, ___E>,
19856 {
19857 #[inline]
19858 fn encode(
19859 self,
19860 encoder_: &mut ___E,
19861 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedGetFlagsResponse>,
19862 _: (),
19863 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19864 ::fidl_next::munge! {
19865 let crate::wire::NodeDeprecatedGetFlagsResponse {
19866
19867 s,
19868 flags,
19869
19870 } = out_;
19871 }
19872
19873 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
19874
19875 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
19876
19877 Ok(())
19878 }
19879 }
19880
19881 pub struct NodeDeprecatedSetFlagsRequest<T0> {
19882 pub flags: T0,
19883 }
19884
19885 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsRequest, ___E>
19886 for NodeDeprecatedSetFlagsRequest<T0>
19887 where
19888 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19889 T0: ::fidl_next::Encode<crate::wire::OpenFlags, ___E>,
19890 {
19891 #[inline]
19892 fn encode(
19893 self,
19894 encoder_: &mut ___E,
19895 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetFlagsRequest>,
19896 _: (),
19897 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19898 ::fidl_next::munge! {
19899 let crate::wire::NodeDeprecatedSetFlagsRequest {
19900
19901 flags,
19902
19903 } = out_;
19904 }
19905
19906 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
19907
19908 Ok(())
19909 }
19910 }
19911
19912 pub struct NodeDeprecatedSetFlagsResponse<T0> {
19913 pub s: T0,
19914 }
19915
19916 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsResponse, ___E>
19917 for NodeDeprecatedSetFlagsResponse<T0>
19918 where
19919 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19920 T0: ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>,
19921 {
19922 #[inline]
19923 fn encode(
19924 self,
19925 encoder_: &mut ___E,
19926 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetFlagsResponse>,
19927 _: (),
19928 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19929 ::fidl_next::munge! {
19930 let crate::wire::NodeDeprecatedSetFlagsResponse {
19931
19932 s,
19933
19934 } = out_;
19935 }
19936
19937 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
19938
19939 Ok(())
19940 }
19941 }
19942
19943 pub struct NodeGetFlagsResponse<T0> {
19944 pub flags: T0,
19945 }
19946
19947 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeGetFlagsResponse, ___E>
19948 for NodeGetFlagsResponse<T0>
19949 where
19950 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19951 T0: ::fidl_next::Encode<crate::wire::Flags, ___E>,
19952 {
19953 #[inline]
19954 fn encode(
19955 self,
19956 encoder_: &mut ___E,
19957 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetFlagsResponse>,
19958 _: (),
19959 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19960 ::fidl_next::munge! {
19961 let crate::wire::NodeGetFlagsResponse {
19962
19963 flags,
19964
19965 } = out_;
19966 }
19967
19968 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
19969
19970 Ok(())
19971 }
19972 }
19973
19974 pub struct NodeSetFlagsRequest<T0> {
19975 pub flags: T0,
19976 }
19977
19978 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeSetFlagsRequest, ___E>
19979 for NodeSetFlagsRequest<T0>
19980 where
19981 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19982 T0: ::fidl_next::Encode<crate::wire::Flags, ___E>,
19983 {
19984 #[inline]
19985 fn encode(
19986 self,
19987 encoder_: &mut ___E,
19988 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeSetFlagsRequest>,
19989 _: (),
19990 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19991 ::fidl_next::munge! {
19992 let crate::wire::NodeSetFlagsRequest {
19993
19994 flags,
19995
19996 } = out_;
19997 }
19998
19999 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
20000
20001 Ok(())
20002 }
20003 }
20004
20005 pub struct EmptyStruct {}
20006
20007 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EmptyStruct, ___E> for EmptyStruct
20008 where
20009 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20010 {
20011 #[inline]
20012 fn encode(
20013 self,
20014 encoder_: &mut ___E,
20015 out_: &mut ::core::mem::MaybeUninit<crate::wire::EmptyStruct>,
20016 _: (),
20017 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20018 ::fidl_next::munge! {
20019 let crate::wire::EmptyStruct {
20020
20021 _empty,
20022
20023
20024 } = out_;
20025 }
20026
20027 Ok(())
20028 }
20029 }
20030
20031 pub struct NodeAttributes2<T0, T1> {
20032 pub mutable_attributes: T0,
20033
20034 pub immutable_attributes: T1,
20035 }
20036
20037 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeAttributes2<'static>, ___E>
20038 for NodeAttributes2<T0, T1>
20039 where
20040 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20041 ___E: ::fidl_next::Encoder,
20042 T0: ::fidl_next::Encode<crate::wire::MutableNodeAttributes<'static>, ___E>,
20043 T1: ::fidl_next::Encode<crate::wire::ImmutableNodeAttributes<'static>, ___E>,
20044 {
20045 #[inline]
20046 fn encode(
20047 self,
20048 encoder_: &mut ___E,
20049 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributes2<'static>>,
20050 _: (),
20051 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20052 ::fidl_next::munge! {
20053 let crate::wire::NodeAttributes2 {
20054
20055 mutable_attributes,
20056 immutable_attributes,
20057
20058 } = out_;
20059 }
20060
20061 ::fidl_next::Encode::encode(self.mutable_attributes, encoder_, mutable_attributes, ())?;
20062
20063 ::fidl_next::Encode::encode(
20064 self.immutable_attributes,
20065 encoder_,
20066 immutable_attributes,
20067 (),
20068 )?;
20069
20070 Ok(())
20071 }
20072 }
20073
20074 pub struct NodeGetAttributesRequest<T0> {
20075 pub query: T0,
20076 }
20077
20078 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeGetAttributesRequest, ___E>
20079 for NodeGetAttributesRequest<T0>
20080 where
20081 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20082 T0: ::fidl_next::Encode<crate::wire::NodeAttributesQuery, ___E>,
20083 {
20084 #[inline]
20085 fn encode(
20086 self,
20087 encoder_: &mut ___E,
20088 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetAttributesRequest>,
20089 _: (),
20090 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20091 ::fidl_next::munge! {
20092 let crate::wire::NodeGetAttributesRequest {
20093
20094 query,
20095
20096 } = out_;
20097 }
20098
20099 ::fidl_next::Encode::encode(self.query, encoder_, query, ())?;
20100
20101 Ok(())
20102 }
20103 }
20104
20105 pub struct DirectoryObject {}
20106
20107 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryObject, ___E> for DirectoryObject
20108 where
20109 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20110 {
20111 #[inline]
20112 fn encode(
20113 self,
20114 encoder_: &mut ___E,
20115 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryObject>,
20116 _: (),
20117 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20118 ::fidl_next::munge! {
20119 let crate::wire::DirectoryObject {
20120
20121 _empty,
20122
20123
20124 } = out_;
20125 }
20126
20127 Ok(())
20128 }
20129 }
20130
20131 pub struct ExtendedAttributeIteratorGetNextResponse<T0, T1> {
20132 pub attributes: T0,
20133
20134 pub last: T1,
20135 }
20136
20137 unsafe impl<___E, T0, T1>
20138 ::fidl_next::Encode<crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>, ___E>
20139 for ExtendedAttributeIteratorGetNextResponse<T0, T1>
20140 where
20141 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20142 ___E: ::fidl_next::Encoder,
20143 T0: ::fidl_next::Encode<
20144 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::Vector<'static, u8>>,
20145 ___E,
20146 >,
20147 T1: ::fidl_next::Encode<bool, ___E>,
20148 {
20149 #[inline]
20150 fn encode(
20151 self,
20152 encoder_: &mut ___E,
20153 out_: &mut ::core::mem::MaybeUninit<
20154 crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
20155 >,
20156 _: (),
20157 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20158 ::fidl_next::munge! {
20159 let crate::wire::ExtendedAttributeIteratorGetNextResponse {
20160
20161 attributes,
20162 last,
20163
20164 } = out_;
20165 }
20166
20167 ::fidl_next::Encode::encode(self.attributes, encoder_, attributes, (128, (255, ())))?;
20168
20169 ::fidl_next::Encode::encode(self.last, encoder_, last, ())?;
20170
20171 Ok(())
20172 }
20173 }
20174
20175 pub struct ReadableReadRequest<T0> {
20176 pub count: T0,
20177 }
20178
20179 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ReadableReadRequest, ___E>
20180 for ReadableReadRequest<T0>
20181 where
20182 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20183 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
20184 {
20185 #[inline]
20186 fn encode(
20187 self,
20188 encoder_: &mut ___E,
20189 out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadableReadRequest>,
20190 _: (),
20191 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20192 ::fidl_next::munge! {
20193 let crate::wire::ReadableReadRequest {
20194
20195 count,
20196
20197 } = out_;
20198 }
20199
20200 ::fidl_next::Encode::encode(self.count, encoder_, count, ())?;
20201
20202 Ok(())
20203 }
20204 }
20205
20206 pub struct ReadableReadResponse<T0> {
20207 pub data: T0,
20208 }
20209
20210 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ReadableReadResponse<'static>, ___E>
20211 for ReadableReadResponse<T0>
20212 where
20213 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20214 ___E: ::fidl_next::Encoder,
20215 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
20216 {
20217 #[inline]
20218 fn encode(
20219 self,
20220 encoder_: &mut ___E,
20221 out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadableReadResponse<'static>>,
20222 _: (),
20223 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20224 ::fidl_next::munge! {
20225 let crate::wire::ReadableReadResponse {
20226
20227 data,
20228
20229 } = out_;
20230 }
20231
20232 ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
20233
20234 Ok(())
20235 }
20236 }
20237
20238 pub struct WritableWriteRequest<T0> {
20239 pub data: T0,
20240 }
20241
20242 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::WritableWriteRequest<'static>, ___E>
20243 for WritableWriteRequest<T0>
20244 where
20245 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20246 ___E: ::fidl_next::Encoder,
20247 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
20248 {
20249 #[inline]
20250 fn encode(
20251 self,
20252 encoder_: &mut ___E,
20253 out_: &mut ::core::mem::MaybeUninit<crate::wire::WritableWriteRequest<'static>>,
20254 _: (),
20255 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20256 ::fidl_next::munge! {
20257 let crate::wire::WritableWriteRequest {
20258
20259 data,
20260
20261 } = out_;
20262 }
20263
20264 ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
20265
20266 Ok(())
20267 }
20268 }
20269
20270 pub struct WritableWriteResponse<T0> {
20271 pub actual_count: T0,
20272 }
20273
20274 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::WritableWriteResponse, ___E>
20275 for WritableWriteResponse<T0>
20276 where
20277 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20278 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
20279 {
20280 #[inline]
20281 fn encode(
20282 self,
20283 encoder_: &mut ___E,
20284 out_: &mut ::core::mem::MaybeUninit<crate::wire::WritableWriteResponse>,
20285 _: (),
20286 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20287 ::fidl_next::munge! {
20288 let crate::wire::WritableWriteResponse {
20289
20290 actual_count,
20291
20292 } = out_;
20293 }
20294
20295 ::fidl_next::Encode::encode(self.actual_count, encoder_, actual_count, ())?;
20296
20297 Ok(())
20298 }
20299 }
20300
20301 pub struct FileSeekRequest<T0, T1> {
20302 pub origin: T0,
20303
20304 pub offset: T1,
20305 }
20306
20307 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::FileSeekRequest, ___E>
20308 for FileSeekRequest<T0, T1>
20309 where
20310 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20311 T0: ::fidl_next::Encode<crate::wire::SeekOrigin, ___E>,
20312 T1: ::fidl_next::Encode<::fidl_next::wire::Int64, ___E>,
20313 {
20314 #[inline]
20315 fn encode(
20316 self,
20317 encoder_: &mut ___E,
20318 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileSeekRequest>,
20319 _: (),
20320 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20321 ::fidl_next::munge! {
20322 let crate::wire::FileSeekRequest {
20323
20324 origin,
20325 offset,
20326
20327 } = out_;
20328 }
20329
20330 ::fidl_next::Encode::encode(self.origin, encoder_, origin, ())?;
20331
20332 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
20333
20334 Ok(())
20335 }
20336 }
20337
20338 pub struct FileSeekResponse<T0> {
20339 pub offset_from_start: T0,
20340 }
20341
20342 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileSeekResponse, ___E>
20343 for FileSeekResponse<T0>
20344 where
20345 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20346 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
20347 {
20348 #[inline]
20349 fn encode(
20350 self,
20351 encoder_: &mut ___E,
20352 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileSeekResponse>,
20353 _: (),
20354 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20355 ::fidl_next::munge! {
20356 let crate::wire::FileSeekResponse {
20357
20358 offset_from_start,
20359
20360 } = out_;
20361 }
20362
20363 ::fidl_next::Encode::encode(self.offset_from_start, encoder_, offset_from_start, ())?;
20364
20365 Ok(())
20366 }
20367 }
20368
20369 pub struct FileReadAtRequest<T0, T1> {
20370 pub count: T0,
20371
20372 pub offset: T1,
20373 }
20374
20375 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::FileReadAtRequest, ___E>
20376 for FileReadAtRequest<T0, T1>
20377 where
20378 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20379 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
20380 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
20381 {
20382 #[inline]
20383 fn encode(
20384 self,
20385 encoder_: &mut ___E,
20386 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileReadAtRequest>,
20387 _: (),
20388 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20389 ::fidl_next::munge! {
20390 let crate::wire::FileReadAtRequest {
20391
20392 count,
20393 offset,
20394
20395 } = out_;
20396 }
20397
20398 ::fidl_next::Encode::encode(self.count, encoder_, count, ())?;
20399
20400 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
20401
20402 Ok(())
20403 }
20404 }
20405
20406 pub struct FileReadAtResponse<T0> {
20407 pub data: T0,
20408 }
20409
20410 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileReadAtResponse<'static>, ___E>
20411 for FileReadAtResponse<T0>
20412 where
20413 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20414 ___E: ::fidl_next::Encoder,
20415 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
20416 {
20417 #[inline]
20418 fn encode(
20419 self,
20420 encoder_: &mut ___E,
20421 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileReadAtResponse<'static>>,
20422 _: (),
20423 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20424 ::fidl_next::munge! {
20425 let crate::wire::FileReadAtResponse {
20426
20427 data,
20428
20429 } = out_;
20430 }
20431
20432 ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
20433
20434 Ok(())
20435 }
20436 }
20437
20438 pub struct FileWriteAtRequest<T0, T1> {
20439 pub data: T0,
20440
20441 pub offset: T1,
20442 }
20443
20444 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::FileWriteAtRequest<'static>, ___E>
20445 for FileWriteAtRequest<T0, T1>
20446 where
20447 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20448 ___E: ::fidl_next::Encoder,
20449 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
20450 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
20451 {
20452 #[inline]
20453 fn encode(
20454 self,
20455 encoder_: &mut ___E,
20456 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileWriteAtRequest<'static>>,
20457 _: (),
20458 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20459 ::fidl_next::munge! {
20460 let crate::wire::FileWriteAtRequest {
20461
20462 data,
20463 offset,
20464
20465 } = out_;
20466 }
20467
20468 ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
20469
20470 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
20471
20472 Ok(())
20473 }
20474 }
20475
20476 pub struct FileWriteAtResponse<T0> {
20477 pub actual_count: T0,
20478 }
20479
20480 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileWriteAtResponse, ___E>
20481 for FileWriteAtResponse<T0>
20482 where
20483 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20484 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
20485 {
20486 #[inline]
20487 fn encode(
20488 self,
20489 encoder_: &mut ___E,
20490 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileWriteAtResponse>,
20491 _: (),
20492 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20493 ::fidl_next::munge! {
20494 let crate::wire::FileWriteAtResponse {
20495
20496 actual_count,
20497
20498 } = out_;
20499 }
20500
20501 ::fidl_next::Encode::encode(self.actual_count, encoder_, actual_count, ())?;
20502
20503 Ok(())
20504 }
20505 }
20506
20507 pub struct FileResizeRequest<T0> {
20508 pub length: T0,
20509 }
20510
20511 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileResizeRequest, ___E>
20512 for FileResizeRequest<T0>
20513 where
20514 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20515 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
20516 {
20517 #[inline]
20518 fn encode(
20519 self,
20520 encoder_: &mut ___E,
20521 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileResizeRequest>,
20522 _: (),
20523 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20524 ::fidl_next::munge! {
20525 let crate::wire::FileResizeRequest {
20526
20527 length,
20528
20529 } = out_;
20530 }
20531
20532 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
20533
20534 Ok(())
20535 }
20536 }
20537
20538 pub struct FileGetBackingMemoryRequest<T0> {
20539 pub flags: T0,
20540 }
20541
20542 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryRequest, ___E>
20543 for FileGetBackingMemoryRequest<T0>
20544 where
20545 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20546 T0: ::fidl_next::Encode<crate::wire::VmoFlags, ___E>,
20547 {
20548 #[inline]
20549 fn encode(
20550 self,
20551 encoder_: &mut ___E,
20552 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryRequest>,
20553 _: (),
20554 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20555 ::fidl_next::munge! {
20556 let crate::wire::FileGetBackingMemoryRequest {
20557
20558 flags,
20559
20560 } = out_;
20561 }
20562
20563 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
20564
20565 Ok(())
20566 }
20567 }
20568
20569 pub struct FilesystemInfo<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> {
20570 pub total_bytes: T0,
20571
20572 pub used_bytes: T1,
20573
20574 pub total_nodes: T2,
20575
20576 pub used_nodes: T3,
20577
20578 pub free_shared_pool_bytes: T4,
20579
20580 pub fs_id: T5,
20581
20582 pub block_size: T6,
20583
20584 pub max_filename_size: T7,
20585
20586 pub fs_type: T8,
20587
20588 pub padding: T9,
20589
20590 pub name: T10,
20591 }
20592
20593 unsafe impl<___E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
20594 ::fidl_next::Encode<crate::wire::FilesystemInfo, ___E>
20595 for FilesystemInfo<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
20596 where
20597 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20598 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
20599 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
20600 T2: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
20601 T3: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
20602 T4: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
20603 T5: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
20604 T6: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
20605 T7: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
20606 T8: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
20607 T9: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
20608 T10: ::fidl_next::Encode<[i8; 32], ___E>,
20609 {
20610 #[inline]
20611 fn encode(
20612 self,
20613 encoder_: &mut ___E,
20614 out_: &mut ::core::mem::MaybeUninit<crate::wire::FilesystemInfo>,
20615 _: (),
20616 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20617 ::fidl_next::munge! {
20618 let crate::wire::FilesystemInfo {
20619
20620 total_bytes,
20621 used_bytes,
20622 total_nodes,
20623 used_nodes,
20624 free_shared_pool_bytes,
20625 fs_id,
20626 block_size,
20627 max_filename_size,
20628 fs_type,
20629 padding,
20630 name,
20631
20632 } = out_;
20633 }
20634
20635 ::fidl_next::Encode::encode(self.total_bytes, encoder_, total_bytes, ())?;
20636
20637 ::fidl_next::Encode::encode(self.used_bytes, encoder_, used_bytes, ())?;
20638
20639 ::fidl_next::Encode::encode(self.total_nodes, encoder_, total_nodes, ())?;
20640
20641 ::fidl_next::Encode::encode(self.used_nodes, encoder_, used_nodes, ())?;
20642
20643 ::fidl_next::Encode::encode(
20644 self.free_shared_pool_bytes,
20645 encoder_,
20646 free_shared_pool_bytes,
20647 (),
20648 )?;
20649
20650 ::fidl_next::Encode::encode(self.fs_id, encoder_, fs_id, ())?;
20651
20652 ::fidl_next::Encode::encode(self.block_size, encoder_, block_size, ())?;
20653
20654 ::fidl_next::Encode::encode(self.max_filename_size, encoder_, max_filename_size, ())?;
20655
20656 ::fidl_next::Encode::encode(self.fs_type, encoder_, fs_type, ())?;
20657
20658 ::fidl_next::Encode::encode(self.padding, encoder_, padding, ())?;
20659
20660 ::fidl_next::Encode::encode(self.name, encoder_, name, ())?;
20661
20662 Ok(())
20663 }
20664 }
20665
20666 pub struct Service {}
20667
20668 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Service, ___E> for Service
20669 where
20670 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20671 {
20672 #[inline]
20673 fn encode(
20674 self,
20675 encoder_: &mut ___E,
20676 out_: &mut ::core::mem::MaybeUninit<crate::wire::Service>,
20677 _: (),
20678 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20679 ::fidl_next::munge! {
20680 let crate::wire::Service {
20681
20682 _empty,
20683
20684
20685 } = out_;
20686 }
20687
20688 Ok(())
20689 }
20690 }
20691
20692 pub struct SymlinkObject<T0> {
20693 pub target: T0,
20694 }
20695
20696 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::SymlinkObject<'static>, ___E>
20697 for SymlinkObject<T0>
20698 where
20699 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20700 ___E: ::fidl_next::Encoder,
20701 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
20702 {
20703 #[inline]
20704 fn encode(
20705 self,
20706 encoder_: &mut ___E,
20707 out_: &mut ::core::mem::MaybeUninit<crate::wire::SymlinkObject<'static>>,
20708 _: (),
20709 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20710 ::fidl_next::munge! {
20711 let crate::wire::SymlinkObject {
20712
20713 target,
20714
20715 } = out_;
20716 }
20717
20718 ::fidl_next::Encode::encode(self.target, encoder_, target, (4095, ()))?;
20719
20720 Ok(())
20721 }
20722 }
20723}
20724
20725pub use self::natural::*;
20726
20727#[doc = " Advisory locking protocol.\n\n This protocol is intended to be composed into the |File| protocol to\n provide support for advisory locking.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n These primitives are designed to support the flock() and fcntl(),\n specifically F_SETLK, F_SETLKW, and F_GETLK, functionality that code\n running on Fuchsia expects from other operating systems.\n"]
20729#[derive(PartialEq, Debug)]
20730pub struct AdvisoryLocking;
20731
20732#[cfg(target_os = "fuchsia")]
20733impl ::fidl_next::HasTransport for AdvisoryLocking {
20734 type Transport = ::fidl_next::fuchsia::zx::Channel;
20735}
20736
20737pub mod advisory_locking {
20738 pub mod prelude {
20739 pub use crate::{
20740 AdvisoryLocking, AdvisoryLockingClientHandler, AdvisoryLockingServerHandler,
20741 advisory_locking,
20742 };
20743
20744 pub use crate::natural::AdvisoryLockingAdvisoryLockRequest;
20745
20746 pub use crate::natural::AdvisoryLockingAdvisoryLockResponse;
20747 }
20748
20749 pub struct AdvisoryLock;
20750
20751 impl ::fidl_next::Method for AdvisoryLock {
20752 const ORDINAL: u64 = 7992130864415541162;
20753 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
20754 ::fidl_next::protocol::Flexibility::Strict;
20755
20756 type Protocol = crate::AdvisoryLocking;
20757
20758 type Request = crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>;
20759 }
20760
20761 impl ::fidl_next::TwoWayMethod for AdvisoryLock {
20762 type Response = ::fidl_next::wire::Result<
20763 'static,
20764 crate::wire::AdvisoryLockingAdvisoryLockResponse,
20765 ::fidl_next::wire::Int32,
20766 >;
20767 }
20768
20769 impl<___R> ::fidl_next::Respond<___R> for AdvisoryLock {
20770 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
20771
20772 fn respond(response: ___R) -> Self::Output {
20773 ::core::result::Result::Ok(response)
20774 }
20775 }
20776
20777 impl<___R> ::fidl_next::RespondErr<___R> for AdvisoryLock {
20778 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
20779
20780 fn respond_err(response: ___R) -> Self::Output {
20781 ::core::result::Result::Err(response)
20782 }
20783 }
20784
20785 mod ___detail {
20786 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::AdvisoryLocking
20787 where
20788 ___T: ::fidl_next::Transport,
20789 {
20790 type Client = AdvisoryLockingClient<___T>;
20791 type Server = AdvisoryLockingServer<___T>;
20792 }
20793
20794 #[repr(transparent)]
20796 pub struct AdvisoryLockingClient<___T: ::fidl_next::Transport> {
20797 #[allow(dead_code)]
20798 client: ::fidl_next::protocol::Client<___T>,
20799 }
20800
20801 impl<___T> AdvisoryLockingClient<___T>
20802 where
20803 ___T: ::fidl_next::Transport,
20804 {
20805 #[doc = " Acquires an advisory lock on the underlying file.\n\n The lock lasts until either this connection is closed or\n this method is called with |AdvisoryLockType.UNLOCK| to release the lock\n explicitly.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].\n * [`Rights.WRITE_BYTES`] if `request.type` is\n [`AdvisoryLockType.WRITE`].\n\n # Errors\n\n * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For\n example, another connection might hold a conflicting lock type.\n * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.\n * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights\n to acquire the given type of lock.\n"]
20806 pub fn advisory_lock(
20807 &self,
20808
20809 request: impl ::fidl_next::Encode<
20810 crate::wire::AdvisoryLockRequest<'static>,
20811 <___T as ::fidl_next::Transport>::SendBuffer,
20812 >,
20813 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
20814 where
20815 <___T as ::fidl_next::Transport>::SendBuffer:
20816 ::fidl_next::encoder::InternalHandleEncoder,
20817 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
20818 {
20819 self.advisory_lock_with(crate::generic::AdvisoryLockingAdvisoryLockRequest {
20820 request,
20821 })
20822 }
20823
20824 #[doc = " Acquires an advisory lock on the underlying file.\n\n The lock lasts until either this connection is closed or\n this method is called with |AdvisoryLockType.UNLOCK| to release the lock\n explicitly.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].\n * [`Rights.WRITE_BYTES`] if `request.type` is\n [`AdvisoryLockType.WRITE`].\n\n # Errors\n\n * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For\n example, another connection might hold a conflicting lock type.\n * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.\n * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights\n to acquire the given type of lock.\n"]
20825 pub fn advisory_lock_with<___R>(
20826 &self,
20827 request: ___R,
20828 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
20829 where
20830 ___R: ::fidl_next::Encode<
20831 crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
20832 <___T as ::fidl_next::Transport>::SendBuffer,
20833 >,
20834 {
20835 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
20836 7992130864415541162,
20837 <super::AdvisoryLock as ::fidl_next::Method>::FLEXIBILITY,
20838 request,
20839 ))
20840 }
20841 }
20842
20843 #[repr(transparent)]
20845 pub struct AdvisoryLockingServer<___T: ::fidl_next::Transport> {
20846 server: ::fidl_next::protocol::Server<___T>,
20847 }
20848
20849 impl<___T> AdvisoryLockingServer<___T> where ___T: ::fidl_next::Transport {}
20850 }
20851}
20852
20853pub trait AdvisoryLockingClientHandler<
20857 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
20858 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
20859>
20860{
20861}
20862
20863impl<___T> AdvisoryLockingClientHandler<___T> for ::fidl_next::IgnoreEvents where
20864 ___T: ::fidl_next::Transport
20865{
20866}
20867
20868impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for AdvisoryLocking
20869where
20870 ___H: AdvisoryLockingClientHandler<___T> + ::core::marker::Send,
20871 ___T: ::fidl_next::Transport,
20872{
20873 async fn on_event(
20874 handler: &mut ___H,
20875 ordinal: u64,
20876 flexibility: ::fidl_next::protocol::Flexibility,
20877 body: ::fidl_next::Body<___T>,
20878 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
20879 match ordinal {
20880 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
20881 }
20882 }
20883}
20884
20885pub trait AdvisoryLockingServerHandler<
20889 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
20890 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
20891>
20892{
20893 #[doc = " Acquires an advisory lock on the underlying file.\n\n The lock lasts until either this connection is closed or\n this method is called with |AdvisoryLockType.UNLOCK| to release the lock\n explicitly.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].\n * [`Rights.WRITE_BYTES`] if `request.type` is\n [`AdvisoryLockType.WRITE`].\n\n # Errors\n\n * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For\n example, another connection might hold a conflicting lock type.\n * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.\n * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights\n to acquire the given type of lock.\n"]
20894 fn advisory_lock(
20895 &mut self,
20896
20897 request: ::fidl_next::Request<advisory_locking::AdvisoryLock, ___T>,
20898
20899 responder: ::fidl_next::Responder<advisory_locking::AdvisoryLock, ___T>,
20900 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
20901}
20902
20903impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for AdvisoryLocking
20904where
20905 ___H: AdvisoryLockingServerHandler<___T> + ::core::marker::Send,
20906 ___T: ::fidl_next::Transport,
20907 for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
20908 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20909 Constraint = (),
20910 >,
20911{
20912 async fn on_one_way(
20913 handler: &mut ___H,
20914 ordinal: u64,
20915 flexibility: ::fidl_next::protocol::Flexibility,
20916 body: ::fidl_next::Body<___T>,
20917 ) -> ::core::result::Result<
20918 (),
20919 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20920 > {
20921 match ordinal {
20922 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
20923 }
20924 }
20925
20926 async fn on_two_way(
20927 handler: &mut ___H,
20928 ordinal: u64,
20929 flexibility: ::fidl_next::protocol::Flexibility,
20930 body: ::fidl_next::Body<___T>,
20931 responder: ::fidl_next::protocol::Responder<___T>,
20932 ) -> ::core::result::Result<
20933 (),
20934 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20935 > {
20936 match ordinal {
20937 7992130864415541162 => {
20938 let responder = ::fidl_next::Responder::from_untyped(responder);
20939
20940 match ::fidl_next::AsDecoderExt::into_decoded(body) {
20941 Ok(decoded) => {
20942 handler
20943 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
20944 .await;
20945 Ok(())
20946 }
20947 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20948 ordinal: 7992130864415541162,
20949 error,
20950 }),
20951 }
20952 }
20953
20954 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
20955 }
20956 }
20957}
20958
20959pub const DIRECTORY_PROTOCOL_NAME: &str = "fuchsia.io/Directory";
20960
20961#[doc = " The maximum length, in bytes, of a filesystem path.\n"]
20962pub const MAX_PATH_LENGTH: u64 = 4095 as u64;
20963
20964#[doc = " The maximal buffer size which can be transmitted for buffered operations.\n This capacity is currently set somewhat arbitrarily.\n"]
20965pub const MAX_BUF: u64 = 8192 as u64;
20966
20967#[doc = " The maximum length, in bytes, of a single filesystem component.\n"]
20968pub const MAX_NAME_LENGTH: u64 = 255 as u64;
20969
20970#[doc = " The maximum size for an extended attribute name.\n"]
20971pub const MAX_ATTRIBUTE_NAME: u64 = 255 as u64;
20972
20973#[doc = " The maximum size for an extended attribute value to be included inline.\n Values larger than this size are passed in a vmo.\n"]
20974pub const MAX_INLINE_ATTRIBUTE_VALUE: u64 = 32768 as u64;
20975
20976#[doc = " The maximum size for passing the SELinux context as an attribute.\n"]
20977pub const MAX_SELINUX_CONTEXT_ATTRIBUTE_LEN: u64 = 256 as u64;
20978
20979#[doc = " DirectoryWatcher transmits messages from a filesystem server\n about events happening in the filesystem. Clients can register\n new watchers using the `Directory.Watch` method, where they can\n filter which events they want to receive notifications for.\n\n The DirectoryWatcher will send messages of the form:\n ```\n struct {\n uint8 event;\n uint8 len;\n char name[];\n };\n ```\n Where names are NOT null-terminated. The name is the relative\n path to the entry the event is refering to. It will be empty if\n the event isn\'t referencing a particular entry (e.g. for the\n `IDLE` event).\n"]
20981#[derive(PartialEq, Debug)]
20982pub struct DirectoryWatcher;
20983
20984#[cfg(target_os = "fuchsia")]
20985impl ::fidl_next::HasTransport for DirectoryWatcher {
20986 type Transport = ::fidl_next::fuchsia::zx::Channel;
20987}
20988
20989pub mod directory_watcher {
20990 pub mod prelude {
20991 pub use crate::{
20992 DirectoryWatcher, DirectoryWatcherClientHandler, DirectoryWatcherServerHandler,
20993 directory_watcher,
20994 };
20995 }
20996
20997 mod ___detail {
20998 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirectoryWatcher
20999 where
21000 ___T: ::fidl_next::Transport,
21001 {
21002 type Client = DirectoryWatcherClient<___T>;
21003 type Server = DirectoryWatcherServer<___T>;
21004 }
21005
21006 #[repr(transparent)]
21008 pub struct DirectoryWatcherClient<___T: ::fidl_next::Transport> {
21009 #[allow(dead_code)]
21010 client: ::fidl_next::protocol::Client<___T>,
21011 }
21012
21013 impl<___T> DirectoryWatcherClient<___T> where ___T: ::fidl_next::Transport {}
21014
21015 #[repr(transparent)]
21017 pub struct DirectoryWatcherServer<___T: ::fidl_next::Transport> {
21018 server: ::fidl_next::protocol::Server<___T>,
21019 }
21020
21021 impl<___T> DirectoryWatcherServer<___T> where ___T: ::fidl_next::Transport {}
21022 }
21023}
21024
21025pub trait DirectoryWatcherClientHandler<
21029 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
21030 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
21031>
21032{
21033}
21034
21035impl<___T> DirectoryWatcherClientHandler<___T> for ::fidl_next::IgnoreEvents where
21036 ___T: ::fidl_next::Transport
21037{
21038}
21039
21040impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirectoryWatcher
21041where
21042 ___H: DirectoryWatcherClientHandler<___T> + ::core::marker::Send,
21043 ___T: ::fidl_next::Transport,
21044{
21045 async fn on_event(
21046 handler: &mut ___H,
21047 ordinal: u64,
21048 flexibility: ::fidl_next::protocol::Flexibility,
21049 body: ::fidl_next::Body<___T>,
21050 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
21051 match ordinal {
21052 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
21053 }
21054 }
21055}
21056
21057pub trait DirectoryWatcherServerHandler<
21061 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
21062 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
21063>
21064{
21065}
21066
21067impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirectoryWatcher
21068where
21069 ___H: DirectoryWatcherServerHandler<___T> + ::core::marker::Send,
21070 ___T: ::fidl_next::Transport,
21071{
21072 async fn on_one_way(
21073 handler: &mut ___H,
21074 ordinal: u64,
21075 flexibility: ::fidl_next::protocol::Flexibility,
21076 body: ::fidl_next::Body<___T>,
21077 ) -> ::core::result::Result<
21078 (),
21079 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
21080 > {
21081 match ordinal {
21082 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
21083 }
21084 }
21085
21086 async fn on_two_way(
21087 handler: &mut ___H,
21088 ordinal: u64,
21089 flexibility: ::fidl_next::protocol::Flexibility,
21090 body: ::fidl_next::Body<___T>,
21091 responder: ::fidl_next::protocol::Responder<___T>,
21092 ) -> ::core::result::Result<
21093 (),
21094 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
21095 > {
21096 match ordinal {
21097 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
21098 }
21099 }
21100}
21101
21102#[doc = " The maximum size of a chunk in the ListExtendedAttributes iterator.\n"]
21103pub const MAX_LIST_ATTRIBUTES_CHUNK: u64 = 128 as u64;
21104
21105#[derive(PartialEq, Debug)]
21107pub struct ExtendedAttributeIterator;
21108
21109#[cfg(target_os = "fuchsia")]
21110impl ::fidl_next::HasTransport for ExtendedAttributeIterator {
21111 type Transport = ::fidl_next::fuchsia::zx::Channel;
21112}
21113
21114pub mod extended_attribute_iterator {
21115 pub mod prelude {
21116 pub use crate::{
21117 ExtendedAttributeIterator, ExtendedAttributeIteratorClientHandler,
21118 ExtendedAttributeIteratorServerHandler, extended_attribute_iterator,
21119 };
21120
21121 pub use crate::natural::ExtendedAttributeIteratorGetNextResponse;
21122 }
21123
21124 pub struct GetNext;
21125
21126 impl ::fidl_next::Method for GetNext {
21127 const ORDINAL: u64 = 268639596268373415;
21128 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
21129 ::fidl_next::protocol::Flexibility::Strict;
21130
21131 type Protocol = crate::ExtendedAttributeIterator;
21132
21133 type Request = ();
21134 }
21135
21136 impl ::fidl_next::TwoWayMethod for GetNext {
21137 type Response = ::fidl_next::wire::Result<
21138 'static,
21139 crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
21140 ::fidl_next::wire::Int32,
21141 >;
21142 }
21143
21144 impl<___R> ::fidl_next::Respond<___R> for GetNext {
21145 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
21146
21147 fn respond(response: ___R) -> Self::Output {
21148 ::core::result::Result::Ok(response)
21149 }
21150 }
21151
21152 impl<___R> ::fidl_next::RespondErr<___R> for GetNext {
21153 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
21154
21155 fn respond_err(response: ___R) -> Self::Output {
21156 ::core::result::Result::Err(response)
21157 }
21158 }
21159
21160 mod ___detail {
21161 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ExtendedAttributeIterator
21162 where
21163 ___T: ::fidl_next::Transport,
21164 {
21165 type Client = ExtendedAttributeIteratorClient<___T>;
21166 type Server = ExtendedAttributeIteratorServer<___T>;
21167 }
21168
21169 #[repr(transparent)]
21171 pub struct ExtendedAttributeIteratorClient<___T: ::fidl_next::Transport> {
21172 #[allow(dead_code)]
21173 client: ::fidl_next::protocol::Client<___T>,
21174 }
21175
21176 impl<___T> ExtendedAttributeIteratorClient<___T>
21177 where
21178 ___T: ::fidl_next::Transport,
21179 {
21180 #[doc = " Get the next chunk of extended attribute names. If this is the last\n chunk, last will be true, and the channel will be closed after the\n call.\n"]
21181 pub fn get_next(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T> {
21182 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
21183 268639596268373415,
21184 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
21185 (),
21186 ))
21187 }
21188 }
21189
21190 #[repr(transparent)]
21192 pub struct ExtendedAttributeIteratorServer<___T: ::fidl_next::Transport> {
21193 server: ::fidl_next::protocol::Server<___T>,
21194 }
21195
21196 impl<___T> ExtendedAttributeIteratorServer<___T> where ___T: ::fidl_next::Transport {}
21197 }
21198}
21199
21200pub trait ExtendedAttributeIteratorClientHandler<
21204 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
21205 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
21206>
21207{
21208}
21209
21210impl<___T> ExtendedAttributeIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents where
21211 ___T: ::fidl_next::Transport
21212{
21213}
21214
21215impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ExtendedAttributeIterator
21216where
21217 ___H: ExtendedAttributeIteratorClientHandler<___T> + ::core::marker::Send,
21218 ___T: ::fidl_next::Transport,
21219{
21220 async fn on_event(
21221 handler: &mut ___H,
21222 ordinal: u64,
21223 flexibility: ::fidl_next::protocol::Flexibility,
21224 body: ::fidl_next::Body<___T>,
21225 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
21226 match ordinal {
21227 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
21228 }
21229 }
21230}
21231
21232pub trait ExtendedAttributeIteratorServerHandler<
21236 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
21237 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
21238>
21239{
21240 #[doc = " Get the next chunk of extended attribute names. If this is the last\n chunk, last will be true, and the channel will be closed after the\n call.\n"]
21241 fn get_next(
21242 &mut self,
21243
21244 responder: ::fidl_next::Responder<extended_attribute_iterator::GetNext, ___T>,
21245 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
21246}
21247
21248impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ExtendedAttributeIterator
21249where
21250 ___H: ExtendedAttributeIteratorServerHandler<___T> + ::core::marker::Send,
21251 ___T: ::fidl_next::Transport,
21252{
21253 async fn on_one_way(
21254 handler: &mut ___H,
21255 ordinal: u64,
21256 flexibility: ::fidl_next::protocol::Flexibility,
21257 body: ::fidl_next::Body<___T>,
21258 ) -> ::core::result::Result<
21259 (),
21260 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
21261 > {
21262 match ordinal {
21263 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
21264 }
21265 }
21266
21267 async fn on_two_way(
21268 handler: &mut ___H,
21269 ordinal: u64,
21270 flexibility: ::fidl_next::protocol::Flexibility,
21271 body: ::fidl_next::Body<___T>,
21272 responder: ::fidl_next::protocol::Responder<___T>,
21273 ) -> ::core::result::Result<
21274 (),
21275 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
21276 > {
21277 match ordinal {
21278 268639596268373415 => {
21279 let responder = ::fidl_next::Responder::from_untyped(responder);
21280
21281 handler.get_next(responder).await;
21282 Ok(())
21283 }
21284
21285 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
21286 }
21287 }
21288}
21289
21290pub const FILE_PROTOCOL_NAME: &str = "fuchsia.io/File";
21291
21292#[doc = " Specifies that this object is not linkable. This is only intended to be used in the context of\n creating a temporary unnamed objects. When that is not the case, the node protocol defines if it\n is linkable (i.e. if it composes the `Linkable` protocol). When this flag is set along with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`, an unnamed temporary object will be created that\n cannot be linked into the filesystem. This would be similar to Linux `O_TMPFILE | O_EXCL`.\n\n CAUTION: if `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY` is not specified, then this is treated as\n a \"must create\" flag.\n\n The reason for overloading `Flags.FLAG_MUST_CREATE` to mean \"not linkable\" in this context and\n \"must create\" in other contexts is due to the assumption that some POSIX flags are compatible\n with the members in `Flags`. In particular the POSIX `O_EXCL` has the same value as\n `Flags.FLAG_MUST_CREATE`. We are not able to define different bit members of the same value,\n hence it is defined separately outside of `Flags`.\n"]
21293pub const FLAG_TEMPORARY_AS_NOT_LINKABLE: crate::natural::Flags =
21294 crate::natural::Flags::FLAG_MUST_CREATE;
21295
21296#[doc = " The maximum I/O size that is allowed for read/write operations using\n byte vectors.\n"]
21297pub const MAX_TRANSFER_SIZE: u64 = 8192 as u64;
21298
21299#[derive(PartialEq, Debug)]
21301pub struct Readable;
21302
21303#[cfg(target_os = "fuchsia")]
21304impl ::fidl_next::HasTransport for Readable {
21305 type Transport = ::fidl_next::fuchsia::zx::Channel;
21306}
21307
21308pub mod readable {
21309 pub mod prelude {
21310 pub use crate::{Readable, ReadableClientHandler, ReadableServerHandler, readable};
21311
21312 pub use crate::natural::ReadableReadRequest;
21313
21314 pub use crate::natural::ReadableReadResponse;
21315 }
21316
21317 pub struct Read;
21318
21319 impl ::fidl_next::Method for Read {
21320 const ORDINAL: u64 = 395825947633028830;
21321 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
21322 ::fidl_next::protocol::Flexibility::Strict;
21323
21324 type Protocol = crate::Readable;
21325
21326 type Request = crate::wire::ReadableReadRequest;
21327 }
21328
21329 impl ::fidl_next::TwoWayMethod for Read {
21330 type Response = ::fidl_next::wire::Result<
21331 'static,
21332 crate::wire::ReadableReadResponse<'static>,
21333 ::fidl_next::wire::Int32,
21334 >;
21335 }
21336
21337 impl<___R> ::fidl_next::Respond<___R> for Read {
21338 type Output = ::core::result::Result<
21339 crate::generic::ReadableReadResponse<___R>,
21340 ::fidl_next::util::Never,
21341 >;
21342
21343 fn respond(response: ___R) -> Self::Output {
21344 ::core::result::Result::Ok(crate::generic::ReadableReadResponse { data: response })
21345 }
21346 }
21347
21348 impl<___R> ::fidl_next::RespondErr<___R> for Read {
21349 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
21350
21351 fn respond_err(response: ___R) -> Self::Output {
21352 ::core::result::Result::Err(response)
21353 }
21354 }
21355
21356 mod ___detail {
21357 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Readable
21358 where
21359 ___T: ::fidl_next::Transport,
21360 {
21361 type Client = ReadableClient<___T>;
21362 type Server = ReadableServer<___T>;
21363 }
21364
21365 #[repr(transparent)]
21367 pub struct ReadableClient<___T: ::fidl_next::Transport> {
21368 #[allow(dead_code)]
21369 client: ::fidl_next::protocol::Client<___T>,
21370 }
21371
21372 impl<___T> ReadableClient<___T>
21373 where
21374 ___T: ::fidl_next::Transport,
21375 {
21376 #[doc = " Reads up to \'count\' bytes at the seek offset.\n The seek offset is moved forward by the number of bytes read.\n\n ## Invariants\n\n * The returned `data.length` will never be greater than `count`.\n * If `data.length` is less than `count`, it means that the seek offset\n has reached the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that the\n seek offset is already at or beyond the end of file, and no data could\n be read.\n * If `count` is zero, the server should perform all the checks ensuring\n read access without actually read anything, and return an empty\n `data` vector.\n\n This method requires the [`Rights.READ_BYTES`] right.\n\n Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.\n"]
21377 pub fn read(
21378 &self,
21379
21380 count: impl ::fidl_next::Encode<
21381 ::fidl_next::wire::Uint64,
21382 <___T as ::fidl_next::Transport>::SendBuffer,
21383 >,
21384 ) -> ::fidl_next::TwoWayFuture<'_, super::Read, ___T>
21385 where
21386 <___T as ::fidl_next::Transport>::SendBuffer:
21387 ::fidl_next::encoder::InternalHandleEncoder,
21388 {
21389 self.read_with(crate::generic::ReadableReadRequest { count })
21390 }
21391
21392 #[doc = " Reads up to \'count\' bytes at the seek offset.\n The seek offset is moved forward by the number of bytes read.\n\n ## Invariants\n\n * The returned `data.length` will never be greater than `count`.\n * If `data.length` is less than `count`, it means that the seek offset\n has reached the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that the\n seek offset is already at or beyond the end of file, and no data could\n be read.\n * If `count` is zero, the server should perform all the checks ensuring\n read access without actually read anything, and return an empty\n `data` vector.\n\n This method requires the [`Rights.READ_BYTES`] right.\n\n Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.\n"]
21393 pub fn read_with<___R>(
21394 &self,
21395 request: ___R,
21396 ) -> ::fidl_next::TwoWayFuture<'_, super::Read, ___T>
21397 where
21398 ___R: ::fidl_next::Encode<
21399 crate::wire::ReadableReadRequest,
21400 <___T as ::fidl_next::Transport>::SendBuffer,
21401 >,
21402 {
21403 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
21404 395825947633028830,
21405 <super::Read as ::fidl_next::Method>::FLEXIBILITY,
21406 request,
21407 ))
21408 }
21409 }
21410
21411 #[repr(transparent)]
21413 pub struct ReadableServer<___T: ::fidl_next::Transport> {
21414 server: ::fidl_next::protocol::Server<___T>,
21415 }
21416
21417 impl<___T> ReadableServer<___T> where ___T: ::fidl_next::Transport {}
21418 }
21419}
21420
21421pub trait ReadableClientHandler<
21425 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
21426 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
21427>
21428{
21429}
21430
21431impl<___T> ReadableClientHandler<___T> for ::fidl_next::IgnoreEvents where
21432 ___T: ::fidl_next::Transport
21433{
21434}
21435
21436impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Readable
21437where
21438 ___H: ReadableClientHandler<___T> + ::core::marker::Send,
21439 ___T: ::fidl_next::Transport,
21440{
21441 async fn on_event(
21442 handler: &mut ___H,
21443 ordinal: u64,
21444 flexibility: ::fidl_next::protocol::Flexibility,
21445 body: ::fidl_next::Body<___T>,
21446 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
21447 match ordinal {
21448 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
21449 }
21450 }
21451}
21452
21453pub trait ReadableServerHandler<
21457 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
21458 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
21459>
21460{
21461 #[doc = " Reads up to \'count\' bytes at the seek offset.\n The seek offset is moved forward by the number of bytes read.\n\n ## Invariants\n\n * The returned `data.length` will never be greater than `count`.\n * If `data.length` is less than `count`, it means that the seek offset\n has reached the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that the\n seek offset is already at or beyond the end of file, and no data could\n be read.\n * If `count` is zero, the server should perform all the checks ensuring\n read access without actually read anything, and return an empty\n `data` vector.\n\n This method requires the [`Rights.READ_BYTES`] right.\n\n Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.\n"]
21462 fn read(
21463 &mut self,
21464
21465 request: ::fidl_next::Request<readable::Read, ___T>,
21466
21467 responder: ::fidl_next::Responder<readable::Read, ___T>,
21468 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
21469}
21470
21471impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Readable
21472where
21473 ___H: ReadableServerHandler<___T> + ::core::marker::Send,
21474 ___T: ::fidl_next::Transport,
21475 for<'de> crate::wire::ReadableReadRequest: ::fidl_next::Decode<
21476 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
21477 Constraint = (),
21478 >,
21479{
21480 async fn on_one_way(
21481 handler: &mut ___H,
21482 ordinal: u64,
21483 flexibility: ::fidl_next::protocol::Flexibility,
21484 body: ::fidl_next::Body<___T>,
21485 ) -> ::core::result::Result<
21486 (),
21487 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
21488 > {
21489 match ordinal {
21490 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
21491 }
21492 }
21493
21494 async fn on_two_way(
21495 handler: &mut ___H,
21496 ordinal: u64,
21497 flexibility: ::fidl_next::protocol::Flexibility,
21498 body: ::fidl_next::Body<___T>,
21499 responder: ::fidl_next::protocol::Responder<___T>,
21500 ) -> ::core::result::Result<
21501 (),
21502 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
21503 > {
21504 match ordinal {
21505 395825947633028830 => {
21506 let responder = ::fidl_next::Responder::from_untyped(responder);
21507
21508 match ::fidl_next::AsDecoderExt::into_decoded(body) {
21509 Ok(decoded) => {
21510 handler.read(::fidl_next::Request::from_decoded(decoded), responder).await;
21511 Ok(())
21512 }
21513 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
21514 ordinal: 395825947633028830,
21515 error,
21516 }),
21517 }
21518 }
21519
21520 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
21521 }
21522 }
21523}
21524
21525#[derive(PartialEq, Debug)]
21527pub struct Writable;
21528
21529#[cfg(target_os = "fuchsia")]
21530impl ::fidl_next::HasTransport for Writable {
21531 type Transport = ::fidl_next::fuchsia::zx::Channel;
21532}
21533
21534pub mod writable {
21535 pub mod prelude {
21536 pub use crate::{Writable, WritableClientHandler, WritableServerHandler, writable};
21537
21538 pub use crate::natural::WritableWriteRequest;
21539
21540 pub use crate::natural::WritableWriteResponse;
21541 }
21542
21543 pub struct Write;
21544
21545 impl ::fidl_next::Method for Write {
21546 const ORDINAL: u64 = 7651971425397809026;
21547 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
21548 ::fidl_next::protocol::Flexibility::Strict;
21549
21550 type Protocol = crate::Writable;
21551
21552 type Request = crate::wire::WritableWriteRequest<'static>;
21553 }
21554
21555 impl ::fidl_next::TwoWayMethod for Write {
21556 type Response = ::fidl_next::wire::Result<
21557 'static,
21558 crate::wire::WritableWriteResponse,
21559 ::fidl_next::wire::Int32,
21560 >;
21561 }
21562
21563 impl<___R> ::fidl_next::Respond<___R> for Write {
21564 type Output = ::core::result::Result<
21565 crate::generic::WritableWriteResponse<___R>,
21566 ::fidl_next::util::Never,
21567 >;
21568
21569 fn respond(response: ___R) -> Self::Output {
21570 ::core::result::Result::Ok(crate::generic::WritableWriteResponse {
21571 actual_count: response,
21572 })
21573 }
21574 }
21575
21576 impl<___R> ::fidl_next::RespondErr<___R> for Write {
21577 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
21578
21579 fn respond_err(response: ___R) -> Self::Output {
21580 ::core::result::Result::Err(response)
21581 }
21582 }
21583
21584 mod ___detail {
21585 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Writable
21586 where
21587 ___T: ::fidl_next::Transport,
21588 {
21589 type Client = WritableClient<___T>;
21590 type Server = WritableServer<___T>;
21591 }
21592
21593 #[repr(transparent)]
21595 pub struct WritableClient<___T: ::fidl_next::Transport> {
21596 #[allow(dead_code)]
21597 client: ::fidl_next::protocol::Client<___T>,
21598 }
21599
21600 impl<___T> WritableClient<___T>
21601 where
21602 ___T: ::fidl_next::Transport,
21603 {
21604 #[doc = " Writes data at the seek offset.\n The seek offset is moved forward by the number of bytes written.\n If the file is in append mode, the seek offset is first set to the end\n of the file, followed by the write, in one atomic step.\n\n The file size may grow if the seek offset plus `data.length` is beyond\n the current end of file.\n\n + request `data` the byte buffer to write to the file.\n - response `actual_count` the number of bytes written.\n\n ## Invariants\n\n * The returned `actual_count` will never be greater than `data.length`.\n * If the server is unable to write all the data due to e.g. not enough\n space, `actual_count` may be less than `data.length`. If no bytes\n could be written, an error is returned.\n * If `data.length` is zero, the server should perform all the checks\n ensuring write access without mutating the file and return a\n successful write of zero bytes. The seek offset is still updated if\n in append mode.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
21605 pub fn write(
21606 &self,
21607
21608 data: impl ::fidl_next::Encode<
21609 ::fidl_next::wire::Vector<'static, u8>,
21610 <___T as ::fidl_next::Transport>::SendBuffer,
21611 >,
21612 ) -> ::fidl_next::TwoWayFuture<'_, super::Write, ___T>
21613 where
21614 <___T as ::fidl_next::Transport>::SendBuffer:
21615 ::fidl_next::encoder::InternalHandleEncoder,
21616 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
21617 {
21618 self.write_with(crate::generic::WritableWriteRequest { data })
21619 }
21620
21621 #[doc = " Writes data at the seek offset.\n The seek offset is moved forward by the number of bytes written.\n If the file is in append mode, the seek offset is first set to the end\n of the file, followed by the write, in one atomic step.\n\n The file size may grow if the seek offset plus `data.length` is beyond\n the current end of file.\n\n + request `data` the byte buffer to write to the file.\n - response `actual_count` the number of bytes written.\n\n ## Invariants\n\n * The returned `actual_count` will never be greater than `data.length`.\n * If the server is unable to write all the data due to e.g. not enough\n space, `actual_count` may be less than `data.length`. If no bytes\n could be written, an error is returned.\n * If `data.length` is zero, the server should perform all the checks\n ensuring write access without mutating the file and return a\n successful write of zero bytes. The seek offset is still updated if\n in append mode.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
21622 pub fn write_with<___R>(
21623 &self,
21624 request: ___R,
21625 ) -> ::fidl_next::TwoWayFuture<'_, super::Write, ___T>
21626 where
21627 ___R: ::fidl_next::Encode<
21628 crate::wire::WritableWriteRequest<'static>,
21629 <___T as ::fidl_next::Transport>::SendBuffer,
21630 >,
21631 {
21632 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
21633 7651971425397809026,
21634 <super::Write as ::fidl_next::Method>::FLEXIBILITY,
21635 request,
21636 ))
21637 }
21638 }
21639
21640 #[repr(transparent)]
21642 pub struct WritableServer<___T: ::fidl_next::Transport> {
21643 server: ::fidl_next::protocol::Server<___T>,
21644 }
21645
21646 impl<___T> WritableServer<___T> where ___T: ::fidl_next::Transport {}
21647 }
21648}
21649
21650pub trait WritableClientHandler<
21654 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
21655 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
21656>
21657{
21658}
21659
21660impl<___T> WritableClientHandler<___T> for ::fidl_next::IgnoreEvents where
21661 ___T: ::fidl_next::Transport
21662{
21663}
21664
21665impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Writable
21666where
21667 ___H: WritableClientHandler<___T> + ::core::marker::Send,
21668 ___T: ::fidl_next::Transport,
21669{
21670 async fn on_event(
21671 handler: &mut ___H,
21672 ordinal: u64,
21673 flexibility: ::fidl_next::protocol::Flexibility,
21674 body: ::fidl_next::Body<___T>,
21675 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
21676 match ordinal {
21677 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
21678 }
21679 }
21680}
21681
21682pub trait WritableServerHandler<
21686 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
21687 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
21688>
21689{
21690 #[doc = " Writes data at the seek offset.\n The seek offset is moved forward by the number of bytes written.\n If the file is in append mode, the seek offset is first set to the end\n of the file, followed by the write, in one atomic step.\n\n The file size may grow if the seek offset plus `data.length` is beyond\n the current end of file.\n\n + request `data` the byte buffer to write to the file.\n - response `actual_count` the number of bytes written.\n\n ## Invariants\n\n * The returned `actual_count` will never be greater than `data.length`.\n * If the server is unable to write all the data due to e.g. not enough\n space, `actual_count` may be less than `data.length`. If no bytes\n could be written, an error is returned.\n * If `data.length` is zero, the server should perform all the checks\n ensuring write access without mutating the file and return a\n successful write of zero bytes. The seek offset is still updated if\n in append mode.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
21691 fn write(
21692 &mut self,
21693
21694 request: ::fidl_next::Request<writable::Write, ___T>,
21695
21696 responder: ::fidl_next::Responder<writable::Write, ___T>,
21697 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
21698}
21699
21700impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Writable
21701where
21702 ___H: WritableServerHandler<___T> + ::core::marker::Send,
21703 ___T: ::fidl_next::Transport,
21704 for<'de> crate::wire::WritableWriteRequest<'de>: ::fidl_next::Decode<
21705 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
21706 Constraint = (),
21707 >,
21708{
21709 async fn on_one_way(
21710 handler: &mut ___H,
21711 ordinal: u64,
21712 flexibility: ::fidl_next::protocol::Flexibility,
21713 body: ::fidl_next::Body<___T>,
21714 ) -> ::core::result::Result<
21715 (),
21716 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
21717 > {
21718 match ordinal {
21719 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
21720 }
21721 }
21722
21723 async fn on_two_way(
21724 handler: &mut ___H,
21725 ordinal: u64,
21726 flexibility: ::fidl_next::protocol::Flexibility,
21727 body: ::fidl_next::Body<___T>,
21728 responder: ::fidl_next::protocol::Responder<___T>,
21729 ) -> ::core::result::Result<
21730 (),
21731 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
21732 > {
21733 match ordinal {
21734 7651971425397809026 => {
21735 let responder = ::fidl_next::Responder::from_untyped(responder);
21736
21737 match ::fidl_next::AsDecoderExt::into_decoded(body) {
21738 Ok(decoded) => {
21739 handler.write(::fidl_next::Request::from_decoded(decoded), responder).await;
21740 Ok(())
21741 }
21742 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
21743 ordinal: 7651971425397809026,
21744 error,
21745 }),
21746 }
21747 }
21748
21749 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
21750 }
21751 }
21752}
21753
21754pub const MAX_FS_NAME_BUFFER: u64 = 32 as u64;
21755
21756#[doc = " Set of rights that [`Flags.PERM_INHERIT_WRITE`] will inherit from the parent connection if\n specified. Note that if any of these permissions are missing from the connection, none of these\n permissions will be inherited.\n"]
21757pub const INHERITED_WRITE_PERMISSIONS: crate::natural::Operations =
21758 crate::natural::Operations::from_bits_retain(356);
21759
21760#[doc = " Nodes which do not have ino values should return this value\n from Readdir and GetAttr.\n"]
21761pub const INO_UNKNOWN: u64 = 18446744073709551615 as u64;
21762
21763pub const MASK_KNOWN_PERMISSIONS: crate::natural::Flags =
21764 crate::natural::Flags::from_bits_retain(25087);
21765
21766pub const MASK_KNOWN_PROTOCOLS: crate::natural::Flags =
21767 crate::natural::Flags::from_bits_retain(30069489664);
21768
21769pub const MASK_PERMISSION_FLAGS: u64 = 65535 as u64;
21770
21771pub const MASK_POSIX_FLAGS: u64 = 4294967295 as u64;
21772
21773#[doc = " The maximum length, in bytes, of a single filesystem component.\n"]
21774pub const MAX_FILENAME: u64 = 255 as u64;
21775
21776pub const NODE_PROTOCOL_NAME: &str = "fuchsia.io/Node";
21777
21778#[doc = " Flags used when opening a node reference must fall within this mask.\n"]
21779pub const OPEN_FLAGS_ALLOWED_WITH_NODE_REFERENCE: crate::natural::OpenFlags =
21780 crate::natural::OpenFlags::from_bits_retain(46661632);
21781
21782#[doc = " All known rights.\n"]
21783pub const OPEN_RIGHTS: crate::natural::OpenFlags = crate::natural::OpenFlags::from_bits_retain(11);
21784
21785#[doc = " Set of permissions that are expected when opening a node as executable.\n"]
21786pub const PERM_EXECUTABLE: crate::natural::Flags = crate::natural::Flags::from_bits_retain(201);
21787
21788#[doc = " Set of permissions that are expected when opening a node as readable.\n"]
21789pub const PERM_READABLE: crate::natural::Flags = crate::natural::Flags::from_bits_retain(211);
21790
21791#[doc = " Set of permissions that are expected when opening a node as writable.\n"]
21792pub const PERM_WRITABLE: crate::natural::Flags = crate::natural::Flags::from_bits_retain(485);
21793
21794#[doc = " Alias for directory permission alias rw*\n"]
21795pub const RW_STAR_DIR: crate::natural::Operations =
21796 crate::natural::Operations::from_bits_retain(503);
21797
21798#[doc = " Alias for directory permission alias rx*\n"]
21799pub const RX_STAR_DIR: crate::natural::Operations =
21800 crate::natural::Operations::from_bits_retain(219);
21801
21802#[doc = " Alias for directory permission alias r*\n"]
21803pub const R_STAR_DIR: crate::natural::Operations =
21804 crate::natural::Operations::from_bits_retain(211);
21805
21806#[doc = " The name of the extended attribute accessible via the SELinux context attribute.\n"]
21807pub const SELINUX_CONTEXT_NAME: &str = "security.selinux";
21808
21809pub const SYMLINK_PROTOCOL_NAME: &str = "fuchsia.io/Symlink";
21810
21811#[doc = " Alias for directory permission alias w*\n"]
21812pub const W_STAR_DIR: crate::natural::Operations =
21813 crate::natural::Operations::from_bits_retain(485);
21814
21815#[doc = " Alias for directory permission alias x*\n"]
21816pub const X_STAR_DIR: crate::natural::Operations =
21817 crate::natural::Operations::from_bits_retain(201);
21818
21819pub mod compat {
21821
21822 impl ::fidl_next::CompatFrom<crate::Operations> for ::fidl_fuchsia_io::Operations {
21823 fn compat_from(value: crate::Operations) -> Self {
21824 Self::from_bits_retain(value.bits())
21825 }
21826 }
21827
21828 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::Operations> for crate::Operations {
21829 fn compat_from(value: ::fidl_fuchsia_io::Operations) -> Self {
21830 Self::from_bits_retain(value.bits())
21831 }
21832 }
21833
21834 impl ::fidl_next::CompatFrom<crate::SeekOrigin> for ::fidl_fuchsia_io::SeekOrigin {
21835 fn compat_from(value: crate::SeekOrigin) -> Self {
21836 match value {
21837 crate::SeekOrigin::Start => Self::Start,
21838
21839 crate::SeekOrigin::Current => Self::Current,
21840
21841 crate::SeekOrigin::End => Self::End,
21842 }
21843 }
21844 }
21845
21846 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::SeekOrigin> for crate::SeekOrigin {
21847 fn compat_from(value: ::fidl_fuchsia_io::SeekOrigin) -> Self {
21848 match value {
21849 ::fidl_fuchsia_io::SeekOrigin::Start => Self::Start,
21850
21851 ::fidl_fuchsia_io::SeekOrigin::Current => Self::Current,
21852
21853 ::fidl_fuchsia_io::SeekOrigin::End => Self::End,
21854 }
21855 }
21856 }
21857
21858 impl ::fidl_next::CompatFrom<crate::AdvisoryLockRange> for ::fidl_fuchsia_io::AdvisoryLockRange {
21859 #[inline]
21860 fn compat_from(value: crate::AdvisoryLockRange) -> Self {
21861 Self {
21862 origin: ::fidl_next::CompatFrom::compat_from(value.origin),
21863
21864 offset: ::fidl_next::CompatFrom::compat_from(value.offset),
21865
21866 length: ::fidl_next::CompatFrom::compat_from(value.length),
21867 }
21868 }
21869 }
21870
21871 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::AdvisoryLockRange> for crate::AdvisoryLockRange {
21872 #[inline]
21873 fn compat_from(value: ::fidl_fuchsia_io::AdvisoryLockRange) -> Self {
21874 Self {
21875 origin: ::fidl_next::CompatFrom::compat_from(value.origin),
21876
21877 offset: ::fidl_next::CompatFrom::compat_from(value.offset),
21878
21879 length: ::fidl_next::CompatFrom::compat_from(value.length),
21880 }
21881 }
21882 }
21883
21884 impl ::fidl_next::CompatFrom<crate::AdvisoryLockType> for ::fidl_fuchsia_io::AdvisoryLockType {
21885 fn compat_from(value: crate::AdvisoryLockType) -> Self {
21886 match value {
21887 crate::AdvisoryLockType::Read => Self::Read,
21888
21889 crate::AdvisoryLockType::Write => Self::Write,
21890
21891 crate::AdvisoryLockType::Unlock => Self::Unlock,
21892 }
21893 }
21894 }
21895
21896 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::AdvisoryLockType> for crate::AdvisoryLockType {
21897 fn compat_from(value: ::fidl_fuchsia_io::AdvisoryLockType) -> Self {
21898 match value {
21899 ::fidl_fuchsia_io::AdvisoryLockType::Read => Self::Read,
21900
21901 ::fidl_fuchsia_io::AdvisoryLockType::Write => Self::Write,
21902
21903 ::fidl_fuchsia_io::AdvisoryLockType::Unlock => Self::Unlock,
21904 }
21905 }
21906 }
21907
21908 impl ::fidl_next::CompatFrom<crate::AdvisoryLockRequest>
21909 for ::fidl_fuchsia_io::AdvisoryLockRequest
21910 {
21911 fn compat_from(value: crate::AdvisoryLockRequest) -> Self {
21912 Self {
21913 type_: ::fidl_next::CompatFrom::compat_from(value.type_),
21914
21915 range: ::fidl_next::CompatFrom::compat_from(value.range),
21916
21917 wait: ::fidl_next::CompatFrom::compat_from(value.wait),
21918
21919 __source_breaking: ::fidl::marker::SourceBreaking,
21920 }
21921 }
21922 }
21923
21924 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::AdvisoryLockRequest>
21925 for crate::AdvisoryLockRequest
21926 {
21927 fn compat_from(value: ::fidl_fuchsia_io::AdvisoryLockRequest) -> Self {
21928 Self {
21929 type_: ::fidl_next::CompatFrom::compat_from(value.type_),
21930
21931 range: ::fidl_next::CompatFrom::compat_from(value.range),
21932
21933 wait: ::fidl_next::CompatFrom::compat_from(value.wait),
21934 }
21935 }
21936 }
21937
21938 impl ::fidl_next::CompatFrom<crate::AdvisoryLockingAdvisoryLockRequest>
21939 for ::fidl_fuchsia_io::AdvisoryLockingAdvisoryLockRequest
21940 {
21941 #[inline]
21942 fn compat_from(value: crate::AdvisoryLockingAdvisoryLockRequest) -> Self {
21943 Self { request: ::fidl_next::CompatFrom::compat_from(value.request) }
21944 }
21945 }
21946
21947 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::AdvisoryLockingAdvisoryLockRequest>
21948 for crate::AdvisoryLockingAdvisoryLockRequest
21949 {
21950 #[inline]
21951 fn compat_from(value: ::fidl_fuchsia_io::AdvisoryLockingAdvisoryLockRequest) -> Self {
21952 Self { request: ::fidl_next::CompatFrom::compat_from(value.request) }
21953 }
21954 }
21955
21956 #[cfg(target_os = "fuchsia")]
21957 pub type AdvisoryLockingProxy = ::fidl_next::Client<crate::AdvisoryLocking>;
21960
21961 impl ::fidl_next::CompatFrom<crate::AdvisoryLocking> for ::fidl_fuchsia_io::AdvisoryLockingMarker {
21962 fn compat_from(_: crate::AdvisoryLocking) -> Self {
21963 Self
21964 }
21965 }
21966
21967 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::AdvisoryLockingMarker> for crate::AdvisoryLocking {
21968 fn compat_from(_: ::fidl_fuchsia_io::AdvisoryLockingMarker) -> Self {
21969 Self
21970 }
21971 }
21972
21973 #[cfg(target_os = "fuchsia")]
21974
21975 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_io::AdvisoryLockingProxy>
21976 for crate::AdvisoryLocking
21977 {
21978 fn client_compat_from(
21979 proxy: ::fidl_fuchsia_io::AdvisoryLockingProxy,
21980 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
21981 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
21982 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
21983 ::fidl_next::ClientDispatcher::new(client_end)
21984 }
21985 }
21986
21987 impl ::fidl_next::CompatFrom<crate::AllocateMode> for ::fidl_fuchsia_io::AllocateMode {
21988 fn compat_from(value: crate::AllocateMode) -> Self {
21989 Self::from_bits_retain(value.bits())
21990 }
21991 }
21992
21993 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::AllocateMode> for crate::AllocateMode {
21994 fn compat_from(value: ::fidl_fuchsia_io::AllocateMode) -> Self {
21995 Self::from_bits_retain(value.bits())
21996 }
21997 }
21998
21999 impl ::fidl_next::CompatFrom<crate::OpenFlags> for ::fidl_fuchsia_io::OpenFlags {
22000 fn compat_from(value: crate::OpenFlags) -> Self {
22001 Self::from_bits_retain(value.bits())
22002 }
22003 }
22004
22005 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::OpenFlags> for crate::OpenFlags {
22006 fn compat_from(value: ::fidl_fuchsia_io::OpenFlags) -> Self {
22007 Self::from_bits_retain(value.bits())
22008 }
22009 }
22010
22011 impl ::fidl_next::CompatFrom<crate::NodeAttributes> for ::fidl_fuchsia_io::NodeAttributes {
22012 #[inline]
22013 fn compat_from(value: crate::NodeAttributes) -> Self {
22014 Self {
22015 mode: ::fidl_next::CompatFrom::compat_from(value.mode),
22016
22017 id: ::fidl_next::CompatFrom::compat_from(value.id),
22018
22019 content_size: ::fidl_next::CompatFrom::compat_from(value.content_size),
22020
22021 storage_size: ::fidl_next::CompatFrom::compat_from(value.storage_size),
22022
22023 link_count: ::fidl_next::CompatFrom::compat_from(value.link_count),
22024
22025 creation_time: ::fidl_next::CompatFrom::compat_from(value.creation_time),
22026
22027 modification_time: ::fidl_next::CompatFrom::compat_from(value.modification_time),
22028 }
22029 }
22030 }
22031
22032 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeAttributes> for crate::NodeAttributes {
22033 #[inline]
22034 fn compat_from(value: ::fidl_fuchsia_io::NodeAttributes) -> Self {
22035 Self {
22036 mode: ::fidl_next::CompatFrom::compat_from(value.mode),
22037
22038 id: ::fidl_next::CompatFrom::compat_from(value.id),
22039
22040 content_size: ::fidl_next::CompatFrom::compat_from(value.content_size),
22041
22042 storage_size: ::fidl_next::CompatFrom::compat_from(value.storage_size),
22043
22044 link_count: ::fidl_next::CompatFrom::compat_from(value.link_count),
22045
22046 creation_time: ::fidl_next::CompatFrom::compat_from(value.creation_time),
22047
22048 modification_time: ::fidl_next::CompatFrom::compat_from(value.modification_time),
22049 }
22050 }
22051 }
22052
22053 impl ::fidl_next::CompatFrom<crate::NodeAttributeFlags> for ::fidl_fuchsia_io::NodeAttributeFlags {
22054 fn compat_from(value: crate::NodeAttributeFlags) -> Self {
22055 Self::from_bits_retain(value.bits())
22056 }
22057 }
22058
22059 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeAttributeFlags> for crate::NodeAttributeFlags {
22060 fn compat_from(value: ::fidl_fuchsia_io::NodeAttributeFlags) -> Self {
22061 Self::from_bits_retain(value.bits())
22062 }
22063 }
22064
22065 impl ::fidl_next::CompatFrom<crate::NodeQueryFilesystemResponse>
22066 for ::fidl_fuchsia_io::NodeQueryFilesystemResponse
22067 {
22068 #[inline]
22069 fn compat_from(value: crate::NodeQueryFilesystemResponse) -> Self {
22070 Self {
22071 s: ::fidl_next::CompatFrom::compat_from(value.s),
22072
22073 info: ::fidl_next::CompatFrom::compat_from(value.info),
22074 }
22075 }
22076 }
22077
22078 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeQueryFilesystemResponse>
22079 for crate::NodeQueryFilesystemResponse
22080 {
22081 #[inline]
22082 fn compat_from(value: ::fidl_fuchsia_io::NodeQueryFilesystemResponse) -> Self {
22083 Self {
22084 s: ::fidl_next::CompatFrom::compat_from(value.s),
22085
22086 info: ::fidl_next::CompatFrom::compat_from(value.info),
22087 }
22088 }
22089 }
22090
22091 impl ::fidl_next::CompatFrom<crate::ModeType> for ::fidl_fuchsia_io::ModeType {
22092 fn compat_from(value: crate::ModeType) -> Self {
22093 Self::from_bits_retain(value.bits())
22094 }
22095 }
22096
22097 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::ModeType> for crate::ModeType {
22098 fn compat_from(value: ::fidl_fuchsia_io::ModeType) -> Self {
22099 Self::from_bits_retain(value.bits())
22100 }
22101 }
22102
22103 impl ::fidl_next::CompatFrom<crate::DirectoryReadDirentsRequest>
22104 for ::fidl_fuchsia_io::DirectoryReadDirentsRequest
22105 {
22106 #[inline]
22107 fn compat_from(value: crate::DirectoryReadDirentsRequest) -> Self {
22108 Self { max_bytes: ::fidl_next::CompatFrom::compat_from(value.max_bytes) }
22109 }
22110 }
22111
22112 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::DirectoryReadDirentsRequest>
22113 for crate::DirectoryReadDirentsRequest
22114 {
22115 #[inline]
22116 fn compat_from(value: ::fidl_fuchsia_io::DirectoryReadDirentsRequest) -> Self {
22117 Self { max_bytes: ::fidl_next::CompatFrom::compat_from(value.max_bytes) }
22118 }
22119 }
22120
22121 impl ::fidl_next::CompatFrom<crate::DirectoryReadDirentsResponse>
22122 for ::fidl_fuchsia_io::DirectoryReadDirentsResponse
22123 {
22124 #[inline]
22125 fn compat_from(value: crate::DirectoryReadDirentsResponse) -> Self {
22126 Self {
22127 s: ::fidl_next::CompatFrom::compat_from(value.s),
22128
22129 dirents: ::fidl_next::CompatFrom::compat_from(value.dirents),
22130 }
22131 }
22132 }
22133
22134 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::DirectoryReadDirentsResponse>
22135 for crate::DirectoryReadDirentsResponse
22136 {
22137 #[inline]
22138 fn compat_from(value: ::fidl_fuchsia_io::DirectoryReadDirentsResponse) -> Self {
22139 Self {
22140 s: ::fidl_next::CompatFrom::compat_from(value.s),
22141
22142 dirents: ::fidl_next::CompatFrom::compat_from(value.dirents),
22143 }
22144 }
22145 }
22146
22147 impl ::fidl_next::CompatFrom<crate::DirectoryRewindResponse>
22148 for ::fidl_fuchsia_io::DirectoryRewindResponse
22149 {
22150 #[inline]
22151 fn compat_from(value: crate::DirectoryRewindResponse) -> Self {
22152 Self { s: ::fidl_next::CompatFrom::compat_from(value.s) }
22153 }
22154 }
22155
22156 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::DirectoryRewindResponse>
22157 for crate::DirectoryRewindResponse
22158 {
22159 #[inline]
22160 fn compat_from(value: ::fidl_fuchsia_io::DirectoryRewindResponse) -> Self {
22161 Self { s: ::fidl_next::CompatFrom::compat_from(value.s) }
22162 }
22163 }
22164
22165 impl ::fidl_next::CompatFrom<crate::DirectoryLinkResponse>
22166 for ::fidl_fuchsia_io::DirectoryLinkResponse
22167 {
22168 #[inline]
22169 fn compat_from(value: crate::DirectoryLinkResponse) -> Self {
22170 Self { s: ::fidl_next::CompatFrom::compat_from(value.s) }
22171 }
22172 }
22173
22174 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::DirectoryLinkResponse>
22175 for crate::DirectoryLinkResponse
22176 {
22177 #[inline]
22178 fn compat_from(value: ::fidl_fuchsia_io::DirectoryLinkResponse) -> Self {
22179 Self { s: ::fidl_next::CompatFrom::compat_from(value.s) }
22180 }
22181 }
22182
22183 impl ::fidl_next::CompatFrom<crate::UnlinkFlags> for ::fidl_fuchsia_io::UnlinkFlags {
22184 fn compat_from(value: crate::UnlinkFlags) -> Self {
22185 Self::from_bits_retain(value.bits())
22186 }
22187 }
22188
22189 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::UnlinkFlags> for crate::UnlinkFlags {
22190 fn compat_from(value: ::fidl_fuchsia_io::UnlinkFlags) -> Self {
22191 Self::from_bits_retain(value.bits())
22192 }
22193 }
22194
22195 impl ::fidl_next::CompatFrom<crate::UnlinkOptions> for ::fidl_fuchsia_io::UnlinkOptions {
22196 fn compat_from(value: crate::UnlinkOptions) -> Self {
22197 Self {
22198 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
22199
22200 __source_breaking: ::fidl::marker::SourceBreaking,
22201 }
22202 }
22203 }
22204
22205 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::UnlinkOptions> for crate::UnlinkOptions {
22206 fn compat_from(value: ::fidl_fuchsia_io::UnlinkOptions) -> Self {
22207 Self { flags: ::fidl_next::CompatFrom::compat_from(value.flags) }
22208 }
22209 }
22210
22211 impl ::fidl_next::CompatFrom<crate::DirectoryUnlinkRequest>
22212 for ::fidl_fuchsia_io::DirectoryUnlinkRequest
22213 {
22214 #[inline]
22215 fn compat_from(value: crate::DirectoryUnlinkRequest) -> Self {
22216 Self {
22217 name: ::fidl_next::CompatFrom::compat_from(value.name),
22218
22219 options: ::fidl_next::CompatFrom::compat_from(value.options),
22220 }
22221 }
22222 }
22223
22224 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::DirectoryUnlinkRequest>
22225 for crate::DirectoryUnlinkRequest
22226 {
22227 #[inline]
22228 fn compat_from(value: ::fidl_fuchsia_io::DirectoryUnlinkRequest) -> Self {
22229 Self {
22230 name: ::fidl_next::CompatFrom::compat_from(value.name),
22231
22232 options: ::fidl_next::CompatFrom::compat_from(value.options),
22233 }
22234 }
22235 }
22236
22237 impl ::fidl_next::CompatFrom<crate::WatchMask> for ::fidl_fuchsia_io::WatchMask {
22238 fn compat_from(value: crate::WatchMask) -> Self {
22239 Self::from_bits_retain(value.bits())
22240 }
22241 }
22242
22243 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::WatchMask> for crate::WatchMask {
22244 fn compat_from(value: ::fidl_fuchsia_io::WatchMask) -> Self {
22245 Self::from_bits_retain(value.bits())
22246 }
22247 }
22248
22249 impl ::fidl_next::CompatFrom<crate::DirectoryWatchResponse>
22250 for ::fidl_fuchsia_io::DirectoryWatchResponse
22251 {
22252 #[inline]
22253 fn compat_from(value: crate::DirectoryWatchResponse) -> Self {
22254 Self { s: ::fidl_next::CompatFrom::compat_from(value.s) }
22255 }
22256 }
22257
22258 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::DirectoryWatchResponse>
22259 for crate::DirectoryWatchResponse
22260 {
22261 #[inline]
22262 fn compat_from(value: ::fidl_fuchsia_io::DirectoryWatchResponse) -> Self {
22263 Self { s: ::fidl_next::CompatFrom::compat_from(value.s) }
22264 }
22265 }
22266
22267 impl ::fidl_next::CompatFrom<crate::NodeGetExtendedAttributeRequest>
22268 for ::fidl_fuchsia_io::NodeGetExtendedAttributeRequest
22269 {
22270 #[inline]
22271 fn compat_from(value: crate::NodeGetExtendedAttributeRequest) -> Self {
22272 Self { name: ::fidl_next::CompatFrom::compat_from(value.name) }
22273 }
22274 }
22275
22276 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeGetExtendedAttributeRequest>
22277 for crate::NodeGetExtendedAttributeRequest
22278 {
22279 #[inline]
22280 fn compat_from(value: ::fidl_fuchsia_io::NodeGetExtendedAttributeRequest) -> Self {
22281 Self { name: ::fidl_next::CompatFrom::compat_from(value.name) }
22282 }
22283 }
22284
22285 impl ::fidl_next::CompatFrom<crate::SetExtendedAttributeMode>
22286 for ::fidl_fuchsia_io::SetExtendedAttributeMode
22287 {
22288 fn compat_from(value: crate::SetExtendedAttributeMode) -> Self {
22289 match value {
22290 crate::SetExtendedAttributeMode::Set => Self::Set,
22291
22292 crate::SetExtendedAttributeMode::Create => Self::Create,
22293
22294 crate::SetExtendedAttributeMode::Replace => Self::Replace,
22295 }
22296 }
22297 }
22298
22299 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::SetExtendedAttributeMode>
22300 for crate::SetExtendedAttributeMode
22301 {
22302 fn compat_from(value: ::fidl_fuchsia_io::SetExtendedAttributeMode) -> Self {
22303 match value {
22304 ::fidl_fuchsia_io::SetExtendedAttributeMode::Set => Self::Set,
22305
22306 ::fidl_fuchsia_io::SetExtendedAttributeMode::Create => Self::Create,
22307
22308 ::fidl_fuchsia_io::SetExtendedAttributeMode::Replace => Self::Replace,
22309 }
22310 }
22311 }
22312
22313 impl ::fidl_next::CompatFrom<crate::NodeRemoveExtendedAttributeRequest>
22314 for ::fidl_fuchsia_io::NodeRemoveExtendedAttributeRequest
22315 {
22316 #[inline]
22317 fn compat_from(value: crate::NodeRemoveExtendedAttributeRequest) -> Self {
22318 Self { name: ::fidl_next::CompatFrom::compat_from(value.name) }
22319 }
22320 }
22321
22322 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeRemoveExtendedAttributeRequest>
22323 for crate::NodeRemoveExtendedAttributeRequest
22324 {
22325 #[inline]
22326 fn compat_from(value: ::fidl_fuchsia_io::NodeRemoveExtendedAttributeRequest) -> Self {
22327 Self { name: ::fidl_next::CompatFrom::compat_from(value.name) }
22328 }
22329 }
22330
22331 impl ::fidl_next::CompatFrom<crate::NodeDeprecatedGetAttrResponse>
22332 for ::fidl_fuchsia_io::NodeDeprecatedGetAttrResponse
22333 {
22334 #[inline]
22335 fn compat_from(value: crate::NodeDeprecatedGetAttrResponse) -> Self {
22336 Self {
22337 s: ::fidl_next::CompatFrom::compat_from(value.s),
22338
22339 attributes: ::fidl_next::CompatFrom::compat_from(value.attributes),
22340 }
22341 }
22342 }
22343
22344 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeDeprecatedGetAttrResponse>
22345 for crate::NodeDeprecatedGetAttrResponse
22346 {
22347 #[inline]
22348 fn compat_from(value: ::fidl_fuchsia_io::NodeDeprecatedGetAttrResponse) -> Self {
22349 Self {
22350 s: ::fidl_next::CompatFrom::compat_from(value.s),
22351
22352 attributes: ::fidl_next::CompatFrom::compat_from(value.attributes),
22353 }
22354 }
22355 }
22356
22357 impl ::fidl_next::CompatFrom<crate::NodeDeprecatedSetAttrRequest>
22358 for ::fidl_fuchsia_io::NodeDeprecatedSetAttrRequest
22359 {
22360 #[inline]
22361 fn compat_from(value: crate::NodeDeprecatedSetAttrRequest) -> Self {
22362 Self {
22363 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
22364
22365 attributes: ::fidl_next::CompatFrom::compat_from(value.attributes),
22366 }
22367 }
22368 }
22369
22370 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeDeprecatedSetAttrRequest>
22371 for crate::NodeDeprecatedSetAttrRequest
22372 {
22373 #[inline]
22374 fn compat_from(value: ::fidl_fuchsia_io::NodeDeprecatedSetAttrRequest) -> Self {
22375 Self {
22376 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
22377
22378 attributes: ::fidl_next::CompatFrom::compat_from(value.attributes),
22379 }
22380 }
22381 }
22382
22383 impl ::fidl_next::CompatFrom<crate::NodeDeprecatedSetAttrResponse>
22384 for ::fidl_fuchsia_io::NodeDeprecatedSetAttrResponse
22385 {
22386 #[inline]
22387 fn compat_from(value: crate::NodeDeprecatedSetAttrResponse) -> Self {
22388 Self { s: ::fidl_next::CompatFrom::compat_from(value.s) }
22389 }
22390 }
22391
22392 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeDeprecatedSetAttrResponse>
22393 for crate::NodeDeprecatedSetAttrResponse
22394 {
22395 #[inline]
22396 fn compat_from(value: ::fidl_fuchsia_io::NodeDeprecatedSetAttrResponse) -> Self {
22397 Self { s: ::fidl_next::CompatFrom::compat_from(value.s) }
22398 }
22399 }
22400
22401 impl ::fidl_next::CompatFrom<crate::NodeDeprecatedGetFlagsResponse>
22402 for ::fidl_fuchsia_io::NodeDeprecatedGetFlagsResponse
22403 {
22404 #[inline]
22405 fn compat_from(value: crate::NodeDeprecatedGetFlagsResponse) -> Self {
22406 Self {
22407 s: ::fidl_next::CompatFrom::compat_from(value.s),
22408
22409 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
22410 }
22411 }
22412 }
22413
22414 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeDeprecatedGetFlagsResponse>
22415 for crate::NodeDeprecatedGetFlagsResponse
22416 {
22417 #[inline]
22418 fn compat_from(value: ::fidl_fuchsia_io::NodeDeprecatedGetFlagsResponse) -> Self {
22419 Self {
22420 s: ::fidl_next::CompatFrom::compat_from(value.s),
22421
22422 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
22423 }
22424 }
22425 }
22426
22427 impl ::fidl_next::CompatFrom<crate::NodeDeprecatedSetFlagsRequest>
22428 for ::fidl_fuchsia_io::NodeDeprecatedSetFlagsRequest
22429 {
22430 #[inline]
22431 fn compat_from(value: crate::NodeDeprecatedSetFlagsRequest) -> Self {
22432 Self { flags: ::fidl_next::CompatFrom::compat_from(value.flags) }
22433 }
22434 }
22435
22436 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeDeprecatedSetFlagsRequest>
22437 for crate::NodeDeprecatedSetFlagsRequest
22438 {
22439 #[inline]
22440 fn compat_from(value: ::fidl_fuchsia_io::NodeDeprecatedSetFlagsRequest) -> Self {
22441 Self { flags: ::fidl_next::CompatFrom::compat_from(value.flags) }
22442 }
22443 }
22444
22445 impl ::fidl_next::CompatFrom<crate::NodeDeprecatedSetFlagsResponse>
22446 for ::fidl_fuchsia_io::NodeDeprecatedSetFlagsResponse
22447 {
22448 #[inline]
22449 fn compat_from(value: crate::NodeDeprecatedSetFlagsResponse) -> Self {
22450 Self { s: ::fidl_next::CompatFrom::compat_from(value.s) }
22451 }
22452 }
22453
22454 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeDeprecatedSetFlagsResponse>
22455 for crate::NodeDeprecatedSetFlagsResponse
22456 {
22457 #[inline]
22458 fn compat_from(value: ::fidl_fuchsia_io::NodeDeprecatedSetFlagsResponse) -> Self {
22459 Self { s: ::fidl_next::CompatFrom::compat_from(value.s) }
22460 }
22461 }
22462
22463 impl ::fidl_next::CompatFrom<crate::Flags> for ::fidl_fuchsia_io::Flags {
22464 fn compat_from(value: crate::Flags) -> Self {
22465 Self::from_bits_retain(value.bits())
22466 }
22467 }
22468
22469 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::Flags> for crate::Flags {
22470 fn compat_from(value: ::fidl_fuchsia_io::Flags) -> Self {
22471 Self::from_bits_retain(value.bits())
22472 }
22473 }
22474
22475 impl ::fidl_next::CompatFrom<crate::NodeGetFlagsResponse>
22476 for ::fidl_fuchsia_io::NodeGetFlagsResponse
22477 {
22478 #[inline]
22479 fn compat_from(value: crate::NodeGetFlagsResponse) -> Self {
22480 Self { flags: ::fidl_next::CompatFrom::compat_from(value.flags) }
22481 }
22482 }
22483
22484 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeGetFlagsResponse>
22485 for crate::NodeGetFlagsResponse
22486 {
22487 #[inline]
22488 fn compat_from(value: ::fidl_fuchsia_io::NodeGetFlagsResponse) -> Self {
22489 Self { flags: ::fidl_next::CompatFrom::compat_from(value.flags) }
22490 }
22491 }
22492
22493 impl ::fidl_next::CompatFrom<crate::NodeSetFlagsRequest>
22494 for ::fidl_fuchsia_io::NodeSetFlagsRequest
22495 {
22496 #[inline]
22497 fn compat_from(value: crate::NodeSetFlagsRequest) -> Self {
22498 Self { flags: ::fidl_next::CompatFrom::compat_from(value.flags) }
22499 }
22500 }
22501
22502 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeSetFlagsRequest>
22503 for crate::NodeSetFlagsRequest
22504 {
22505 #[inline]
22506 fn compat_from(value: ::fidl_fuchsia_io::NodeSetFlagsRequest) -> Self {
22507 Self { flags: ::fidl_next::CompatFrom::compat_from(value.flags) }
22508 }
22509 }
22510
22511 impl ::fidl_next::CompatFrom<crate::EmptyStruct> for ::fidl_fuchsia_io::EmptyStruct {
22512 #[inline]
22513 fn compat_from(value: crate::EmptyStruct) -> Self {
22514 Self {}
22515 }
22516 }
22517
22518 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::EmptyStruct> for crate::EmptyStruct {
22519 #[inline]
22520 fn compat_from(value: ::fidl_fuchsia_io::EmptyStruct) -> Self {
22521 Self {}
22522 }
22523 }
22524
22525 impl ::fidl_next::CompatFrom<crate::SelinuxContext> for ::fidl_fuchsia_io::SelinuxContext {
22526 fn compat_from(value: crate::SelinuxContext) -> Self {
22527 match value {
22528 crate::SelinuxContext::Data(value) => {
22529 Self::Data(::fidl_next::CompatFrom::compat_from(value))
22530 }
22531
22532 crate::SelinuxContext::UseExtendedAttributes(value) => {
22533 Self::UseExtendedAttributes(::fidl_next::CompatFrom::compat_from(value))
22534 }
22535
22536 crate::SelinuxContext::UnknownOrdinal_(unknown_ordinal) => {
22537 Self::__SourceBreaking { unknown_ordinal }
22538 }
22539 }
22540 }
22541 }
22542
22543 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::SelinuxContext> for crate::SelinuxContext {
22544 fn compat_from(value: ::fidl_fuchsia_io::SelinuxContext) -> Self {
22545 match value {
22546 ::fidl_fuchsia_io::SelinuxContext::Data(value) => {
22547 Self::Data(::fidl_next::CompatFrom::compat_from(value))
22548 }
22549
22550 ::fidl_fuchsia_io::SelinuxContext::UseExtendedAttributes(value) => {
22551 Self::UseExtendedAttributes(::fidl_next::CompatFrom::compat_from(value))
22552 }
22553
22554 ::fidl_fuchsia_io::SelinuxContext::__SourceBreaking { unknown_ordinal } => {
22555 Self::UnknownOrdinal_(unknown_ordinal)
22556 }
22557 }
22558 }
22559 }
22560
22561 impl ::fidl_next::CompatFrom<crate::MutableNodeAttributes>
22562 for ::fidl_fuchsia_io::MutableNodeAttributes
22563 {
22564 fn compat_from(value: crate::MutableNodeAttributes) -> Self {
22565 Self {
22566 creation_time: ::fidl_next::CompatFrom::compat_from(value.creation_time),
22567
22568 modification_time: ::fidl_next::CompatFrom::compat_from(value.modification_time),
22569
22570 mode: ::fidl_next::CompatFrom::compat_from(value.mode),
22571
22572 uid: ::fidl_next::CompatFrom::compat_from(value.uid),
22573
22574 gid: ::fidl_next::CompatFrom::compat_from(value.gid),
22575
22576 rdev: ::fidl_next::CompatFrom::compat_from(value.rdev),
22577
22578 access_time: ::fidl_next::CompatFrom::compat_from(value.access_time),
22579
22580 casefold: ::fidl_next::CompatFrom::compat_from(value.casefold),
22581
22582 selinux_context: ::fidl_next::CompatFrom::compat_from(value.selinux_context),
22583
22584 wrapping_key_id: ::fidl_next::CompatFrom::compat_from(value.wrapping_key_id),
22585
22586 __source_breaking: ::fidl::marker::SourceBreaking,
22587 }
22588 }
22589 }
22590
22591 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::MutableNodeAttributes>
22592 for crate::MutableNodeAttributes
22593 {
22594 fn compat_from(value: ::fidl_fuchsia_io::MutableNodeAttributes) -> Self {
22595 Self {
22596 creation_time: ::fidl_next::CompatFrom::compat_from(value.creation_time),
22597
22598 modification_time: ::fidl_next::CompatFrom::compat_from(value.modification_time),
22599
22600 mode: ::fidl_next::CompatFrom::compat_from(value.mode),
22601
22602 uid: ::fidl_next::CompatFrom::compat_from(value.uid),
22603
22604 gid: ::fidl_next::CompatFrom::compat_from(value.gid),
22605
22606 rdev: ::fidl_next::CompatFrom::compat_from(value.rdev),
22607
22608 access_time: ::fidl_next::CompatFrom::compat_from(value.access_time),
22609
22610 casefold: ::fidl_next::CompatFrom::compat_from(value.casefold),
22611
22612 selinux_context: ::fidl_next::CompatFrom::compat_from(value.selinux_context),
22613
22614 wrapping_key_id: ::fidl_next::CompatFrom::compat_from(value.wrapping_key_id),
22615 }
22616 }
22617 }
22618
22619 impl ::fidl_next::CompatFrom<crate::NodeProtocolKinds> for ::fidl_fuchsia_io::NodeProtocolKinds {
22620 fn compat_from(value: crate::NodeProtocolKinds) -> Self {
22621 Self::from_bits_retain(value.bits())
22622 }
22623 }
22624
22625 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeProtocolKinds> for crate::NodeProtocolKinds {
22626 fn compat_from(value: ::fidl_fuchsia_io::NodeProtocolKinds) -> Self {
22627 Self::from_bits_retain(value.bits())
22628 }
22629 }
22630
22631 impl ::fidl_next::CompatFrom<crate::HashAlgorithm> for ::fidl_fuchsia_io::HashAlgorithm {
22632 fn compat_from(value: crate::HashAlgorithm) -> Self {
22633 match value {
22634 crate::HashAlgorithm::Sha256 => Self::Sha256,
22635
22636 crate::HashAlgorithm::Sha512 => Self::Sha512,
22637
22638 crate::HashAlgorithm::UnknownOrdinal_(unknown_ordinal) => {
22639 Self::__SourceBreaking { unknown_ordinal }
22640 }
22641 }
22642 }
22643 }
22644
22645 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::HashAlgorithm> for crate::HashAlgorithm {
22646 fn compat_from(value: ::fidl_fuchsia_io::HashAlgorithm) -> Self {
22647 match value {
22648 ::fidl_fuchsia_io::HashAlgorithm::Sha256 => Self::Sha256,
22649
22650 ::fidl_fuchsia_io::HashAlgorithm::Sha512 => Self::Sha512,
22651
22652 ::fidl_fuchsia_io::HashAlgorithm::__SourceBreaking { unknown_ordinal: value } => {
22653 Self::UnknownOrdinal_(value)
22654 }
22655 }
22656 }
22657 }
22658
22659 impl ::fidl_next::CompatFrom<crate::VerificationOptions>
22660 for ::fidl_fuchsia_io::VerificationOptions
22661 {
22662 fn compat_from(value: crate::VerificationOptions) -> Self {
22663 Self {
22664 hash_algorithm: ::fidl_next::CompatFrom::compat_from(value.hash_algorithm),
22665
22666 salt: ::fidl_next::CompatFrom::compat_from(value.salt),
22667
22668 __source_breaking: ::fidl::marker::SourceBreaking,
22669 }
22670 }
22671 }
22672
22673 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::VerificationOptions>
22674 for crate::VerificationOptions
22675 {
22676 fn compat_from(value: ::fidl_fuchsia_io::VerificationOptions) -> Self {
22677 Self {
22678 hash_algorithm: ::fidl_next::CompatFrom::compat_from(value.hash_algorithm),
22679
22680 salt: ::fidl_next::CompatFrom::compat_from(value.salt),
22681 }
22682 }
22683 }
22684
22685 impl ::fidl_next::CompatFrom<crate::ImmutableNodeAttributes>
22686 for ::fidl_fuchsia_io::ImmutableNodeAttributes
22687 {
22688 fn compat_from(value: crate::ImmutableNodeAttributes) -> Self {
22689 Self {
22690 protocols: ::fidl_next::CompatFrom::compat_from(value.protocols),
22691
22692 abilities: ::fidl_next::CompatFrom::compat_from(value.abilities),
22693
22694 content_size: ::fidl_next::CompatFrom::compat_from(value.content_size),
22695
22696 storage_size: ::fidl_next::CompatFrom::compat_from(value.storage_size),
22697
22698 link_count: ::fidl_next::CompatFrom::compat_from(value.link_count),
22699
22700 id: ::fidl_next::CompatFrom::compat_from(value.id),
22701
22702 change_time: ::fidl_next::CompatFrom::compat_from(value.change_time),
22703
22704 options: ::fidl_next::CompatFrom::compat_from(value.options),
22705
22706 root_hash: ::fidl_next::CompatFrom::compat_from(value.root_hash),
22707
22708 verity_enabled: ::fidl_next::CompatFrom::compat_from(value.verity_enabled),
22709
22710 __source_breaking: ::fidl::marker::SourceBreaking,
22711 }
22712 }
22713 }
22714
22715 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::ImmutableNodeAttributes>
22716 for crate::ImmutableNodeAttributes
22717 {
22718 fn compat_from(value: ::fidl_fuchsia_io::ImmutableNodeAttributes) -> Self {
22719 Self {
22720 protocols: ::fidl_next::CompatFrom::compat_from(value.protocols),
22721
22722 abilities: ::fidl_next::CompatFrom::compat_from(value.abilities),
22723
22724 content_size: ::fidl_next::CompatFrom::compat_from(value.content_size),
22725
22726 storage_size: ::fidl_next::CompatFrom::compat_from(value.storage_size),
22727
22728 link_count: ::fidl_next::CompatFrom::compat_from(value.link_count),
22729
22730 id: ::fidl_next::CompatFrom::compat_from(value.id),
22731
22732 change_time: ::fidl_next::CompatFrom::compat_from(value.change_time),
22733
22734 options: ::fidl_next::CompatFrom::compat_from(value.options),
22735
22736 root_hash: ::fidl_next::CompatFrom::compat_from(value.root_hash),
22737
22738 verity_enabled: ::fidl_next::CompatFrom::compat_from(value.verity_enabled),
22739 }
22740 }
22741 }
22742
22743 impl ::fidl_next::CompatFrom<crate::NodeAttributes2> for ::fidl_fuchsia_io::NodeAttributes2 {
22744 #[inline]
22745 fn compat_from(value: crate::NodeAttributes2) -> Self {
22746 Self {
22747 mutable_attributes: ::fidl_next::CompatFrom::compat_from(value.mutable_attributes),
22748
22749 immutable_attributes: ::fidl_next::CompatFrom::compat_from(
22750 value.immutable_attributes,
22751 ),
22752 }
22753 }
22754 }
22755
22756 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeAttributes2> for crate::NodeAttributes2 {
22757 #[inline]
22758 fn compat_from(value: ::fidl_fuchsia_io::NodeAttributes2) -> Self {
22759 Self {
22760 mutable_attributes: ::fidl_next::CompatFrom::compat_from(value.mutable_attributes),
22761
22762 immutable_attributes: ::fidl_next::CompatFrom::compat_from(
22763 value.immutable_attributes,
22764 ),
22765 }
22766 }
22767 }
22768
22769 impl ::fidl_next::CompatFrom<crate::NodeInfo> for ::fidl_fuchsia_io::NodeInfo {
22770 fn compat_from(value: crate::NodeInfo) -> Self {
22771 Self {
22772 attributes: ::fidl_next::CompatFrom::compat_from(value.attributes),
22773
22774 __source_breaking: ::fidl::marker::SourceBreaking,
22775 }
22776 }
22777 }
22778
22779 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeInfo> for crate::NodeInfo {
22780 fn compat_from(value: ::fidl_fuchsia_io::NodeInfo) -> Self {
22781 Self { attributes: ::fidl_next::CompatFrom::compat_from(value.attributes) }
22782 }
22783 }
22784
22785 impl ::fidl_next::CompatFrom<crate::DirectoryInfo> for ::fidl_fuchsia_io::DirectoryInfo {
22786 fn compat_from(value: crate::DirectoryInfo) -> Self {
22787 Self {
22788 attributes: ::fidl_next::CompatFrom::compat_from(value.attributes),
22789
22790 __source_breaking: ::fidl::marker::SourceBreaking,
22791 }
22792 }
22793 }
22794
22795 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::DirectoryInfo> for crate::DirectoryInfo {
22796 fn compat_from(value: ::fidl_fuchsia_io::DirectoryInfo) -> Self {
22797 Self { attributes: ::fidl_next::CompatFrom::compat_from(value.attributes) }
22798 }
22799 }
22800
22801 impl ::fidl_next::CompatFrom<crate::SymlinkInfo> for ::fidl_fuchsia_io::SymlinkInfo {
22802 fn compat_from(value: crate::SymlinkInfo) -> Self {
22803 Self {
22804 target: ::fidl_next::CompatFrom::compat_from(value.target),
22805
22806 attributes: ::fidl_next::CompatFrom::compat_from(value.attributes),
22807
22808 __source_breaking: ::fidl::marker::SourceBreaking,
22809 }
22810 }
22811 }
22812
22813 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::SymlinkInfo> for crate::SymlinkInfo {
22814 fn compat_from(value: ::fidl_fuchsia_io::SymlinkInfo) -> Self {
22815 Self {
22816 target: ::fidl_next::CompatFrom::compat_from(value.target),
22817
22818 attributes: ::fidl_next::CompatFrom::compat_from(value.attributes),
22819 }
22820 }
22821 }
22822
22823 impl ::fidl_next::CompatFrom<crate::NodeAttributesQuery>
22824 for ::fidl_fuchsia_io::NodeAttributesQuery
22825 {
22826 fn compat_from(value: crate::NodeAttributesQuery) -> Self {
22827 Self::from_bits_retain(value.bits())
22828 }
22829 }
22830
22831 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeAttributesQuery>
22832 for crate::NodeAttributesQuery
22833 {
22834 fn compat_from(value: ::fidl_fuchsia_io::NodeAttributesQuery) -> Self {
22835 Self::from_bits_retain(value.bits())
22836 }
22837 }
22838
22839 impl ::fidl_next::CompatFrom<crate::NodeGetAttributesRequest>
22840 for ::fidl_fuchsia_io::NodeGetAttributesRequest
22841 {
22842 #[inline]
22843 fn compat_from(value: crate::NodeGetAttributesRequest) -> Self {
22844 Self { query: ::fidl_next::CompatFrom::compat_from(value.query) }
22845 }
22846 }
22847
22848 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeGetAttributesRequest>
22849 for crate::NodeGetAttributesRequest
22850 {
22851 #[inline]
22852 fn compat_from(value: ::fidl_fuchsia_io::NodeGetAttributesRequest) -> Self {
22853 Self { query: ::fidl_next::CompatFrom::compat_from(value.query) }
22854 }
22855 }
22856
22857 impl ::fidl_next::CompatFrom<crate::Options> for ::fidl_fuchsia_io::Options {
22858 fn compat_from(value: crate::Options) -> Self {
22859 Self {
22860 attributes: ::fidl_next::CompatFrom::compat_from(value.attributes),
22861
22862 create_attributes: ::fidl_next::CompatFrom::compat_from(value.create_attributes),
22863
22864 __source_breaking: ::fidl::marker::SourceBreaking,
22865 }
22866 }
22867 }
22868
22869 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::Options> for crate::Options {
22870 fn compat_from(value: ::fidl_fuchsia_io::Options) -> Self {
22871 Self {
22872 attributes: ::fidl_next::CompatFrom::compat_from(value.attributes),
22873
22874 create_attributes: ::fidl_next::CompatFrom::compat_from(value.create_attributes),
22875 }
22876 }
22877 }
22878
22879 impl ::fidl_next::CompatFrom<crate::DirectoryObject> for ::fidl_fuchsia_io::DirectoryObject {
22880 #[inline]
22881 fn compat_from(value: crate::DirectoryObject) -> Self {
22882 Self {}
22883 }
22884 }
22885
22886 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::DirectoryObject> for crate::DirectoryObject {
22887 #[inline]
22888 fn compat_from(value: ::fidl_fuchsia_io::DirectoryObject) -> Self {
22889 Self {}
22890 }
22891 }
22892
22893 #[cfg(target_os = "fuchsia")]
22894 pub type DirectoryWatcherProxy = ::fidl_next::Client<crate::DirectoryWatcher>;
22897
22898 impl ::fidl_next::CompatFrom<crate::DirectoryWatcher>
22899 for ::fidl_fuchsia_io::DirectoryWatcherMarker
22900 {
22901 fn compat_from(_: crate::DirectoryWatcher) -> Self {
22902 Self
22903 }
22904 }
22905
22906 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::DirectoryWatcherMarker>
22907 for crate::DirectoryWatcher
22908 {
22909 fn compat_from(_: ::fidl_fuchsia_io::DirectoryWatcherMarker) -> Self {
22910 Self
22911 }
22912 }
22913
22914 #[cfg(target_os = "fuchsia")]
22915
22916 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_io::DirectoryWatcherProxy>
22917 for crate::DirectoryWatcher
22918 {
22919 fn client_compat_from(
22920 proxy: ::fidl_fuchsia_io::DirectoryWatcherProxy,
22921 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
22922 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
22923 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
22924 ::fidl_next::ClientDispatcher::new(client_end)
22925 }
22926 }
22927
22928 impl ::fidl_next::CompatFrom<crate::DirentType> for ::fidl_fuchsia_io::DirentType {
22929 fn compat_from(value: crate::DirentType) -> Self {
22930 match value {
22931 crate::DirentType::Unknown => Self::Unknown,
22932
22933 crate::DirentType::Directory => Self::Directory,
22934
22935 crate::DirentType::BlockDevice => Self::BlockDevice,
22936
22937 crate::DirentType::File => Self::File,
22938
22939 crate::DirentType::Symlink => Self::Symlink,
22940
22941 crate::DirentType::Service => Self::Service,
22942
22943 crate::DirentType::UnknownOrdinal_(unknown_ordinal) => {
22944 Self::__SourceBreaking { unknown_ordinal }
22945 }
22946 }
22947 }
22948 }
22949
22950 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::DirentType> for crate::DirentType {
22951 fn compat_from(value: ::fidl_fuchsia_io::DirentType) -> Self {
22952 match value {
22953 ::fidl_fuchsia_io::DirentType::Unknown => Self::Unknown,
22954
22955 ::fidl_fuchsia_io::DirentType::Directory => Self::Directory,
22956
22957 ::fidl_fuchsia_io::DirentType::BlockDevice => Self::BlockDevice,
22958
22959 ::fidl_fuchsia_io::DirentType::File => Self::File,
22960
22961 ::fidl_fuchsia_io::DirentType::Symlink => Self::Symlink,
22962
22963 ::fidl_fuchsia_io::DirentType::Service => Self::Service,
22964
22965 ::fidl_fuchsia_io::DirentType::__SourceBreaking { unknown_ordinal: value } => {
22966 Self::UnknownOrdinal_(value)
22967 }
22968 }
22969 }
22970 }
22971
22972 impl ::fidl_next::CompatFrom<crate::ExtendedAttributeIteratorGetNextResponse>
22973 for ::fidl_fuchsia_io::ExtendedAttributeIteratorGetNextResponse
22974 {
22975 #[inline]
22976 fn compat_from(value: crate::ExtendedAttributeIteratorGetNextResponse) -> Self {
22977 Self {
22978 attributes: ::fidl_next::CompatFrom::compat_from(value.attributes),
22979
22980 last: ::fidl_next::CompatFrom::compat_from(value.last),
22981 }
22982 }
22983 }
22984
22985 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::ExtendedAttributeIteratorGetNextResponse>
22986 for crate::ExtendedAttributeIteratorGetNextResponse
22987 {
22988 #[inline]
22989 fn compat_from(value: ::fidl_fuchsia_io::ExtendedAttributeIteratorGetNextResponse) -> Self {
22990 Self {
22991 attributes: ::fidl_next::CompatFrom::compat_from(value.attributes),
22992
22993 last: ::fidl_next::CompatFrom::compat_from(value.last),
22994 }
22995 }
22996 }
22997
22998 #[cfg(target_os = "fuchsia")]
22999 pub type ExtendedAttributeIteratorProxy = ::fidl_next::Client<crate::ExtendedAttributeIterator>;
23002
23003 impl ::fidl_next::CompatFrom<crate::ExtendedAttributeIterator>
23004 for ::fidl_fuchsia_io::ExtendedAttributeIteratorMarker
23005 {
23006 fn compat_from(_: crate::ExtendedAttributeIterator) -> Self {
23007 Self
23008 }
23009 }
23010
23011 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::ExtendedAttributeIteratorMarker>
23012 for crate::ExtendedAttributeIterator
23013 {
23014 fn compat_from(_: ::fidl_fuchsia_io::ExtendedAttributeIteratorMarker) -> Self {
23015 Self
23016 }
23017 }
23018
23019 #[cfg(target_os = "fuchsia")]
23020
23021 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_io::ExtendedAttributeIteratorProxy>
23022 for crate::ExtendedAttributeIterator
23023 {
23024 fn client_compat_from(
23025 proxy: ::fidl_fuchsia_io::ExtendedAttributeIteratorProxy,
23026 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
23027 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
23028 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
23029 ::fidl_next::ClientDispatcher::new(client_end)
23030 }
23031 }
23032
23033 impl ::fidl_next::CompatFrom<crate::ReadableReadRequest>
23034 for ::fidl_fuchsia_io::ReadableReadRequest
23035 {
23036 #[inline]
23037 fn compat_from(value: crate::ReadableReadRequest) -> Self {
23038 Self { count: ::fidl_next::CompatFrom::compat_from(value.count) }
23039 }
23040 }
23041
23042 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::ReadableReadRequest>
23043 for crate::ReadableReadRequest
23044 {
23045 #[inline]
23046 fn compat_from(value: ::fidl_fuchsia_io::ReadableReadRequest) -> Self {
23047 Self { count: ::fidl_next::CompatFrom::compat_from(value.count) }
23048 }
23049 }
23050
23051 impl ::fidl_next::CompatFrom<crate::ReadableReadResponse>
23052 for ::fidl_fuchsia_io::ReadableReadResponse
23053 {
23054 #[inline]
23055 fn compat_from(value: crate::ReadableReadResponse) -> Self {
23056 Self { data: ::fidl_next::CompatFrom::compat_from(value.data) }
23057 }
23058 }
23059
23060 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::ReadableReadResponse>
23061 for crate::ReadableReadResponse
23062 {
23063 #[inline]
23064 fn compat_from(value: ::fidl_fuchsia_io::ReadableReadResponse) -> Self {
23065 Self { data: ::fidl_next::CompatFrom::compat_from(value.data) }
23066 }
23067 }
23068
23069 #[cfg(target_os = "fuchsia")]
23070 pub type ReadableProxy = ::fidl_next::Client<crate::Readable>;
23073
23074 impl ::fidl_next::CompatFrom<crate::Readable> for ::fidl_fuchsia_io::ReadableMarker {
23075 fn compat_from(_: crate::Readable) -> Self {
23076 Self
23077 }
23078 }
23079
23080 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::ReadableMarker> for crate::Readable {
23081 fn compat_from(_: ::fidl_fuchsia_io::ReadableMarker) -> Self {
23082 Self
23083 }
23084 }
23085
23086 #[cfg(target_os = "fuchsia")]
23087
23088 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_io::ReadableProxy> for crate::Readable {
23089 fn client_compat_from(
23090 proxy: ::fidl_fuchsia_io::ReadableProxy,
23091 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
23092 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
23093 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
23094 ::fidl_next::ClientDispatcher::new(client_end)
23095 }
23096 }
23097
23098 impl ::fidl_next::CompatFrom<crate::WritableWriteRequest>
23099 for ::fidl_fuchsia_io::WritableWriteRequest
23100 {
23101 #[inline]
23102 fn compat_from(value: crate::WritableWriteRequest) -> Self {
23103 Self { data: ::fidl_next::CompatFrom::compat_from(value.data) }
23104 }
23105 }
23106
23107 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::WritableWriteRequest>
23108 for crate::WritableWriteRequest
23109 {
23110 #[inline]
23111 fn compat_from(value: ::fidl_fuchsia_io::WritableWriteRequest) -> Self {
23112 Self { data: ::fidl_next::CompatFrom::compat_from(value.data) }
23113 }
23114 }
23115
23116 impl ::fidl_next::CompatFrom<crate::WritableWriteResponse>
23117 for ::fidl_fuchsia_io::WritableWriteResponse
23118 {
23119 #[inline]
23120 fn compat_from(value: crate::WritableWriteResponse) -> Self {
23121 Self { actual_count: ::fidl_next::CompatFrom::compat_from(value.actual_count) }
23122 }
23123 }
23124
23125 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::WritableWriteResponse>
23126 for crate::WritableWriteResponse
23127 {
23128 #[inline]
23129 fn compat_from(value: ::fidl_fuchsia_io::WritableWriteResponse) -> Self {
23130 Self { actual_count: ::fidl_next::CompatFrom::compat_from(value.actual_count) }
23131 }
23132 }
23133
23134 #[cfg(target_os = "fuchsia")]
23135 pub type WritableProxy = ::fidl_next::Client<crate::Writable>;
23138
23139 impl ::fidl_next::CompatFrom<crate::Writable> for ::fidl_fuchsia_io::WritableMarker {
23140 fn compat_from(_: crate::Writable) -> Self {
23141 Self
23142 }
23143 }
23144
23145 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::WritableMarker> for crate::Writable {
23146 fn compat_from(_: ::fidl_fuchsia_io::WritableMarker) -> Self {
23147 Self
23148 }
23149 }
23150
23151 #[cfg(target_os = "fuchsia")]
23152
23153 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_io::WritableProxy> for crate::Writable {
23154 fn client_compat_from(
23155 proxy: ::fidl_fuchsia_io::WritableProxy,
23156 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
23157 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
23158 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
23159 ::fidl_next::ClientDispatcher::new(client_end)
23160 }
23161 }
23162
23163 impl ::fidl_next::CompatFrom<crate::FileSeekRequest> for ::fidl_fuchsia_io::FileSeekRequest {
23164 #[inline]
23165 fn compat_from(value: crate::FileSeekRequest) -> Self {
23166 Self {
23167 origin: ::fidl_next::CompatFrom::compat_from(value.origin),
23168
23169 offset: ::fidl_next::CompatFrom::compat_from(value.offset),
23170 }
23171 }
23172 }
23173
23174 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::FileSeekRequest> for crate::FileSeekRequest {
23175 #[inline]
23176 fn compat_from(value: ::fidl_fuchsia_io::FileSeekRequest) -> Self {
23177 Self {
23178 origin: ::fidl_next::CompatFrom::compat_from(value.origin),
23179
23180 offset: ::fidl_next::CompatFrom::compat_from(value.offset),
23181 }
23182 }
23183 }
23184
23185 impl ::fidl_next::CompatFrom<crate::FileSeekResponse> for ::fidl_fuchsia_io::FileSeekResponse {
23186 #[inline]
23187 fn compat_from(value: crate::FileSeekResponse) -> Self {
23188 Self {
23189 offset_from_start: ::fidl_next::CompatFrom::compat_from(value.offset_from_start),
23190 }
23191 }
23192 }
23193
23194 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::FileSeekResponse> for crate::FileSeekResponse {
23195 #[inline]
23196 fn compat_from(value: ::fidl_fuchsia_io::FileSeekResponse) -> Self {
23197 Self {
23198 offset_from_start: ::fidl_next::CompatFrom::compat_from(value.offset_from_start),
23199 }
23200 }
23201 }
23202
23203 impl ::fidl_next::CompatFrom<crate::FileReadAtRequest> for ::fidl_fuchsia_io::FileReadAtRequest {
23204 #[inline]
23205 fn compat_from(value: crate::FileReadAtRequest) -> Self {
23206 Self {
23207 count: ::fidl_next::CompatFrom::compat_from(value.count),
23208
23209 offset: ::fidl_next::CompatFrom::compat_from(value.offset),
23210 }
23211 }
23212 }
23213
23214 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::FileReadAtRequest> for crate::FileReadAtRequest {
23215 #[inline]
23216 fn compat_from(value: ::fidl_fuchsia_io::FileReadAtRequest) -> Self {
23217 Self {
23218 count: ::fidl_next::CompatFrom::compat_from(value.count),
23219
23220 offset: ::fidl_next::CompatFrom::compat_from(value.offset),
23221 }
23222 }
23223 }
23224
23225 impl ::fidl_next::CompatFrom<crate::FileReadAtResponse> for ::fidl_fuchsia_io::FileReadAtResponse {
23226 #[inline]
23227 fn compat_from(value: crate::FileReadAtResponse) -> Self {
23228 Self { data: ::fidl_next::CompatFrom::compat_from(value.data) }
23229 }
23230 }
23231
23232 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::FileReadAtResponse> for crate::FileReadAtResponse {
23233 #[inline]
23234 fn compat_from(value: ::fidl_fuchsia_io::FileReadAtResponse) -> Self {
23235 Self { data: ::fidl_next::CompatFrom::compat_from(value.data) }
23236 }
23237 }
23238
23239 impl ::fidl_next::CompatFrom<crate::FileWriteAtRequest> for ::fidl_fuchsia_io::FileWriteAtRequest {
23240 #[inline]
23241 fn compat_from(value: crate::FileWriteAtRequest) -> Self {
23242 Self {
23243 data: ::fidl_next::CompatFrom::compat_from(value.data),
23244
23245 offset: ::fidl_next::CompatFrom::compat_from(value.offset),
23246 }
23247 }
23248 }
23249
23250 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::FileWriteAtRequest> for crate::FileWriteAtRequest {
23251 #[inline]
23252 fn compat_from(value: ::fidl_fuchsia_io::FileWriteAtRequest) -> Self {
23253 Self {
23254 data: ::fidl_next::CompatFrom::compat_from(value.data),
23255
23256 offset: ::fidl_next::CompatFrom::compat_from(value.offset),
23257 }
23258 }
23259 }
23260
23261 impl ::fidl_next::CompatFrom<crate::FileWriteAtResponse>
23262 for ::fidl_fuchsia_io::FileWriteAtResponse
23263 {
23264 #[inline]
23265 fn compat_from(value: crate::FileWriteAtResponse) -> Self {
23266 Self { actual_count: ::fidl_next::CompatFrom::compat_from(value.actual_count) }
23267 }
23268 }
23269
23270 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::FileWriteAtResponse>
23271 for crate::FileWriteAtResponse
23272 {
23273 #[inline]
23274 fn compat_from(value: ::fidl_fuchsia_io::FileWriteAtResponse) -> Self {
23275 Self { actual_count: ::fidl_next::CompatFrom::compat_from(value.actual_count) }
23276 }
23277 }
23278
23279 impl ::fidl_next::CompatFrom<crate::FileResizeRequest> for ::fidl_fuchsia_io::FileResizeRequest {
23280 #[inline]
23281 fn compat_from(value: crate::FileResizeRequest) -> Self {
23282 Self { length: ::fidl_next::CompatFrom::compat_from(value.length) }
23283 }
23284 }
23285
23286 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::FileResizeRequest> for crate::FileResizeRequest {
23287 #[inline]
23288 fn compat_from(value: ::fidl_fuchsia_io::FileResizeRequest) -> Self {
23289 Self { length: ::fidl_next::CompatFrom::compat_from(value.length) }
23290 }
23291 }
23292
23293 impl ::fidl_next::CompatFrom<crate::VmoFlags> for ::fidl_fuchsia_io::VmoFlags {
23294 fn compat_from(value: crate::VmoFlags) -> Self {
23295 Self::from_bits_retain(value.bits())
23296 }
23297 }
23298
23299 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::VmoFlags> for crate::VmoFlags {
23300 fn compat_from(value: ::fidl_fuchsia_io::VmoFlags) -> Self {
23301 Self::from_bits_retain(value.bits())
23302 }
23303 }
23304
23305 impl ::fidl_next::CompatFrom<crate::FileGetBackingMemoryRequest>
23306 for ::fidl_fuchsia_io::FileGetBackingMemoryRequest
23307 {
23308 #[inline]
23309 fn compat_from(value: crate::FileGetBackingMemoryRequest) -> Self {
23310 Self { flags: ::fidl_next::CompatFrom::compat_from(value.flags) }
23311 }
23312 }
23313
23314 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::FileGetBackingMemoryRequest>
23315 for crate::FileGetBackingMemoryRequest
23316 {
23317 #[inline]
23318 fn compat_from(value: ::fidl_fuchsia_io::FileGetBackingMemoryRequest) -> Self {
23319 Self { flags: ::fidl_next::CompatFrom::compat_from(value.flags) }
23320 }
23321 }
23322
23323 impl ::fidl_next::CompatFrom<crate::FileSignal> for ::fidl_fuchsia_io::FileSignal {
23324 fn compat_from(value: crate::FileSignal) -> Self {
23325 Self::from_bits_retain(value.bits())
23326 }
23327 }
23328
23329 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::FileSignal> for crate::FileSignal {
23330 fn compat_from(value: ::fidl_fuchsia_io::FileSignal) -> Self {
23331 Self::from_bits_retain(value.bits())
23332 }
23333 }
23334
23335 impl ::fidl_next::CompatFrom<crate::FilesystemInfo> for ::fidl_fuchsia_io::FilesystemInfo {
23336 #[inline]
23337 fn compat_from(value: crate::FilesystemInfo) -> Self {
23338 Self {
23339 total_bytes: ::fidl_next::CompatFrom::compat_from(value.total_bytes),
23340
23341 used_bytes: ::fidl_next::CompatFrom::compat_from(value.used_bytes),
23342
23343 total_nodes: ::fidl_next::CompatFrom::compat_from(value.total_nodes),
23344
23345 used_nodes: ::fidl_next::CompatFrom::compat_from(value.used_nodes),
23346
23347 free_shared_pool_bytes: ::fidl_next::CompatFrom::compat_from(
23348 value.free_shared_pool_bytes,
23349 ),
23350
23351 fs_id: ::fidl_next::CompatFrom::compat_from(value.fs_id),
23352
23353 block_size: ::fidl_next::CompatFrom::compat_from(value.block_size),
23354
23355 max_filename_size: ::fidl_next::CompatFrom::compat_from(value.max_filename_size),
23356
23357 fs_type: ::fidl_next::CompatFrom::compat_from(value.fs_type),
23358
23359 padding: ::fidl_next::CompatFrom::compat_from(value.padding),
23360
23361 name: ::fidl_next::CompatFrom::compat_from(value.name),
23362 }
23363 }
23364 }
23365
23366 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::FilesystemInfo> for crate::FilesystemInfo {
23367 #[inline]
23368 fn compat_from(value: ::fidl_fuchsia_io::FilesystemInfo) -> Self {
23369 Self {
23370 total_bytes: ::fidl_next::CompatFrom::compat_from(value.total_bytes),
23371
23372 used_bytes: ::fidl_next::CompatFrom::compat_from(value.used_bytes),
23373
23374 total_nodes: ::fidl_next::CompatFrom::compat_from(value.total_nodes),
23375
23376 used_nodes: ::fidl_next::CompatFrom::compat_from(value.used_nodes),
23377
23378 free_shared_pool_bytes: ::fidl_next::CompatFrom::compat_from(
23379 value.free_shared_pool_bytes,
23380 ),
23381
23382 fs_id: ::fidl_next::CompatFrom::compat_from(value.fs_id),
23383
23384 block_size: ::fidl_next::CompatFrom::compat_from(value.block_size),
23385
23386 max_filename_size: ::fidl_next::CompatFrom::compat_from(value.max_filename_size),
23387
23388 fs_type: ::fidl_next::CompatFrom::compat_from(value.fs_type),
23389
23390 padding: ::fidl_next::CompatFrom::compat_from(value.padding),
23391
23392 name: ::fidl_next::CompatFrom::compat_from(value.name),
23393 }
23394 }
23395 }
23396
23397 impl ::fidl_next::CompatFrom<crate::Service> for ::fidl_fuchsia_io::Service {
23398 #[inline]
23399 fn compat_from(value: crate::Service) -> Self {
23400 Self {}
23401 }
23402 }
23403
23404 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::Service> for crate::Service {
23405 #[inline]
23406 fn compat_from(value: ::fidl_fuchsia_io::Service) -> Self {
23407 Self {}
23408 }
23409 }
23410
23411 impl ::fidl_next::CompatFrom<crate::SymlinkObject> for ::fidl_fuchsia_io::SymlinkObject {
23412 #[inline]
23413 fn compat_from(value: crate::SymlinkObject) -> Self {
23414 Self { target: ::fidl_next::CompatFrom::compat_from(value.target) }
23415 }
23416 }
23417
23418 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::SymlinkObject> for crate::SymlinkObject {
23419 #[inline]
23420 fn compat_from(value: ::fidl_fuchsia_io::SymlinkObject) -> Self {
23421 Self { target: ::fidl_next::CompatFrom::compat_from(value.target) }
23422 }
23423 }
23424
23425 impl ::fidl_next::CompatFrom<crate::WatchEvent> for ::fidl_fuchsia_io::WatchEvent {
23426 fn compat_from(value: crate::WatchEvent) -> Self {
23427 match value {
23428 crate::WatchEvent::Deleted => Self::Deleted,
23429
23430 crate::WatchEvent::Added => Self::Added,
23431
23432 crate::WatchEvent::Removed => Self::Removed,
23433
23434 crate::WatchEvent::Existing => Self::Existing,
23435
23436 crate::WatchEvent::Idle => Self::Idle,
23437 }
23438 }
23439 }
23440
23441 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::WatchEvent> for crate::WatchEvent {
23442 fn compat_from(value: ::fidl_fuchsia_io::WatchEvent) -> Self {
23443 match value {
23444 ::fidl_fuchsia_io::WatchEvent::Deleted => Self::Deleted,
23445
23446 ::fidl_fuchsia_io::WatchEvent::Added => Self::Added,
23447
23448 ::fidl_fuchsia_io::WatchEvent::Removed => Self::Removed,
23449
23450 ::fidl_fuchsia_io::WatchEvent::Existing => Self::Existing,
23451
23452 ::fidl_fuchsia_io::WatchEvent::Idle => Self::Idle,
23453 }
23454 }
23455 }
23456}