1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 pub use fidl_next_common_fuchsia_io::natural::*;
8
9 #[derive(PartialEq, Debug, Default)]
10 pub struct ConnectionInfo {
11 pub rights: ::core::option::Option<crate::natural::Operations>,
12 }
13
14 impl ConnectionInfo {
15 fn __max_ordinal(&self) -> usize {
16 if self.rights.is_some() {
17 return 1;
18 }
19
20 0
21 }
22 }
23
24 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConnectionInfo<'static>, ___E> for ConnectionInfo
25 where
26 ___E: ::fidl_next::Encoder + ?Sized,
27 ___E: ::fidl_next::fuchsia::HandleEncoder,
28 {
29 #[inline]
30 fn encode(
31 mut self,
32 encoder: &mut ___E,
33 out: &mut ::core::mem::MaybeUninit<crate::wire::ConnectionInfo<'static>>,
34 _: (),
35 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
36 ::fidl_next::munge!(let crate::wire::ConnectionInfo { table } = out);
37
38 let max_ord = self.__max_ordinal();
39
40 let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
41 ::fidl_next::Wire::zero_padding(&mut out);
42
43 let mut preallocated =
44 ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);
45
46 for i in 1..=max_ord {
47 match i {
48 1 => {
49 if let Some(value) = self.rights.take() {
50 ::fidl_next::WireEnvelope::encode_value::<crate::wire::Operations, ___E>(
51 value,
52 preallocated.encoder,
53 &mut out,
54 (),
55 )?;
56 } else {
57 ::fidl_next::WireEnvelope::encode_zero(&mut out)
58 }
59 }
60
61 _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
62 }
63 unsafe {
64 preallocated.write_next(out.assume_init_ref());
65 }
66 }
67
68 ::fidl_next::WireTable::encode_len(table, max_ord);
69
70 Ok(())
71 }
72 }
73
74 impl<'de> ::fidl_next::FromWire<crate::wire::ConnectionInfo<'de>> for ConnectionInfo {
75 #[inline]
76 fn from_wire(wire_: crate::wire::ConnectionInfo<'de>) -> Self {
77 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
78
79 let rights = wire_.table.get(1);
80
81 Self {
82 rights: rights.map(|envelope| {
83 ::fidl_next::FromWire::from_wire(unsafe {
84 envelope.read_unchecked::<crate::wire::Operations>()
85 })
86 }),
87 }
88 }
89 }
90
91 #[derive(PartialEq, Debug)]
92 #[repr(C)]
93 pub struct DirectoryGetTokenResponse {
94 pub s: i32,
95
96 pub token: ::core::option::Option<::fidl_next::fuchsia::zx::Handle>,
97 }
98
99 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryGetTokenResponse, ___E>
100 for DirectoryGetTokenResponse
101 where
102 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
103 ___E: ::fidl_next::fuchsia::HandleEncoder,
104 {
105 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
106 Self,
107 crate::wire::DirectoryGetTokenResponse,
108 > = unsafe {
109 ::fidl_next::CopyOptimization::enable_if(
110 true
111
112 && <
113 i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>
114 >::COPY_OPTIMIZATION.is_enabled()
115
116 && <
117 ::core::option::Option<::fidl_next::fuchsia::zx::Handle> as ::fidl_next::Encode<::fidl_next::fuchsia::WireOptionalHandle, ___E>
118 >::COPY_OPTIMIZATION.is_enabled()
119
120 )
121 };
122
123 #[inline]
124 fn encode(
125 self,
126 encoder_: &mut ___E,
127 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryGetTokenResponse>,
128 _: (),
129 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
130 ::fidl_next::munge! {
131 let crate::wire::DirectoryGetTokenResponse {
132 s,
133 token,
134
135 } = out_;
136 }
137
138 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
139
140 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
141
142 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
143
144 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
145
146 Ok(())
147 }
148 }
149
150 unsafe impl<___E>
151 ::fidl_next::EncodeOption<
152 ::fidl_next::WireBox<'static, crate::wire::DirectoryGetTokenResponse>,
153 ___E,
154 > for DirectoryGetTokenResponse
155 where
156 ___E: ::fidl_next::Encoder + ?Sized,
157 DirectoryGetTokenResponse:
158 ::fidl_next::Encode<crate::wire::DirectoryGetTokenResponse, ___E>,
159 {
160 #[inline]
161 fn encode_option(
162 this: ::core::option::Option<Self>,
163 encoder: &mut ___E,
164 out: &mut ::core::mem::MaybeUninit<
165 ::fidl_next::WireBox<'static, crate::wire::DirectoryGetTokenResponse>,
166 >,
167 _: (),
168 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
169 if let Some(inner) = this {
170 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
171 ::fidl_next::WireBox::encode_present(out);
172 } else {
173 ::fidl_next::WireBox::encode_absent(out);
174 }
175
176 Ok(())
177 }
178 }
179
180 impl ::fidl_next::FromWire<crate::wire::DirectoryGetTokenResponse> for DirectoryGetTokenResponse {
181 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
182 crate::wire::DirectoryGetTokenResponse,
183 Self,
184 > = unsafe {
185 ::fidl_next::CopyOptimization::enable_if(
186 true
187
188 && <
189 i32 as ::fidl_next::FromWire<::fidl_next::WireI32>
190 >::COPY_OPTIMIZATION.is_enabled()
191
192 && <
193 ::core::option::Option<::fidl_next::fuchsia::zx::Handle> as ::fidl_next::FromWire<::fidl_next::fuchsia::WireOptionalHandle>
194 >::COPY_OPTIMIZATION.is_enabled()
195
196 )
197 };
198
199 #[inline]
200 fn from_wire(wire: crate::wire::DirectoryGetTokenResponse) -> Self {
201 Self {
202 s: ::fidl_next::FromWire::from_wire(wire.s),
203
204 token: ::fidl_next::FromWire::from_wire(wire.token),
205 }
206 }
207 }
208
209 #[derive(PartialEq, Debug)]
210 pub struct DirectoryLinkRequest {
211 pub src: ::std::string::String,
212
213 pub dst_parent_token: ::fidl_next::fuchsia::zx::Handle,
214
215 pub dst: ::std::string::String,
216 }
217
218 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryLinkRequest<'static>, ___E>
219 for DirectoryLinkRequest
220 where
221 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
222 ___E: ::fidl_next::Encoder,
223 ___E: ::fidl_next::fuchsia::HandleEncoder,
224 {
225 #[inline]
226 fn encode(
227 self,
228 encoder_: &mut ___E,
229 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkRequest<'static>>,
230 _: (),
231 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
232 ::fidl_next::munge! {
233 let crate::wire::DirectoryLinkRequest {
234 src,
235 dst_parent_token,
236 dst,
237
238 } = out_;
239 }
240
241 ::fidl_next::Encode::encode(self.src, encoder_, src, 255)?;
242
243 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(src.as_mut_ptr()) };
244 ::fidl_next::Constrained::validate(_field, 255)?;
245
246 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
247
248 let mut _field =
249 unsafe { ::fidl_next::Slot::new_unchecked(dst_parent_token.as_mut_ptr()) };
250
251 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
252
253 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dst.as_mut_ptr()) };
254 ::fidl_next::Constrained::validate(_field, 255)?;
255
256 Ok(())
257 }
258 }
259
260 unsafe impl<___E>
261 ::fidl_next::EncodeOption<
262 ::fidl_next::WireBox<'static, crate::wire::DirectoryLinkRequest<'static>>,
263 ___E,
264 > for DirectoryLinkRequest
265 where
266 ___E: ::fidl_next::Encoder + ?Sized,
267 DirectoryLinkRequest: ::fidl_next::Encode<crate::wire::DirectoryLinkRequest<'static>, ___E>,
268 {
269 #[inline]
270 fn encode_option(
271 this: ::core::option::Option<Self>,
272 encoder: &mut ___E,
273 out: &mut ::core::mem::MaybeUninit<
274 ::fidl_next::WireBox<'static, crate::wire::DirectoryLinkRequest<'static>>,
275 >,
276 _: (),
277 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
278 if let Some(inner) = this {
279 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
280 ::fidl_next::WireBox::encode_present(out);
281 } else {
282 ::fidl_next::WireBox::encode_absent(out);
283 }
284
285 Ok(())
286 }
287 }
288
289 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryLinkRequest<'de>> for DirectoryLinkRequest {
290 #[inline]
291 fn from_wire(wire: crate::wire::DirectoryLinkRequest<'de>) -> Self {
292 Self {
293 src: ::fidl_next::FromWire::from_wire(wire.src),
294
295 dst_parent_token: ::fidl_next::FromWire::from_wire(wire.dst_parent_token),
296
297 dst: ::fidl_next::FromWire::from_wire(wire.dst),
298 }
299 }
300 }
301
302 #[doc = " The type to identify a connection to a node.\n It represents a capability: a reference to a node with associated rights.\n"]
303 pub type Token = ::fidl_next::fuchsia::zx::Event;
304
305 #[derive(PartialEq, Debug)]
306 pub struct DirectoryRenameRequest {
307 pub src: ::std::string::String,
308
309 pub dst_parent_token: ::fidl_next::fuchsia::zx::Event,
310
311 pub dst: ::std::string::String,
312 }
313
314 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryRenameRequest<'static>, ___E>
315 for DirectoryRenameRequest
316 where
317 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
318 ___E: ::fidl_next::Encoder,
319 ___E: ::fidl_next::fuchsia::HandleEncoder,
320 {
321 #[inline]
322 fn encode(
323 self,
324 encoder_: &mut ___E,
325 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRenameRequest<'static>>,
326 _: (),
327 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
328 ::fidl_next::munge! {
329 let crate::wire::DirectoryRenameRequest {
330 src,
331 dst_parent_token,
332 dst,
333
334 } = out_;
335 }
336
337 ::fidl_next::Encode::encode(self.src, encoder_, src, 255)?;
338
339 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(src.as_mut_ptr()) };
340 ::fidl_next::Constrained::validate(_field, 255)?;
341
342 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
343
344 let mut _field =
345 unsafe { ::fidl_next::Slot::new_unchecked(dst_parent_token.as_mut_ptr()) };
346
347 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
348
349 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dst.as_mut_ptr()) };
350 ::fidl_next::Constrained::validate(_field, 255)?;
351
352 Ok(())
353 }
354 }
355
356 unsafe impl<___E>
357 ::fidl_next::EncodeOption<
358 ::fidl_next::WireBox<'static, crate::wire::DirectoryRenameRequest<'static>>,
359 ___E,
360 > for DirectoryRenameRequest
361 where
362 ___E: ::fidl_next::Encoder + ?Sized,
363 DirectoryRenameRequest:
364 ::fidl_next::Encode<crate::wire::DirectoryRenameRequest<'static>, ___E>,
365 {
366 #[inline]
367 fn encode_option(
368 this: ::core::option::Option<Self>,
369 encoder: &mut ___E,
370 out: &mut ::core::mem::MaybeUninit<
371 ::fidl_next::WireBox<'static, crate::wire::DirectoryRenameRequest<'static>>,
372 >,
373 _: (),
374 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
375 if let Some(inner) = this {
376 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
377 ::fidl_next::WireBox::encode_present(out);
378 } else {
379 ::fidl_next::WireBox::encode_absent(out);
380 }
381
382 Ok(())
383 }
384 }
385
386 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryRenameRequest<'de>>
387 for DirectoryRenameRequest
388 {
389 #[inline]
390 fn from_wire(wire: crate::wire::DirectoryRenameRequest<'de>) -> Self {
391 Self {
392 src: ::fidl_next::FromWire::from_wire(wire.src),
393
394 dst_parent_token: ::fidl_next::FromWire::from_wire(wire.dst_parent_token),
395
396 dst: ::fidl_next::FromWire::from_wire(wire.dst),
397 }
398 }
399 }
400
401 #[derive(PartialEq, Debug)]
402 #[repr(C)]
403 pub struct DirectoryWatchRequest {
404 pub mask: crate::natural::WatchMask,
405
406 pub options: u32,
407
408 pub watcher:
409 ::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fidl_next::fuchsia::zx::Channel>,
410 }
411
412 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryWatchRequest, ___E>
413 for DirectoryWatchRequest
414 where
415 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
416 ___E: ::fidl_next::fuchsia::HandleEncoder,
417 {
418 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
419 Self,
420 crate::wire::DirectoryWatchRequest,
421 > = unsafe {
422 ::fidl_next::CopyOptimization::enable_if(
423 true && <crate::natural::WatchMask as ::fidl_next::Encode<
424 crate::wire::WatchMask,
425 ___E,
426 >>::COPY_OPTIMIZATION
427 .is_enabled()
428 && <u32 as ::fidl_next::Encode<::fidl_next::WireU32, ___E>>::COPY_OPTIMIZATION
429 .is_enabled()
430 && <::fidl_next::ServerEnd<
431 crate::DirectoryWatcher,
432 ::fidl_next::fuchsia::zx::Channel,
433 > as ::fidl_next::Encode<
434 ::fidl_next::ServerEnd<
435 crate::DirectoryWatcher,
436 ::fidl_next::fuchsia::WireChannel,
437 >,
438 ___E,
439 >>::COPY_OPTIMIZATION
440 .is_enabled(),
441 )
442 };
443
444 #[inline]
445 fn encode(
446 self,
447 encoder_: &mut ___E,
448 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchRequest>,
449 _: (),
450 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
451 ::fidl_next::munge! {
452 let crate::wire::DirectoryWatchRequest {
453 mask,
454 options,
455 watcher,
456
457 } = out_;
458 }
459
460 ::fidl_next::Encode::encode(self.mask, encoder_, mask, ())?;
461
462 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mask.as_mut_ptr()) };
463
464 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
465
466 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
467
468 ::fidl_next::Encode::encode(self.watcher, encoder_, watcher, ())?;
469
470 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(watcher.as_mut_ptr()) };
471
472 Ok(())
473 }
474 }
475
476 unsafe impl<___E>
477 ::fidl_next::EncodeOption<
478 ::fidl_next::WireBox<'static, crate::wire::DirectoryWatchRequest>,
479 ___E,
480 > for DirectoryWatchRequest
481 where
482 ___E: ::fidl_next::Encoder + ?Sized,
483 DirectoryWatchRequest: ::fidl_next::Encode<crate::wire::DirectoryWatchRequest, ___E>,
484 {
485 #[inline]
486 fn encode_option(
487 this: ::core::option::Option<Self>,
488 encoder: &mut ___E,
489 out: &mut ::core::mem::MaybeUninit<
490 ::fidl_next::WireBox<'static, crate::wire::DirectoryWatchRequest>,
491 >,
492 _: (),
493 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
494 if let Some(inner) = this {
495 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
496 ::fidl_next::WireBox::encode_present(out);
497 } else {
498 ::fidl_next::WireBox::encode_absent(out);
499 }
500
501 Ok(())
502 }
503 }
504
505 impl ::fidl_next::FromWire<crate::wire::DirectoryWatchRequest> for DirectoryWatchRequest {
506 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
507 crate::wire::DirectoryWatchRequest,
508 Self,
509 > = unsafe {
510 ::fidl_next::CopyOptimization::enable_if(
511 true && <crate::natural::WatchMask as ::fidl_next::FromWire<
512 crate::wire::WatchMask,
513 >>::COPY_OPTIMIZATION
514 .is_enabled()
515 && <u32 as ::fidl_next::FromWire<::fidl_next::WireU32>>::COPY_OPTIMIZATION
516 .is_enabled()
517 && <::fidl_next::ServerEnd<
518 crate::DirectoryWatcher,
519 ::fidl_next::fuchsia::zx::Channel,
520 > as ::fidl_next::FromWire<
521 ::fidl_next::ServerEnd<
522 crate::DirectoryWatcher,
523 ::fidl_next::fuchsia::WireChannel,
524 >,
525 >>::COPY_OPTIMIZATION
526 .is_enabled(),
527 )
528 };
529
530 #[inline]
531 fn from_wire(wire: crate::wire::DirectoryWatchRequest) -> Self {
532 Self {
533 mask: ::fidl_next::FromWire::from_wire(wire.mask),
534
535 options: ::fidl_next::FromWire::from_wire(wire.options),
536
537 watcher: ::fidl_next::FromWire::from_wire(wire.watcher),
538 }
539 }
540 }
541
542 #[derive(PartialEq, Debug)]
543 pub struct NodeOnOpenRequest {
544 pub s: i32,
545
546 pub info: ::core::option::Option<::std::boxed::Box<crate::natural::NodeInfoDeprecated>>,
547 }
548
549 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeOnOpenRequest<'static>, ___E>
550 for NodeOnOpenRequest
551 where
552 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
553 ___E: ::fidl_next::Encoder,
554 ___E: ::fidl_next::fuchsia::HandleEncoder,
555 {
556 #[inline]
557 fn encode(
558 self,
559 encoder_: &mut ___E,
560 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeOnOpenRequest<'static>>,
561 _: (),
562 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
563 ::fidl_next::munge! {
564 let crate::wire::NodeOnOpenRequest {
565 s,
566 info,
567
568 } = out_;
569 }
570
571 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
572
573 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
574
575 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
576
577 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
578
579 Ok(())
580 }
581 }
582
583 unsafe impl<___E>
584 ::fidl_next::EncodeOption<
585 ::fidl_next::WireBox<'static, crate::wire::NodeOnOpenRequest<'static>>,
586 ___E,
587 > for NodeOnOpenRequest
588 where
589 ___E: ::fidl_next::Encoder + ?Sized,
590 NodeOnOpenRequest: ::fidl_next::Encode<crate::wire::NodeOnOpenRequest<'static>, ___E>,
591 {
592 #[inline]
593 fn encode_option(
594 this: ::core::option::Option<Self>,
595 encoder: &mut ___E,
596 out: &mut ::core::mem::MaybeUninit<
597 ::fidl_next::WireBox<'static, crate::wire::NodeOnOpenRequest<'static>>,
598 >,
599 _: (),
600 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
601 if let Some(inner) = this {
602 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
603 ::fidl_next::WireBox::encode_present(out);
604 } else {
605 ::fidl_next::WireBox::encode_absent(out);
606 }
607
608 Ok(())
609 }
610 }
611
612 impl<'de> ::fidl_next::FromWire<crate::wire::NodeOnOpenRequest<'de>> for NodeOnOpenRequest {
613 #[inline]
614 fn from_wire(wire: crate::wire::NodeOnOpenRequest<'de>) -> Self {
615 Self {
616 s: ::fidl_next::FromWire::from_wire(wire.s),
617
618 info: ::fidl_next::FromWire::from_wire(wire.info),
619 }
620 }
621 }
622
623 #[derive(PartialEq, Debug)]
624 #[repr(C)]
625 pub struct NodeListExtendedAttributesRequest {
626 pub iterator: ::fidl_next::ServerEnd<
627 crate::ExtendedAttributeIterator,
628 ::fidl_next::fuchsia::zx::Channel,
629 >,
630 }
631
632 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeListExtendedAttributesRequest, ___E>
633 for NodeListExtendedAttributesRequest
634 where
635 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
636 ___E: ::fidl_next::fuchsia::HandleEncoder,
637 {
638 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
639 Self,
640 crate::wire::NodeListExtendedAttributesRequest,
641 > = unsafe {
642 ::fidl_next::CopyOptimization::enable_if(
643 true && <::fidl_next::ServerEnd<
644 crate::ExtendedAttributeIterator,
645 ::fidl_next::fuchsia::zx::Channel,
646 > as ::fidl_next::Encode<
647 ::fidl_next::ServerEnd<
648 crate::ExtendedAttributeIterator,
649 ::fidl_next::fuchsia::WireChannel,
650 >,
651 ___E,
652 >>::COPY_OPTIMIZATION
653 .is_enabled(),
654 )
655 };
656
657 #[inline]
658 fn encode(
659 self,
660 encoder_: &mut ___E,
661 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeListExtendedAttributesRequest>,
662 _: (),
663 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
664 ::fidl_next::munge! {
665 let crate::wire::NodeListExtendedAttributesRequest {
666 iterator,
667
668 } = out_;
669 }
670
671 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
672
673 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
674
675 Ok(())
676 }
677 }
678
679 unsafe impl<___E>
680 ::fidl_next::EncodeOption<
681 ::fidl_next::WireBox<'static, crate::wire::NodeListExtendedAttributesRequest>,
682 ___E,
683 > for NodeListExtendedAttributesRequest
684 where
685 ___E: ::fidl_next::Encoder + ?Sized,
686 NodeListExtendedAttributesRequest:
687 ::fidl_next::Encode<crate::wire::NodeListExtendedAttributesRequest, ___E>,
688 {
689 #[inline]
690 fn encode_option(
691 this: ::core::option::Option<Self>,
692 encoder: &mut ___E,
693 out: &mut ::core::mem::MaybeUninit<
694 ::fidl_next::WireBox<'static, crate::wire::NodeListExtendedAttributesRequest>,
695 >,
696 _: (),
697 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
698 if let Some(inner) = this {
699 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
700 ::fidl_next::WireBox::encode_present(out);
701 } else {
702 ::fidl_next::WireBox::encode_absent(out);
703 }
704
705 Ok(())
706 }
707 }
708
709 impl ::fidl_next::FromWire<crate::wire::NodeListExtendedAttributesRequest>
710 for NodeListExtendedAttributesRequest
711 {
712 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
713 crate::wire::NodeListExtendedAttributesRequest,
714 Self,
715 > = unsafe {
716 ::fidl_next::CopyOptimization::enable_if(
717 true && <::fidl_next::ServerEnd<
718 crate::ExtendedAttributeIterator,
719 ::fidl_next::fuchsia::zx::Channel,
720 > as ::fidl_next::FromWire<
721 ::fidl_next::ServerEnd<
722 crate::ExtendedAttributeIterator,
723 ::fidl_next::fuchsia::WireChannel,
724 >,
725 >>::COPY_OPTIMIZATION
726 .is_enabled(),
727 )
728 };
729
730 #[inline]
731 fn from_wire(wire: crate::wire::NodeListExtendedAttributesRequest) -> Self {
732 Self { iterator: ::fidl_next::FromWire::from_wire(wire.iterator) }
733 }
734 }
735
736 #[doc = " The value type for an extended attribute. If the value is less than 32768\n bytes, then it is included inline. Values larger than this size are written\n into a vmo buffer.\n"]
737 #[derive(PartialEq, Debug)]
738 pub enum ExtendedAttributeValue {
739 Bytes(::std::vec::Vec<u8>),
740
741 Buffer(::fidl_next::fuchsia::zx::Vmo),
742
743 UnknownOrdinal_(u64),
744 }
745
746 impl ExtendedAttributeValue {
747 pub fn is_unknown(&self) -> bool {
748 #[allow(unreachable_patterns)]
749 match self {
750 Self::UnknownOrdinal_(_) => true,
751 _ => false,
752 }
753 }
754 }
755
756 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExtendedAttributeValue<'static>, ___E>
757 for ExtendedAttributeValue
758 where
759 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
760 ___E: ::fidl_next::Encoder,
761 ___E: ::fidl_next::fuchsia::HandleEncoder,
762 {
763 #[inline]
764 fn encode(
765 self,
766 encoder: &mut ___E,
767 out: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedAttributeValue<'static>>,
768 _: (),
769 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
770 ::fidl_next::munge!(let crate::wire::ExtendedAttributeValue { raw, _phantom: _ } = out);
771
772 match self {
773 Self::Bytes(value) => ::fidl_next::RawWireUnion::encode_as::<
774 ___E,
775 ::fidl_next::WireVector<'static, u8>,
776 >(value, 1, encoder, raw, (32768, ()))?,
777
778 Self::Buffer(value) => ::fidl_next::RawWireUnion::encode_as::<
779 ___E,
780 ::fidl_next::fuchsia::WireVmo,
781 >(value, 2, encoder, raw, ())?,
782
783 Self::UnknownOrdinal_(ordinal) => {
784 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
785 }
786 }
787
788 Ok(())
789 }
790 }
791
792 unsafe impl<___E>
793 ::fidl_next::EncodeOption<crate::wire_optional::ExtendedAttributeValue<'static>, ___E>
794 for ExtendedAttributeValue
795 where
796 ___E: ?Sized,
797 ExtendedAttributeValue:
798 ::fidl_next::Encode<crate::wire::ExtendedAttributeValue<'static>, ___E>,
799 {
800 #[inline]
801 fn encode_option(
802 this: ::core::option::Option<Self>,
803 encoder: &mut ___E,
804 out: &mut ::core::mem::MaybeUninit<
805 crate::wire_optional::ExtendedAttributeValue<'static>,
806 >,
807 _: (),
808 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
809 ::fidl_next::munge!(let crate::wire_optional::ExtendedAttributeValue { raw, _phantom: _ } = &mut *out);
810
811 if let Some(inner) = this {
812 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
813 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
814 } else {
815 ::fidl_next::RawWireUnion::encode_absent(raw);
816 }
817
818 Ok(())
819 }
820 }
821
822 impl<'de> ::fidl_next::FromWire<crate::wire::ExtendedAttributeValue<'de>>
823 for ExtendedAttributeValue
824 {
825 #[inline]
826 fn from_wire(wire: crate::wire::ExtendedAttributeValue<'de>) -> Self {
827 let wire = ::core::mem::ManuallyDrop::new(wire);
828 match wire.raw.ordinal() {
829 1 => Self::Bytes(::fidl_next::FromWire::from_wire(unsafe {
830 wire.raw.get().read_unchecked::<::fidl_next::WireVector<'de, u8>>()
831 })),
832
833 2 => Self::Buffer(::fidl_next::FromWire::from_wire(unsafe {
834 wire.raw.get().read_unchecked::<::fidl_next::fuchsia::WireVmo>()
835 })),
836
837 ord => return Self::UnknownOrdinal_(ord as u64),
838 }
839 }
840 }
841
842 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ExtendedAttributeValue<'de>>
843 for ExtendedAttributeValue
844 {
845 #[inline]
846 fn from_wire_option(
847 wire: crate::wire_optional::ExtendedAttributeValue<'de>,
848 ) -> ::core::option::Option<Self> {
849 if let Some(inner) = wire.into_option() {
850 Some(::fidl_next::FromWire::from_wire(inner))
851 } else {
852 None
853 }
854 }
855 }
856
857 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ExtendedAttributeValue<'de>>
858 for Box<ExtendedAttributeValue>
859 {
860 #[inline]
861 fn from_wire_option(
862 wire: crate::wire_optional::ExtendedAttributeValue<'de>,
863 ) -> ::core::option::Option<Self> {
864 <ExtendedAttributeValue as ::fidl_next::FromWireOption<
865 crate::wire_optional::ExtendedAttributeValue<'de>,
866 >>::from_wire_option(wire)
867 .map(Box::new)
868 }
869 }
870
871 #[derive(PartialEq, Debug)]
872 pub struct NodeSetExtendedAttributeRequest {
873 pub name: ::std::vec::Vec<u8>,
874
875 pub value: crate::natural::ExtendedAttributeValue,
876
877 pub mode: crate::natural::SetExtendedAttributeMode,
878 }
879
880 unsafe impl<___E>
881 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeRequest<'static>, ___E>
882 for NodeSetExtendedAttributeRequest
883 where
884 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
885 ___E: ::fidl_next::Encoder,
886 ___E: ::fidl_next::fuchsia::HandleEncoder,
887 {
888 #[inline]
889 fn encode(
890 self,
891 encoder_: &mut ___E,
892 out_: &mut ::core::mem::MaybeUninit<
893 crate::wire::NodeSetExtendedAttributeRequest<'static>,
894 >,
895 _: (),
896 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
897 ::fidl_next::munge! {
898 let crate::wire::NodeSetExtendedAttributeRequest {
899 name,
900 value,
901 mode,
902
903 } = out_;
904 }
905
906 ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
907
908 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
909 ::fidl_next::Constrained::validate(_field, (255, ()))?;
910
911 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
912
913 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
914
915 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
916
917 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
918
919 Ok(())
920 }
921 }
922
923 unsafe impl<___E>
924 ::fidl_next::EncodeOption<
925 ::fidl_next::WireBox<'static, crate::wire::NodeSetExtendedAttributeRequest<'static>>,
926 ___E,
927 > for NodeSetExtendedAttributeRequest
928 where
929 ___E: ::fidl_next::Encoder + ?Sized,
930 NodeSetExtendedAttributeRequest:
931 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeRequest<'static>, ___E>,
932 {
933 #[inline]
934 fn encode_option(
935 this: ::core::option::Option<Self>,
936 encoder: &mut ___E,
937 out: &mut ::core::mem::MaybeUninit<
938 ::fidl_next::WireBox<
939 'static,
940 crate::wire::NodeSetExtendedAttributeRequest<'static>,
941 >,
942 >,
943 _: (),
944 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
945 if let Some(inner) = this {
946 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
947 ::fidl_next::WireBox::encode_present(out);
948 } else {
949 ::fidl_next::WireBox::encode_absent(out);
950 }
951
952 Ok(())
953 }
954 }
955
956 impl<'de> ::fidl_next::FromWire<crate::wire::NodeSetExtendedAttributeRequest<'de>>
957 for NodeSetExtendedAttributeRequest
958 {
959 #[inline]
960 fn from_wire(wire: crate::wire::NodeSetExtendedAttributeRequest<'de>) -> Self {
961 Self {
962 name: ::fidl_next::FromWire::from_wire(wire.name),
963
964 value: ::fidl_next::FromWire::from_wire(wire.value),
965
966 mode: ::fidl_next::FromWire::from_wire(wire.mode),
967 }
968 }
969 }
970
971 #[doc = " Auxiliary data for the file representation of a node.\n"]
972 #[derive(PartialEq, Debug, Default)]
973 pub struct FileInfo {
974 pub is_append: ::core::option::Option<bool>,
975
976 pub observer: ::core::option::Option<::fidl_next::fuchsia::zx::Event>,
977
978 pub stream: ::core::option::Option<::fidl_next::fuchsia::zx::Stream>,
979
980 pub attributes: ::core::option::Option<crate::natural::NodeAttributes2>,
981 }
982
983 impl FileInfo {
984 fn __max_ordinal(&self) -> usize {
985 if self.attributes.is_some() {
986 return 4;
987 }
988
989 if self.stream.is_some() {
990 return 3;
991 }
992
993 if self.observer.is_some() {
994 return 2;
995 }
996
997 if self.is_append.is_some() {
998 return 1;
999 }
1000
1001 0
1002 }
1003 }
1004
1005 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileInfo<'static>, ___E> for FileInfo
1006 where
1007 ___E: ::fidl_next::Encoder + ?Sized,
1008 ___E: ::fidl_next::fuchsia::HandleEncoder,
1009 {
1010 #[inline]
1011 fn encode(
1012 mut self,
1013 encoder: &mut ___E,
1014 out: &mut ::core::mem::MaybeUninit<crate::wire::FileInfo<'static>>,
1015 _: (),
1016 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1017 ::fidl_next::munge!(let crate::wire::FileInfo { table } = out);
1018
1019 let max_ord = self.__max_ordinal();
1020
1021 let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
1022 ::fidl_next::Wire::zero_padding(&mut out);
1023
1024 let mut preallocated =
1025 ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);
1026
1027 for i in 1..=max_ord {
1028 match i {
1029 4 => {
1030 if let Some(value) = self.attributes.take() {
1031 ::fidl_next::WireEnvelope::encode_value::<
1032 crate::wire::NodeAttributes2<'static>,
1033 ___E,
1034 >(
1035 value, preallocated.encoder, &mut out, ()
1036 )?;
1037 } else {
1038 ::fidl_next::WireEnvelope::encode_zero(&mut out)
1039 }
1040 }
1041
1042 3 => {
1043 if let Some(value) = self.stream.take() {
1044 ::fidl_next::WireEnvelope::encode_value::<
1045 ::fidl_next::fuchsia::WireStream,
1046 ___E,
1047 >(
1048 value, preallocated.encoder, &mut out, ()
1049 )?;
1050 } else {
1051 ::fidl_next::WireEnvelope::encode_zero(&mut out)
1052 }
1053 }
1054
1055 2 => {
1056 if let Some(value) = self.observer.take() {
1057 ::fidl_next::WireEnvelope::encode_value::<
1058 ::fidl_next::fuchsia::WireEvent,
1059 ___E,
1060 >(
1061 value, preallocated.encoder, &mut out, ()
1062 )?;
1063 } else {
1064 ::fidl_next::WireEnvelope::encode_zero(&mut out)
1065 }
1066 }
1067
1068 1 => {
1069 if let Some(value) = self.is_append.take() {
1070 ::fidl_next::WireEnvelope::encode_value::<bool, ___E>(
1071 value,
1072 preallocated.encoder,
1073 &mut out,
1074 (),
1075 )?;
1076 } else {
1077 ::fidl_next::WireEnvelope::encode_zero(&mut out)
1078 }
1079 }
1080
1081 _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
1082 }
1083 unsafe {
1084 preallocated.write_next(out.assume_init_ref());
1085 }
1086 }
1087
1088 ::fidl_next::WireTable::encode_len(table, max_ord);
1089
1090 Ok(())
1091 }
1092 }
1093
1094 impl<'de> ::fidl_next::FromWire<crate::wire::FileInfo<'de>> for FileInfo {
1095 #[inline]
1096 fn from_wire(wire_: crate::wire::FileInfo<'de>) -> Self {
1097 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1098
1099 let is_append = wire_.table.get(1);
1100
1101 let observer = wire_.table.get(2);
1102
1103 let stream = wire_.table.get(3);
1104
1105 let attributes = wire_.table.get(4);
1106
1107 Self {
1108 is_append: is_append.map(|envelope| {
1109 ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
1110 }),
1111
1112 observer: observer.map(|envelope| {
1113 ::fidl_next::FromWire::from_wire(unsafe {
1114 envelope.read_unchecked::<::fidl_next::fuchsia::WireEvent>()
1115 })
1116 }),
1117
1118 stream: stream.map(|envelope| {
1119 ::fidl_next::FromWire::from_wire(unsafe {
1120 envelope.read_unchecked::<::fidl_next::fuchsia::WireStream>()
1121 })
1122 }),
1123
1124 attributes: attributes.map(|envelope| {
1125 ::fidl_next::FromWire::from_wire(unsafe {
1126 envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
1127 })
1128 }),
1129 }
1130 }
1131 }
1132
1133 #[derive(PartialEq, Debug)]
1134 pub enum Representation {
1135 Node(crate::natural::NodeInfo),
1136
1137 Directory(crate::natural::DirectoryInfo),
1138
1139 File(crate::natural::FileInfo),
1140
1141 Symlink(crate::natural::SymlinkInfo),
1142
1143 UnknownOrdinal_(u64),
1144 }
1145
1146 impl Representation {
1147 pub fn is_unknown(&self) -> bool {
1148 #[allow(unreachable_patterns)]
1149 match self {
1150 Self::UnknownOrdinal_(_) => true,
1151 _ => false,
1152 }
1153 }
1154 }
1155
1156 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Representation<'static>, ___E> for Representation
1157 where
1158 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1159 ___E: ::fidl_next::Encoder,
1160 ___E: ::fidl_next::fuchsia::HandleEncoder,
1161 {
1162 #[inline]
1163 fn encode(
1164 self,
1165 encoder: &mut ___E,
1166 out: &mut ::core::mem::MaybeUninit<crate::wire::Representation<'static>>,
1167 _: (),
1168 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1169 ::fidl_next::munge!(let crate::wire::Representation { raw, _phantom: _ } = out);
1170
1171 match self {
1172 Self::Node(value) => ::fidl_next::RawWireUnion::encode_as::<
1173 ___E,
1174 crate::wire::NodeInfo<'static>,
1175 >(value, 1, encoder, raw, ())?,
1176
1177 Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as::<
1178 ___E,
1179 crate::wire::DirectoryInfo<'static>,
1180 >(value, 2, encoder, raw, ())?,
1181
1182 Self::File(value) => ::fidl_next::RawWireUnion::encode_as::<
1183 ___E,
1184 crate::wire::FileInfo<'static>,
1185 >(value, 3, encoder, raw, ())?,
1186
1187 Self::Symlink(value) => ::fidl_next::RawWireUnion::encode_as::<
1188 ___E,
1189 crate::wire::SymlinkInfo<'static>,
1190 >(value, 4, encoder, raw, ())?,
1191
1192 Self::UnknownOrdinal_(ordinal) => {
1193 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
1194 }
1195 }
1196
1197 Ok(())
1198 }
1199 }
1200
1201 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::Representation<'static>, ___E>
1202 for Representation
1203 where
1204 ___E: ?Sized,
1205 Representation: ::fidl_next::Encode<crate::wire::Representation<'static>, ___E>,
1206 {
1207 #[inline]
1208 fn encode_option(
1209 this: ::core::option::Option<Self>,
1210 encoder: &mut ___E,
1211 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::Representation<'static>>,
1212 _: (),
1213 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1214 ::fidl_next::munge!(let crate::wire_optional::Representation { raw, _phantom: _ } = &mut *out);
1215
1216 if let Some(inner) = this {
1217 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
1218 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
1219 } else {
1220 ::fidl_next::RawWireUnion::encode_absent(raw);
1221 }
1222
1223 Ok(())
1224 }
1225 }
1226
1227 impl<'de> ::fidl_next::FromWire<crate::wire::Representation<'de>> for Representation {
1228 #[inline]
1229 fn from_wire(wire: crate::wire::Representation<'de>) -> Self {
1230 let wire = ::core::mem::ManuallyDrop::new(wire);
1231 match wire.raw.ordinal() {
1232 1 => Self::Node(::fidl_next::FromWire::from_wire(unsafe {
1233 wire.raw.get().read_unchecked::<crate::wire::NodeInfo<'de>>()
1234 })),
1235
1236 2 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
1237 wire.raw.get().read_unchecked::<crate::wire::DirectoryInfo<'de>>()
1238 })),
1239
1240 3 => Self::File(::fidl_next::FromWire::from_wire(unsafe {
1241 wire.raw.get().read_unchecked::<crate::wire::FileInfo<'de>>()
1242 })),
1243
1244 4 => Self::Symlink(::fidl_next::FromWire::from_wire(unsafe {
1245 wire.raw.get().read_unchecked::<crate::wire::SymlinkInfo<'de>>()
1246 })),
1247
1248 ord => return Self::UnknownOrdinal_(ord as u64),
1249 }
1250 }
1251 }
1252
1253 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Representation<'de>>
1254 for Representation
1255 {
1256 #[inline]
1257 fn from_wire_option(
1258 wire: crate::wire_optional::Representation<'de>,
1259 ) -> ::core::option::Option<Self> {
1260 if let Some(inner) = wire.into_option() {
1261 Some(::fidl_next::FromWire::from_wire(inner))
1262 } else {
1263 None
1264 }
1265 }
1266 }
1267
1268 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Representation<'de>>
1269 for Box<Representation>
1270 {
1271 #[inline]
1272 fn from_wire_option(
1273 wire: crate::wire_optional::Representation<'de>,
1274 ) -> ::core::option::Option<Self> {
1275 <Representation as ::fidl_next::FromWireOption<
1276 crate::wire_optional::Representation<'de>,
1277 >>::from_wire_option(wire)
1278 .map(Box::new)
1279 }
1280 }
1281
1282 #[derive(PartialEq, Debug)]
1283 pub struct DirectoryOpenRequest {
1284 pub path: ::std::string::String,
1285
1286 pub flags: crate::natural::Flags,
1287
1288 pub options: crate::natural::Options,
1289
1290 pub object: ::fidl_next::fuchsia::zx::Channel,
1291 }
1292
1293 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryOpenRequest<'static>, ___E>
1294 for DirectoryOpenRequest
1295 where
1296 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1297 ___E: ::fidl_next::Encoder,
1298 ___E: ::fidl_next::fuchsia::HandleEncoder,
1299 {
1300 #[inline]
1301 fn encode(
1302 self,
1303 encoder_: &mut ___E,
1304 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryOpenRequest<'static>>,
1305 _: (),
1306 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1307 ::fidl_next::munge! {
1308 let crate::wire::DirectoryOpenRequest {
1309 path,
1310 flags,
1311 options,
1312 object,
1313
1314 } = out_;
1315 }
1316
1317 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
1318
1319 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
1320 ::fidl_next::Constrained::validate(_field, 4095)?;
1321
1322 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
1323
1324 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
1325
1326 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
1327
1328 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
1329
1330 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
1331
1332 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
1333
1334 Ok(())
1335 }
1336 }
1337
1338 unsafe impl<___E>
1339 ::fidl_next::EncodeOption<
1340 ::fidl_next::WireBox<'static, crate::wire::DirectoryOpenRequest<'static>>,
1341 ___E,
1342 > for DirectoryOpenRequest
1343 where
1344 ___E: ::fidl_next::Encoder + ?Sized,
1345 DirectoryOpenRequest: ::fidl_next::Encode<crate::wire::DirectoryOpenRequest<'static>, ___E>,
1346 {
1347 #[inline]
1348 fn encode_option(
1349 this: ::core::option::Option<Self>,
1350 encoder: &mut ___E,
1351 out: &mut ::core::mem::MaybeUninit<
1352 ::fidl_next::WireBox<'static, crate::wire::DirectoryOpenRequest<'static>>,
1353 >,
1354 _: (),
1355 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1356 if let Some(inner) = this {
1357 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1358 ::fidl_next::WireBox::encode_present(out);
1359 } else {
1360 ::fidl_next::WireBox::encode_absent(out);
1361 }
1362
1363 Ok(())
1364 }
1365 }
1366
1367 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryOpenRequest<'de>> for DirectoryOpenRequest {
1368 #[inline]
1369 fn from_wire(wire: crate::wire::DirectoryOpenRequest<'de>) -> Self {
1370 Self {
1371 path: ::fidl_next::FromWire::from_wire(wire.path),
1372
1373 flags: ::fidl_next::FromWire::from_wire(wire.flags),
1374
1375 options: ::fidl_next::FromWire::from_wire(wire.options),
1376
1377 object: ::fidl_next::FromWire::from_wire(wire.object),
1378 }
1379 }
1380 }
1381
1382 #[derive(PartialEq, Debug)]
1383 #[repr(C)]
1384 pub struct NodeDeprecatedCloneRequest {
1385 pub flags: crate::natural::OpenFlags,
1386
1387 pub object: ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::zx::Channel>,
1388 }
1389
1390 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedCloneRequest, ___E>
1391 for NodeDeprecatedCloneRequest
1392 where
1393 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1394 ___E: ::fidl_next::fuchsia::HandleEncoder,
1395 {
1396 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1397 Self,
1398 crate::wire::NodeDeprecatedCloneRequest,
1399 > = unsafe {
1400 ::fidl_next::CopyOptimization::enable_if(
1401 true
1402
1403 && <
1404 crate::natural::OpenFlags as ::fidl_next::Encode<crate::wire::OpenFlags, ___E>
1405 >::COPY_OPTIMIZATION.is_enabled()
1406
1407 && <
1408 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::zx::Channel> as ::fidl_next::Encode<::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>, ___E>
1409 >::COPY_OPTIMIZATION.is_enabled()
1410
1411 )
1412 };
1413
1414 #[inline]
1415 fn encode(
1416 self,
1417 encoder_: &mut ___E,
1418 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedCloneRequest>,
1419 _: (),
1420 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1421 ::fidl_next::munge! {
1422 let crate::wire::NodeDeprecatedCloneRequest {
1423 flags,
1424 object,
1425
1426 } = out_;
1427 }
1428
1429 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
1430
1431 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
1432
1433 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
1434
1435 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
1436
1437 Ok(())
1438 }
1439 }
1440
1441 unsafe impl<___E>
1442 ::fidl_next::EncodeOption<
1443 ::fidl_next::WireBox<'static, crate::wire::NodeDeprecatedCloneRequest>,
1444 ___E,
1445 > for NodeDeprecatedCloneRequest
1446 where
1447 ___E: ::fidl_next::Encoder + ?Sized,
1448 NodeDeprecatedCloneRequest:
1449 ::fidl_next::Encode<crate::wire::NodeDeprecatedCloneRequest, ___E>,
1450 {
1451 #[inline]
1452 fn encode_option(
1453 this: ::core::option::Option<Self>,
1454 encoder: &mut ___E,
1455 out: &mut ::core::mem::MaybeUninit<
1456 ::fidl_next::WireBox<'static, crate::wire::NodeDeprecatedCloneRequest>,
1457 >,
1458 _: (),
1459 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1460 if let Some(inner) = this {
1461 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1462 ::fidl_next::WireBox::encode_present(out);
1463 } else {
1464 ::fidl_next::WireBox::encode_absent(out);
1465 }
1466
1467 Ok(())
1468 }
1469 }
1470
1471 impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedCloneRequest> for NodeDeprecatedCloneRequest {
1472 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1473 crate::wire::NodeDeprecatedCloneRequest,
1474 Self,
1475 > = unsafe {
1476 ::fidl_next::CopyOptimization::enable_if(
1477 true
1478
1479 && <
1480 crate::natural::OpenFlags as ::fidl_next::FromWire<crate::wire::OpenFlags>
1481 >::COPY_OPTIMIZATION.is_enabled()
1482
1483 && <
1484 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::zx::Channel> as ::fidl_next::FromWire<::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>>
1485 >::COPY_OPTIMIZATION.is_enabled()
1486
1487 )
1488 };
1489
1490 #[inline]
1491 fn from_wire(wire: crate::wire::NodeDeprecatedCloneRequest) -> Self {
1492 Self {
1493 flags: ::fidl_next::FromWire::from_wire(wire.flags),
1494
1495 object: ::fidl_next::FromWire::from_wire(wire.object),
1496 }
1497 }
1498 }
1499
1500 #[derive(PartialEq, Debug)]
1501 pub struct DirectoryDeprecatedOpenRequest {
1502 pub flags: crate::natural::OpenFlags,
1503
1504 pub mode: crate::natural::ModeType,
1505
1506 pub path: ::std::string::String,
1507
1508 pub object: ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::zx::Channel>,
1509 }
1510
1511 unsafe impl<___E>
1512 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedOpenRequest<'static>, ___E>
1513 for DirectoryDeprecatedOpenRequest
1514 where
1515 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1516 ___E: ::fidl_next::Encoder,
1517 ___E: ::fidl_next::fuchsia::HandleEncoder,
1518 {
1519 #[inline]
1520 fn encode(
1521 self,
1522 encoder_: &mut ___E,
1523 out_: &mut ::core::mem::MaybeUninit<
1524 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
1525 >,
1526 _: (),
1527 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1528 ::fidl_next::munge! {
1529 let crate::wire::DirectoryDeprecatedOpenRequest {
1530 flags,
1531 mode,
1532 path,
1533 object,
1534
1535 } = out_;
1536 }
1537
1538 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
1539
1540 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
1541
1542 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
1543
1544 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
1545
1546 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
1547
1548 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
1549 ::fidl_next::Constrained::validate(_field, 4095)?;
1550
1551 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
1552
1553 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
1554
1555 Ok(())
1556 }
1557 }
1558
1559 unsafe impl<___E>
1560 ::fidl_next::EncodeOption<
1561 ::fidl_next::WireBox<'static, crate::wire::DirectoryDeprecatedOpenRequest<'static>>,
1562 ___E,
1563 > for DirectoryDeprecatedOpenRequest
1564 where
1565 ___E: ::fidl_next::Encoder + ?Sized,
1566 DirectoryDeprecatedOpenRequest:
1567 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedOpenRequest<'static>, ___E>,
1568 {
1569 #[inline]
1570 fn encode_option(
1571 this: ::core::option::Option<Self>,
1572 encoder: &mut ___E,
1573 out: &mut ::core::mem::MaybeUninit<
1574 ::fidl_next::WireBox<'static, crate::wire::DirectoryDeprecatedOpenRequest<'static>>,
1575 >,
1576 _: (),
1577 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1578 if let Some(inner) = this {
1579 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1580 ::fidl_next::WireBox::encode_present(out);
1581 } else {
1582 ::fidl_next::WireBox::encode_absent(out);
1583 }
1584
1585 Ok(())
1586 }
1587 }
1588
1589 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryDeprecatedOpenRequest<'de>>
1590 for DirectoryDeprecatedOpenRequest
1591 {
1592 #[inline]
1593 fn from_wire(wire: crate::wire::DirectoryDeprecatedOpenRequest<'de>) -> Self {
1594 Self {
1595 flags: ::fidl_next::FromWire::from_wire(wire.flags),
1596
1597 mode: ::fidl_next::FromWire::from_wire(wire.mode),
1598
1599 path: ::fidl_next::FromWire::from_wire(wire.path),
1600
1601 object: ::fidl_next::FromWire::from_wire(wire.object),
1602 }
1603 }
1604 }
1605
1606 #[derive(PartialEq, Debug)]
1607 pub struct DirectoryCreateSymlinkRequest {
1608 pub name: ::std::string::String,
1609
1610 pub target: ::std::vec::Vec<u8>,
1611
1612 pub connection: ::core::option::Option<
1613 ::fidl_next::ServerEnd<crate::Symlink, ::fidl_next::fuchsia::zx::Channel>,
1614 >,
1615 }
1616
1617 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkRequest<'static>, ___E>
1618 for DirectoryCreateSymlinkRequest
1619 where
1620 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1621 ___E: ::fidl_next::Encoder,
1622 ___E: ::fidl_next::fuchsia::HandleEncoder,
1623 {
1624 #[inline]
1625 fn encode(
1626 self,
1627 encoder_: &mut ___E,
1628 out_: &mut ::core::mem::MaybeUninit<
1629 crate::wire::DirectoryCreateSymlinkRequest<'static>,
1630 >,
1631 _: (),
1632 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1633 ::fidl_next::munge! {
1634 let crate::wire::DirectoryCreateSymlinkRequest {
1635 name,
1636 target,
1637 connection,
1638
1639 } = out_;
1640 }
1641
1642 ::fidl_next::Encode::encode(self.name, encoder_, name, 255)?;
1643
1644 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
1645 ::fidl_next::Constrained::validate(_field, 255)?;
1646
1647 ::fidl_next::Encode::encode(self.target, encoder_, target, (4095, ()))?;
1648
1649 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(target.as_mut_ptr()) };
1650 ::fidl_next::Constrained::validate(_field, (4095, ()))?;
1651
1652 ::fidl_next::Encode::encode(self.connection, encoder_, connection, ())?;
1653
1654 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(connection.as_mut_ptr()) };
1655
1656 Ok(())
1657 }
1658 }
1659
1660 unsafe impl<___E>
1661 ::fidl_next::EncodeOption<
1662 ::fidl_next::WireBox<'static, crate::wire::DirectoryCreateSymlinkRequest<'static>>,
1663 ___E,
1664 > for DirectoryCreateSymlinkRequest
1665 where
1666 ___E: ::fidl_next::Encoder + ?Sized,
1667 DirectoryCreateSymlinkRequest:
1668 ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkRequest<'static>, ___E>,
1669 {
1670 #[inline]
1671 fn encode_option(
1672 this: ::core::option::Option<Self>,
1673 encoder: &mut ___E,
1674 out: &mut ::core::mem::MaybeUninit<
1675 ::fidl_next::WireBox<'static, crate::wire::DirectoryCreateSymlinkRequest<'static>>,
1676 >,
1677 _: (),
1678 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1679 if let Some(inner) = this {
1680 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1681 ::fidl_next::WireBox::encode_present(out);
1682 } else {
1683 ::fidl_next::WireBox::encode_absent(out);
1684 }
1685
1686 Ok(())
1687 }
1688 }
1689
1690 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryCreateSymlinkRequest<'de>>
1691 for DirectoryCreateSymlinkRequest
1692 {
1693 #[inline]
1694 fn from_wire(wire: crate::wire::DirectoryCreateSymlinkRequest<'de>) -> Self {
1695 Self {
1696 name: ::fidl_next::FromWire::from_wire(wire.name),
1697
1698 target: ::fidl_next::FromWire::from_wire(wire.target),
1699
1700 connection: ::fidl_next::FromWire::from_wire(wire.connection),
1701 }
1702 }
1703 }
1704
1705 #[derive(PartialEq, Debug)]
1706 #[repr(C)]
1707 pub struct FileGetBackingMemoryResponse {
1708 pub vmo: ::fidl_next::fuchsia::zx::Vmo,
1709 }
1710
1711 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryResponse, ___E>
1712 for FileGetBackingMemoryResponse
1713 where
1714 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1715 ___E: ::fidl_next::fuchsia::HandleEncoder,
1716 {
1717 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1718 Self,
1719 crate::wire::FileGetBackingMemoryResponse,
1720 > = unsafe {
1721 ::fidl_next::CopyOptimization::enable_if(
1722 true && <::fidl_next::fuchsia::zx::Vmo as ::fidl_next::Encode<
1723 ::fidl_next::fuchsia::WireVmo,
1724 ___E,
1725 >>::COPY_OPTIMIZATION
1726 .is_enabled(),
1727 )
1728 };
1729
1730 #[inline]
1731 fn encode(
1732 self,
1733 encoder_: &mut ___E,
1734 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryResponse>,
1735 _: (),
1736 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1737 ::fidl_next::munge! {
1738 let crate::wire::FileGetBackingMemoryResponse {
1739 vmo,
1740
1741 } = out_;
1742 }
1743
1744 ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
1745
1746 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vmo.as_mut_ptr()) };
1747
1748 Ok(())
1749 }
1750 }
1751
1752 unsafe impl<___E>
1753 ::fidl_next::EncodeOption<
1754 ::fidl_next::WireBox<'static, crate::wire::FileGetBackingMemoryResponse>,
1755 ___E,
1756 > for FileGetBackingMemoryResponse
1757 where
1758 ___E: ::fidl_next::Encoder + ?Sized,
1759 FileGetBackingMemoryResponse:
1760 ::fidl_next::Encode<crate::wire::FileGetBackingMemoryResponse, ___E>,
1761 {
1762 #[inline]
1763 fn encode_option(
1764 this: ::core::option::Option<Self>,
1765 encoder: &mut ___E,
1766 out: &mut ::core::mem::MaybeUninit<
1767 ::fidl_next::WireBox<'static, crate::wire::FileGetBackingMemoryResponse>,
1768 >,
1769 _: (),
1770 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1771 if let Some(inner) = this {
1772 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1773 ::fidl_next::WireBox::encode_present(out);
1774 } else {
1775 ::fidl_next::WireBox::encode_absent(out);
1776 }
1777
1778 Ok(())
1779 }
1780 }
1781
1782 impl ::fidl_next::FromWire<crate::wire::FileGetBackingMemoryResponse>
1783 for FileGetBackingMemoryResponse
1784 {
1785 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1786 crate::wire::FileGetBackingMemoryResponse,
1787 Self,
1788 > = unsafe {
1789 ::fidl_next::CopyOptimization::enable_if(
1790 true && <::fidl_next::fuchsia::zx::Vmo as ::fidl_next::FromWire<
1791 ::fidl_next::fuchsia::WireVmo,
1792 >>::COPY_OPTIMIZATION
1793 .is_enabled(),
1794 )
1795 };
1796
1797 #[inline]
1798 fn from_wire(wire: crate::wire::FileGetBackingMemoryResponse) -> Self {
1799 Self { vmo: ::fidl_next::FromWire::from_wire(wire.vmo) }
1800 }
1801 }
1802
1803 #[derive(PartialEq, Debug)]
1804 pub struct LinkableLinkIntoRequest {
1805 pub dst_parent_token: ::fidl_next::fuchsia::zx::Event,
1806
1807 pub dst: ::std::string::String,
1808 }
1809
1810 unsafe impl<___E> ::fidl_next::Encode<crate::wire::LinkableLinkIntoRequest<'static>, ___E>
1811 for LinkableLinkIntoRequest
1812 where
1813 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1814 ___E: ::fidl_next::Encoder,
1815 ___E: ::fidl_next::fuchsia::HandleEncoder,
1816 {
1817 #[inline]
1818 fn encode(
1819 self,
1820 encoder_: &mut ___E,
1821 out_: &mut ::core::mem::MaybeUninit<crate::wire::LinkableLinkIntoRequest<'static>>,
1822 _: (),
1823 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1824 ::fidl_next::munge! {
1825 let crate::wire::LinkableLinkIntoRequest {
1826 dst_parent_token,
1827 dst,
1828
1829 } = out_;
1830 }
1831
1832 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
1833
1834 let mut _field =
1835 unsafe { ::fidl_next::Slot::new_unchecked(dst_parent_token.as_mut_ptr()) };
1836
1837 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
1838
1839 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dst.as_mut_ptr()) };
1840 ::fidl_next::Constrained::validate(_field, 255)?;
1841
1842 Ok(())
1843 }
1844 }
1845
1846 unsafe impl<___E>
1847 ::fidl_next::EncodeOption<
1848 ::fidl_next::WireBox<'static, crate::wire::LinkableLinkIntoRequest<'static>>,
1849 ___E,
1850 > for LinkableLinkIntoRequest
1851 where
1852 ___E: ::fidl_next::Encoder + ?Sized,
1853 LinkableLinkIntoRequest:
1854 ::fidl_next::Encode<crate::wire::LinkableLinkIntoRequest<'static>, ___E>,
1855 {
1856 #[inline]
1857 fn encode_option(
1858 this: ::core::option::Option<Self>,
1859 encoder: &mut ___E,
1860 out: &mut ::core::mem::MaybeUninit<
1861 ::fidl_next::WireBox<'static, crate::wire::LinkableLinkIntoRequest<'static>>,
1862 >,
1863 _: (),
1864 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1865 if let Some(inner) = this {
1866 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1867 ::fidl_next::WireBox::encode_present(out);
1868 } else {
1869 ::fidl_next::WireBox::encode_absent(out);
1870 }
1871
1872 Ok(())
1873 }
1874 }
1875
1876 impl<'de> ::fidl_next::FromWire<crate::wire::LinkableLinkIntoRequest<'de>>
1877 for LinkableLinkIntoRequest
1878 {
1879 #[inline]
1880 fn from_wire(wire: crate::wire::LinkableLinkIntoRequest<'de>) -> Self {
1881 Self {
1882 dst_parent_token: ::fidl_next::FromWire::from_wire(wire.dst_parent_token),
1883
1884 dst: ::fidl_next::FromWire::from_wire(wire.dst),
1885 }
1886 }
1887 }
1888
1889 #[derive(PartialEq, Debug)]
1890 pub struct FileAllocateRequest {
1891 pub offset: u64,
1892
1893 pub length: u64,
1894
1895 pub mode: crate::natural::AllocateMode,
1896 }
1897
1898 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileAllocateRequest, ___E>
1899 for FileAllocateRequest
1900 where
1901 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1902 ___E: ::fidl_next::fuchsia::HandleEncoder,
1903 {
1904 #[inline]
1905 fn encode(
1906 self,
1907 encoder_: &mut ___E,
1908 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileAllocateRequest>,
1909 _: (),
1910 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1911 ::fidl_next::munge! {
1912 let crate::wire::FileAllocateRequest {
1913 offset,
1914 length,
1915 mode,
1916
1917 } = out_;
1918 }
1919
1920 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
1921
1922 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
1923
1924 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
1925
1926 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
1927
1928 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
1929
1930 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
1931
1932 Ok(())
1933 }
1934 }
1935
1936 unsafe impl<___E>
1937 ::fidl_next::EncodeOption<
1938 ::fidl_next::WireBox<'static, crate::wire::FileAllocateRequest>,
1939 ___E,
1940 > for FileAllocateRequest
1941 where
1942 ___E: ::fidl_next::Encoder + ?Sized,
1943 FileAllocateRequest: ::fidl_next::Encode<crate::wire::FileAllocateRequest, ___E>,
1944 {
1945 #[inline]
1946 fn encode_option(
1947 this: ::core::option::Option<Self>,
1948 encoder: &mut ___E,
1949 out: &mut ::core::mem::MaybeUninit<
1950 ::fidl_next::WireBox<'static, crate::wire::FileAllocateRequest>,
1951 >,
1952 _: (),
1953 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1954 if let Some(inner) = this {
1955 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1956 ::fidl_next::WireBox::encode_present(out);
1957 } else {
1958 ::fidl_next::WireBox::encode_absent(out);
1959 }
1960
1961 Ok(())
1962 }
1963 }
1964
1965 impl ::fidl_next::FromWire<crate::wire::FileAllocateRequest> for FileAllocateRequest {
1966 #[inline]
1967 fn from_wire(wire: crate::wire::FileAllocateRequest) -> Self {
1968 Self {
1969 offset: ::fidl_next::FromWire::from_wire(wire.offset),
1970
1971 length: ::fidl_next::FromWire::from_wire(wire.length),
1972
1973 mode: ::fidl_next::FromWire::from_wire(wire.mode),
1974 }
1975 }
1976 }
1977
1978 #[derive(PartialEq, Debug)]
1979 pub struct FileEnableVerityRequest {
1980 pub options: crate::natural::VerificationOptions,
1981 }
1982
1983 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileEnableVerityRequest<'static>, ___E>
1984 for FileEnableVerityRequest
1985 where
1986 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1987 ___E: ::fidl_next::Encoder,
1988 ___E: ::fidl_next::fuchsia::HandleEncoder,
1989 {
1990 #[inline]
1991 fn encode(
1992 self,
1993 encoder_: &mut ___E,
1994 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileEnableVerityRequest<'static>>,
1995 _: (),
1996 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1997 ::fidl_next::munge! {
1998 let crate::wire::FileEnableVerityRequest {
1999 options,
2000
2001 } = out_;
2002 }
2003
2004 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
2005
2006 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
2007
2008 Ok(())
2009 }
2010 }
2011
2012 unsafe impl<___E>
2013 ::fidl_next::EncodeOption<
2014 ::fidl_next::WireBox<'static, crate::wire::FileEnableVerityRequest<'static>>,
2015 ___E,
2016 > for FileEnableVerityRequest
2017 where
2018 ___E: ::fidl_next::Encoder + ?Sized,
2019 FileEnableVerityRequest:
2020 ::fidl_next::Encode<crate::wire::FileEnableVerityRequest<'static>, ___E>,
2021 {
2022 #[inline]
2023 fn encode_option(
2024 this: ::core::option::Option<Self>,
2025 encoder: &mut ___E,
2026 out: &mut ::core::mem::MaybeUninit<
2027 ::fidl_next::WireBox<'static, crate::wire::FileEnableVerityRequest<'static>>,
2028 >,
2029 _: (),
2030 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2031 if let Some(inner) = this {
2032 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2033 ::fidl_next::WireBox::encode_present(out);
2034 } else {
2035 ::fidl_next::WireBox::encode_absent(out);
2036 }
2037
2038 Ok(())
2039 }
2040 }
2041
2042 impl<'de> ::fidl_next::FromWire<crate::wire::FileEnableVerityRequest<'de>>
2043 for FileEnableVerityRequest
2044 {
2045 #[inline]
2046 fn from_wire(wire: crate::wire::FileEnableVerityRequest<'de>) -> Self {
2047 Self { options: ::fidl_next::FromWire::from_wire(wire.options) }
2048 }
2049 }
2050
2051 #[derive(PartialEq, Debug)]
2052 #[repr(C)]
2053 pub struct FileObject {
2054 pub event: ::core::option::Option<::fidl_next::fuchsia::zx::Event>,
2055
2056 pub stream: ::core::option::Option<::fidl_next::fuchsia::zx::Stream>,
2057 }
2058
2059 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileObject, ___E> for FileObject
2060 where
2061 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2062 ___E: ::fidl_next::fuchsia::HandleEncoder,
2063 {
2064 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::FileObject> = unsafe {
2065 ::fidl_next::CopyOptimization::enable_if(
2066 true
2067
2068 && <
2069 ::core::option::Option<::fidl_next::fuchsia::zx::Event> as ::fidl_next::Encode<::fidl_next::fuchsia::WireOptionalEvent, ___E>
2070 >::COPY_OPTIMIZATION.is_enabled()
2071
2072 && <
2073 ::core::option::Option<::fidl_next::fuchsia::zx::Stream> as ::fidl_next::Encode<::fidl_next::fuchsia::WireOptionalStream, ___E>
2074 >::COPY_OPTIMIZATION.is_enabled()
2075
2076 )
2077 };
2078
2079 #[inline]
2080 fn encode(
2081 self,
2082 encoder_: &mut ___E,
2083 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileObject>,
2084 _: (),
2085 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2086 ::fidl_next::munge! {
2087 let crate::wire::FileObject {
2088 event,
2089 stream,
2090
2091 } = out_;
2092 }
2093
2094 ::fidl_next::Encode::encode(self.event, encoder_, event, ())?;
2095
2096 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(event.as_mut_ptr()) };
2097
2098 ::fidl_next::Encode::encode(self.stream, encoder_, stream, ())?;
2099
2100 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(stream.as_mut_ptr()) };
2101
2102 Ok(())
2103 }
2104 }
2105
2106 unsafe impl<___E>
2107 ::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::FileObject>, ___E>
2108 for FileObject
2109 where
2110 ___E: ::fidl_next::Encoder + ?Sized,
2111 FileObject: ::fidl_next::Encode<crate::wire::FileObject, ___E>,
2112 {
2113 #[inline]
2114 fn encode_option(
2115 this: ::core::option::Option<Self>,
2116 encoder: &mut ___E,
2117 out: &mut ::core::mem::MaybeUninit<
2118 ::fidl_next::WireBox<'static, crate::wire::FileObject>,
2119 >,
2120 _: (),
2121 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2122 if let Some(inner) = this {
2123 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2124 ::fidl_next::WireBox::encode_present(out);
2125 } else {
2126 ::fidl_next::WireBox::encode_absent(out);
2127 }
2128
2129 Ok(())
2130 }
2131 }
2132
2133 impl ::fidl_next::FromWire<crate::wire::FileObject> for FileObject {
2134 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::FileObject, Self> = unsafe {
2135 ::fidl_next::CopyOptimization::enable_if(
2136 true
2137
2138 && <
2139 ::core::option::Option<::fidl_next::fuchsia::zx::Event> as ::fidl_next::FromWire<::fidl_next::fuchsia::WireOptionalEvent>
2140 >::COPY_OPTIMIZATION.is_enabled()
2141
2142 && <
2143 ::core::option::Option<::fidl_next::fuchsia::zx::Stream> as ::fidl_next::FromWire<::fidl_next::fuchsia::WireOptionalStream>
2144 >::COPY_OPTIMIZATION.is_enabled()
2145
2146 )
2147 };
2148
2149 #[inline]
2150 fn from_wire(wire: crate::wire::FileObject) -> Self {
2151 Self {
2152 event: ::fidl_next::FromWire::from_wire(wire.event),
2153
2154 stream: ::fidl_next::FromWire::from_wire(wire.stream),
2155 }
2156 }
2157 }
2158
2159 #[derive(PartialEq, Debug)]
2160 pub enum NodeInfoDeprecated {
2161 Service(crate::natural::Service),
2162
2163 File(crate::natural::FileObject),
2164
2165 Directory(crate::natural::DirectoryObject),
2166
2167 Symlink(crate::natural::SymlinkObject),
2168 }
2169
2170 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeInfoDeprecated<'static>, ___E>
2171 for NodeInfoDeprecated
2172 where
2173 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2174 ___E: ::fidl_next::Encoder,
2175 ___E: ::fidl_next::fuchsia::HandleEncoder,
2176 {
2177 #[inline]
2178 fn encode(
2179 self,
2180 encoder: &mut ___E,
2181 out: &mut ::core::mem::MaybeUninit<crate::wire::NodeInfoDeprecated<'static>>,
2182 _: (),
2183 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2184 ::fidl_next::munge!(let crate::wire::NodeInfoDeprecated { raw, _phantom: _ } = out);
2185
2186 match self {
2187 Self::Service(value) => ::fidl_next::RawWireUnion::encode_as::<
2188 ___E,
2189 crate::wire::Service,
2190 >(value, 1, encoder, raw, ())?,
2191
2192 Self::File(value) => ::fidl_next::RawWireUnion::encode_as::<
2193 ___E,
2194 crate::wire::FileObject,
2195 >(value, 2, encoder, raw, ())?,
2196
2197 Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as::<
2198 ___E,
2199 crate::wire::DirectoryObject,
2200 >(value, 3, encoder, raw, ())?,
2201
2202 Self::Symlink(value) => ::fidl_next::RawWireUnion::encode_as::<
2203 ___E,
2204 crate::wire::SymlinkObject<'static>,
2205 >(value, 4, encoder, raw, ())?,
2206 }
2207
2208 Ok(())
2209 }
2210 }
2211
2212 unsafe impl<___E>
2213 ::fidl_next::EncodeOption<crate::wire_optional::NodeInfoDeprecated<'static>, ___E>
2214 for NodeInfoDeprecated
2215 where
2216 ___E: ?Sized,
2217 NodeInfoDeprecated: ::fidl_next::Encode<crate::wire::NodeInfoDeprecated<'static>, ___E>,
2218 {
2219 #[inline]
2220 fn encode_option(
2221 this: ::core::option::Option<Self>,
2222 encoder: &mut ___E,
2223 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::NodeInfoDeprecated<'static>>,
2224 _: (),
2225 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2226 ::fidl_next::munge!(let crate::wire_optional::NodeInfoDeprecated { raw, _phantom: _ } = &mut *out);
2227
2228 if let Some(inner) = this {
2229 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2230 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2231 } else {
2232 ::fidl_next::RawWireUnion::encode_absent(raw);
2233 }
2234
2235 Ok(())
2236 }
2237 }
2238
2239 impl<'de> ::fidl_next::FromWire<crate::wire::NodeInfoDeprecated<'de>> for NodeInfoDeprecated {
2240 #[inline]
2241 fn from_wire(wire: crate::wire::NodeInfoDeprecated<'de>) -> Self {
2242 let wire = ::core::mem::ManuallyDrop::new(wire);
2243 match wire.raw.ordinal() {
2244 1 => Self::Service(::fidl_next::FromWire::from_wire(unsafe {
2245 wire.raw.get().read_unchecked::<crate::wire::Service>()
2246 })),
2247
2248 2 => Self::File(::fidl_next::FromWire::from_wire(unsafe {
2249 wire.raw.get().read_unchecked::<crate::wire::FileObject>()
2250 })),
2251
2252 3 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
2253 wire.raw.get().read_unchecked::<crate::wire::DirectoryObject>()
2254 })),
2255
2256 4 => Self::Symlink(::fidl_next::FromWire::from_wire(unsafe {
2257 wire.raw.get().read_unchecked::<crate::wire::SymlinkObject<'de>>()
2258 })),
2259
2260 _ => unsafe { ::core::hint::unreachable_unchecked() },
2261 }
2262 }
2263 }
2264
2265 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::NodeInfoDeprecated<'de>>
2266 for NodeInfoDeprecated
2267 {
2268 #[inline]
2269 fn from_wire_option(
2270 wire: crate::wire_optional::NodeInfoDeprecated<'de>,
2271 ) -> ::core::option::Option<Self> {
2272 if let Some(inner) = wire.into_option() {
2273 Some(::fidl_next::FromWire::from_wire(inner))
2274 } else {
2275 None
2276 }
2277 }
2278 }
2279
2280 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::NodeInfoDeprecated<'de>>
2281 for Box<NodeInfoDeprecated>
2282 {
2283 #[inline]
2284 fn from_wire_option(
2285 wire: crate::wire_optional::NodeInfoDeprecated<'de>,
2286 ) -> ::core::option::Option<Self> {
2287 <NodeInfoDeprecated as ::fidl_next::FromWireOption<
2288 crate::wire_optional::NodeInfoDeprecated<'de>,
2289 >>::from_wire_option(wire)
2290 .map(Box::new)
2291 }
2292 }
2293}
2294
2295pub mod wire {
2296
2297 pub use fidl_next_common_fuchsia_io::wire::*;
2298
2299 #[repr(C)]
2301 pub struct ConnectionInfo<'de> {
2302 pub(crate) table: ::fidl_next::WireTable<'de>,
2303 }
2304
2305 impl<'de> Drop for ConnectionInfo<'de> {
2306 fn drop(&mut self) {
2307 let _ = self
2308 .table
2309 .get(1)
2310 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Operations>() });
2311 }
2312 }
2313
2314 unsafe impl ::fidl_next::Wire for ConnectionInfo<'static> {
2315 type Owned<'de> = ConnectionInfo<'de>;
2316
2317 #[inline]
2318 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
2319 ::fidl_next::munge!(let Self { table } = out);
2320 ::fidl_next::WireTable::zero_padding(table);
2321 }
2322 }
2323
2324 unsafe impl<___D> ::fidl_next::Decode<___D> for ConnectionInfo<'static>
2325 where
2326 ___D: ::fidl_next::Decoder + ?Sized,
2327 ___D: ::fidl_next::fuchsia::HandleDecoder,
2328 {
2329 fn decode(
2330 slot: ::fidl_next::Slot<'_, Self>,
2331 decoder: &mut ___D,
2332 _: (),
2333 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2334 ::fidl_next::munge!(let Self { table } = slot);
2335
2336 ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
2337 match ordinal {
2338 0 => unsafe { ::core::hint::unreachable_unchecked() },
2339
2340 1 => {
2341 ::fidl_next::WireEnvelope::decode_as::<___D, crate::wire::Operations>(
2342 slot.as_mut(),
2343 decoder,
2344 (),
2345 )?;
2346
2347 Ok(())
2348 }
2349
2350 _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
2351 }
2352 })
2353 }
2354 }
2355
2356 impl<'de> ConnectionInfo<'de> {
2357 pub fn rights(&self) -> ::core::option::Option<&crate::wire::Operations> {
2358 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
2359 }
2360 }
2361
2362 impl<'de> ::core::fmt::Debug for ConnectionInfo<'de> {
2363 fn fmt(
2364 &self,
2365 f: &mut ::core::fmt::Formatter<'_>,
2366 ) -> ::core::result::Result<(), ::core::fmt::Error> {
2367 f.debug_struct("ConnectionInfo").field("rights", &self.rights()).finish()
2368 }
2369 }
2370
2371 impl<'de> ::fidl_next::IntoNatural for ConnectionInfo<'de> {
2372 type Natural = crate::natural::ConnectionInfo;
2373 }
2374
2375 impl ::fidl_next::Unconstrained for ConnectionInfo<'_> {}
2376
2377 #[derive(Debug)]
2379 #[repr(C)]
2380 pub struct DirectoryGetTokenResponse {
2381 pub s: ::fidl_next::WireI32,
2382
2383 pub token: ::fidl_next::fuchsia::WireOptionalHandle,
2384 }
2385
2386 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryGetTokenResponse>(), 8);
2387 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryGetTokenResponse>(), 4);
2388
2389 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryGetTokenResponse, s), 0);
2390
2391 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryGetTokenResponse, token), 4);
2392
2393 unsafe impl ::fidl_next::Wire for DirectoryGetTokenResponse {
2394 type Owned<'de> = DirectoryGetTokenResponse;
2395
2396 #[inline]
2397 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2398 ::fidl_next::munge! {
2399 let Self {
2400
2401 s,
2402 token,
2403
2404 } = &mut *out_;
2405 }
2406
2407 ::fidl_next::Wire::zero_padding(s);
2408
2409 ::fidl_next::Wire::zero_padding(token);
2410 }
2411 }
2412
2413 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryGetTokenResponse
2414 where
2415 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2416 ___D: ::fidl_next::fuchsia::HandleDecoder,
2417 {
2418 fn decode(
2419 slot_: ::fidl_next::Slot<'_, Self>,
2420 decoder_: &mut ___D,
2421 _: (),
2422 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2423 ::fidl_next::munge! {
2424 let Self {
2425
2426 mut s,
2427 mut token,
2428
2429 } = slot_;
2430 }
2431
2432 let _field = s.as_mut();
2433
2434 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
2435
2436 let _field = token.as_mut();
2437
2438 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
2439
2440 Ok(())
2441 }
2442 }
2443
2444 impl ::fidl_next::IntoNatural for DirectoryGetTokenResponse {
2445 type Natural = crate::natural::DirectoryGetTokenResponse;
2446 }
2447
2448 impl ::fidl_next::Unconstrained for DirectoryGetTokenResponse {}
2449
2450 #[derive(Debug)]
2452 #[repr(C)]
2453 pub struct DirectoryLinkRequest<'de> {
2454 pub src: ::fidl_next::WireString<'de>,
2455
2456 pub dst_parent_token: ::fidl_next::fuchsia::WireHandle,
2457
2458 pub dst: ::fidl_next::WireString<'de>,
2459 }
2460
2461 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryLinkRequest<'_>>(), 40);
2462 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryLinkRequest<'_>>(), 8);
2463
2464 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryLinkRequest<'_>, src), 0);
2465
2466 static_assertions::const_assert_eq!(
2467 std::mem::offset_of!(DirectoryLinkRequest<'_>, dst_parent_token),
2468 16
2469 );
2470
2471 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryLinkRequest<'_>, dst), 24);
2472
2473 unsafe impl ::fidl_next::Wire for DirectoryLinkRequest<'static> {
2474 type Owned<'de> = DirectoryLinkRequest<'de>;
2475
2476 #[inline]
2477 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2478 ::fidl_next::munge! {
2479 let Self {
2480
2481 src,
2482 dst_parent_token,
2483 dst,
2484
2485 } = &mut *out_;
2486 }
2487
2488 ::fidl_next::Wire::zero_padding(src);
2489
2490 ::fidl_next::Wire::zero_padding(dst_parent_token);
2491
2492 ::fidl_next::Wire::zero_padding(dst);
2493
2494 unsafe {
2495 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
2496 }
2497 }
2498 }
2499
2500 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryLinkRequest<'static>
2501 where
2502 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2503 ___D: ::fidl_next::Decoder,
2504 ___D: ::fidl_next::fuchsia::HandleDecoder,
2505 {
2506 fn decode(
2507 slot_: ::fidl_next::Slot<'_, Self>,
2508 decoder_: &mut ___D,
2509 _: (),
2510 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2511 if slot_.as_bytes()[20..24] != [0u8; 4] {
2512 return Err(::fidl_next::DecodeError::InvalidPadding);
2513 }
2514
2515 ::fidl_next::munge! {
2516 let Self {
2517
2518 mut src,
2519 mut dst_parent_token,
2520 mut dst,
2521
2522 } = slot_;
2523 }
2524
2525 let _field = src.as_mut();
2526 ::fidl_next::Constrained::validate(_field, 255)?;
2527 ::fidl_next::Decode::decode(src.as_mut(), decoder_, 255)?;
2528
2529 let src = unsafe { src.deref_unchecked() };
2530
2531 if src.len() > 255 {
2532 return Err(::fidl_next::DecodeError::VectorTooLong {
2533 size: src.len() as u64,
2534 limit: 255,
2535 });
2536 }
2537
2538 let _field = dst_parent_token.as_mut();
2539
2540 ::fidl_next::Decode::decode(dst_parent_token.as_mut(), decoder_, ())?;
2541
2542 let _field = dst.as_mut();
2543 ::fidl_next::Constrained::validate(_field, 255)?;
2544 ::fidl_next::Decode::decode(dst.as_mut(), decoder_, 255)?;
2545
2546 let dst = unsafe { dst.deref_unchecked() };
2547
2548 if dst.len() > 255 {
2549 return Err(::fidl_next::DecodeError::VectorTooLong {
2550 size: dst.len() as u64,
2551 limit: 255,
2552 });
2553 }
2554
2555 Ok(())
2556 }
2557 }
2558
2559 impl<'de> ::fidl_next::IntoNatural for DirectoryLinkRequest<'de> {
2560 type Natural = crate::natural::DirectoryLinkRequest;
2561 }
2562
2563 impl ::fidl_next::Unconstrained for DirectoryLinkRequest<'static> {}
2564
2565 pub type Token = ::fidl_next::fuchsia::WireEvent;
2567
2568 #[derive(Debug)]
2570 #[repr(C)]
2571 pub struct DirectoryRenameRequest<'de> {
2572 pub src: ::fidl_next::WireString<'de>,
2573
2574 pub dst_parent_token: ::fidl_next::fuchsia::WireEvent,
2575
2576 pub dst: ::fidl_next::WireString<'de>,
2577 }
2578
2579 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryRenameRequest<'_>>(), 40);
2580 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryRenameRequest<'_>>(), 8);
2581
2582 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryRenameRequest<'_>, src), 0);
2583
2584 static_assertions::const_assert_eq!(
2585 std::mem::offset_of!(DirectoryRenameRequest<'_>, dst_parent_token),
2586 16
2587 );
2588
2589 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryRenameRequest<'_>, dst), 24);
2590
2591 unsafe impl ::fidl_next::Wire for DirectoryRenameRequest<'static> {
2592 type Owned<'de> = DirectoryRenameRequest<'de>;
2593
2594 #[inline]
2595 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2596 ::fidl_next::munge! {
2597 let Self {
2598
2599 src,
2600 dst_parent_token,
2601 dst,
2602
2603 } = &mut *out_;
2604 }
2605
2606 ::fidl_next::Wire::zero_padding(src);
2607
2608 ::fidl_next::Wire::zero_padding(dst_parent_token);
2609
2610 ::fidl_next::Wire::zero_padding(dst);
2611
2612 unsafe {
2613 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
2614 }
2615 }
2616 }
2617
2618 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRenameRequest<'static>
2619 where
2620 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2621 ___D: ::fidl_next::Decoder,
2622 ___D: ::fidl_next::fuchsia::HandleDecoder,
2623 {
2624 fn decode(
2625 slot_: ::fidl_next::Slot<'_, Self>,
2626 decoder_: &mut ___D,
2627 _: (),
2628 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2629 if slot_.as_bytes()[20..24] != [0u8; 4] {
2630 return Err(::fidl_next::DecodeError::InvalidPadding);
2631 }
2632
2633 ::fidl_next::munge! {
2634 let Self {
2635
2636 mut src,
2637 mut dst_parent_token,
2638 mut dst,
2639
2640 } = slot_;
2641 }
2642
2643 let _field = src.as_mut();
2644 ::fidl_next::Constrained::validate(_field, 255)?;
2645 ::fidl_next::Decode::decode(src.as_mut(), decoder_, 255)?;
2646
2647 let src = unsafe { src.deref_unchecked() };
2648
2649 if src.len() > 255 {
2650 return Err(::fidl_next::DecodeError::VectorTooLong {
2651 size: src.len() as u64,
2652 limit: 255,
2653 });
2654 }
2655
2656 let _field = dst_parent_token.as_mut();
2657
2658 ::fidl_next::Decode::decode(dst_parent_token.as_mut(), decoder_, ())?;
2659
2660 let _field = dst.as_mut();
2661 ::fidl_next::Constrained::validate(_field, 255)?;
2662 ::fidl_next::Decode::decode(dst.as_mut(), decoder_, 255)?;
2663
2664 let dst = unsafe { dst.deref_unchecked() };
2665
2666 if dst.len() > 255 {
2667 return Err(::fidl_next::DecodeError::VectorTooLong {
2668 size: dst.len() as u64,
2669 limit: 255,
2670 });
2671 }
2672
2673 Ok(())
2674 }
2675 }
2676
2677 impl<'de> ::fidl_next::IntoNatural for DirectoryRenameRequest<'de> {
2678 type Natural = crate::natural::DirectoryRenameRequest;
2679 }
2680
2681 impl ::fidl_next::Unconstrained for DirectoryRenameRequest<'static> {}
2682
2683 #[derive(Debug)]
2685 #[repr(C)]
2686 pub struct DirectoryWatchRequest {
2687 pub mask: crate::wire::WatchMask,
2688
2689 pub options: ::fidl_next::WireU32,
2690
2691 pub watcher:
2692 ::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fidl_next::fuchsia::WireChannel>,
2693 }
2694
2695 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryWatchRequest>(), 12);
2696 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryWatchRequest>(), 4);
2697
2698 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryWatchRequest, mask), 0);
2699
2700 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryWatchRequest, options), 4);
2701
2702 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryWatchRequest, watcher), 8);
2703
2704 unsafe impl ::fidl_next::Wire for DirectoryWatchRequest {
2705 type Owned<'de> = DirectoryWatchRequest;
2706
2707 #[inline]
2708 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2709 ::fidl_next::munge! {
2710 let Self {
2711
2712 mask,
2713 options,
2714 watcher,
2715
2716 } = &mut *out_;
2717 }
2718
2719 ::fidl_next::Wire::zero_padding(mask);
2720
2721 ::fidl_next::Wire::zero_padding(options);
2722
2723 ::fidl_next::Wire::zero_padding(watcher);
2724 }
2725 }
2726
2727 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryWatchRequest
2728 where
2729 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2730 ___D: ::fidl_next::fuchsia::HandleDecoder,
2731 {
2732 fn decode(
2733 slot_: ::fidl_next::Slot<'_, Self>,
2734 decoder_: &mut ___D,
2735 _: (),
2736 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2737 ::fidl_next::munge! {
2738 let Self {
2739
2740 mut mask,
2741 mut options,
2742 mut watcher,
2743
2744 } = slot_;
2745 }
2746
2747 let _field = mask.as_mut();
2748
2749 ::fidl_next::Decode::decode(mask.as_mut(), decoder_, ())?;
2750
2751 let _field = options.as_mut();
2752
2753 ::fidl_next::Decode::decode(options.as_mut(), decoder_, ())?;
2754
2755 let _field = watcher.as_mut();
2756
2757 ::fidl_next::Decode::decode(watcher.as_mut(), decoder_, ())?;
2758
2759 Ok(())
2760 }
2761 }
2762
2763 impl ::fidl_next::IntoNatural for DirectoryWatchRequest {
2764 type Natural = crate::natural::DirectoryWatchRequest;
2765 }
2766
2767 impl ::fidl_next::Unconstrained for DirectoryWatchRequest {}
2768
2769 #[derive(Debug)]
2771 #[repr(C)]
2772 pub struct NodeOnOpenRequest<'de> {
2773 pub s: ::fidl_next::WireI32,
2774
2775 pub info: crate::wire_optional::NodeInfoDeprecated<'de>,
2776 }
2777
2778 static_assertions::const_assert_eq!(std::mem::size_of::<NodeOnOpenRequest<'_>>(), 24);
2779 static_assertions::const_assert_eq!(std::mem::align_of::<NodeOnOpenRequest<'_>>(), 8);
2780
2781 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeOnOpenRequest<'_>, s), 0);
2782
2783 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeOnOpenRequest<'_>, info), 8);
2784
2785 unsafe impl ::fidl_next::Wire for NodeOnOpenRequest<'static> {
2786 type Owned<'de> = NodeOnOpenRequest<'de>;
2787
2788 #[inline]
2789 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2790 ::fidl_next::munge! {
2791 let Self {
2792
2793 s,
2794 info,
2795
2796 } = &mut *out_;
2797 }
2798
2799 ::fidl_next::Wire::zero_padding(s);
2800
2801 ::fidl_next::Wire::zero_padding(info);
2802
2803 unsafe {
2804 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
2805 }
2806 }
2807 }
2808
2809 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeOnOpenRequest<'static>
2810 where
2811 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2812 ___D: ::fidl_next::Decoder,
2813 ___D: ::fidl_next::fuchsia::HandleDecoder,
2814 {
2815 fn decode(
2816 slot_: ::fidl_next::Slot<'_, Self>,
2817 decoder_: &mut ___D,
2818 _: (),
2819 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2820 if slot_.as_bytes()[4..8] != [0u8; 4] {
2821 return Err(::fidl_next::DecodeError::InvalidPadding);
2822 }
2823
2824 ::fidl_next::munge! {
2825 let Self {
2826
2827 mut s,
2828 mut info,
2829
2830 } = slot_;
2831 }
2832
2833 let _field = s.as_mut();
2834
2835 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
2836
2837 let _field = info.as_mut();
2838
2839 ::fidl_next::Decode::decode(info.as_mut(), decoder_, ())?;
2840
2841 Ok(())
2842 }
2843 }
2844
2845 impl<'de> ::fidl_next::IntoNatural for NodeOnOpenRequest<'de> {
2846 type Natural = crate::natural::NodeOnOpenRequest;
2847 }
2848
2849 impl ::fidl_next::Unconstrained for NodeOnOpenRequest<'static> {}
2850
2851 #[derive(Debug)]
2853 #[repr(C)]
2854 pub struct NodeListExtendedAttributesRequest {
2855 pub iterator: ::fidl_next::ServerEnd<
2856 crate::ExtendedAttributeIterator,
2857 ::fidl_next::fuchsia::WireChannel,
2858 >,
2859 }
2860
2861 static_assertions::const_assert_eq!(
2862 std::mem::size_of::<NodeListExtendedAttributesRequest>(),
2863 4
2864 );
2865 static_assertions::const_assert_eq!(
2866 std::mem::align_of::<NodeListExtendedAttributesRequest>(),
2867 4
2868 );
2869
2870 static_assertions::const_assert_eq!(
2871 std::mem::offset_of!(NodeListExtendedAttributesRequest, iterator),
2872 0
2873 );
2874
2875 unsafe impl ::fidl_next::Wire for NodeListExtendedAttributesRequest {
2876 type Owned<'de> = NodeListExtendedAttributesRequest;
2877
2878 #[inline]
2879 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2880 ::fidl_next::munge! {
2881 let Self {
2882
2883 iterator,
2884
2885 } = &mut *out_;
2886 }
2887
2888 ::fidl_next::Wire::zero_padding(iterator);
2889 }
2890 }
2891
2892 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeListExtendedAttributesRequest
2893 where
2894 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2895 ___D: ::fidl_next::fuchsia::HandleDecoder,
2896 {
2897 fn decode(
2898 slot_: ::fidl_next::Slot<'_, Self>,
2899 decoder_: &mut ___D,
2900 _: (),
2901 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2902 ::fidl_next::munge! {
2903 let Self {
2904
2905 mut iterator,
2906
2907 } = slot_;
2908 }
2909
2910 let _field = iterator.as_mut();
2911
2912 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
2913
2914 Ok(())
2915 }
2916 }
2917
2918 impl ::fidl_next::IntoNatural for NodeListExtendedAttributesRequest {
2919 type Natural = crate::natural::NodeListExtendedAttributesRequest;
2920 }
2921
2922 impl ::fidl_next::Unconstrained for NodeListExtendedAttributesRequest {}
2923
2924 #[repr(transparent)]
2926 pub struct ExtendedAttributeValue<'de> {
2927 pub(crate) raw: ::fidl_next::RawWireUnion,
2928 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
2929 }
2930
2931 impl<'de> Drop for ExtendedAttributeValue<'de> {
2932 fn drop(&mut self) {
2933 match self.raw.ordinal() {
2934 1 => {
2935 let _ = unsafe {
2936 self.raw.get().read_unchecked::<::fidl_next::WireVector<'de, u8>>()
2937 };
2938 }
2939
2940 2 => {
2941 let _ =
2942 unsafe { self.raw.get().read_unchecked::<::fidl_next::fuchsia::WireVmo>() };
2943 }
2944
2945 _ => (),
2946 }
2947 }
2948 }
2949
2950 unsafe impl ::fidl_next::Wire for ExtendedAttributeValue<'static> {
2951 type Owned<'de> = ExtendedAttributeValue<'de>;
2952
2953 #[inline]
2954 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
2955 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
2956 ::fidl_next::RawWireUnion::zero_padding(raw);
2957 }
2958 }
2959
2960 pub mod extended_attribute_value {
2961 pub enum Ref<'de> {
2962 Bytes(&'de ::fidl_next::WireVector<'de, u8>),
2963
2964 Buffer(&'de ::fidl_next::fuchsia::WireVmo),
2965
2966 UnknownOrdinal_(u64),
2967 }
2968 }
2969
2970 impl<'de> ExtendedAttributeValue<'de> {
2971 pub fn as_ref(&self) -> crate::wire::extended_attribute_value::Ref<'_> {
2972 match self.raw.ordinal() {
2973 1 => crate::wire::extended_attribute_value::Ref::Bytes(unsafe {
2974 self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, u8>>()
2975 }),
2976
2977 2 => crate::wire::extended_attribute_value::Ref::Buffer(unsafe {
2978 self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireVmo>()
2979 }),
2980
2981 unknown => crate::wire::extended_attribute_value::Ref::UnknownOrdinal_(unknown),
2982 }
2983 }
2984 }
2985
2986 unsafe impl<___D> ::fidl_next::Decode<___D> for ExtendedAttributeValue<'static>
2987 where
2988 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2989 ___D: ::fidl_next::Decoder,
2990 ___D: ::fidl_next::fuchsia::HandleDecoder,
2991 {
2992 fn decode(
2993 mut slot: ::fidl_next::Slot<'_, Self>,
2994 decoder: &mut ___D,
2995 _: (),
2996 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2997 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
2998 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
2999 1 => ::fidl_next::RawWireUnion::decode_as::<
3000 ___D,
3001 ::fidl_next::WireVector<'static, u8>,
3002 >(raw, decoder, (32768, ()))?,
3003
3004 2 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::fuchsia::WireVmo>(
3005 raw,
3006 decoder,
3007 (),
3008 )?,
3009
3010 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
3011 }
3012
3013 Ok(())
3014 }
3015 }
3016
3017 impl<'de> ::core::fmt::Debug for ExtendedAttributeValue<'de> {
3018 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3019 match self.raw.ordinal() {
3020 1 => unsafe {
3021 self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, u8>>().fmt(f)
3022 },
3023 2 => unsafe {
3024 self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireVmo>().fmt(f)
3025 },
3026 _ => unsafe { ::core::hint::unreachable_unchecked() },
3027 }
3028 }
3029 }
3030
3031 impl<'de> ::fidl_next::IntoNatural for ExtendedAttributeValue<'de> {
3032 type Natural = crate::natural::ExtendedAttributeValue;
3033 }
3034
3035 impl ::fidl_next::Unconstrained for ExtendedAttributeValue<'static> {}
3036
3037 #[derive(Debug)]
3039 #[repr(C)]
3040 pub struct NodeSetExtendedAttributeRequest<'de> {
3041 pub name: ::fidl_next::WireVector<'de, u8>,
3042
3043 pub value: crate::wire::ExtendedAttributeValue<'de>,
3044
3045 pub mode: crate::wire::SetExtendedAttributeMode,
3046 }
3047
3048 static_assertions::const_assert_eq!(
3049 std::mem::size_of::<NodeSetExtendedAttributeRequest<'_>>(),
3050 40
3051 );
3052 static_assertions::const_assert_eq!(
3053 std::mem::align_of::<NodeSetExtendedAttributeRequest<'_>>(),
3054 8
3055 );
3056
3057 static_assertions::const_assert_eq!(
3058 std::mem::offset_of!(NodeSetExtendedAttributeRequest<'_>, name),
3059 0
3060 );
3061
3062 static_assertions::const_assert_eq!(
3063 std::mem::offset_of!(NodeSetExtendedAttributeRequest<'_>, value),
3064 16
3065 );
3066
3067 static_assertions::const_assert_eq!(
3068 std::mem::offset_of!(NodeSetExtendedAttributeRequest<'_>, mode),
3069 32
3070 );
3071
3072 unsafe impl ::fidl_next::Wire for NodeSetExtendedAttributeRequest<'static> {
3073 type Owned<'de> = NodeSetExtendedAttributeRequest<'de>;
3074
3075 #[inline]
3076 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3077 ::fidl_next::munge! {
3078 let Self {
3079
3080 name,
3081 value,
3082 mode,
3083
3084 } = &mut *out_;
3085 }
3086
3087 ::fidl_next::Wire::zero_padding(name);
3088
3089 ::fidl_next::Wire::zero_padding(value);
3090
3091 ::fidl_next::Wire::zero_padding(mode);
3092
3093 unsafe {
3094 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
3095 }
3096 }
3097 }
3098
3099 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeSetExtendedAttributeRequest<'static>
3100 where
3101 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3102 ___D: ::fidl_next::Decoder,
3103 ___D: ::fidl_next::fuchsia::HandleDecoder,
3104 {
3105 fn decode(
3106 slot_: ::fidl_next::Slot<'_, Self>,
3107 decoder_: &mut ___D,
3108 _: (),
3109 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3110 if slot_.as_bytes()[36..40] != [0u8; 4] {
3111 return Err(::fidl_next::DecodeError::InvalidPadding);
3112 }
3113
3114 ::fidl_next::munge! {
3115 let Self {
3116
3117 mut name,
3118 mut value,
3119 mut mode,
3120
3121 } = slot_;
3122 }
3123
3124 let _field = name.as_mut();
3125 ::fidl_next::Constrained::validate(_field, (255, ()))?;
3126 ::fidl_next::Decode::decode(name.as_mut(), decoder_, (255, ()))?;
3127
3128 let name = unsafe { name.deref_unchecked() };
3129
3130 if name.len() > 255 {
3131 return Err(::fidl_next::DecodeError::VectorTooLong {
3132 size: name.len() as u64,
3133 limit: 255,
3134 });
3135 }
3136
3137 let _field = value.as_mut();
3138
3139 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
3140
3141 let _field = mode.as_mut();
3142
3143 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
3144
3145 Ok(())
3146 }
3147 }
3148
3149 impl<'de> ::fidl_next::IntoNatural for NodeSetExtendedAttributeRequest<'de> {
3150 type Natural = crate::natural::NodeSetExtendedAttributeRequest;
3151 }
3152
3153 impl ::fidl_next::Unconstrained for NodeSetExtendedAttributeRequest<'static> {}
3154
3155 #[repr(C)]
3157 pub struct FileInfo<'de> {
3158 pub(crate) table: ::fidl_next::WireTable<'de>,
3159 }
3160
3161 impl<'de> Drop for FileInfo<'de> {
3162 fn drop(&mut self) {
3163 let _ = self.table.get(1).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });
3164
3165 let _ = self.table.get(2).map(|envelope| unsafe {
3166 envelope.read_unchecked::<::fidl_next::fuchsia::WireEvent>()
3167 });
3168
3169 let _ = self.table.get(3).map(|envelope| unsafe {
3170 envelope.read_unchecked::<::fidl_next::fuchsia::WireStream>()
3171 });
3172
3173 let _ = self.table.get(4).map(|envelope| unsafe {
3174 envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
3175 });
3176 }
3177 }
3178
3179 unsafe impl ::fidl_next::Wire for FileInfo<'static> {
3180 type Owned<'de> = FileInfo<'de>;
3181
3182 #[inline]
3183 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3184 ::fidl_next::munge!(let Self { table } = out);
3185 ::fidl_next::WireTable::zero_padding(table);
3186 }
3187 }
3188
3189 unsafe impl<___D> ::fidl_next::Decode<___D> for FileInfo<'static>
3190 where
3191 ___D: ::fidl_next::Decoder + ?Sized,
3192 ___D: ::fidl_next::fuchsia::HandleDecoder,
3193 {
3194 fn decode(
3195 slot: ::fidl_next::Slot<'_, Self>,
3196 decoder: &mut ___D,
3197 _: (),
3198 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3199 ::fidl_next::munge!(let Self { table } = slot);
3200
3201 ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3202 match ordinal {
3203 0 => unsafe { ::core::hint::unreachable_unchecked() },
3204
3205 1 => {
3206 ::fidl_next::WireEnvelope::decode_as::<___D, bool>(
3207 slot.as_mut(),
3208 decoder,
3209 (),
3210 )?;
3211
3212 Ok(())
3213 }
3214
3215 2 => {
3216 ::fidl_next::WireEnvelope::decode_as::<
3217 ___D,
3218 ::fidl_next::fuchsia::WireEvent,
3219 >(slot.as_mut(), decoder, ())?;
3220
3221 Ok(())
3222 }
3223
3224 3 => {
3225 ::fidl_next::WireEnvelope::decode_as::<
3226 ___D,
3227 ::fidl_next::fuchsia::WireStream,
3228 >(slot.as_mut(), decoder, ())?;
3229
3230 Ok(())
3231 }
3232
3233 4 => {
3234 ::fidl_next::WireEnvelope::decode_as::<
3235 ___D,
3236 crate::wire::NodeAttributes2<'static>,
3237 >(slot.as_mut(), decoder, ())?;
3238
3239 Ok(())
3240 }
3241
3242 _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
3243 }
3244 })
3245 }
3246 }
3247
3248 impl<'de> FileInfo<'de> {
3249 pub fn is_append(&self) -> ::core::option::Option<&bool> {
3250 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3251 }
3252
3253 pub fn observer(&self) -> ::core::option::Option<&::fidl_next::fuchsia::WireEvent> {
3254 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3255 }
3256
3257 pub fn stream(&self) -> ::core::option::Option<&::fidl_next::fuchsia::WireStream> {
3258 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
3259 }
3260
3261 pub fn attributes(&self) -> ::core::option::Option<&crate::wire::NodeAttributes2<'de>> {
3262 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
3263 }
3264 }
3265
3266 impl<'de> ::core::fmt::Debug for FileInfo<'de> {
3267 fn fmt(
3268 &self,
3269 f: &mut ::core::fmt::Formatter<'_>,
3270 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3271 f.debug_struct("FileInfo")
3272 .field("is_append", &self.is_append())
3273 .field("observer", &self.observer())
3274 .field("stream", &self.stream())
3275 .field("attributes", &self.attributes())
3276 .finish()
3277 }
3278 }
3279
3280 impl<'de> ::fidl_next::IntoNatural for FileInfo<'de> {
3281 type Natural = crate::natural::FileInfo;
3282 }
3283
3284 impl ::fidl_next::Unconstrained for FileInfo<'_> {}
3285
3286 #[repr(transparent)]
3288 pub struct Representation<'de> {
3289 pub(crate) raw: ::fidl_next::RawWireUnion,
3290 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
3291 }
3292
3293 impl<'de> Drop for Representation<'de> {
3294 fn drop(&mut self) {
3295 match self.raw.ordinal() {
3296 1 => {
3297 let _ =
3298 unsafe { self.raw.get().read_unchecked::<crate::wire::NodeInfo<'de>>() };
3299 }
3300
3301 2 => {
3302 let _ = unsafe {
3303 self.raw.get().read_unchecked::<crate::wire::DirectoryInfo<'de>>()
3304 };
3305 }
3306
3307 3 => {
3308 let _ =
3309 unsafe { self.raw.get().read_unchecked::<crate::wire::FileInfo<'de>>() };
3310 }
3311
3312 4 => {
3313 let _ =
3314 unsafe { self.raw.get().read_unchecked::<crate::wire::SymlinkInfo<'de>>() };
3315 }
3316
3317 _ => (),
3318 }
3319 }
3320 }
3321
3322 unsafe impl ::fidl_next::Wire for Representation<'static> {
3323 type Owned<'de> = Representation<'de>;
3324
3325 #[inline]
3326 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3327 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
3328 ::fidl_next::RawWireUnion::zero_padding(raw);
3329 }
3330 }
3331
3332 pub mod representation {
3333 pub enum Ref<'de> {
3334 Node(&'de crate::wire::NodeInfo<'de>),
3335
3336 Directory(&'de crate::wire::DirectoryInfo<'de>),
3337
3338 File(&'de crate::wire::FileInfo<'de>),
3339
3340 Symlink(&'de crate::wire::SymlinkInfo<'de>),
3341
3342 UnknownOrdinal_(u64),
3343 }
3344 }
3345
3346 impl<'de> Representation<'de> {
3347 pub fn as_ref(&self) -> crate::wire::representation::Ref<'_> {
3348 match self.raw.ordinal() {
3349 1 => crate::wire::representation::Ref::Node(unsafe {
3350 self.raw.get().deref_unchecked::<crate::wire::NodeInfo<'_>>()
3351 }),
3352
3353 2 => crate::wire::representation::Ref::Directory(unsafe {
3354 self.raw.get().deref_unchecked::<crate::wire::DirectoryInfo<'_>>()
3355 }),
3356
3357 3 => crate::wire::representation::Ref::File(unsafe {
3358 self.raw.get().deref_unchecked::<crate::wire::FileInfo<'_>>()
3359 }),
3360
3361 4 => crate::wire::representation::Ref::Symlink(unsafe {
3362 self.raw.get().deref_unchecked::<crate::wire::SymlinkInfo<'_>>()
3363 }),
3364
3365 unknown => crate::wire::representation::Ref::UnknownOrdinal_(unknown),
3366 }
3367 }
3368 }
3369
3370 unsafe impl<___D> ::fidl_next::Decode<___D> for Representation<'static>
3371 where
3372 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3373 ___D: ::fidl_next::Decoder,
3374 ___D: ::fidl_next::fuchsia::HandleDecoder,
3375 {
3376 fn decode(
3377 mut slot: ::fidl_next::Slot<'_, Self>,
3378 decoder: &mut ___D,
3379 _: (),
3380 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3381 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
3382 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
3383 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::NodeInfo<'static>>(
3384 raw,
3385 decoder,
3386 (),
3387 )?,
3388
3389 2 => ::fidl_next::RawWireUnion::decode_as::<
3390 ___D,
3391 crate::wire::DirectoryInfo<'static>,
3392 >(raw, decoder, ())?,
3393
3394 3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::FileInfo<'static>>(
3395 raw,
3396 decoder,
3397 (),
3398 )?,
3399
3400 4 => {
3401 ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::SymlinkInfo<'static>>(
3402 raw,
3403 decoder,
3404 (),
3405 )?
3406 }
3407
3408 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
3409 }
3410
3411 Ok(())
3412 }
3413 }
3414
3415 impl<'de> ::core::fmt::Debug for Representation<'de> {
3416 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3417 match self.raw.ordinal() {
3418 1 => unsafe {
3419 self.raw.get().deref_unchecked::<crate::wire::NodeInfo<'_>>().fmt(f)
3420 },
3421 2 => unsafe {
3422 self.raw.get().deref_unchecked::<crate::wire::DirectoryInfo<'_>>().fmt(f)
3423 },
3424 3 => unsafe {
3425 self.raw.get().deref_unchecked::<crate::wire::FileInfo<'_>>().fmt(f)
3426 },
3427 4 => unsafe {
3428 self.raw.get().deref_unchecked::<crate::wire::SymlinkInfo<'_>>().fmt(f)
3429 },
3430 _ => unsafe { ::core::hint::unreachable_unchecked() },
3431 }
3432 }
3433 }
3434
3435 impl<'de> ::fidl_next::IntoNatural for Representation<'de> {
3436 type Natural = crate::natural::Representation;
3437 }
3438
3439 impl ::fidl_next::Unconstrained for Representation<'static> {}
3440
3441 #[derive(Debug)]
3443 #[repr(C)]
3444 pub struct DirectoryOpenRequest<'de> {
3445 pub path: ::fidl_next::WireString<'de>,
3446
3447 pub flags: crate::wire::Flags,
3448
3449 pub options: crate::wire::Options<'de>,
3450
3451 pub object: ::fidl_next::fuchsia::WireChannel,
3452 }
3453
3454 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryOpenRequest<'_>>(), 48);
3455 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryOpenRequest<'_>>(), 8);
3456
3457 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryOpenRequest<'_>, path), 0);
3458
3459 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryOpenRequest<'_>, flags), 16);
3460
3461 static_assertions::const_assert_eq!(
3462 std::mem::offset_of!(DirectoryOpenRequest<'_>, options),
3463 24
3464 );
3465
3466 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryOpenRequest<'_>, object), 40);
3467
3468 unsafe impl ::fidl_next::Wire for DirectoryOpenRequest<'static> {
3469 type Owned<'de> = DirectoryOpenRequest<'de>;
3470
3471 #[inline]
3472 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3473 ::fidl_next::munge! {
3474 let Self {
3475
3476 path,
3477 flags,
3478 options,
3479 object,
3480
3481 } = &mut *out_;
3482 }
3483
3484 ::fidl_next::Wire::zero_padding(path);
3485
3486 ::fidl_next::Wire::zero_padding(flags);
3487
3488 ::fidl_next::Wire::zero_padding(options);
3489
3490 ::fidl_next::Wire::zero_padding(object);
3491
3492 unsafe {
3493 out_.as_mut_ptr().cast::<u8>().add(44).write_bytes(0, 4);
3494 }
3495 }
3496 }
3497
3498 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryOpenRequest<'static>
3499 where
3500 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3501 ___D: ::fidl_next::Decoder,
3502 ___D: ::fidl_next::fuchsia::HandleDecoder,
3503 {
3504 fn decode(
3505 slot_: ::fidl_next::Slot<'_, Self>,
3506 decoder_: &mut ___D,
3507 _: (),
3508 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3509 if slot_.as_bytes()[44..48] != [0u8; 4] {
3510 return Err(::fidl_next::DecodeError::InvalidPadding);
3511 }
3512
3513 ::fidl_next::munge! {
3514 let Self {
3515
3516 mut path,
3517 mut flags,
3518 mut options,
3519 mut object,
3520
3521 } = slot_;
3522 }
3523
3524 let _field = path.as_mut();
3525 ::fidl_next::Constrained::validate(_field, 4095)?;
3526 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
3527
3528 let path = unsafe { path.deref_unchecked() };
3529
3530 if path.len() > 4095 {
3531 return Err(::fidl_next::DecodeError::VectorTooLong {
3532 size: path.len() as u64,
3533 limit: 4095,
3534 });
3535 }
3536
3537 let _field = flags.as_mut();
3538
3539 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
3540
3541 let _field = options.as_mut();
3542
3543 ::fidl_next::Decode::decode(options.as_mut(), decoder_, ())?;
3544
3545 let _field = object.as_mut();
3546
3547 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
3548
3549 Ok(())
3550 }
3551 }
3552
3553 impl<'de> ::fidl_next::IntoNatural for DirectoryOpenRequest<'de> {
3554 type Natural = crate::natural::DirectoryOpenRequest;
3555 }
3556
3557 impl ::fidl_next::Unconstrained for DirectoryOpenRequest<'static> {}
3558
3559 #[derive(Debug)]
3561 #[repr(C)]
3562 pub struct NodeDeprecatedCloneRequest {
3563 pub flags: crate::wire::OpenFlags,
3564
3565 pub object: ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
3566 }
3567
3568 static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedCloneRequest>(), 8);
3569 static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedCloneRequest>(), 4);
3570
3571 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeDeprecatedCloneRequest, flags), 0);
3572
3573 static_assertions::const_assert_eq!(
3574 std::mem::offset_of!(NodeDeprecatedCloneRequest, object),
3575 4
3576 );
3577
3578 unsafe impl ::fidl_next::Wire for NodeDeprecatedCloneRequest {
3579 type Owned<'de> = NodeDeprecatedCloneRequest;
3580
3581 #[inline]
3582 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3583 ::fidl_next::munge! {
3584 let Self {
3585
3586 flags,
3587 object,
3588
3589 } = &mut *out_;
3590 }
3591
3592 ::fidl_next::Wire::zero_padding(flags);
3593
3594 ::fidl_next::Wire::zero_padding(object);
3595 }
3596 }
3597
3598 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedCloneRequest
3599 where
3600 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3601 ___D: ::fidl_next::fuchsia::HandleDecoder,
3602 {
3603 fn decode(
3604 slot_: ::fidl_next::Slot<'_, Self>,
3605 decoder_: &mut ___D,
3606 _: (),
3607 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3608 ::fidl_next::munge! {
3609 let Self {
3610
3611 mut flags,
3612 mut object,
3613
3614 } = slot_;
3615 }
3616
3617 let _field = flags.as_mut();
3618
3619 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
3620
3621 let _field = object.as_mut();
3622
3623 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
3624
3625 Ok(())
3626 }
3627 }
3628
3629 impl ::fidl_next::IntoNatural for NodeDeprecatedCloneRequest {
3630 type Natural = crate::natural::NodeDeprecatedCloneRequest;
3631 }
3632
3633 impl ::fidl_next::Unconstrained for NodeDeprecatedCloneRequest {}
3634
3635 #[derive(Debug)]
3637 #[repr(C)]
3638 pub struct DirectoryDeprecatedOpenRequest<'de> {
3639 pub flags: crate::wire::OpenFlags,
3640
3641 pub mode: crate::wire::ModeType,
3642
3643 pub path: ::fidl_next::WireString<'de>,
3644
3645 pub object: ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
3646 }
3647
3648 static_assertions::const_assert_eq!(
3649 std::mem::size_of::<DirectoryDeprecatedOpenRequest<'_>>(),
3650 32
3651 );
3652 static_assertions::const_assert_eq!(
3653 std::mem::align_of::<DirectoryDeprecatedOpenRequest<'_>>(),
3654 8
3655 );
3656
3657 static_assertions::const_assert_eq!(
3658 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, flags),
3659 0
3660 );
3661
3662 static_assertions::const_assert_eq!(
3663 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, mode),
3664 4
3665 );
3666
3667 static_assertions::const_assert_eq!(
3668 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, path),
3669 8
3670 );
3671
3672 static_assertions::const_assert_eq!(
3673 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, object),
3674 24
3675 );
3676
3677 unsafe impl ::fidl_next::Wire for DirectoryDeprecatedOpenRequest<'static> {
3678 type Owned<'de> = DirectoryDeprecatedOpenRequest<'de>;
3679
3680 #[inline]
3681 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3682 ::fidl_next::munge! {
3683 let Self {
3684
3685 flags,
3686 mode,
3687 path,
3688 object,
3689
3690 } = &mut *out_;
3691 }
3692
3693 ::fidl_next::Wire::zero_padding(flags);
3694
3695 ::fidl_next::Wire::zero_padding(mode);
3696
3697 ::fidl_next::Wire::zero_padding(path);
3698
3699 ::fidl_next::Wire::zero_padding(object);
3700
3701 unsafe {
3702 out_.as_mut_ptr().cast::<u8>().add(28).write_bytes(0, 4);
3703 }
3704 }
3705 }
3706
3707 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryDeprecatedOpenRequest<'static>
3708 where
3709 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3710 ___D: ::fidl_next::Decoder,
3711 ___D: ::fidl_next::fuchsia::HandleDecoder,
3712 {
3713 fn decode(
3714 slot_: ::fidl_next::Slot<'_, Self>,
3715 decoder_: &mut ___D,
3716 _: (),
3717 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3718 if slot_.as_bytes()[28..32] != [0u8; 4] {
3719 return Err(::fidl_next::DecodeError::InvalidPadding);
3720 }
3721
3722 ::fidl_next::munge! {
3723 let Self {
3724
3725 mut flags,
3726 mut mode,
3727 mut path,
3728 mut object,
3729
3730 } = slot_;
3731 }
3732
3733 let _field = flags.as_mut();
3734
3735 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
3736
3737 let _field = mode.as_mut();
3738
3739 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
3740
3741 let _field = path.as_mut();
3742 ::fidl_next::Constrained::validate(_field, 4095)?;
3743 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
3744
3745 let path = unsafe { path.deref_unchecked() };
3746
3747 if path.len() > 4095 {
3748 return Err(::fidl_next::DecodeError::VectorTooLong {
3749 size: path.len() as u64,
3750 limit: 4095,
3751 });
3752 }
3753
3754 let _field = object.as_mut();
3755
3756 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
3757
3758 Ok(())
3759 }
3760 }
3761
3762 impl<'de> ::fidl_next::IntoNatural for DirectoryDeprecatedOpenRequest<'de> {
3763 type Natural = crate::natural::DirectoryDeprecatedOpenRequest;
3764 }
3765
3766 impl ::fidl_next::Unconstrained for DirectoryDeprecatedOpenRequest<'static> {}
3767
3768 #[derive(Debug)]
3770 #[repr(C)]
3771 pub struct DirectoryCreateSymlinkRequest<'de> {
3772 pub name: ::fidl_next::WireString<'de>,
3773
3774 pub target: ::fidl_next::WireVector<'de, u8>,
3775
3776 pub connection:
3777 ::fidl_next::ServerEnd<crate::Symlink, ::fidl_next::fuchsia::WireOptionalChannel>,
3778 }
3779
3780 static_assertions::const_assert_eq!(
3781 std::mem::size_of::<DirectoryCreateSymlinkRequest<'_>>(),
3782 40
3783 );
3784 static_assertions::const_assert_eq!(
3785 std::mem::align_of::<DirectoryCreateSymlinkRequest<'_>>(),
3786 8
3787 );
3788
3789 static_assertions::const_assert_eq!(
3790 std::mem::offset_of!(DirectoryCreateSymlinkRequest<'_>, name),
3791 0
3792 );
3793
3794 static_assertions::const_assert_eq!(
3795 std::mem::offset_of!(DirectoryCreateSymlinkRequest<'_>, target),
3796 16
3797 );
3798
3799 static_assertions::const_assert_eq!(
3800 std::mem::offset_of!(DirectoryCreateSymlinkRequest<'_>, connection),
3801 32
3802 );
3803
3804 unsafe impl ::fidl_next::Wire for DirectoryCreateSymlinkRequest<'static> {
3805 type Owned<'de> = DirectoryCreateSymlinkRequest<'de>;
3806
3807 #[inline]
3808 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3809 ::fidl_next::munge! {
3810 let Self {
3811
3812 name,
3813 target,
3814 connection,
3815
3816 } = &mut *out_;
3817 }
3818
3819 ::fidl_next::Wire::zero_padding(name);
3820
3821 ::fidl_next::Wire::zero_padding(target);
3822
3823 ::fidl_next::Wire::zero_padding(connection);
3824
3825 unsafe {
3826 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
3827 }
3828 }
3829 }
3830
3831 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryCreateSymlinkRequest<'static>
3832 where
3833 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3834 ___D: ::fidl_next::Decoder,
3835 ___D: ::fidl_next::fuchsia::HandleDecoder,
3836 {
3837 fn decode(
3838 slot_: ::fidl_next::Slot<'_, Self>,
3839 decoder_: &mut ___D,
3840 _: (),
3841 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3842 if slot_.as_bytes()[36..40] != [0u8; 4] {
3843 return Err(::fidl_next::DecodeError::InvalidPadding);
3844 }
3845
3846 ::fidl_next::munge! {
3847 let Self {
3848
3849 mut name,
3850 mut target,
3851 mut connection,
3852
3853 } = slot_;
3854 }
3855
3856 let _field = name.as_mut();
3857 ::fidl_next::Constrained::validate(_field, 255)?;
3858 ::fidl_next::Decode::decode(name.as_mut(), decoder_, 255)?;
3859
3860 let name = unsafe { name.deref_unchecked() };
3861
3862 if name.len() > 255 {
3863 return Err(::fidl_next::DecodeError::VectorTooLong {
3864 size: name.len() as u64,
3865 limit: 255,
3866 });
3867 }
3868
3869 let _field = target.as_mut();
3870 ::fidl_next::Constrained::validate(_field, (4095, ()))?;
3871 ::fidl_next::Decode::decode(target.as_mut(), decoder_, (4095, ()))?;
3872
3873 let target = unsafe { target.deref_unchecked() };
3874
3875 if target.len() > 4095 {
3876 return Err(::fidl_next::DecodeError::VectorTooLong {
3877 size: target.len() as u64,
3878 limit: 4095,
3879 });
3880 }
3881
3882 let _field = connection.as_mut();
3883
3884 ::fidl_next::Decode::decode(connection.as_mut(), decoder_, ())?;
3885
3886 Ok(())
3887 }
3888 }
3889
3890 impl<'de> ::fidl_next::IntoNatural for DirectoryCreateSymlinkRequest<'de> {
3891 type Natural = crate::natural::DirectoryCreateSymlinkRequest;
3892 }
3893
3894 impl ::fidl_next::Unconstrained for DirectoryCreateSymlinkRequest<'static> {}
3895
3896 #[derive(Debug)]
3898 #[repr(C)]
3899 pub struct FileGetBackingMemoryResponse {
3900 pub vmo: ::fidl_next::fuchsia::WireVmo,
3901 }
3902
3903 static_assertions::const_assert_eq!(std::mem::size_of::<FileGetBackingMemoryResponse>(), 4);
3904 static_assertions::const_assert_eq!(std::mem::align_of::<FileGetBackingMemoryResponse>(), 4);
3905
3906 static_assertions::const_assert_eq!(std::mem::offset_of!(FileGetBackingMemoryResponse, vmo), 0);
3907
3908 unsafe impl ::fidl_next::Wire for FileGetBackingMemoryResponse {
3909 type Owned<'de> = FileGetBackingMemoryResponse;
3910
3911 #[inline]
3912 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3913 ::fidl_next::munge! {
3914 let Self {
3915
3916 vmo,
3917
3918 } = &mut *out_;
3919 }
3920
3921 ::fidl_next::Wire::zero_padding(vmo);
3922 }
3923 }
3924
3925 unsafe impl<___D> ::fidl_next::Decode<___D> for FileGetBackingMemoryResponse
3926 where
3927 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3928 ___D: ::fidl_next::fuchsia::HandleDecoder,
3929 {
3930 fn decode(
3931 slot_: ::fidl_next::Slot<'_, Self>,
3932 decoder_: &mut ___D,
3933 _: (),
3934 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3935 ::fidl_next::munge! {
3936 let Self {
3937
3938 mut vmo,
3939
3940 } = slot_;
3941 }
3942
3943 let _field = vmo.as_mut();
3944
3945 ::fidl_next::Decode::decode(vmo.as_mut(), decoder_, ())?;
3946
3947 Ok(())
3948 }
3949 }
3950
3951 impl ::fidl_next::IntoNatural for FileGetBackingMemoryResponse {
3952 type Natural = crate::natural::FileGetBackingMemoryResponse;
3953 }
3954
3955 impl ::fidl_next::Unconstrained for FileGetBackingMemoryResponse {}
3956
3957 #[derive(Debug)]
3959 #[repr(C)]
3960 pub struct LinkableLinkIntoRequest<'de> {
3961 pub dst_parent_token: ::fidl_next::fuchsia::WireEvent,
3962
3963 pub dst: ::fidl_next::WireString<'de>,
3964 }
3965
3966 static_assertions::const_assert_eq!(std::mem::size_of::<LinkableLinkIntoRequest<'_>>(), 24);
3967 static_assertions::const_assert_eq!(std::mem::align_of::<LinkableLinkIntoRequest<'_>>(), 8);
3968
3969 static_assertions::const_assert_eq!(
3970 std::mem::offset_of!(LinkableLinkIntoRequest<'_>, dst_parent_token),
3971 0
3972 );
3973
3974 static_assertions::const_assert_eq!(std::mem::offset_of!(LinkableLinkIntoRequest<'_>, dst), 8);
3975
3976 unsafe impl ::fidl_next::Wire for LinkableLinkIntoRequest<'static> {
3977 type Owned<'de> = LinkableLinkIntoRequest<'de>;
3978
3979 #[inline]
3980 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3981 ::fidl_next::munge! {
3982 let Self {
3983
3984 dst_parent_token,
3985 dst,
3986
3987 } = &mut *out_;
3988 }
3989
3990 ::fidl_next::Wire::zero_padding(dst_parent_token);
3991
3992 ::fidl_next::Wire::zero_padding(dst);
3993
3994 unsafe {
3995 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
3996 }
3997 }
3998 }
3999
4000 unsafe impl<___D> ::fidl_next::Decode<___D> for LinkableLinkIntoRequest<'static>
4001 where
4002 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4003 ___D: ::fidl_next::Decoder,
4004 ___D: ::fidl_next::fuchsia::HandleDecoder,
4005 {
4006 fn decode(
4007 slot_: ::fidl_next::Slot<'_, Self>,
4008 decoder_: &mut ___D,
4009 _: (),
4010 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4011 if slot_.as_bytes()[4..8] != [0u8; 4] {
4012 return Err(::fidl_next::DecodeError::InvalidPadding);
4013 }
4014
4015 ::fidl_next::munge! {
4016 let Self {
4017
4018 mut dst_parent_token,
4019 mut dst,
4020
4021 } = slot_;
4022 }
4023
4024 let _field = dst_parent_token.as_mut();
4025
4026 ::fidl_next::Decode::decode(dst_parent_token.as_mut(), decoder_, ())?;
4027
4028 let _field = dst.as_mut();
4029 ::fidl_next::Constrained::validate(_field, 255)?;
4030 ::fidl_next::Decode::decode(dst.as_mut(), decoder_, 255)?;
4031
4032 let dst = unsafe { dst.deref_unchecked() };
4033
4034 if dst.len() > 255 {
4035 return Err(::fidl_next::DecodeError::VectorTooLong {
4036 size: dst.len() as u64,
4037 limit: 255,
4038 });
4039 }
4040
4041 Ok(())
4042 }
4043 }
4044
4045 impl<'de> ::fidl_next::IntoNatural for LinkableLinkIntoRequest<'de> {
4046 type Natural = crate::natural::LinkableLinkIntoRequest;
4047 }
4048
4049 impl ::fidl_next::Unconstrained for LinkableLinkIntoRequest<'static> {}
4050
4051 #[derive(Debug)]
4053 #[repr(C)]
4054 pub struct FileAllocateRequest {
4055 pub offset: ::fidl_next::WireU64,
4056
4057 pub length: ::fidl_next::WireU64,
4058
4059 pub mode: crate::wire::AllocateMode,
4060 }
4061
4062 static_assertions::const_assert_eq!(std::mem::size_of::<FileAllocateRequest>(), 24);
4063 static_assertions::const_assert_eq!(std::mem::align_of::<FileAllocateRequest>(), 8);
4064
4065 static_assertions::const_assert_eq!(std::mem::offset_of!(FileAllocateRequest, offset), 0);
4066
4067 static_assertions::const_assert_eq!(std::mem::offset_of!(FileAllocateRequest, length), 8);
4068
4069 static_assertions::const_assert_eq!(std::mem::offset_of!(FileAllocateRequest, mode), 16);
4070
4071 unsafe impl ::fidl_next::Wire for FileAllocateRequest {
4072 type Owned<'de> = FileAllocateRequest;
4073
4074 #[inline]
4075 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4076 ::fidl_next::munge! {
4077 let Self {
4078
4079 offset,
4080 length,
4081 mode,
4082
4083 } = &mut *out_;
4084 }
4085
4086 ::fidl_next::Wire::zero_padding(offset);
4087
4088 ::fidl_next::Wire::zero_padding(length);
4089
4090 ::fidl_next::Wire::zero_padding(mode);
4091
4092 unsafe {
4093 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
4094 }
4095 }
4096 }
4097
4098 unsafe impl<___D> ::fidl_next::Decode<___D> for FileAllocateRequest
4099 where
4100 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4101 ___D: ::fidl_next::fuchsia::HandleDecoder,
4102 {
4103 fn decode(
4104 slot_: ::fidl_next::Slot<'_, Self>,
4105 decoder_: &mut ___D,
4106 _: (),
4107 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4108 if slot_.as_bytes()[20..24] != [0u8; 4] {
4109 return Err(::fidl_next::DecodeError::InvalidPadding);
4110 }
4111
4112 ::fidl_next::munge! {
4113 let Self {
4114
4115 mut offset,
4116 mut length,
4117 mut mode,
4118
4119 } = slot_;
4120 }
4121
4122 let _field = offset.as_mut();
4123
4124 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
4125
4126 let _field = length.as_mut();
4127
4128 ::fidl_next::Decode::decode(length.as_mut(), decoder_, ())?;
4129
4130 let _field = mode.as_mut();
4131
4132 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
4133
4134 Ok(())
4135 }
4136 }
4137
4138 impl ::fidl_next::IntoNatural for FileAllocateRequest {
4139 type Natural = crate::natural::FileAllocateRequest;
4140 }
4141
4142 impl ::fidl_next::Unconstrained for FileAllocateRequest {}
4143
4144 #[derive(Debug)]
4146 #[repr(C)]
4147 pub struct FileEnableVerityRequest<'de> {
4148 pub options: crate::wire::VerificationOptions<'de>,
4149 }
4150
4151 static_assertions::const_assert_eq!(std::mem::size_of::<FileEnableVerityRequest<'_>>(), 16);
4152 static_assertions::const_assert_eq!(std::mem::align_of::<FileEnableVerityRequest<'_>>(), 8);
4153
4154 static_assertions::const_assert_eq!(
4155 std::mem::offset_of!(FileEnableVerityRequest<'_>, options),
4156 0
4157 );
4158
4159 unsafe impl ::fidl_next::Wire for FileEnableVerityRequest<'static> {
4160 type Owned<'de> = FileEnableVerityRequest<'de>;
4161
4162 #[inline]
4163 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4164 ::fidl_next::munge! {
4165 let Self {
4166
4167 options,
4168
4169 } = &mut *out_;
4170 }
4171
4172 ::fidl_next::Wire::zero_padding(options);
4173 }
4174 }
4175
4176 unsafe impl<___D> ::fidl_next::Decode<___D> for FileEnableVerityRequest<'static>
4177 where
4178 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4179 ___D: ::fidl_next::Decoder,
4180 ___D: ::fidl_next::fuchsia::HandleDecoder,
4181 {
4182 fn decode(
4183 slot_: ::fidl_next::Slot<'_, Self>,
4184 decoder_: &mut ___D,
4185 _: (),
4186 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4187 ::fidl_next::munge! {
4188 let Self {
4189
4190 mut options,
4191
4192 } = slot_;
4193 }
4194
4195 let _field = options.as_mut();
4196
4197 ::fidl_next::Decode::decode(options.as_mut(), decoder_, ())?;
4198
4199 Ok(())
4200 }
4201 }
4202
4203 impl<'de> ::fidl_next::IntoNatural for FileEnableVerityRequest<'de> {
4204 type Natural = crate::natural::FileEnableVerityRequest;
4205 }
4206
4207 impl ::fidl_next::Unconstrained for FileEnableVerityRequest<'static> {}
4208
4209 #[derive(Debug)]
4211 #[repr(C)]
4212 pub struct FileObject {
4213 pub event: ::fidl_next::fuchsia::WireOptionalEvent,
4214
4215 pub stream: ::fidl_next::fuchsia::WireOptionalStream,
4216 }
4217
4218 static_assertions::const_assert_eq!(std::mem::size_of::<FileObject>(), 8);
4219 static_assertions::const_assert_eq!(std::mem::align_of::<FileObject>(), 4);
4220
4221 static_assertions::const_assert_eq!(std::mem::offset_of!(FileObject, event), 0);
4222
4223 static_assertions::const_assert_eq!(std::mem::offset_of!(FileObject, stream), 4);
4224
4225 unsafe impl ::fidl_next::Wire for FileObject {
4226 type Owned<'de> = FileObject;
4227
4228 #[inline]
4229 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4230 ::fidl_next::munge! {
4231 let Self {
4232
4233 event,
4234 stream,
4235
4236 } = &mut *out_;
4237 }
4238
4239 ::fidl_next::Wire::zero_padding(event);
4240
4241 ::fidl_next::Wire::zero_padding(stream);
4242 }
4243 }
4244
4245 unsafe impl<___D> ::fidl_next::Decode<___D> for FileObject
4246 where
4247 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4248 ___D: ::fidl_next::fuchsia::HandleDecoder,
4249 {
4250 fn decode(
4251 slot_: ::fidl_next::Slot<'_, Self>,
4252 decoder_: &mut ___D,
4253 _: (),
4254 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4255 ::fidl_next::munge! {
4256 let Self {
4257
4258 mut event,
4259 mut stream,
4260
4261 } = slot_;
4262 }
4263
4264 let _field = event.as_mut();
4265
4266 ::fidl_next::Decode::decode(event.as_mut(), decoder_, ())?;
4267
4268 let _field = stream.as_mut();
4269
4270 ::fidl_next::Decode::decode(stream.as_mut(), decoder_, ())?;
4271
4272 Ok(())
4273 }
4274 }
4275
4276 impl ::fidl_next::IntoNatural for FileObject {
4277 type Natural = crate::natural::FileObject;
4278 }
4279
4280 impl ::fidl_next::Unconstrained for FileObject {}
4281
4282 #[repr(transparent)]
4284 pub struct NodeInfoDeprecated<'de> {
4285 pub(crate) raw: ::fidl_next::RawWireUnion,
4286 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4287 }
4288
4289 impl<'de> Drop for NodeInfoDeprecated<'de> {
4290 fn drop(&mut self) {
4291 match self.raw.ordinal() {
4292 1 => {
4293 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Service>() };
4294 }
4295
4296 2 => {
4297 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::FileObject>() };
4298 }
4299
4300 3 => {
4301 let _ =
4302 unsafe { self.raw.get().read_unchecked::<crate::wire::DirectoryObject>() };
4303 }
4304
4305 4 => {
4306 let _ = unsafe {
4307 self.raw.get().read_unchecked::<crate::wire::SymlinkObject<'de>>()
4308 };
4309 }
4310
4311 _ => unsafe { ::core::hint::unreachable_unchecked() },
4312 }
4313 }
4314 }
4315
4316 unsafe impl ::fidl_next::Wire for NodeInfoDeprecated<'static> {
4317 type Owned<'de> = NodeInfoDeprecated<'de>;
4318
4319 #[inline]
4320 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4321 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4322 ::fidl_next::RawWireUnion::zero_padding(raw);
4323 }
4324 }
4325
4326 pub mod node_info_deprecated {
4327 pub enum Ref<'de> {
4328 Service(&'de crate::wire::Service),
4329
4330 File(&'de crate::wire::FileObject),
4331
4332 Directory(&'de crate::wire::DirectoryObject),
4333
4334 Symlink(&'de crate::wire::SymlinkObject<'de>),
4335 }
4336 }
4337
4338 impl<'de> NodeInfoDeprecated<'de> {
4339 pub fn as_ref(&self) -> crate::wire::node_info_deprecated::Ref<'_> {
4340 match self.raw.ordinal() {
4341 1 => crate::wire::node_info_deprecated::Ref::Service(unsafe {
4342 self.raw.get().deref_unchecked::<crate::wire::Service>()
4343 }),
4344
4345 2 => crate::wire::node_info_deprecated::Ref::File(unsafe {
4346 self.raw.get().deref_unchecked::<crate::wire::FileObject>()
4347 }),
4348
4349 3 => crate::wire::node_info_deprecated::Ref::Directory(unsafe {
4350 self.raw.get().deref_unchecked::<crate::wire::DirectoryObject>()
4351 }),
4352
4353 4 => crate::wire::node_info_deprecated::Ref::Symlink(unsafe {
4354 self.raw.get().deref_unchecked::<crate::wire::SymlinkObject<'_>>()
4355 }),
4356
4357 _ => unsafe { ::core::hint::unreachable_unchecked() },
4358 }
4359 }
4360 }
4361
4362 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeInfoDeprecated<'static>
4363 where
4364 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4365 ___D: ::fidl_next::Decoder,
4366 ___D: ::fidl_next::fuchsia::HandleDecoder,
4367 {
4368 fn decode(
4369 mut slot: ::fidl_next::Slot<'_, Self>,
4370 decoder: &mut ___D,
4371 _: (),
4372 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4373 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4374 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
4375 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Service>(
4376 raw,
4377 decoder,
4378 (),
4379 )?,
4380
4381 2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::FileObject>(
4382 raw,
4383 decoder,
4384 (),
4385 )?,
4386
4387 3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirectoryObject>(
4388 raw,
4389 decoder,
4390 (),
4391 )?,
4392
4393 4 => ::fidl_next::RawWireUnion::decode_as::<
4394 ___D,
4395 crate::wire::SymlinkObject<'static>,
4396 >(raw, decoder, ())?,
4397
4398 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
4399 }
4400
4401 Ok(())
4402 }
4403 }
4404
4405 impl<'de> ::core::fmt::Debug for NodeInfoDeprecated<'de> {
4406 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4407 match self.raw.ordinal() {
4408 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Service>().fmt(f) },
4409 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::FileObject>().fmt(f) },
4410 3 => unsafe {
4411 self.raw.get().deref_unchecked::<crate::wire::DirectoryObject>().fmt(f)
4412 },
4413 4 => unsafe {
4414 self.raw.get().deref_unchecked::<crate::wire::SymlinkObject<'_>>().fmt(f)
4415 },
4416 _ => unsafe { ::core::hint::unreachable_unchecked() },
4417 }
4418 }
4419 }
4420
4421 impl<'de> ::fidl_next::IntoNatural for NodeInfoDeprecated<'de> {
4422 type Natural = crate::natural::NodeInfoDeprecated;
4423 }
4424
4425 impl ::fidl_next::Unconstrained for NodeInfoDeprecated<'static> {}
4426}
4427
4428pub mod wire_optional {
4429
4430 pub use fidl_next_common_fuchsia_io::wire_optional::*;
4431
4432 #[repr(transparent)]
4433 pub struct ExtendedAttributeValue<'de> {
4434 pub(crate) raw: ::fidl_next::RawWireUnion,
4435 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4436 }
4437
4438 unsafe impl ::fidl_next::Wire for ExtendedAttributeValue<'static> {
4439 type Owned<'de> = ExtendedAttributeValue<'de>;
4440
4441 #[inline]
4442 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4443 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4444 ::fidl_next::RawWireUnion::zero_padding(raw);
4445 }
4446 }
4447
4448 impl<'de> ExtendedAttributeValue<'de> {
4449 pub fn is_some(&self) -> bool {
4450 self.raw.is_some()
4451 }
4452
4453 pub fn is_none(&self) -> bool {
4454 self.raw.is_none()
4455 }
4456
4457 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::ExtendedAttributeValue<'de>> {
4458 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
4459 }
4460
4461 pub fn into_option(
4462 self,
4463 ) -> ::core::option::Option<crate::wire::ExtendedAttributeValue<'de>> {
4464 if self.is_some() {
4465 Some(crate::wire::ExtendedAttributeValue {
4466 raw: self.raw,
4467 _phantom: ::core::marker::PhantomData,
4468 })
4469 } else {
4470 None
4471 }
4472 }
4473 }
4474
4475 unsafe impl<___D> ::fidl_next::Decode<___D> for ExtendedAttributeValue<'static>
4476 where
4477 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4478 ___D: ::fidl_next::Decoder,
4479 ___D: ::fidl_next::fuchsia::HandleDecoder,
4480 {
4481 fn decode(
4482 mut slot: ::fidl_next::Slot<'_, Self>,
4483 decoder: &mut ___D,
4484 _: (),
4485 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4486 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4487 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
4488 1 => ::fidl_next::RawWireUnion::decode_as::<
4489 ___D,
4490 ::fidl_next::WireVector<'static, u8>,
4491 >(raw, decoder, (32768, ()))?,
4492
4493 2 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::fuchsia::WireVmo>(
4494 raw,
4495 decoder,
4496 (),
4497 )?,
4498
4499 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
4500 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
4501 }
4502
4503 Ok(())
4504 }
4505 }
4506
4507 impl<'de> ::core::fmt::Debug for ExtendedAttributeValue<'de> {
4508 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4509 self.as_ref().fmt(f)
4510 }
4511 }
4512
4513 impl<'de> ::fidl_next::IntoNatural for ExtendedAttributeValue<'de> {
4514 type Natural = ::core::option::Option<crate::natural::ExtendedAttributeValue>;
4515 }
4516
4517 impl ::fidl_next::Unconstrained for ExtendedAttributeValue<'static> {}
4518
4519 #[repr(transparent)]
4520 pub struct Representation<'de> {
4521 pub(crate) raw: ::fidl_next::RawWireUnion,
4522 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4523 }
4524
4525 unsafe impl ::fidl_next::Wire for Representation<'static> {
4526 type Owned<'de> = Representation<'de>;
4527
4528 #[inline]
4529 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4530 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4531 ::fidl_next::RawWireUnion::zero_padding(raw);
4532 }
4533 }
4534
4535 impl<'de> Representation<'de> {
4536 pub fn is_some(&self) -> bool {
4537 self.raw.is_some()
4538 }
4539
4540 pub fn is_none(&self) -> bool {
4541 self.raw.is_none()
4542 }
4543
4544 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Representation<'de>> {
4545 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
4546 }
4547
4548 pub fn into_option(self) -> ::core::option::Option<crate::wire::Representation<'de>> {
4549 if self.is_some() {
4550 Some(crate::wire::Representation {
4551 raw: self.raw,
4552 _phantom: ::core::marker::PhantomData,
4553 })
4554 } else {
4555 None
4556 }
4557 }
4558 }
4559
4560 unsafe impl<___D> ::fidl_next::Decode<___D> for Representation<'static>
4561 where
4562 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4563 ___D: ::fidl_next::Decoder,
4564 ___D: ::fidl_next::fuchsia::HandleDecoder,
4565 {
4566 fn decode(
4567 mut slot: ::fidl_next::Slot<'_, Self>,
4568 decoder: &mut ___D,
4569 _: (),
4570 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4571 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4572 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
4573 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::NodeInfo<'static>>(
4574 raw,
4575 decoder,
4576 (),
4577 )?,
4578
4579 2 => ::fidl_next::RawWireUnion::decode_as::<
4580 ___D,
4581 crate::wire::DirectoryInfo<'static>,
4582 >(raw, decoder, ())?,
4583
4584 3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::FileInfo<'static>>(
4585 raw,
4586 decoder,
4587 (),
4588 )?,
4589
4590 4 => {
4591 ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::SymlinkInfo<'static>>(
4592 raw,
4593 decoder,
4594 (),
4595 )?
4596 }
4597
4598 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
4599 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
4600 }
4601
4602 Ok(())
4603 }
4604 }
4605
4606 impl<'de> ::core::fmt::Debug for Representation<'de> {
4607 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4608 self.as_ref().fmt(f)
4609 }
4610 }
4611
4612 impl<'de> ::fidl_next::IntoNatural for Representation<'de> {
4613 type Natural = ::core::option::Option<crate::natural::Representation>;
4614 }
4615
4616 impl ::fidl_next::Unconstrained for Representation<'static> {}
4617
4618 #[repr(transparent)]
4619 pub struct NodeInfoDeprecated<'de> {
4620 pub(crate) raw: ::fidl_next::RawWireUnion,
4621 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4622 }
4623
4624 unsafe impl ::fidl_next::Wire for NodeInfoDeprecated<'static> {
4625 type Owned<'de> = NodeInfoDeprecated<'de>;
4626
4627 #[inline]
4628 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4629 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4630 ::fidl_next::RawWireUnion::zero_padding(raw);
4631 }
4632 }
4633
4634 impl<'de> NodeInfoDeprecated<'de> {
4635 pub fn is_some(&self) -> bool {
4636 self.raw.is_some()
4637 }
4638
4639 pub fn is_none(&self) -> bool {
4640 self.raw.is_none()
4641 }
4642
4643 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::NodeInfoDeprecated<'de>> {
4644 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
4645 }
4646
4647 pub fn into_option(self) -> ::core::option::Option<crate::wire::NodeInfoDeprecated<'de>> {
4648 if self.is_some() {
4649 Some(crate::wire::NodeInfoDeprecated {
4650 raw: self.raw,
4651 _phantom: ::core::marker::PhantomData,
4652 })
4653 } else {
4654 None
4655 }
4656 }
4657 }
4658
4659 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeInfoDeprecated<'static>
4660 where
4661 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4662 ___D: ::fidl_next::Decoder,
4663 ___D: ::fidl_next::fuchsia::HandleDecoder,
4664 {
4665 fn decode(
4666 mut slot: ::fidl_next::Slot<'_, Self>,
4667 decoder: &mut ___D,
4668 _: (),
4669 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4670 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4671 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
4672 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Service>(
4673 raw,
4674 decoder,
4675 (),
4676 )?,
4677
4678 2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::FileObject>(
4679 raw,
4680 decoder,
4681 (),
4682 )?,
4683
4684 3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirectoryObject>(
4685 raw,
4686 decoder,
4687 (),
4688 )?,
4689
4690 4 => ::fidl_next::RawWireUnion::decode_as::<
4691 ___D,
4692 crate::wire::SymlinkObject<'static>,
4693 >(raw, decoder, ())?,
4694
4695 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
4696 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
4697 }
4698
4699 Ok(())
4700 }
4701 }
4702
4703 impl<'de> ::core::fmt::Debug for NodeInfoDeprecated<'de> {
4704 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4705 self.as_ref().fmt(f)
4706 }
4707 }
4708
4709 impl<'de> ::fidl_next::IntoNatural for NodeInfoDeprecated<'de> {
4710 type Natural = ::core::option::Option<crate::natural::NodeInfoDeprecated>;
4711 }
4712
4713 impl ::fidl_next::Unconstrained for NodeInfoDeprecated<'static> {}
4714}
4715
4716pub mod generic {
4717
4718 pub use fidl_next_common_fuchsia_io::generic::*;
4719
4720 pub struct DirectoryGetTokenResponse<T0, T1> {
4721 pub s: T0,
4722
4723 pub token: T1,
4724 }
4725
4726 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DirectoryGetTokenResponse, ___E>
4727 for DirectoryGetTokenResponse<T0, T1>
4728 where
4729 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4730 ___E: ::fidl_next::fuchsia::HandleEncoder,
4731 T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
4732 T1: ::fidl_next::Encode<::fidl_next::fuchsia::WireOptionalHandle, ___E>,
4733 {
4734 #[inline]
4735 fn encode(
4736 self,
4737 encoder_: &mut ___E,
4738 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryGetTokenResponse>,
4739 _: (),
4740 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4741 ::fidl_next::munge! {
4742 let crate::wire::DirectoryGetTokenResponse {
4743
4744 s,
4745 token,
4746
4747 } = out_;
4748 }
4749
4750 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
4751
4752 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
4753
4754 Ok(())
4755 }
4756 }
4757
4758 pub struct DirectoryLinkRequest<T0, T1, T2> {
4759 pub src: T0,
4760
4761 pub dst_parent_token: T1,
4762
4763 pub dst: T2,
4764 }
4765
4766 unsafe impl<___E, T0, T1, T2>
4767 ::fidl_next::Encode<crate::wire::DirectoryLinkRequest<'static>, ___E>
4768 for DirectoryLinkRequest<T0, T1, T2>
4769 where
4770 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4771 ___E: ::fidl_next::Encoder,
4772 ___E: ::fidl_next::fuchsia::HandleEncoder,
4773 T0: ::fidl_next::Encode<::fidl_next::WireString<'static>, ___E>,
4774 T1: ::fidl_next::Encode<::fidl_next::fuchsia::WireHandle, ___E>,
4775 T2: ::fidl_next::Encode<::fidl_next::WireString<'static>, ___E>,
4776 {
4777 #[inline]
4778 fn encode(
4779 self,
4780 encoder_: &mut ___E,
4781 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkRequest<'static>>,
4782 _: (),
4783 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4784 ::fidl_next::munge! {
4785 let crate::wire::DirectoryLinkRequest {
4786
4787 src,
4788 dst_parent_token,
4789 dst,
4790
4791 } = out_;
4792 }
4793
4794 ::fidl_next::Encode::encode(self.src, encoder_, src, 255)?;
4795
4796 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
4797
4798 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
4799
4800 Ok(())
4801 }
4802 }
4803
4804 pub struct DirectoryRenameRequest<T0, T1, T2> {
4805 pub src: T0,
4806
4807 pub dst_parent_token: T1,
4808
4809 pub dst: T2,
4810 }
4811
4812 unsafe impl<___E, T0, T1, T2>
4813 ::fidl_next::Encode<crate::wire::DirectoryRenameRequest<'static>, ___E>
4814 for DirectoryRenameRequest<T0, T1, T2>
4815 where
4816 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4817 ___E: ::fidl_next::Encoder,
4818 ___E: ::fidl_next::fuchsia::HandleEncoder,
4819 T0: ::fidl_next::Encode<::fidl_next::WireString<'static>, ___E>,
4820 T1: ::fidl_next::Encode<::fidl_next::fuchsia::WireEvent, ___E>,
4821 T2: ::fidl_next::Encode<::fidl_next::WireString<'static>, ___E>,
4822 {
4823 #[inline]
4824 fn encode(
4825 self,
4826 encoder_: &mut ___E,
4827 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRenameRequest<'static>>,
4828 _: (),
4829 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4830 ::fidl_next::munge! {
4831 let crate::wire::DirectoryRenameRequest {
4832
4833 src,
4834 dst_parent_token,
4835 dst,
4836
4837 } = out_;
4838 }
4839
4840 ::fidl_next::Encode::encode(self.src, encoder_, src, 255)?;
4841
4842 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
4843
4844 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
4845
4846 Ok(())
4847 }
4848 }
4849
4850 pub struct DirectoryWatchRequest<T0, T1, T2> {
4851 pub mask: T0,
4852
4853 pub options: T1,
4854
4855 pub watcher: T2,
4856 }
4857
4858 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::DirectoryWatchRequest, ___E>
4859 for DirectoryWatchRequest<T0, T1, T2>
4860 where
4861 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4862 ___E: ::fidl_next::fuchsia::HandleEncoder,
4863 T0: ::fidl_next::Encode<crate::wire::WatchMask, ___E>,
4864 T1: ::fidl_next::Encode<::fidl_next::WireU32, ___E>,
4865 T2: ::fidl_next::Encode<
4866 ::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fidl_next::fuchsia::WireChannel>,
4867 ___E,
4868 >,
4869 {
4870 #[inline]
4871 fn encode(
4872 self,
4873 encoder_: &mut ___E,
4874 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchRequest>,
4875 _: (),
4876 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4877 ::fidl_next::munge! {
4878 let crate::wire::DirectoryWatchRequest {
4879
4880 mask,
4881 options,
4882 watcher,
4883
4884 } = out_;
4885 }
4886
4887 ::fidl_next::Encode::encode(self.mask, encoder_, mask, ())?;
4888
4889 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
4890
4891 ::fidl_next::Encode::encode(self.watcher, encoder_, watcher, ())?;
4892
4893 Ok(())
4894 }
4895 }
4896
4897 pub struct NodeOnOpenRequest<T0, T1> {
4898 pub s: T0,
4899
4900 pub info: T1,
4901 }
4902
4903 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeOnOpenRequest<'static>, ___E>
4904 for NodeOnOpenRequest<T0, T1>
4905 where
4906 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4907 ___E: ::fidl_next::Encoder,
4908 ___E: ::fidl_next::fuchsia::HandleEncoder,
4909 T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
4910 T1: ::fidl_next::Encode<crate::wire_optional::NodeInfoDeprecated<'static>, ___E>,
4911 {
4912 #[inline]
4913 fn encode(
4914 self,
4915 encoder_: &mut ___E,
4916 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeOnOpenRequest<'static>>,
4917 _: (),
4918 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4919 ::fidl_next::munge! {
4920 let crate::wire::NodeOnOpenRequest {
4921
4922 s,
4923 info,
4924
4925 } = out_;
4926 }
4927
4928 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
4929
4930 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
4931
4932 Ok(())
4933 }
4934 }
4935
4936 pub struct NodeListExtendedAttributesRequest<T0> {
4937 pub iterator: T0,
4938 }
4939
4940 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeListExtendedAttributesRequest, ___E>
4941 for NodeListExtendedAttributesRequest<T0>
4942 where
4943 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4944 ___E: ::fidl_next::fuchsia::HandleEncoder,
4945 T0: ::fidl_next::Encode<
4946 ::fidl_next::ServerEnd<
4947 crate::ExtendedAttributeIterator,
4948 ::fidl_next::fuchsia::WireChannel,
4949 >,
4950 ___E,
4951 >,
4952 {
4953 #[inline]
4954 fn encode(
4955 self,
4956 encoder_: &mut ___E,
4957 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeListExtendedAttributesRequest>,
4958 _: (),
4959 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4960 ::fidl_next::munge! {
4961 let crate::wire::NodeListExtendedAttributesRequest {
4962
4963 iterator,
4964
4965 } = out_;
4966 }
4967
4968 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
4969
4970 Ok(())
4971 }
4972 }
4973
4974 pub struct NodeSetExtendedAttributeRequest<T0, T1, T2> {
4975 pub name: T0,
4976
4977 pub value: T1,
4978
4979 pub mode: T2,
4980 }
4981
4982 unsafe impl<___E, T0, T1, T2>
4983 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeRequest<'static>, ___E>
4984 for NodeSetExtendedAttributeRequest<T0, T1, T2>
4985 where
4986 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4987 ___E: ::fidl_next::Encoder,
4988 ___E: ::fidl_next::fuchsia::HandleEncoder,
4989 T0: ::fidl_next::Encode<::fidl_next::WireVector<'static, u8>, ___E>,
4990 T1: ::fidl_next::Encode<crate::wire::ExtendedAttributeValue<'static>, ___E>,
4991 T2: ::fidl_next::Encode<crate::wire::SetExtendedAttributeMode, ___E>,
4992 {
4993 #[inline]
4994 fn encode(
4995 self,
4996 encoder_: &mut ___E,
4997 out_: &mut ::core::mem::MaybeUninit<
4998 crate::wire::NodeSetExtendedAttributeRequest<'static>,
4999 >,
5000 _: (),
5001 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5002 ::fidl_next::munge! {
5003 let crate::wire::NodeSetExtendedAttributeRequest {
5004
5005 name,
5006 value,
5007 mode,
5008
5009 } = out_;
5010 }
5011
5012 ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
5013
5014 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
5015
5016 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
5017
5018 Ok(())
5019 }
5020 }
5021
5022 pub struct DirectoryOpenRequest<T0, T1, T2, T3> {
5023 pub path: T0,
5024
5025 pub flags: T1,
5026
5027 pub options: T2,
5028
5029 pub object: T3,
5030 }
5031
5032 unsafe impl<___E, T0, T1, T2, T3>
5033 ::fidl_next::Encode<crate::wire::DirectoryOpenRequest<'static>, ___E>
5034 for DirectoryOpenRequest<T0, T1, T2, T3>
5035 where
5036 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5037 ___E: ::fidl_next::Encoder,
5038 ___E: ::fidl_next::fuchsia::HandleEncoder,
5039 T0: ::fidl_next::Encode<::fidl_next::WireString<'static>, ___E>,
5040 T1: ::fidl_next::Encode<crate::wire::Flags, ___E>,
5041 T2: ::fidl_next::Encode<crate::wire::Options<'static>, ___E>,
5042 T3: ::fidl_next::Encode<::fidl_next::fuchsia::WireChannel, ___E>,
5043 {
5044 #[inline]
5045 fn encode(
5046 self,
5047 encoder_: &mut ___E,
5048 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryOpenRequest<'static>>,
5049 _: (),
5050 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5051 ::fidl_next::munge! {
5052 let crate::wire::DirectoryOpenRequest {
5053
5054 path,
5055 flags,
5056 options,
5057 object,
5058
5059 } = out_;
5060 }
5061
5062 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
5063
5064 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
5065
5066 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
5067
5068 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
5069
5070 Ok(())
5071 }
5072 }
5073
5074 pub struct NodeDeprecatedCloneRequest<T0, T1> {
5075 pub flags: T0,
5076
5077 pub object: T1,
5078 }
5079
5080 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeDeprecatedCloneRequest, ___E>
5081 for NodeDeprecatedCloneRequest<T0, T1>
5082 where
5083 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5084 ___E: ::fidl_next::fuchsia::HandleEncoder,
5085 T0: ::fidl_next::Encode<crate::wire::OpenFlags, ___E>,
5086 T1: ::fidl_next::Encode<
5087 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
5088 ___E,
5089 >,
5090 {
5091 #[inline]
5092 fn encode(
5093 self,
5094 encoder_: &mut ___E,
5095 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedCloneRequest>,
5096 _: (),
5097 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5098 ::fidl_next::munge! {
5099 let crate::wire::NodeDeprecatedCloneRequest {
5100
5101 flags,
5102 object,
5103
5104 } = out_;
5105 }
5106
5107 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
5108
5109 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
5110
5111 Ok(())
5112 }
5113 }
5114
5115 pub struct DirectoryDeprecatedOpenRequest<T0, T1, T2, T3> {
5116 pub flags: T0,
5117
5118 pub mode: T1,
5119
5120 pub path: T2,
5121
5122 pub object: T3,
5123 }
5124
5125 unsafe impl<___E, T0, T1, T2, T3>
5126 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedOpenRequest<'static>, ___E>
5127 for DirectoryDeprecatedOpenRequest<T0, T1, T2, T3>
5128 where
5129 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5130 ___E: ::fidl_next::Encoder,
5131 ___E: ::fidl_next::fuchsia::HandleEncoder,
5132 T0: ::fidl_next::Encode<crate::wire::OpenFlags, ___E>,
5133 T1: ::fidl_next::Encode<crate::wire::ModeType, ___E>,
5134 T2: ::fidl_next::Encode<::fidl_next::WireString<'static>, ___E>,
5135 T3: ::fidl_next::Encode<
5136 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
5137 ___E,
5138 >,
5139 {
5140 #[inline]
5141 fn encode(
5142 self,
5143 encoder_: &mut ___E,
5144 out_: &mut ::core::mem::MaybeUninit<
5145 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
5146 >,
5147 _: (),
5148 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5149 ::fidl_next::munge! {
5150 let crate::wire::DirectoryDeprecatedOpenRequest {
5151
5152 flags,
5153 mode,
5154 path,
5155 object,
5156
5157 } = out_;
5158 }
5159
5160 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
5161
5162 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
5163
5164 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
5165
5166 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
5167
5168 Ok(())
5169 }
5170 }
5171
5172 pub struct DirectoryCreateSymlinkRequest<T0, T1, T2> {
5173 pub name: T0,
5174
5175 pub target: T1,
5176
5177 pub connection: T2,
5178 }
5179
5180 unsafe impl<___E, T0, T1, T2>
5181 ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkRequest<'static>, ___E>
5182 for DirectoryCreateSymlinkRequest<T0, T1, T2>
5183 where
5184 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5185 ___E: ::fidl_next::Encoder,
5186 ___E: ::fidl_next::fuchsia::HandleEncoder,
5187 T0: ::fidl_next::Encode<::fidl_next::WireString<'static>, ___E>,
5188 T1: ::fidl_next::Encode<::fidl_next::WireVector<'static, u8>, ___E>,
5189 T2: ::fidl_next::Encode<
5190 ::fidl_next::ServerEnd<crate::Symlink, ::fidl_next::fuchsia::WireOptionalChannel>,
5191 ___E,
5192 >,
5193 {
5194 #[inline]
5195 fn encode(
5196 self,
5197 encoder_: &mut ___E,
5198 out_: &mut ::core::mem::MaybeUninit<
5199 crate::wire::DirectoryCreateSymlinkRequest<'static>,
5200 >,
5201 _: (),
5202 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5203 ::fidl_next::munge! {
5204 let crate::wire::DirectoryCreateSymlinkRequest {
5205
5206 name,
5207 target,
5208 connection,
5209
5210 } = out_;
5211 }
5212
5213 ::fidl_next::Encode::encode(self.name, encoder_, name, 255)?;
5214
5215 ::fidl_next::Encode::encode(self.target, encoder_, target, (4095, ()))?;
5216
5217 ::fidl_next::Encode::encode(self.connection, encoder_, connection, ())?;
5218
5219 Ok(())
5220 }
5221 }
5222
5223 pub struct FileGetBackingMemoryResponse<T0> {
5224 pub vmo: T0,
5225 }
5226
5227 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryResponse, ___E>
5228 for FileGetBackingMemoryResponse<T0>
5229 where
5230 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5231 ___E: ::fidl_next::fuchsia::HandleEncoder,
5232 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireVmo, ___E>,
5233 {
5234 #[inline]
5235 fn encode(
5236 self,
5237 encoder_: &mut ___E,
5238 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryResponse>,
5239 _: (),
5240 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5241 ::fidl_next::munge! {
5242 let crate::wire::FileGetBackingMemoryResponse {
5243
5244 vmo,
5245
5246 } = out_;
5247 }
5248
5249 ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
5250
5251 Ok(())
5252 }
5253 }
5254
5255 pub struct LinkableLinkIntoRequest<T0, T1> {
5256 pub dst_parent_token: T0,
5257
5258 pub dst: T1,
5259 }
5260
5261 unsafe impl<___E, T0, T1>
5262 ::fidl_next::Encode<crate::wire::LinkableLinkIntoRequest<'static>, ___E>
5263 for LinkableLinkIntoRequest<T0, T1>
5264 where
5265 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5266 ___E: ::fidl_next::Encoder,
5267 ___E: ::fidl_next::fuchsia::HandleEncoder,
5268 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireEvent, ___E>,
5269 T1: ::fidl_next::Encode<::fidl_next::WireString<'static>, ___E>,
5270 {
5271 #[inline]
5272 fn encode(
5273 self,
5274 encoder_: &mut ___E,
5275 out_: &mut ::core::mem::MaybeUninit<crate::wire::LinkableLinkIntoRequest<'static>>,
5276 _: (),
5277 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5278 ::fidl_next::munge! {
5279 let crate::wire::LinkableLinkIntoRequest {
5280
5281 dst_parent_token,
5282 dst,
5283
5284 } = out_;
5285 }
5286
5287 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
5288
5289 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
5290
5291 Ok(())
5292 }
5293 }
5294
5295 pub struct FileAllocateRequest<T0, T1, T2> {
5296 pub offset: T0,
5297
5298 pub length: T1,
5299
5300 pub mode: T2,
5301 }
5302
5303 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::FileAllocateRequest, ___E>
5304 for FileAllocateRequest<T0, T1, T2>
5305 where
5306 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5307 ___E: ::fidl_next::fuchsia::HandleEncoder,
5308 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
5309 T1: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
5310 T2: ::fidl_next::Encode<crate::wire::AllocateMode, ___E>,
5311 {
5312 #[inline]
5313 fn encode(
5314 self,
5315 encoder_: &mut ___E,
5316 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileAllocateRequest>,
5317 _: (),
5318 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5319 ::fidl_next::munge! {
5320 let crate::wire::FileAllocateRequest {
5321
5322 offset,
5323 length,
5324 mode,
5325
5326 } = out_;
5327 }
5328
5329 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
5330
5331 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
5332
5333 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
5334
5335 Ok(())
5336 }
5337 }
5338
5339 pub struct FileEnableVerityRequest<T0> {
5340 pub options: T0,
5341 }
5342
5343 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileEnableVerityRequest<'static>, ___E>
5344 for FileEnableVerityRequest<T0>
5345 where
5346 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5347 ___E: ::fidl_next::Encoder,
5348 ___E: ::fidl_next::fuchsia::HandleEncoder,
5349 T0: ::fidl_next::Encode<crate::wire::VerificationOptions<'static>, ___E>,
5350 {
5351 #[inline]
5352 fn encode(
5353 self,
5354 encoder_: &mut ___E,
5355 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileEnableVerityRequest<'static>>,
5356 _: (),
5357 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5358 ::fidl_next::munge! {
5359 let crate::wire::FileEnableVerityRequest {
5360
5361 options,
5362
5363 } = out_;
5364 }
5365
5366 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
5367
5368 Ok(())
5369 }
5370 }
5371
5372 pub struct FileObject<T0, T1> {
5373 pub event: T0,
5374
5375 pub stream: T1,
5376 }
5377
5378 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::FileObject, ___E> for FileObject<T0, T1>
5379 where
5380 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5381 ___E: ::fidl_next::fuchsia::HandleEncoder,
5382 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireOptionalEvent, ___E>,
5383 T1: ::fidl_next::Encode<::fidl_next::fuchsia::WireOptionalStream, ___E>,
5384 {
5385 #[inline]
5386 fn encode(
5387 self,
5388 encoder_: &mut ___E,
5389 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileObject>,
5390 _: (),
5391 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5392 ::fidl_next::munge! {
5393 let crate::wire::FileObject {
5394
5395 event,
5396 stream,
5397
5398 } = out_;
5399 }
5400
5401 ::fidl_next::Encode::encode(self.event, encoder_, event, ())?;
5402
5403 ::fidl_next::Encode::encode(self.stream, encoder_, stream, ())?;
5404
5405 Ok(())
5406 }
5407 }
5408}
5409
5410pub use self::natural::*;
5411
5412#[doc = " Node defines the minimal interface for entities which can be accessed in a filesystem.\n"]
5414#[derive(PartialEq, Debug)]
5415pub struct Node;
5416
5417impl ::fidl_next::Discoverable for Node {
5418 const PROTOCOL_NAME: &'static str = "fuchsia.io.Node";
5419}
5420
5421#[cfg(target_os = "fuchsia")]
5422impl ::fidl_next::HasTransport for Node {
5423 type Transport = ::fidl_next::fuchsia::zx::Channel;
5424}
5425
5426pub mod node {
5427 pub mod prelude {
5428 pub use crate::{Node, NodeClientHandler, NodeServerHandler, node};
5429
5430 pub use crate::natural::ExtendedAttributeValue;
5431
5432 pub use crate::natural::MutableNodeAttributes;
5433
5434 pub use crate::natural::NodeAttributes2;
5435
5436 pub use crate::natural::NodeDeprecatedCloneRequest;
5437
5438 pub use crate::natural::NodeDeprecatedGetAttrResponse;
5439
5440 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
5441
5442 pub use crate::natural::NodeDeprecatedSetAttrRequest;
5443
5444 pub use crate::natural::NodeDeprecatedSetAttrResponse;
5445
5446 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
5447
5448 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
5449
5450 pub use crate::natural::NodeGetAttributesRequest;
5451
5452 pub use crate::natural::NodeGetExtendedAttributeRequest;
5453
5454 pub use crate::natural::NodeListExtendedAttributesRequest;
5455
5456 pub use crate::natural::NodeOnOpenRequest;
5457
5458 pub use crate::natural::NodeQueryFilesystemResponse;
5459
5460 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
5461
5462 pub use crate::natural::NodeSetExtendedAttributeRequest;
5463
5464 pub use crate::natural::NodeSetFlagsRequest;
5465
5466 pub use crate::natural::NodeGetFlagsResponse;
5467
5468 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
5469
5470 pub use crate::natural::NodeSetExtendedAttributeResponse;
5471
5472 pub use crate::natural::NodeSetFlagsResponse;
5473
5474 pub use crate::natural::NodeSyncResponse;
5475
5476 pub use crate::natural::NodeUpdateAttributesResponse;
5477
5478 pub use crate::natural::Representation;
5479
5480 pub use ::fidl_next_fuchsia_unknown::natural::CloneableCloneRequest;
5481
5482 pub use ::fidl_next_fuchsia_unknown::natural::CloseableCloseResponse;
5483
5484 pub use ::fidl_next_fuchsia_unknown::natural::QueryableQueryResponse;
5485 }
5486
5487 pub struct Clone;
5488
5489 impl ::fidl_next::Method for Clone {
5490 const ORDINAL: u64 = 2366825959783828089;
5491 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5492 ::fidl_next::protocol::Flexibility::Strict;
5493
5494 type Protocol = crate::Node;
5495
5496 type Request = ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest;
5497 }
5498
5499 pub struct Close;
5500
5501 impl ::fidl_next::Method for Close {
5502 const ORDINAL: u64 = 6540867515453498750;
5503 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5504 ::fidl_next::protocol::Flexibility::Strict;
5505
5506 type Protocol = crate::Node;
5507
5508 type Request = ();
5509 }
5510
5511 impl ::fidl_next::TwoWayMethod for Close {
5512 type Response = ::fidl_next::WireResult<
5513 'static,
5514 ::fidl_next_fuchsia_unknown::wire::CloseableCloseResponse,
5515 ::fidl_next::WireI32,
5516 >;
5517 }
5518
5519 impl<___R> ::fidl_next::Respond<___R> for Close {
5520 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
5521
5522 fn respond(response: ___R) -> Self::Output {
5523 ::core::result::Result::Ok(response)
5524 }
5525 }
5526
5527 impl<___R> ::fidl_next::RespondErr<___R> for Close {
5528 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
5529
5530 fn respond_err(response: ___R) -> Self::Output {
5531 ::core::result::Result::Err(response)
5532 }
5533 }
5534
5535 pub struct Query;
5536
5537 impl ::fidl_next::Method for Query {
5538 const ORDINAL: u64 = 2763219980499352582;
5539 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5540 ::fidl_next::protocol::Flexibility::Strict;
5541
5542 type Protocol = crate::Node;
5543
5544 type Request = ();
5545 }
5546
5547 impl ::fidl_next::TwoWayMethod for Query {
5548 type Response = ::fidl_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>;
5549 }
5550
5551 impl<___R> ::fidl_next::Respond<___R> for Query {
5552 type Output = ::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>;
5553
5554 fn respond(response: ___R) -> Self::Output {
5555 ::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse { protocol: response }
5556 }
5557 }
5558
5559 pub struct DeprecatedClone;
5560
5561 impl ::fidl_next::Method for DeprecatedClone {
5562 const ORDINAL: u64 = 6512600400724287855;
5563 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5564 ::fidl_next::protocol::Flexibility::Flexible;
5565
5566 type Protocol = crate::Node;
5567
5568 type Request = crate::wire::NodeDeprecatedCloneRequest;
5569 }
5570
5571 pub struct OnOpen;
5572
5573 impl ::fidl_next::Method for OnOpen {
5574 const ORDINAL: u64 = 9207534335756671346;
5575 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5576 ::fidl_next::protocol::Flexibility::Flexible;
5577
5578 type Protocol = crate::Node;
5579
5580 type Request = crate::wire::NodeOnOpenRequest<'static>;
5581 }
5582
5583 pub struct DeprecatedGetAttr;
5584
5585 impl ::fidl_next::Method for DeprecatedGetAttr {
5586 const ORDINAL: u64 = 8689798978500614909;
5587 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5588 ::fidl_next::protocol::Flexibility::Strict;
5589
5590 type Protocol = crate::Node;
5591
5592 type Request = ();
5593 }
5594
5595 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
5596 type Response = crate::wire::NodeDeprecatedGetAttrResponse;
5597 }
5598
5599 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
5600 type Output = ___R;
5601
5602 fn respond(response: ___R) -> Self::Output {
5603 response
5604 }
5605 }
5606
5607 pub struct DeprecatedSetAttr;
5608
5609 impl ::fidl_next::Method for DeprecatedSetAttr {
5610 const ORDINAL: u64 = 4721673413776871238;
5611 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5612 ::fidl_next::protocol::Flexibility::Strict;
5613
5614 type Protocol = crate::Node;
5615
5616 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
5617 }
5618
5619 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
5620 type Response = crate::wire::NodeDeprecatedSetAttrResponse;
5621 }
5622
5623 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
5624 type Output = crate::generic::NodeDeprecatedSetAttrResponse<___R>;
5625
5626 fn respond(response: ___R) -> Self::Output {
5627 crate::generic::NodeDeprecatedSetAttrResponse { s: response }
5628 }
5629 }
5630
5631 pub struct DeprecatedGetFlags;
5632
5633 impl ::fidl_next::Method for DeprecatedGetFlags {
5634 const ORDINAL: u64 = 6595803110182632097;
5635 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5636 ::fidl_next::protocol::Flexibility::Strict;
5637
5638 type Protocol = crate::Node;
5639
5640 type Request = ();
5641 }
5642
5643 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
5644 type Response = crate::wire::NodeDeprecatedGetFlagsResponse;
5645 }
5646
5647 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
5648 type Output = ___R;
5649
5650 fn respond(response: ___R) -> Self::Output {
5651 response
5652 }
5653 }
5654
5655 pub struct DeprecatedSetFlags;
5656
5657 impl ::fidl_next::Method for DeprecatedSetFlags {
5658 const ORDINAL: u64 = 5950864159036794675;
5659 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5660 ::fidl_next::protocol::Flexibility::Strict;
5661
5662 type Protocol = crate::Node;
5663
5664 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
5665 }
5666
5667 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
5668 type Response = crate::wire::NodeDeprecatedSetFlagsResponse;
5669 }
5670
5671 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
5672 type Output = crate::generic::NodeDeprecatedSetFlagsResponse<___R>;
5673
5674 fn respond(response: ___R) -> Self::Output {
5675 crate::generic::NodeDeprecatedSetFlagsResponse { s: response }
5676 }
5677 }
5678
5679 pub struct GetFlags;
5680
5681 impl ::fidl_next::Method for GetFlags {
5682 const ORDINAL: u64 = 105530239381466147;
5683 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5684 ::fidl_next::protocol::Flexibility::Flexible;
5685
5686 type Protocol = crate::Node;
5687
5688 type Request = ();
5689 }
5690
5691 impl ::fidl_next::TwoWayMethod for GetFlags {
5692 type Response = ::fidl_next::WireFlexibleResult<
5693 'static,
5694 crate::wire::NodeGetFlagsResponse,
5695 ::fidl_next::WireI32,
5696 >;
5697 }
5698
5699 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
5700 type Output = ::fidl_next::FlexibleResult<
5701 crate::generic::NodeGetFlagsResponse<___R>,
5702 ::fidl_next::util::Never,
5703 >;
5704
5705 fn respond(response: ___R) -> Self::Output {
5706 ::fidl_next::FlexibleResult::Ok(crate::generic::NodeGetFlagsResponse {
5707 flags: response,
5708 })
5709 }
5710 }
5711
5712 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
5713 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
5714
5715 fn respond_err(response: ___R) -> Self::Output {
5716 ::fidl_next::FlexibleResult::Err(response)
5717 }
5718 }
5719
5720 pub struct SetFlags;
5721
5722 impl ::fidl_next::Method for SetFlags {
5723 const ORDINAL: u64 = 6172186066099445416;
5724 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5725 ::fidl_next::protocol::Flexibility::Flexible;
5726
5727 type Protocol = crate::Node;
5728
5729 type Request = crate::wire::NodeSetFlagsRequest;
5730 }
5731
5732 impl ::fidl_next::TwoWayMethod for SetFlags {
5733 type Response = ::fidl_next::WireFlexibleResult<
5734 'static,
5735 crate::wire::NodeSetFlagsResponse,
5736 ::fidl_next::WireI32,
5737 >;
5738 }
5739
5740 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
5741 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
5742
5743 fn respond(response: ___R) -> Self::Output {
5744 ::fidl_next::FlexibleResult::Ok(response)
5745 }
5746 }
5747
5748 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
5749 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
5750
5751 fn respond_err(response: ___R) -> Self::Output {
5752 ::fidl_next::FlexibleResult::Err(response)
5753 }
5754 }
5755
5756 pub struct QueryFilesystem;
5757
5758 impl ::fidl_next::Method for QueryFilesystem {
5759 const ORDINAL: u64 = 8013111122914313744;
5760 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5761 ::fidl_next::protocol::Flexibility::Strict;
5762
5763 type Protocol = crate::Node;
5764
5765 type Request = ();
5766 }
5767
5768 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
5769 type Response = crate::wire::NodeQueryFilesystemResponse<'static>;
5770 }
5771
5772 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
5773 type Output = ___R;
5774
5775 fn respond(response: ___R) -> Self::Output {
5776 response
5777 }
5778 }
5779
5780 pub struct OnRepresentation;
5781
5782 impl ::fidl_next::Method for OnRepresentation {
5783 const ORDINAL: u64 = 6679970090861613324;
5784 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5785 ::fidl_next::protocol::Flexibility::Strict;
5786
5787 type Protocol = crate::Node;
5788
5789 type Request = crate::wire::Representation<'static>;
5790 }
5791
5792 pub struct GetAttributes;
5793
5794 impl ::fidl_next::Method for GetAttributes {
5795 const ORDINAL: u64 = 4414537700416816443;
5796 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5797 ::fidl_next::protocol::Flexibility::Strict;
5798
5799 type Protocol = crate::Node;
5800
5801 type Request = crate::wire::NodeGetAttributesRequest;
5802 }
5803
5804 impl ::fidl_next::TwoWayMethod for GetAttributes {
5805 type Response = ::fidl_next::WireResult<
5806 'static,
5807 crate::wire::NodeAttributes2<'static>,
5808 ::fidl_next::WireI32,
5809 >;
5810 }
5811
5812 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
5813 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
5814
5815 fn respond(response: ___R) -> Self::Output {
5816 ::core::result::Result::Ok(response)
5817 }
5818 }
5819
5820 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
5821 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
5822
5823 fn respond_err(response: ___R) -> Self::Output {
5824 ::core::result::Result::Err(response)
5825 }
5826 }
5827
5828 pub struct UpdateAttributes;
5829
5830 impl ::fidl_next::Method for UpdateAttributes {
5831 const ORDINAL: u64 = 3677402239314018056;
5832 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5833 ::fidl_next::protocol::Flexibility::Strict;
5834
5835 type Protocol = crate::Node;
5836
5837 type Request = crate::wire::MutableNodeAttributes<'static>;
5838 }
5839
5840 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
5841 type Response = ::fidl_next::WireResult<
5842 'static,
5843 crate::wire::NodeUpdateAttributesResponse,
5844 ::fidl_next::WireI32,
5845 >;
5846 }
5847
5848 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
5849 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
5850
5851 fn respond(response: ___R) -> Self::Output {
5852 ::core::result::Result::Ok(response)
5853 }
5854 }
5855
5856 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
5857 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
5858
5859 fn respond_err(response: ___R) -> Self::Output {
5860 ::core::result::Result::Err(response)
5861 }
5862 }
5863
5864 pub struct Sync;
5865
5866 impl ::fidl_next::Method for Sync {
5867 const ORDINAL: u64 = 3196473584242777161;
5868 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5869 ::fidl_next::protocol::Flexibility::Strict;
5870
5871 type Protocol = crate::Node;
5872
5873 type Request = ();
5874 }
5875
5876 impl ::fidl_next::TwoWayMethod for Sync {
5877 type Response =
5878 ::fidl_next::WireResult<'static, crate::wire::NodeSyncResponse, ::fidl_next::WireI32>;
5879 }
5880
5881 impl<___R> ::fidl_next::Respond<___R> for Sync {
5882 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
5883
5884 fn respond(response: ___R) -> Self::Output {
5885 ::core::result::Result::Ok(response)
5886 }
5887 }
5888
5889 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
5890 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
5891
5892 fn respond_err(response: ___R) -> Self::Output {
5893 ::core::result::Result::Err(response)
5894 }
5895 }
5896
5897 pub struct ListExtendedAttributes;
5898
5899 impl ::fidl_next::Method for ListExtendedAttributes {
5900 const ORDINAL: u64 = 5431626189872037072;
5901 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5902 ::fidl_next::protocol::Flexibility::Strict;
5903
5904 type Protocol = crate::Node;
5905
5906 type Request = crate::wire::NodeListExtendedAttributesRequest;
5907 }
5908
5909 pub struct GetExtendedAttribute;
5910
5911 impl ::fidl_next::Method for GetExtendedAttribute {
5912 const ORDINAL: u64 = 5043930208506967771;
5913 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5914 ::fidl_next::protocol::Flexibility::Strict;
5915
5916 type Protocol = crate::Node;
5917
5918 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
5919 }
5920
5921 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
5922 type Response = ::fidl_next::WireResult<
5923 'static,
5924 crate::wire::ExtendedAttributeValue<'static>,
5925 ::fidl_next::WireI32,
5926 >;
5927 }
5928
5929 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
5930 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
5931
5932 fn respond(response: ___R) -> Self::Output {
5933 ::core::result::Result::Ok(response)
5934 }
5935 }
5936
5937 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
5938 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
5939
5940 fn respond_err(response: ___R) -> Self::Output {
5941 ::core::result::Result::Err(response)
5942 }
5943 }
5944
5945 pub struct SetExtendedAttribute;
5946
5947 impl ::fidl_next::Method for SetExtendedAttribute {
5948 const ORDINAL: u64 = 5374223046099989052;
5949 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5950 ::fidl_next::protocol::Flexibility::Strict;
5951
5952 type Protocol = crate::Node;
5953
5954 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
5955 }
5956
5957 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
5958 type Response = ::fidl_next::WireResult<
5959 'static,
5960 crate::wire::NodeSetExtendedAttributeResponse,
5961 ::fidl_next::WireI32,
5962 >;
5963 }
5964
5965 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
5966 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
5967
5968 fn respond(response: ___R) -> Self::Output {
5969 ::core::result::Result::Ok(response)
5970 }
5971 }
5972
5973 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
5974 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
5975
5976 fn respond_err(response: ___R) -> Self::Output {
5977 ::core::result::Result::Err(response)
5978 }
5979 }
5980
5981 pub struct RemoveExtendedAttribute;
5982
5983 impl ::fidl_next::Method for RemoveExtendedAttribute {
5984 const ORDINAL: u64 = 8794297771444732717;
5985 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5986 ::fidl_next::protocol::Flexibility::Strict;
5987
5988 type Protocol = crate::Node;
5989
5990 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
5991 }
5992
5993 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
5994 type Response = ::fidl_next::WireResult<
5995 'static,
5996 crate::wire::NodeRemoveExtendedAttributeResponse,
5997 ::fidl_next::WireI32,
5998 >;
5999 }
6000
6001 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
6002 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
6003
6004 fn respond(response: ___R) -> Self::Output {
6005 ::core::result::Result::Ok(response)
6006 }
6007 }
6008
6009 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
6010 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
6011
6012 fn respond_err(response: ___R) -> Self::Output {
6013 ::core::result::Result::Err(response)
6014 }
6015 }
6016
6017 mod ___detail {
6018 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Node
6019 where
6020 ___T: ::fidl_next::Transport,
6021 {
6022 type Client = NodeClient<___T>;
6023 type Server = NodeServer<___T>;
6024 }
6025
6026 #[repr(transparent)]
6028 pub struct NodeClient<___T: ::fidl_next::Transport> {
6029 #[allow(dead_code)]
6030 client: ::fidl_next::protocol::Client<___T>,
6031 }
6032
6033 impl<___T> NodeClient<___T>
6034 where
6035 ___T: ::fidl_next::Transport,
6036 {
6037 pub fn clone(
6038 &self,
6039
6040 request: impl ::fidl_next::Encode<
6041 ::fidl_next::ServerEnd<
6042 ::fidl_next_fuchsia_unknown::Cloneable,
6043 ::fidl_next::fuchsia::WireChannel,
6044 >,
6045 <___T as ::fidl_next::Transport>::SendBuffer,
6046 >,
6047 ) -> ::fidl_next::SendFuture<'_, ___T>
6048 where
6049 <___T as ::fidl_next::Transport>::SendBuffer:
6050 ::fidl_next::encoder::InternalHandleEncoder,
6051 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
6052 {
6053 self.clone_with(::fidl_next_fuchsia_unknown::generic::CloneableCloneRequest {
6054 request,
6055 })
6056 }
6057
6058 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
6059 where
6060 ___R: ::fidl_next::Encode<
6061 ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest,
6062 <___T as ::fidl_next::Transport>::SendBuffer,
6063 >,
6064 {
6065 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
6066 2366825959783828089,
6067 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
6068 request,
6069 ))
6070 }
6071
6072 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
6073 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
6074 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6075 6540867515453498750,
6076 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
6077 (),
6078 ))
6079 }
6080
6081 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
6082 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6083 2763219980499352582,
6084 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
6085 (),
6086 ))
6087 }
6088
6089 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
6090 pub fn deprecated_clone(
6091 &self,
6092
6093 flags: impl ::fidl_next::Encode<
6094 crate::wire::OpenFlags,
6095 <___T as ::fidl_next::Transport>::SendBuffer,
6096 >,
6097
6098 object: impl ::fidl_next::Encode<
6099 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
6100 <___T as ::fidl_next::Transport>::SendBuffer,
6101 >,
6102 ) -> ::fidl_next::SendFuture<'_, ___T>
6103 where
6104 <___T as ::fidl_next::Transport>::SendBuffer:
6105 ::fidl_next::encoder::InternalHandleEncoder,
6106 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
6107 {
6108 self.deprecated_clone_with(crate::generic::NodeDeprecatedCloneRequest {
6109 flags,
6110
6111 object,
6112 })
6113 }
6114
6115 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
6116 pub fn deprecated_clone_with<___R>(
6117 &self,
6118 request: ___R,
6119 ) -> ::fidl_next::SendFuture<'_, ___T>
6120 where
6121 ___R: ::fidl_next::Encode<
6122 crate::wire::NodeDeprecatedCloneRequest,
6123 <___T as ::fidl_next::Transport>::SendBuffer,
6124 >,
6125 {
6126 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
6127 6512600400724287855,
6128 <super::DeprecatedClone as ::fidl_next::Method>::FLEXIBILITY,
6129 request,
6130 ))
6131 }
6132
6133 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
6134 pub fn deprecated_get_attr(
6135 &self,
6136 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
6137 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6138 8689798978500614909,
6139 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
6140 (),
6141 ))
6142 }
6143
6144 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
6145 pub fn deprecated_set_attr(
6146 &self,
6147
6148 flags: impl ::fidl_next::Encode<
6149 crate::wire::NodeAttributeFlags,
6150 <___T as ::fidl_next::Transport>::SendBuffer,
6151 >,
6152
6153 attributes: impl ::fidl_next::Encode<
6154 crate::wire::NodeAttributes,
6155 <___T as ::fidl_next::Transport>::SendBuffer,
6156 >,
6157 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
6158 where
6159 <___T as ::fidl_next::Transport>::SendBuffer:
6160 ::fidl_next::encoder::InternalHandleEncoder,
6161 {
6162 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
6163 flags,
6164
6165 attributes,
6166 })
6167 }
6168
6169 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
6170 pub fn deprecated_set_attr_with<___R>(
6171 &self,
6172 request: ___R,
6173 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
6174 where
6175 ___R: ::fidl_next::Encode<
6176 crate::wire::NodeDeprecatedSetAttrRequest,
6177 <___T as ::fidl_next::Transport>::SendBuffer,
6178 >,
6179 {
6180 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6181 4721673413776871238,
6182 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
6183 request,
6184 ))
6185 }
6186
6187 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
6188 pub fn deprecated_get_flags(
6189 &self,
6190 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
6191 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6192 6595803110182632097,
6193 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
6194 (),
6195 ))
6196 }
6197
6198 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
6199 pub fn deprecated_set_flags(
6200 &self,
6201
6202 flags: impl ::fidl_next::Encode<
6203 crate::wire::OpenFlags,
6204 <___T as ::fidl_next::Transport>::SendBuffer,
6205 >,
6206 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
6207 where
6208 <___T as ::fidl_next::Transport>::SendBuffer:
6209 ::fidl_next::encoder::InternalHandleEncoder,
6210 {
6211 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
6212 flags,
6213 })
6214 }
6215
6216 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
6217 pub fn deprecated_set_flags_with<___R>(
6218 &self,
6219 request: ___R,
6220 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
6221 where
6222 ___R: ::fidl_next::Encode<
6223 crate::wire::NodeDeprecatedSetFlagsRequest,
6224 <___T as ::fidl_next::Transport>::SendBuffer,
6225 >,
6226 {
6227 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6228 5950864159036794675,
6229 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
6230 request,
6231 ))
6232 }
6233
6234 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
6235 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
6236 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6237 105530239381466147,
6238 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
6239 (),
6240 ))
6241 }
6242
6243 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
6244 pub fn set_flags(
6245 &self,
6246
6247 flags: impl ::fidl_next::Encode<
6248 crate::wire::Flags,
6249 <___T as ::fidl_next::Transport>::SendBuffer,
6250 >,
6251 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
6252 where
6253 <___T as ::fidl_next::Transport>::SendBuffer:
6254 ::fidl_next::encoder::InternalHandleEncoder,
6255 {
6256 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
6257 }
6258
6259 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
6260 pub fn set_flags_with<___R>(
6261 &self,
6262 request: ___R,
6263 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
6264 where
6265 ___R: ::fidl_next::Encode<
6266 crate::wire::NodeSetFlagsRequest,
6267 <___T as ::fidl_next::Transport>::SendBuffer,
6268 >,
6269 {
6270 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6271 6172186066099445416,
6272 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
6273 request,
6274 ))
6275 }
6276
6277 #[doc = " Query the filesystem for filesystem-specific information.\n"]
6278 pub fn query_filesystem(
6279 &self,
6280 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
6281 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6282 8013111122914313744,
6283 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
6284 (),
6285 ))
6286 }
6287
6288 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
6289 pub fn get_attributes(
6290 &self,
6291
6292 query: impl ::fidl_next::Encode<
6293 crate::wire::NodeAttributesQuery,
6294 <___T as ::fidl_next::Transport>::SendBuffer,
6295 >,
6296 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
6297 where
6298 <___T as ::fidl_next::Transport>::SendBuffer:
6299 ::fidl_next::encoder::InternalHandleEncoder,
6300 {
6301 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
6302 }
6303
6304 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
6305 pub fn get_attributes_with<___R>(
6306 &self,
6307 request: ___R,
6308 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
6309 where
6310 ___R: ::fidl_next::Encode<
6311 crate::wire::NodeGetAttributesRequest,
6312 <___T as ::fidl_next::Transport>::SendBuffer,
6313 >,
6314 {
6315 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6316 4414537700416816443,
6317 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
6318 request,
6319 ))
6320 }
6321
6322 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
6323 pub fn update_attributes_with<___R>(
6324 &self,
6325 request: ___R,
6326 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
6327 where
6328 ___R: ::fidl_next::Encode<
6329 crate::wire::MutableNodeAttributes<'static>,
6330 <___T as ::fidl_next::Transport>::SendBuffer,
6331 >,
6332 {
6333 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6334 3677402239314018056,
6335 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
6336 request,
6337 ))
6338 }
6339
6340 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
6341 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
6342 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6343 3196473584242777161,
6344 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
6345 (),
6346 ))
6347 }
6348
6349 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
6350 pub fn list_extended_attributes(
6351 &self,
6352
6353 iterator: impl ::fidl_next::Encode<
6354 ::fidl_next::ServerEnd<
6355 crate::ExtendedAttributeIterator,
6356 ::fidl_next::fuchsia::WireChannel,
6357 >,
6358 <___T as ::fidl_next::Transport>::SendBuffer,
6359 >,
6360 ) -> ::fidl_next::SendFuture<'_, ___T>
6361 where
6362 <___T as ::fidl_next::Transport>::SendBuffer:
6363 ::fidl_next::encoder::InternalHandleEncoder,
6364 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
6365 {
6366 self.list_extended_attributes_with(
6367 crate::generic::NodeListExtendedAttributesRequest { iterator },
6368 )
6369 }
6370
6371 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
6372 pub fn list_extended_attributes_with<___R>(
6373 &self,
6374 request: ___R,
6375 ) -> ::fidl_next::SendFuture<'_, ___T>
6376 where
6377 ___R: ::fidl_next::Encode<
6378 crate::wire::NodeListExtendedAttributesRequest,
6379 <___T as ::fidl_next::Transport>::SendBuffer,
6380 >,
6381 {
6382 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
6383 5431626189872037072,
6384 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
6385 request,
6386 ))
6387 }
6388
6389 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
6390 pub fn get_extended_attribute(
6391 &self,
6392
6393 name: impl ::fidl_next::Encode<
6394 ::fidl_next::WireVector<'static, u8>,
6395 <___T as ::fidl_next::Transport>::SendBuffer,
6396 >,
6397 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
6398 where
6399 <___T as ::fidl_next::Transport>::SendBuffer:
6400 ::fidl_next::encoder::InternalHandleEncoder,
6401 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
6402 {
6403 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
6404 name,
6405 })
6406 }
6407
6408 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
6409 pub fn get_extended_attribute_with<___R>(
6410 &self,
6411 request: ___R,
6412 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
6413 where
6414 ___R: ::fidl_next::Encode<
6415 crate::wire::NodeGetExtendedAttributeRequest<'static>,
6416 <___T as ::fidl_next::Transport>::SendBuffer,
6417 >,
6418 {
6419 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6420 5043930208506967771,
6421 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
6422 request,
6423 ))
6424 }
6425
6426 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
6427 pub fn set_extended_attribute(
6428 &self,
6429
6430 name: impl ::fidl_next::Encode<
6431 ::fidl_next::WireVector<'static, u8>,
6432 <___T as ::fidl_next::Transport>::SendBuffer,
6433 >,
6434
6435 value: impl ::fidl_next::Encode<
6436 crate::wire::ExtendedAttributeValue<'static>,
6437 <___T as ::fidl_next::Transport>::SendBuffer,
6438 >,
6439
6440 mode: impl ::fidl_next::Encode<
6441 crate::wire::SetExtendedAttributeMode,
6442 <___T as ::fidl_next::Transport>::SendBuffer,
6443 >,
6444 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
6445 where
6446 <___T as ::fidl_next::Transport>::SendBuffer:
6447 ::fidl_next::encoder::InternalHandleEncoder,
6448 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
6449 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
6450 {
6451 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
6452 name,
6453
6454 value,
6455
6456 mode,
6457 })
6458 }
6459
6460 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
6461 pub fn set_extended_attribute_with<___R>(
6462 &self,
6463 request: ___R,
6464 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
6465 where
6466 ___R: ::fidl_next::Encode<
6467 crate::wire::NodeSetExtendedAttributeRequest<'static>,
6468 <___T as ::fidl_next::Transport>::SendBuffer,
6469 >,
6470 {
6471 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6472 5374223046099989052,
6473 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
6474 request,
6475 ))
6476 }
6477
6478 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
6479 pub fn remove_extended_attribute(
6480 &self,
6481
6482 name: impl ::fidl_next::Encode<
6483 ::fidl_next::WireVector<'static, u8>,
6484 <___T as ::fidl_next::Transport>::SendBuffer,
6485 >,
6486 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
6487 where
6488 <___T as ::fidl_next::Transport>::SendBuffer:
6489 ::fidl_next::encoder::InternalHandleEncoder,
6490 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
6491 {
6492 self.remove_extended_attribute_with(
6493 crate::generic::NodeRemoveExtendedAttributeRequest { name },
6494 )
6495 }
6496
6497 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
6498 pub fn remove_extended_attribute_with<___R>(
6499 &self,
6500 request: ___R,
6501 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
6502 where
6503 ___R: ::fidl_next::Encode<
6504 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
6505 <___T as ::fidl_next::Transport>::SendBuffer,
6506 >,
6507 {
6508 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6509 8794297771444732717,
6510 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
6511 request,
6512 ))
6513 }
6514 }
6515
6516 #[repr(transparent)]
6518 pub struct NodeServer<___T: ::fidl_next::Transport> {
6519 server: ::fidl_next::protocol::Server<___T>,
6520 }
6521
6522 impl<___T> NodeServer<___T>
6523 where
6524 ___T: ::fidl_next::Transport,
6525 {
6526 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
6527 pub fn on_open(
6528 &self,
6529
6530 s: impl ::fidl_next::Encode<
6531 ::fidl_next::WireI32,
6532 <___T as ::fidl_next::Transport>::SendBuffer,
6533 >,
6534
6535 info: impl ::fidl_next::Encode<
6536 crate::wire_optional::NodeInfoDeprecated<'static>,
6537 <___T as ::fidl_next::Transport>::SendBuffer,
6538 >,
6539 ) -> ::fidl_next::SendFuture<'_, ___T>
6540 where
6541 <___T as ::fidl_next::Transport>::SendBuffer:
6542 ::fidl_next::encoder::InternalHandleEncoder,
6543 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
6544 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
6545 {
6546 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
6547 }
6548
6549 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
6550
6551 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
6552 where
6553 ___R: ::fidl_next::Encode<
6554 <super::OnOpen as ::fidl_next::Method>::Request,
6555 <___T as ::fidl_next::Transport>::SendBuffer,
6556 >,
6557 {
6558 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
6559 9207534335756671346,
6560 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
6561 request,
6562 ))
6563 }
6564
6565 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
6566
6567 pub fn on_representation_with<___R>(
6568 &self,
6569 request: ___R,
6570 ) -> ::fidl_next::SendFuture<'_, ___T>
6571 where
6572 ___R: ::fidl_next::Encode<
6573 <super::OnRepresentation as ::fidl_next::Method>::Request,
6574 <___T as ::fidl_next::Transport>::SendBuffer,
6575 >,
6576 {
6577 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
6578 6679970090861613324,
6579 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
6580 request,
6581 ))
6582 }
6583 }
6584 }
6585}
6586
6587pub trait NodeClientHandler<
6591 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6592 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6593>
6594{
6595 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
6596 fn on_open(
6597 &mut self,
6598
6599 request: ::fidl_next::Request<node::OnOpen, ___T>,
6600 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6601
6602 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
6603 fn on_representation(
6604 &mut self,
6605
6606 request: ::fidl_next::Request<node::OnRepresentation, ___T>,
6607 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6608
6609 fn on_unknown_interaction(
6610 &mut self,
6611 ordinal: u64,
6612 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
6613 ::core::future::ready(())
6614 }
6615}
6616
6617impl<___T> NodeClientHandler<___T> for ::fidl_next::IgnoreEvents
6618where
6619 ___T: ::fidl_next::Transport,
6620{
6621 async fn on_open(&mut self, _: ::fidl_next::Request<node::OnOpen, ___T>) {}
6622
6623 async fn on_representation(&mut self, _: ::fidl_next::Request<node::OnRepresentation, ___T>) {}
6624
6625 async fn on_unknown_interaction(&mut self, _: u64) {}
6626}
6627
6628impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Node
6629where
6630 ___H: NodeClientHandler<___T> + ::core::marker::Send,
6631 ___T: ::fidl_next::Transport,
6632 <node::OnOpen as ::fidl_next::Method>::Request:
6633 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
6634 <node::OnRepresentation as ::fidl_next::Method>::Request:
6635 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
6636{
6637 async fn on_event(
6638 handler: &mut ___H,
6639 ordinal: u64,
6640 flexibility: ::fidl_next::protocol::Flexibility,
6641 buffer: ___T::RecvBuffer,
6642 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
6643 match ordinal {
6644 9207534335756671346 => match ::fidl_next::DecoderExt::decode(buffer) {
6645 Ok(decoded) => {
6646 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
6647 Ok(())
6648 }
6649 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
6650 ordinal: 9207534335756671346,
6651 error,
6652 }),
6653 },
6654
6655 6679970090861613324 => match ::fidl_next::DecoderExt::decode(buffer) {
6656 Ok(decoded) => {
6657 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
6658 Ok(())
6659 }
6660 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
6661 ordinal: 6679970090861613324,
6662 error,
6663 }),
6664 },
6665
6666 ordinal => {
6667 handler.on_unknown_interaction(ordinal).await;
6668 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
6669 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
6670 } else {
6671 Ok(())
6672 }
6673 }
6674 }
6675 }
6676}
6677
6678pub trait NodeServerHandler<
6682 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6683 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6684>
6685{
6686 fn clone(
6687 &mut self,
6688
6689 request: ::fidl_next::Request<node::Clone, ___T>,
6690 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6691
6692 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
6693 fn close(
6694 &mut self,
6695
6696 responder: ::fidl_next::Responder<node::Close, ___T>,
6697 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6698
6699 fn query(
6700 &mut self,
6701
6702 responder: ::fidl_next::Responder<node::Query, ___T>,
6703 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6704
6705 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
6706 fn deprecated_clone(
6707 &mut self,
6708
6709 request: ::fidl_next::Request<node::DeprecatedClone, ___T>,
6710 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6711
6712 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
6713 fn deprecated_get_attr(
6714 &mut self,
6715
6716 responder: ::fidl_next::Responder<node::DeprecatedGetAttr, ___T>,
6717 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6718
6719 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
6720 fn deprecated_set_attr(
6721 &mut self,
6722
6723 request: ::fidl_next::Request<node::DeprecatedSetAttr, ___T>,
6724
6725 responder: ::fidl_next::Responder<node::DeprecatedSetAttr, ___T>,
6726 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6727
6728 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
6729 fn deprecated_get_flags(
6730 &mut self,
6731
6732 responder: ::fidl_next::Responder<node::DeprecatedGetFlags, ___T>,
6733 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6734
6735 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
6736 fn deprecated_set_flags(
6737 &mut self,
6738
6739 request: ::fidl_next::Request<node::DeprecatedSetFlags, ___T>,
6740
6741 responder: ::fidl_next::Responder<node::DeprecatedSetFlags, ___T>,
6742 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6743
6744 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
6745 fn get_flags(
6746 &mut self,
6747
6748 responder: ::fidl_next::Responder<node::GetFlags, ___T>,
6749 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6750
6751 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
6752 fn set_flags(
6753 &mut self,
6754
6755 request: ::fidl_next::Request<node::SetFlags, ___T>,
6756
6757 responder: ::fidl_next::Responder<node::SetFlags, ___T>,
6758 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6759
6760 #[doc = " Query the filesystem for filesystem-specific information.\n"]
6761 fn query_filesystem(
6762 &mut self,
6763
6764 responder: ::fidl_next::Responder<node::QueryFilesystem, ___T>,
6765 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6766
6767 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
6768 fn get_attributes(
6769 &mut self,
6770
6771 request: ::fidl_next::Request<node::GetAttributes, ___T>,
6772
6773 responder: ::fidl_next::Responder<node::GetAttributes, ___T>,
6774 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6775
6776 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
6777 fn update_attributes(
6778 &mut self,
6779
6780 request: ::fidl_next::Request<node::UpdateAttributes, ___T>,
6781
6782 responder: ::fidl_next::Responder<node::UpdateAttributes, ___T>,
6783 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6784
6785 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
6786 fn sync(
6787 &mut self,
6788
6789 responder: ::fidl_next::Responder<node::Sync, ___T>,
6790 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6791
6792 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
6793 fn list_extended_attributes(
6794 &mut self,
6795
6796 request: ::fidl_next::Request<node::ListExtendedAttributes, ___T>,
6797 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6798
6799 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
6800 fn get_extended_attribute(
6801 &mut self,
6802
6803 request: ::fidl_next::Request<node::GetExtendedAttribute, ___T>,
6804
6805 responder: ::fidl_next::Responder<node::GetExtendedAttribute, ___T>,
6806 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6807
6808 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
6809 fn set_extended_attribute(
6810 &mut self,
6811
6812 request: ::fidl_next::Request<node::SetExtendedAttribute, ___T>,
6813
6814 responder: ::fidl_next::Responder<node::SetExtendedAttribute, ___T>,
6815 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6816
6817 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
6818 fn remove_extended_attribute(
6819 &mut self,
6820
6821 request: ::fidl_next::Request<node::RemoveExtendedAttribute, ___T>,
6822
6823 responder: ::fidl_next::Responder<node::RemoveExtendedAttribute, ___T>,
6824 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6825
6826 fn on_unknown_interaction(
6827 &mut self,
6828 ordinal: u64,
6829 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
6830 ::core::future::ready(())
6831 }
6832}
6833
6834impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Node
6835where
6836 ___H: NodeServerHandler<___T> + ::core::marker::Send,
6837 ___T: ::fidl_next::Transport,
6838 <node::Clone as ::fidl_next::Method>::Request:
6839 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
6840 <node::DeprecatedClone as ::fidl_next::Method>::Request:
6841 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
6842 <node::DeprecatedSetAttr as ::fidl_next::Method>::Request:
6843 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
6844 <node::DeprecatedSetFlags as ::fidl_next::Method>::Request:
6845 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
6846 <node::SetFlags as ::fidl_next::Method>::Request:
6847 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
6848 <node::GetAttributes as ::fidl_next::Method>::Request:
6849 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
6850 <node::UpdateAttributes as ::fidl_next::Method>::Request:
6851 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
6852 <node::ListExtendedAttributes as ::fidl_next::Method>::Request:
6853 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
6854 <node::GetExtendedAttribute as ::fidl_next::Method>::Request:
6855 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
6856 <node::SetExtendedAttribute as ::fidl_next::Method>::Request:
6857 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
6858 <node::RemoveExtendedAttribute as ::fidl_next::Method>::Request:
6859 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
6860{
6861 async fn on_one_way(
6862 handler: &mut ___H,
6863 ordinal: u64,
6864 flexibility: ::fidl_next::protocol::Flexibility,
6865 buffer: ___T::RecvBuffer,
6866 ) -> ::core::result::Result<
6867 (),
6868 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6869 > {
6870 match ordinal {
6871 2366825959783828089 => match ::fidl_next::DecoderExt::decode(buffer) {
6872 Ok(decoded) => {
6873 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
6874 Ok(())
6875 }
6876 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
6877 ordinal: 2366825959783828089,
6878 error,
6879 }),
6880 },
6881
6882 6512600400724287855 => match ::fidl_next::DecoderExt::decode(buffer) {
6883 Ok(decoded) => {
6884 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
6885 Ok(())
6886 }
6887 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
6888 ordinal: 6512600400724287855,
6889 error,
6890 }),
6891 },
6892
6893 5431626189872037072 => match ::fidl_next::DecoderExt::decode(buffer) {
6894 Ok(decoded) => {
6895 handler
6896 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
6897 .await;
6898 Ok(())
6899 }
6900 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
6901 ordinal: 5431626189872037072,
6902 error,
6903 }),
6904 },
6905
6906 ordinal => {
6907 handler.on_unknown_interaction(ordinal).await;
6908 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
6909 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
6910 } else {
6911 Ok(())
6912 }
6913 }
6914 }
6915 }
6916
6917 async fn on_two_way(
6918 handler: &mut ___H,
6919 ordinal: u64,
6920 flexibility: ::fidl_next::protocol::Flexibility,
6921 buffer: ___T::RecvBuffer,
6922 responder: ::fidl_next::protocol::Responder<___T>,
6923 ) -> ::core::result::Result<
6924 (),
6925 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6926 > {
6927 match ordinal {
6928 6540867515453498750 => {
6929 let responder = ::fidl_next::Responder::from_untyped(responder);
6930
6931 handler.close(responder).await;
6932 Ok(())
6933 }
6934
6935 2763219980499352582 => {
6936 let responder = ::fidl_next::Responder::from_untyped(responder);
6937
6938 handler.query(responder).await;
6939 Ok(())
6940 }
6941
6942 8689798978500614909 => {
6943 let responder = ::fidl_next::Responder::from_untyped(responder);
6944
6945 handler.deprecated_get_attr(responder).await;
6946 Ok(())
6947 }
6948
6949 4721673413776871238 => {
6950 let responder = ::fidl_next::Responder::from_untyped(responder);
6951
6952 match ::fidl_next::DecoderExt::decode(buffer) {
6953 Ok(decoded) => {
6954 handler
6955 .deprecated_set_attr(
6956 ::fidl_next::Request::from_decoded(decoded),
6957 responder,
6958 )
6959 .await;
6960 Ok(())
6961 }
6962 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
6963 ordinal: 4721673413776871238,
6964 error,
6965 }),
6966 }
6967 }
6968
6969 6595803110182632097 => {
6970 let responder = ::fidl_next::Responder::from_untyped(responder);
6971
6972 handler.deprecated_get_flags(responder).await;
6973 Ok(())
6974 }
6975
6976 5950864159036794675 => {
6977 let responder = ::fidl_next::Responder::from_untyped(responder);
6978
6979 match ::fidl_next::DecoderExt::decode(buffer) {
6980 Ok(decoded) => {
6981 handler
6982 .deprecated_set_flags(
6983 ::fidl_next::Request::from_decoded(decoded),
6984 responder,
6985 )
6986 .await;
6987 Ok(())
6988 }
6989 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
6990 ordinal: 5950864159036794675,
6991 error,
6992 }),
6993 }
6994 }
6995
6996 105530239381466147 => {
6997 let responder = ::fidl_next::Responder::from_untyped(responder);
6998
6999 handler.get_flags(responder).await;
7000 Ok(())
7001 }
7002
7003 6172186066099445416 => {
7004 let responder = ::fidl_next::Responder::from_untyped(responder);
7005
7006 match ::fidl_next::DecoderExt::decode(buffer) {
7007 Ok(decoded) => {
7008 handler
7009 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
7010 .await;
7011 Ok(())
7012 }
7013 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7014 ordinal: 6172186066099445416,
7015 error,
7016 }),
7017 }
7018 }
7019
7020 8013111122914313744 => {
7021 let responder = ::fidl_next::Responder::from_untyped(responder);
7022
7023 handler.query_filesystem(responder).await;
7024 Ok(())
7025 }
7026
7027 4414537700416816443 => {
7028 let responder = ::fidl_next::Responder::from_untyped(responder);
7029
7030 match ::fidl_next::DecoderExt::decode(buffer) {
7031 Ok(decoded) => {
7032 handler
7033 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
7034 .await;
7035 Ok(())
7036 }
7037 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7038 ordinal: 4414537700416816443,
7039 error,
7040 }),
7041 }
7042 }
7043
7044 3677402239314018056 => {
7045 let responder = ::fidl_next::Responder::from_untyped(responder);
7046
7047 match ::fidl_next::DecoderExt::decode(buffer) {
7048 Ok(decoded) => {
7049 handler
7050 .update_attributes(
7051 ::fidl_next::Request::from_decoded(decoded),
7052 responder,
7053 )
7054 .await;
7055 Ok(())
7056 }
7057 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7058 ordinal: 3677402239314018056,
7059 error,
7060 }),
7061 }
7062 }
7063
7064 3196473584242777161 => {
7065 let responder = ::fidl_next::Responder::from_untyped(responder);
7066
7067 handler.sync(responder).await;
7068 Ok(())
7069 }
7070
7071 5043930208506967771 => {
7072 let responder = ::fidl_next::Responder::from_untyped(responder);
7073
7074 match ::fidl_next::DecoderExt::decode(buffer) {
7075 Ok(decoded) => {
7076 handler
7077 .get_extended_attribute(
7078 ::fidl_next::Request::from_decoded(decoded),
7079 responder,
7080 )
7081 .await;
7082 Ok(())
7083 }
7084 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7085 ordinal: 5043930208506967771,
7086 error,
7087 }),
7088 }
7089 }
7090
7091 5374223046099989052 => {
7092 let responder = ::fidl_next::Responder::from_untyped(responder);
7093
7094 match ::fidl_next::DecoderExt::decode(buffer) {
7095 Ok(decoded) => {
7096 handler
7097 .set_extended_attribute(
7098 ::fidl_next::Request::from_decoded(decoded),
7099 responder,
7100 )
7101 .await;
7102 Ok(())
7103 }
7104 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7105 ordinal: 5374223046099989052,
7106 error,
7107 }),
7108 }
7109 }
7110
7111 8794297771444732717 => {
7112 let responder = ::fidl_next::Responder::from_untyped(responder);
7113
7114 match ::fidl_next::DecoderExt::decode(buffer) {
7115 Ok(decoded) => {
7116 handler
7117 .remove_extended_attribute(
7118 ::fidl_next::Request::from_decoded(decoded),
7119 responder,
7120 )
7121 .await;
7122 Ok(())
7123 }
7124 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7125 ordinal: 8794297771444732717,
7126 error,
7127 }),
7128 }
7129 }
7130
7131 ordinal => {
7132 handler.on_unknown_interaction(ordinal).await;
7133 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
7134 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
7135 } else {
7136 responder
7137 .respond(
7138 ordinal,
7139 flexibility,
7140 ::fidl_next::Flexible::<()>::FrameworkErr(
7141 ::fidl_next::FrameworkError::UnknownMethod,
7142 ),
7143 )
7144 .expect("encoding a framework error should never fail")
7145 .await?;
7146 Ok(())
7147 }
7148 }
7149 }
7150 }
7151}
7152
7153#[doc = " Directory defines a node which is capable of containing other Objects.\n"]
7155#[derive(PartialEq, Debug)]
7156pub struct Directory;
7157
7158impl ::fidl_next::Discoverable for Directory {
7159 const PROTOCOL_NAME: &'static str = "fuchsia.io.Directory";
7160}
7161
7162#[cfg(target_os = "fuchsia")]
7163impl ::fidl_next::HasTransport for Directory {
7164 type Transport = ::fidl_next::fuchsia::zx::Channel;
7165}
7166
7167pub mod directory {
7168 pub mod prelude {
7169 pub use crate::{Directory, DirectoryClientHandler, DirectoryServerHandler, directory};
7170
7171 pub use crate::natural::AdvisoryLockingAdvisoryLockRequest;
7172
7173 pub use crate::natural::AdvisoryLockingAdvisoryLockResponse;
7174
7175 pub use crate::natural::DirectoryCreateSymlinkRequest;
7176
7177 pub use crate::natural::DirectoryDeprecatedOpenRequest;
7178
7179 pub use crate::natural::DirectoryGetTokenResponse;
7180
7181 pub use crate::natural::DirectoryLinkRequest;
7182
7183 pub use crate::natural::DirectoryLinkResponse;
7184
7185 pub use crate::natural::DirectoryOpenRequest;
7186
7187 pub use crate::natural::DirectoryReadDirentsRequest;
7188
7189 pub use crate::natural::DirectoryReadDirentsResponse;
7190
7191 pub use crate::natural::DirectoryRenameRequest;
7192
7193 pub use crate::natural::DirectoryRewindResponse;
7194
7195 pub use crate::natural::DirectoryUnlinkRequest;
7196
7197 pub use crate::natural::DirectoryWatchRequest;
7198
7199 pub use crate::natural::DirectoryWatchResponse;
7200
7201 pub use crate::natural::DirectoryCreateSymlinkResponse;
7202
7203 pub use crate::natural::DirectoryRenameResponse;
7204
7205 pub use crate::natural::DirectoryUnlinkResponse;
7206
7207 pub use crate::natural::ExtendedAttributeValue;
7208
7209 pub use crate::natural::MutableNodeAttributes;
7210
7211 pub use crate::natural::NodeAttributes2;
7212
7213 pub use crate::natural::NodeDeprecatedCloneRequest;
7214
7215 pub use crate::natural::NodeDeprecatedGetAttrResponse;
7216
7217 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
7218
7219 pub use crate::natural::NodeDeprecatedSetAttrRequest;
7220
7221 pub use crate::natural::NodeDeprecatedSetAttrResponse;
7222
7223 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
7224
7225 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
7226
7227 pub use crate::natural::NodeGetAttributesRequest;
7228
7229 pub use crate::natural::NodeGetExtendedAttributeRequest;
7230
7231 pub use crate::natural::NodeListExtendedAttributesRequest;
7232
7233 pub use crate::natural::NodeOnOpenRequest;
7234
7235 pub use crate::natural::NodeQueryFilesystemResponse;
7236
7237 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
7238
7239 pub use crate::natural::NodeSetExtendedAttributeRequest;
7240
7241 pub use crate::natural::NodeSetFlagsRequest;
7242
7243 pub use crate::natural::NodeGetFlagsResponse;
7244
7245 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
7246
7247 pub use crate::natural::NodeSetExtendedAttributeResponse;
7248
7249 pub use crate::natural::NodeSetFlagsResponse;
7250
7251 pub use crate::natural::NodeSyncResponse;
7252
7253 pub use crate::natural::NodeUpdateAttributesResponse;
7254
7255 pub use crate::natural::Representation;
7256
7257 pub use ::fidl_next_fuchsia_unknown::natural::CloneableCloneRequest;
7258
7259 pub use ::fidl_next_fuchsia_unknown::natural::CloseableCloseResponse;
7260
7261 pub use ::fidl_next_fuchsia_unknown::natural::QueryableQueryResponse;
7262 }
7263
7264 pub struct AdvisoryLock;
7265
7266 impl ::fidl_next::Method for AdvisoryLock {
7267 const ORDINAL: u64 = 7992130864415541162;
7268 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7269 ::fidl_next::protocol::Flexibility::Strict;
7270
7271 type Protocol = crate::Directory;
7272
7273 type Request = crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>;
7274 }
7275
7276 impl ::fidl_next::TwoWayMethod for AdvisoryLock {
7277 type Response = ::fidl_next::WireResult<
7278 'static,
7279 crate::wire::AdvisoryLockingAdvisoryLockResponse,
7280 ::fidl_next::WireI32,
7281 >;
7282 }
7283
7284 impl<___R> ::fidl_next::Respond<___R> for AdvisoryLock {
7285 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
7286
7287 fn respond(response: ___R) -> Self::Output {
7288 ::core::result::Result::Ok(response)
7289 }
7290 }
7291
7292 impl<___R> ::fidl_next::RespondErr<___R> for AdvisoryLock {
7293 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
7294
7295 fn respond_err(response: ___R) -> Self::Output {
7296 ::core::result::Result::Err(response)
7297 }
7298 }
7299
7300 pub struct Clone;
7301
7302 impl ::fidl_next::Method for Clone {
7303 const ORDINAL: u64 = 2366825959783828089;
7304 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7305 ::fidl_next::protocol::Flexibility::Strict;
7306
7307 type Protocol = crate::Directory;
7308
7309 type Request = ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest;
7310 }
7311
7312 pub struct Close;
7313
7314 impl ::fidl_next::Method for Close {
7315 const ORDINAL: u64 = 6540867515453498750;
7316 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7317 ::fidl_next::protocol::Flexibility::Strict;
7318
7319 type Protocol = crate::Directory;
7320
7321 type Request = ();
7322 }
7323
7324 impl ::fidl_next::TwoWayMethod for Close {
7325 type Response = ::fidl_next::WireResult<
7326 'static,
7327 ::fidl_next_fuchsia_unknown::wire::CloseableCloseResponse,
7328 ::fidl_next::WireI32,
7329 >;
7330 }
7331
7332 impl<___R> ::fidl_next::Respond<___R> for Close {
7333 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
7334
7335 fn respond(response: ___R) -> Self::Output {
7336 ::core::result::Result::Ok(response)
7337 }
7338 }
7339
7340 impl<___R> ::fidl_next::RespondErr<___R> for Close {
7341 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
7342
7343 fn respond_err(response: ___R) -> Self::Output {
7344 ::core::result::Result::Err(response)
7345 }
7346 }
7347
7348 pub struct Query;
7349
7350 impl ::fidl_next::Method for Query {
7351 const ORDINAL: u64 = 2763219980499352582;
7352 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7353 ::fidl_next::protocol::Flexibility::Strict;
7354
7355 type Protocol = crate::Directory;
7356
7357 type Request = ();
7358 }
7359
7360 impl ::fidl_next::TwoWayMethod for Query {
7361 type Response = ::fidl_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>;
7362 }
7363
7364 impl<___R> ::fidl_next::Respond<___R> for Query {
7365 type Output = ::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>;
7366
7367 fn respond(response: ___R) -> Self::Output {
7368 ::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse { protocol: response }
7369 }
7370 }
7371
7372 pub struct DeprecatedClone;
7373
7374 impl ::fidl_next::Method for DeprecatedClone {
7375 const ORDINAL: u64 = 6512600400724287855;
7376 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7377 ::fidl_next::protocol::Flexibility::Flexible;
7378
7379 type Protocol = crate::Directory;
7380
7381 type Request = crate::wire::NodeDeprecatedCloneRequest;
7382 }
7383
7384 pub struct OnOpen;
7385
7386 impl ::fidl_next::Method for OnOpen {
7387 const ORDINAL: u64 = 9207534335756671346;
7388 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7389 ::fidl_next::protocol::Flexibility::Flexible;
7390
7391 type Protocol = crate::Directory;
7392
7393 type Request = crate::wire::NodeOnOpenRequest<'static>;
7394 }
7395
7396 pub struct DeprecatedGetAttr;
7397
7398 impl ::fidl_next::Method for DeprecatedGetAttr {
7399 const ORDINAL: u64 = 8689798978500614909;
7400 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7401 ::fidl_next::protocol::Flexibility::Strict;
7402
7403 type Protocol = crate::Directory;
7404
7405 type Request = ();
7406 }
7407
7408 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
7409 type Response = crate::wire::NodeDeprecatedGetAttrResponse;
7410 }
7411
7412 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
7413 type Output = ___R;
7414
7415 fn respond(response: ___R) -> Self::Output {
7416 response
7417 }
7418 }
7419
7420 pub struct DeprecatedSetAttr;
7421
7422 impl ::fidl_next::Method for DeprecatedSetAttr {
7423 const ORDINAL: u64 = 4721673413776871238;
7424 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7425 ::fidl_next::protocol::Flexibility::Strict;
7426
7427 type Protocol = crate::Directory;
7428
7429 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
7430 }
7431
7432 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
7433 type Response = crate::wire::NodeDeprecatedSetAttrResponse;
7434 }
7435
7436 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
7437 type Output = crate::generic::NodeDeprecatedSetAttrResponse<___R>;
7438
7439 fn respond(response: ___R) -> Self::Output {
7440 crate::generic::NodeDeprecatedSetAttrResponse { s: response }
7441 }
7442 }
7443
7444 pub struct DeprecatedGetFlags;
7445
7446 impl ::fidl_next::Method for DeprecatedGetFlags {
7447 const ORDINAL: u64 = 6595803110182632097;
7448 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7449 ::fidl_next::protocol::Flexibility::Strict;
7450
7451 type Protocol = crate::Directory;
7452
7453 type Request = ();
7454 }
7455
7456 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
7457 type Response = crate::wire::NodeDeprecatedGetFlagsResponse;
7458 }
7459
7460 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
7461 type Output = ___R;
7462
7463 fn respond(response: ___R) -> Self::Output {
7464 response
7465 }
7466 }
7467
7468 pub struct DeprecatedSetFlags;
7469
7470 impl ::fidl_next::Method for DeprecatedSetFlags {
7471 const ORDINAL: u64 = 5950864159036794675;
7472 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7473 ::fidl_next::protocol::Flexibility::Strict;
7474
7475 type Protocol = crate::Directory;
7476
7477 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
7478 }
7479
7480 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
7481 type Response = crate::wire::NodeDeprecatedSetFlagsResponse;
7482 }
7483
7484 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
7485 type Output = crate::generic::NodeDeprecatedSetFlagsResponse<___R>;
7486
7487 fn respond(response: ___R) -> Self::Output {
7488 crate::generic::NodeDeprecatedSetFlagsResponse { s: response }
7489 }
7490 }
7491
7492 pub struct GetFlags;
7493
7494 impl ::fidl_next::Method for GetFlags {
7495 const ORDINAL: u64 = 105530239381466147;
7496 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7497 ::fidl_next::protocol::Flexibility::Flexible;
7498
7499 type Protocol = crate::Directory;
7500
7501 type Request = ();
7502 }
7503
7504 impl ::fidl_next::TwoWayMethod for GetFlags {
7505 type Response = ::fidl_next::WireFlexibleResult<
7506 'static,
7507 crate::wire::NodeGetFlagsResponse,
7508 ::fidl_next::WireI32,
7509 >;
7510 }
7511
7512 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
7513 type Output = ::fidl_next::FlexibleResult<
7514 crate::generic::NodeGetFlagsResponse<___R>,
7515 ::fidl_next::util::Never,
7516 >;
7517
7518 fn respond(response: ___R) -> Self::Output {
7519 ::fidl_next::FlexibleResult::Ok(crate::generic::NodeGetFlagsResponse {
7520 flags: response,
7521 })
7522 }
7523 }
7524
7525 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
7526 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7527
7528 fn respond_err(response: ___R) -> Self::Output {
7529 ::fidl_next::FlexibleResult::Err(response)
7530 }
7531 }
7532
7533 pub struct SetFlags;
7534
7535 impl ::fidl_next::Method for SetFlags {
7536 const ORDINAL: u64 = 6172186066099445416;
7537 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7538 ::fidl_next::protocol::Flexibility::Flexible;
7539
7540 type Protocol = crate::Directory;
7541
7542 type Request = crate::wire::NodeSetFlagsRequest;
7543 }
7544
7545 impl ::fidl_next::TwoWayMethod for SetFlags {
7546 type Response = ::fidl_next::WireFlexibleResult<
7547 'static,
7548 crate::wire::NodeSetFlagsResponse,
7549 ::fidl_next::WireI32,
7550 >;
7551 }
7552
7553 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
7554 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
7555
7556 fn respond(response: ___R) -> Self::Output {
7557 ::fidl_next::FlexibleResult::Ok(response)
7558 }
7559 }
7560
7561 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
7562 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7563
7564 fn respond_err(response: ___R) -> Self::Output {
7565 ::fidl_next::FlexibleResult::Err(response)
7566 }
7567 }
7568
7569 pub struct QueryFilesystem;
7570
7571 impl ::fidl_next::Method for QueryFilesystem {
7572 const ORDINAL: u64 = 8013111122914313744;
7573 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7574 ::fidl_next::protocol::Flexibility::Strict;
7575
7576 type Protocol = crate::Directory;
7577
7578 type Request = ();
7579 }
7580
7581 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
7582 type Response = crate::wire::NodeQueryFilesystemResponse<'static>;
7583 }
7584
7585 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
7586 type Output = ___R;
7587
7588 fn respond(response: ___R) -> Self::Output {
7589 response
7590 }
7591 }
7592
7593 pub struct OnRepresentation;
7594
7595 impl ::fidl_next::Method for OnRepresentation {
7596 const ORDINAL: u64 = 6679970090861613324;
7597 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7598 ::fidl_next::protocol::Flexibility::Strict;
7599
7600 type Protocol = crate::Directory;
7601
7602 type Request = crate::wire::Representation<'static>;
7603 }
7604
7605 pub struct GetAttributes;
7606
7607 impl ::fidl_next::Method for GetAttributes {
7608 const ORDINAL: u64 = 4414537700416816443;
7609 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7610 ::fidl_next::protocol::Flexibility::Strict;
7611
7612 type Protocol = crate::Directory;
7613
7614 type Request = crate::wire::NodeGetAttributesRequest;
7615 }
7616
7617 impl ::fidl_next::TwoWayMethod for GetAttributes {
7618 type Response = ::fidl_next::WireResult<
7619 'static,
7620 crate::wire::NodeAttributes2<'static>,
7621 ::fidl_next::WireI32,
7622 >;
7623 }
7624
7625 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
7626 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
7627
7628 fn respond(response: ___R) -> Self::Output {
7629 ::core::result::Result::Ok(response)
7630 }
7631 }
7632
7633 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
7634 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
7635
7636 fn respond_err(response: ___R) -> Self::Output {
7637 ::core::result::Result::Err(response)
7638 }
7639 }
7640
7641 pub struct UpdateAttributes;
7642
7643 impl ::fidl_next::Method for UpdateAttributes {
7644 const ORDINAL: u64 = 3677402239314018056;
7645 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7646 ::fidl_next::protocol::Flexibility::Strict;
7647
7648 type Protocol = crate::Directory;
7649
7650 type Request = crate::wire::MutableNodeAttributes<'static>;
7651 }
7652
7653 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
7654 type Response = ::fidl_next::WireResult<
7655 'static,
7656 crate::wire::NodeUpdateAttributesResponse,
7657 ::fidl_next::WireI32,
7658 >;
7659 }
7660
7661 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
7662 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
7663
7664 fn respond(response: ___R) -> Self::Output {
7665 ::core::result::Result::Ok(response)
7666 }
7667 }
7668
7669 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
7670 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
7671
7672 fn respond_err(response: ___R) -> Self::Output {
7673 ::core::result::Result::Err(response)
7674 }
7675 }
7676
7677 pub struct Sync;
7678
7679 impl ::fidl_next::Method for Sync {
7680 const ORDINAL: u64 = 3196473584242777161;
7681 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7682 ::fidl_next::protocol::Flexibility::Strict;
7683
7684 type Protocol = crate::Directory;
7685
7686 type Request = ();
7687 }
7688
7689 impl ::fidl_next::TwoWayMethod for Sync {
7690 type Response =
7691 ::fidl_next::WireResult<'static, crate::wire::NodeSyncResponse, ::fidl_next::WireI32>;
7692 }
7693
7694 impl<___R> ::fidl_next::Respond<___R> for Sync {
7695 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
7696
7697 fn respond(response: ___R) -> Self::Output {
7698 ::core::result::Result::Ok(response)
7699 }
7700 }
7701
7702 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
7703 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
7704
7705 fn respond_err(response: ___R) -> Self::Output {
7706 ::core::result::Result::Err(response)
7707 }
7708 }
7709
7710 pub struct ListExtendedAttributes;
7711
7712 impl ::fidl_next::Method for ListExtendedAttributes {
7713 const ORDINAL: u64 = 5431626189872037072;
7714 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7715 ::fidl_next::protocol::Flexibility::Strict;
7716
7717 type Protocol = crate::Directory;
7718
7719 type Request = crate::wire::NodeListExtendedAttributesRequest;
7720 }
7721
7722 pub struct GetExtendedAttribute;
7723
7724 impl ::fidl_next::Method for GetExtendedAttribute {
7725 const ORDINAL: u64 = 5043930208506967771;
7726 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7727 ::fidl_next::protocol::Flexibility::Strict;
7728
7729 type Protocol = crate::Directory;
7730
7731 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
7732 }
7733
7734 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
7735 type Response = ::fidl_next::WireResult<
7736 'static,
7737 crate::wire::ExtendedAttributeValue<'static>,
7738 ::fidl_next::WireI32,
7739 >;
7740 }
7741
7742 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
7743 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
7744
7745 fn respond(response: ___R) -> Self::Output {
7746 ::core::result::Result::Ok(response)
7747 }
7748 }
7749
7750 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
7751 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
7752
7753 fn respond_err(response: ___R) -> Self::Output {
7754 ::core::result::Result::Err(response)
7755 }
7756 }
7757
7758 pub struct SetExtendedAttribute;
7759
7760 impl ::fidl_next::Method for SetExtendedAttribute {
7761 const ORDINAL: u64 = 5374223046099989052;
7762 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7763 ::fidl_next::protocol::Flexibility::Strict;
7764
7765 type Protocol = crate::Directory;
7766
7767 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
7768 }
7769
7770 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
7771 type Response = ::fidl_next::WireResult<
7772 'static,
7773 crate::wire::NodeSetExtendedAttributeResponse,
7774 ::fidl_next::WireI32,
7775 >;
7776 }
7777
7778 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
7779 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
7780
7781 fn respond(response: ___R) -> Self::Output {
7782 ::core::result::Result::Ok(response)
7783 }
7784 }
7785
7786 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
7787 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
7788
7789 fn respond_err(response: ___R) -> Self::Output {
7790 ::core::result::Result::Err(response)
7791 }
7792 }
7793
7794 pub struct RemoveExtendedAttribute;
7795
7796 impl ::fidl_next::Method for RemoveExtendedAttribute {
7797 const ORDINAL: u64 = 8794297771444732717;
7798 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7799 ::fidl_next::protocol::Flexibility::Strict;
7800
7801 type Protocol = crate::Directory;
7802
7803 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
7804 }
7805
7806 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
7807 type Response = ::fidl_next::WireResult<
7808 'static,
7809 crate::wire::NodeRemoveExtendedAttributeResponse,
7810 ::fidl_next::WireI32,
7811 >;
7812 }
7813
7814 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
7815 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
7816
7817 fn respond(response: ___R) -> Self::Output {
7818 ::core::result::Result::Ok(response)
7819 }
7820 }
7821
7822 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
7823 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
7824
7825 fn respond_err(response: ___R) -> Self::Output {
7826 ::core::result::Result::Err(response)
7827 }
7828 }
7829
7830 pub struct DeprecatedOpen;
7831
7832 impl ::fidl_next::Method for DeprecatedOpen {
7833 const ORDINAL: u64 = 3193127272456937152;
7834 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7835 ::fidl_next::protocol::Flexibility::Flexible;
7836
7837 type Protocol = crate::Directory;
7838
7839 type Request = crate::wire::DirectoryDeprecatedOpenRequest<'static>;
7840 }
7841
7842 pub struct Open;
7843
7844 impl ::fidl_next::Method for Open {
7845 const ORDINAL: u64 = 6236883748953765593;
7846 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7847 ::fidl_next::protocol::Flexibility::Strict;
7848
7849 type Protocol = crate::Directory;
7850
7851 type Request = crate::wire::DirectoryOpenRequest<'static>;
7852 }
7853
7854 pub struct ReadDirents;
7855
7856 impl ::fidl_next::Method for ReadDirents {
7857 const ORDINAL: u64 = 3855785432100874762;
7858 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7859 ::fidl_next::protocol::Flexibility::Strict;
7860
7861 type Protocol = crate::Directory;
7862
7863 type Request = crate::wire::DirectoryReadDirentsRequest;
7864 }
7865
7866 impl ::fidl_next::TwoWayMethod for ReadDirents {
7867 type Response = crate::wire::DirectoryReadDirentsResponse<'static>;
7868 }
7869
7870 impl<___R> ::fidl_next::Respond<___R> for ReadDirents {
7871 type Output = ___R;
7872
7873 fn respond(response: ___R) -> Self::Output {
7874 response
7875 }
7876 }
7877
7878 pub struct Rewind;
7879
7880 impl ::fidl_next::Method for Rewind {
7881 const ORDINAL: u64 = 1635123508515392625;
7882 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7883 ::fidl_next::protocol::Flexibility::Strict;
7884
7885 type Protocol = crate::Directory;
7886
7887 type Request = ();
7888 }
7889
7890 impl ::fidl_next::TwoWayMethod for Rewind {
7891 type Response = crate::wire::DirectoryRewindResponse;
7892 }
7893
7894 impl<___R> ::fidl_next::Respond<___R> for Rewind {
7895 type Output = crate::generic::DirectoryRewindResponse<___R>;
7896
7897 fn respond(response: ___R) -> Self::Output {
7898 crate::generic::DirectoryRewindResponse { s: response }
7899 }
7900 }
7901
7902 pub struct GetToken;
7903
7904 impl ::fidl_next::Method for GetToken {
7905 const ORDINAL: u64 = 2787337947777369685;
7906 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7907 ::fidl_next::protocol::Flexibility::Strict;
7908
7909 type Protocol = crate::Directory;
7910
7911 type Request = ();
7912 }
7913
7914 impl ::fidl_next::TwoWayMethod for GetToken {
7915 type Response = crate::wire::DirectoryGetTokenResponse;
7916 }
7917
7918 impl<___R> ::fidl_next::Respond<___R> for GetToken {
7919 type Output = ___R;
7920
7921 fn respond(response: ___R) -> Self::Output {
7922 response
7923 }
7924 }
7925
7926 pub struct Link;
7927
7928 impl ::fidl_next::Method for Link {
7929 const ORDINAL: u64 = 8360374984291987687;
7930 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7931 ::fidl_next::protocol::Flexibility::Strict;
7932
7933 type Protocol = crate::Directory;
7934
7935 type Request = crate::wire::DirectoryLinkRequest<'static>;
7936 }
7937
7938 impl ::fidl_next::TwoWayMethod for Link {
7939 type Response = crate::wire::DirectoryLinkResponse;
7940 }
7941
7942 impl<___R> ::fidl_next::Respond<___R> for Link {
7943 type Output = crate::generic::DirectoryLinkResponse<___R>;
7944
7945 fn respond(response: ___R) -> Self::Output {
7946 crate::generic::DirectoryLinkResponse { s: response }
7947 }
7948 }
7949
7950 pub struct Unlink;
7951
7952 impl ::fidl_next::Method for Unlink {
7953 const ORDINAL: u64 = 8433556716759383021;
7954 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7955 ::fidl_next::protocol::Flexibility::Strict;
7956
7957 type Protocol = crate::Directory;
7958
7959 type Request = crate::wire::DirectoryUnlinkRequest<'static>;
7960 }
7961
7962 impl ::fidl_next::TwoWayMethod for Unlink {
7963 type Response = ::fidl_next::WireResult<
7964 'static,
7965 crate::wire::DirectoryUnlinkResponse,
7966 ::fidl_next::WireI32,
7967 >;
7968 }
7969
7970 impl<___R> ::fidl_next::Respond<___R> for Unlink {
7971 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
7972
7973 fn respond(response: ___R) -> Self::Output {
7974 ::core::result::Result::Ok(response)
7975 }
7976 }
7977
7978 impl<___R> ::fidl_next::RespondErr<___R> for Unlink {
7979 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
7980
7981 fn respond_err(response: ___R) -> Self::Output {
7982 ::core::result::Result::Err(response)
7983 }
7984 }
7985
7986 pub struct Rename;
7987
7988 impl ::fidl_next::Method for Rename {
7989 const ORDINAL: u64 = 8097726607824333022;
7990 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7991 ::fidl_next::protocol::Flexibility::Strict;
7992
7993 type Protocol = crate::Directory;
7994
7995 type Request = crate::wire::DirectoryRenameRequest<'static>;
7996 }
7997
7998 impl ::fidl_next::TwoWayMethod for Rename {
7999 type Response = ::fidl_next::WireResult<
8000 'static,
8001 crate::wire::DirectoryRenameResponse,
8002 ::fidl_next::WireI32,
8003 >;
8004 }
8005
8006 impl<___R> ::fidl_next::Respond<___R> for Rename {
8007 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
8008
8009 fn respond(response: ___R) -> Self::Output {
8010 ::core::result::Result::Ok(response)
8011 }
8012 }
8013
8014 impl<___R> ::fidl_next::RespondErr<___R> for Rename {
8015 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
8016
8017 fn respond_err(response: ___R) -> Self::Output {
8018 ::core::result::Result::Err(response)
8019 }
8020 }
8021
8022 pub struct CreateSymlink;
8023
8024 impl ::fidl_next::Method for CreateSymlink {
8025 const ORDINAL: u64 = 2435901052462315657;
8026 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8027 ::fidl_next::protocol::Flexibility::Strict;
8028
8029 type Protocol = crate::Directory;
8030
8031 type Request = crate::wire::DirectoryCreateSymlinkRequest<'static>;
8032 }
8033
8034 impl ::fidl_next::TwoWayMethod for CreateSymlink {
8035 type Response = ::fidl_next::WireResult<
8036 'static,
8037 crate::wire::DirectoryCreateSymlinkResponse,
8038 ::fidl_next::WireI32,
8039 >;
8040 }
8041
8042 impl<___R> ::fidl_next::Respond<___R> for CreateSymlink {
8043 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
8044
8045 fn respond(response: ___R) -> Self::Output {
8046 ::core::result::Result::Ok(response)
8047 }
8048 }
8049
8050 impl<___R> ::fidl_next::RespondErr<___R> for CreateSymlink {
8051 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
8052
8053 fn respond_err(response: ___R) -> Self::Output {
8054 ::core::result::Result::Err(response)
8055 }
8056 }
8057
8058 pub struct Watch;
8059
8060 impl ::fidl_next::Method for Watch {
8061 const ORDINAL: u64 = 6275512344170098065;
8062 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8063 ::fidl_next::protocol::Flexibility::Strict;
8064
8065 type Protocol = crate::Directory;
8066
8067 type Request = crate::wire::DirectoryWatchRequest;
8068 }
8069
8070 impl ::fidl_next::TwoWayMethod for Watch {
8071 type Response = crate::wire::DirectoryWatchResponse;
8072 }
8073
8074 impl<___R> ::fidl_next::Respond<___R> for Watch {
8075 type Output = crate::generic::DirectoryWatchResponse<___R>;
8076
8077 fn respond(response: ___R) -> Self::Output {
8078 crate::generic::DirectoryWatchResponse { s: response }
8079 }
8080 }
8081
8082 mod ___detail {
8083 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Directory
8084 where
8085 ___T: ::fidl_next::Transport,
8086 {
8087 type Client = DirectoryClient<___T>;
8088 type Server = DirectoryServer<___T>;
8089 }
8090
8091 #[repr(transparent)]
8093 pub struct DirectoryClient<___T: ::fidl_next::Transport> {
8094 #[allow(dead_code)]
8095 client: ::fidl_next::protocol::Client<___T>,
8096 }
8097
8098 impl<___T> DirectoryClient<___T>
8099 where
8100 ___T: ::fidl_next::Transport,
8101 {
8102 #[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"]
8103 pub fn advisory_lock(
8104 &self,
8105
8106 request: impl ::fidl_next::Encode<
8107 crate::wire::AdvisoryLockRequest<'static>,
8108 <___T as ::fidl_next::Transport>::SendBuffer,
8109 >,
8110 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
8111 where
8112 <___T as ::fidl_next::Transport>::SendBuffer:
8113 ::fidl_next::encoder::InternalHandleEncoder,
8114 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8115 {
8116 self.advisory_lock_with(crate::generic::AdvisoryLockingAdvisoryLockRequest {
8117 request,
8118 })
8119 }
8120
8121 #[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"]
8122 pub fn advisory_lock_with<___R>(
8123 &self,
8124 request: ___R,
8125 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
8126 where
8127 ___R: ::fidl_next::Encode<
8128 crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
8129 <___T as ::fidl_next::Transport>::SendBuffer,
8130 >,
8131 {
8132 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8133 7992130864415541162,
8134 <super::AdvisoryLock as ::fidl_next::Method>::FLEXIBILITY,
8135 request,
8136 ))
8137 }
8138
8139 pub fn clone(
8140 &self,
8141
8142 request: impl ::fidl_next::Encode<
8143 ::fidl_next::ServerEnd<
8144 ::fidl_next_fuchsia_unknown::Cloneable,
8145 ::fidl_next::fuchsia::WireChannel,
8146 >,
8147 <___T as ::fidl_next::Transport>::SendBuffer,
8148 >,
8149 ) -> ::fidl_next::SendFuture<'_, ___T>
8150 where
8151 <___T as ::fidl_next::Transport>::SendBuffer:
8152 ::fidl_next::encoder::InternalHandleEncoder,
8153 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8154 {
8155 self.clone_with(::fidl_next_fuchsia_unknown::generic::CloneableCloneRequest {
8156 request,
8157 })
8158 }
8159
8160 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
8161 where
8162 ___R: ::fidl_next::Encode<
8163 ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest,
8164 <___T as ::fidl_next::Transport>::SendBuffer,
8165 >,
8166 {
8167 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
8168 2366825959783828089,
8169 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
8170 request,
8171 ))
8172 }
8173
8174 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
8175 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
8176 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8177 6540867515453498750,
8178 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
8179 (),
8180 ))
8181 }
8182
8183 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
8184 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8185 2763219980499352582,
8186 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
8187 (),
8188 ))
8189 }
8190
8191 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
8192 pub fn deprecated_clone(
8193 &self,
8194
8195 flags: impl ::fidl_next::Encode<
8196 crate::wire::OpenFlags,
8197 <___T as ::fidl_next::Transport>::SendBuffer,
8198 >,
8199
8200 object: impl ::fidl_next::Encode<
8201 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
8202 <___T as ::fidl_next::Transport>::SendBuffer,
8203 >,
8204 ) -> ::fidl_next::SendFuture<'_, ___T>
8205 where
8206 <___T as ::fidl_next::Transport>::SendBuffer:
8207 ::fidl_next::encoder::InternalHandleEncoder,
8208 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8209 {
8210 self.deprecated_clone_with(crate::generic::NodeDeprecatedCloneRequest {
8211 flags,
8212
8213 object,
8214 })
8215 }
8216
8217 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
8218 pub fn deprecated_clone_with<___R>(
8219 &self,
8220 request: ___R,
8221 ) -> ::fidl_next::SendFuture<'_, ___T>
8222 where
8223 ___R: ::fidl_next::Encode<
8224 crate::wire::NodeDeprecatedCloneRequest,
8225 <___T as ::fidl_next::Transport>::SendBuffer,
8226 >,
8227 {
8228 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
8229 6512600400724287855,
8230 <super::DeprecatedClone as ::fidl_next::Method>::FLEXIBILITY,
8231 request,
8232 ))
8233 }
8234
8235 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
8236 pub fn deprecated_get_attr(
8237 &self,
8238 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
8239 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8240 8689798978500614909,
8241 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
8242 (),
8243 ))
8244 }
8245
8246 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
8247 pub fn deprecated_set_attr(
8248 &self,
8249
8250 flags: impl ::fidl_next::Encode<
8251 crate::wire::NodeAttributeFlags,
8252 <___T as ::fidl_next::Transport>::SendBuffer,
8253 >,
8254
8255 attributes: impl ::fidl_next::Encode<
8256 crate::wire::NodeAttributes,
8257 <___T as ::fidl_next::Transport>::SendBuffer,
8258 >,
8259 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
8260 where
8261 <___T as ::fidl_next::Transport>::SendBuffer:
8262 ::fidl_next::encoder::InternalHandleEncoder,
8263 {
8264 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
8265 flags,
8266
8267 attributes,
8268 })
8269 }
8270
8271 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
8272 pub fn deprecated_set_attr_with<___R>(
8273 &self,
8274 request: ___R,
8275 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
8276 where
8277 ___R: ::fidl_next::Encode<
8278 crate::wire::NodeDeprecatedSetAttrRequest,
8279 <___T as ::fidl_next::Transport>::SendBuffer,
8280 >,
8281 {
8282 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8283 4721673413776871238,
8284 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
8285 request,
8286 ))
8287 }
8288
8289 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
8290 pub fn deprecated_get_flags(
8291 &self,
8292 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
8293 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8294 6595803110182632097,
8295 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
8296 (),
8297 ))
8298 }
8299
8300 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
8301 pub fn deprecated_set_flags(
8302 &self,
8303
8304 flags: impl ::fidl_next::Encode<
8305 crate::wire::OpenFlags,
8306 <___T as ::fidl_next::Transport>::SendBuffer,
8307 >,
8308 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
8309 where
8310 <___T as ::fidl_next::Transport>::SendBuffer:
8311 ::fidl_next::encoder::InternalHandleEncoder,
8312 {
8313 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
8314 flags,
8315 })
8316 }
8317
8318 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
8319 pub fn deprecated_set_flags_with<___R>(
8320 &self,
8321 request: ___R,
8322 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
8323 where
8324 ___R: ::fidl_next::Encode<
8325 crate::wire::NodeDeprecatedSetFlagsRequest,
8326 <___T as ::fidl_next::Transport>::SendBuffer,
8327 >,
8328 {
8329 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8330 5950864159036794675,
8331 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
8332 request,
8333 ))
8334 }
8335
8336 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
8337 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
8338 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8339 105530239381466147,
8340 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
8341 (),
8342 ))
8343 }
8344
8345 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
8346 pub fn set_flags(
8347 &self,
8348
8349 flags: impl ::fidl_next::Encode<
8350 crate::wire::Flags,
8351 <___T as ::fidl_next::Transport>::SendBuffer,
8352 >,
8353 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
8354 where
8355 <___T as ::fidl_next::Transport>::SendBuffer:
8356 ::fidl_next::encoder::InternalHandleEncoder,
8357 {
8358 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
8359 }
8360
8361 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
8362 pub fn set_flags_with<___R>(
8363 &self,
8364 request: ___R,
8365 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
8366 where
8367 ___R: ::fidl_next::Encode<
8368 crate::wire::NodeSetFlagsRequest,
8369 <___T as ::fidl_next::Transport>::SendBuffer,
8370 >,
8371 {
8372 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8373 6172186066099445416,
8374 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
8375 request,
8376 ))
8377 }
8378
8379 #[doc = " Query the filesystem for filesystem-specific information.\n"]
8380 pub fn query_filesystem(
8381 &self,
8382 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
8383 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8384 8013111122914313744,
8385 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
8386 (),
8387 ))
8388 }
8389
8390 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
8391 pub fn get_attributes(
8392 &self,
8393
8394 query: impl ::fidl_next::Encode<
8395 crate::wire::NodeAttributesQuery,
8396 <___T as ::fidl_next::Transport>::SendBuffer,
8397 >,
8398 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
8399 where
8400 <___T as ::fidl_next::Transport>::SendBuffer:
8401 ::fidl_next::encoder::InternalHandleEncoder,
8402 {
8403 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
8404 }
8405
8406 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
8407 pub fn get_attributes_with<___R>(
8408 &self,
8409 request: ___R,
8410 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
8411 where
8412 ___R: ::fidl_next::Encode<
8413 crate::wire::NodeGetAttributesRequest,
8414 <___T as ::fidl_next::Transport>::SendBuffer,
8415 >,
8416 {
8417 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8418 4414537700416816443,
8419 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
8420 request,
8421 ))
8422 }
8423
8424 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
8425 pub fn update_attributes_with<___R>(
8426 &self,
8427 request: ___R,
8428 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
8429 where
8430 ___R: ::fidl_next::Encode<
8431 crate::wire::MutableNodeAttributes<'static>,
8432 <___T as ::fidl_next::Transport>::SendBuffer,
8433 >,
8434 {
8435 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8436 3677402239314018056,
8437 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
8438 request,
8439 ))
8440 }
8441
8442 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
8443 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
8444 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8445 3196473584242777161,
8446 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
8447 (),
8448 ))
8449 }
8450
8451 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
8452 pub fn list_extended_attributes(
8453 &self,
8454
8455 iterator: impl ::fidl_next::Encode<
8456 ::fidl_next::ServerEnd<
8457 crate::ExtendedAttributeIterator,
8458 ::fidl_next::fuchsia::WireChannel,
8459 >,
8460 <___T as ::fidl_next::Transport>::SendBuffer,
8461 >,
8462 ) -> ::fidl_next::SendFuture<'_, ___T>
8463 where
8464 <___T as ::fidl_next::Transport>::SendBuffer:
8465 ::fidl_next::encoder::InternalHandleEncoder,
8466 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8467 {
8468 self.list_extended_attributes_with(
8469 crate::generic::NodeListExtendedAttributesRequest { iterator },
8470 )
8471 }
8472
8473 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
8474 pub fn list_extended_attributes_with<___R>(
8475 &self,
8476 request: ___R,
8477 ) -> ::fidl_next::SendFuture<'_, ___T>
8478 where
8479 ___R: ::fidl_next::Encode<
8480 crate::wire::NodeListExtendedAttributesRequest,
8481 <___T as ::fidl_next::Transport>::SendBuffer,
8482 >,
8483 {
8484 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
8485 5431626189872037072,
8486 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
8487 request,
8488 ))
8489 }
8490
8491 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
8492 pub fn get_extended_attribute(
8493 &self,
8494
8495 name: impl ::fidl_next::Encode<
8496 ::fidl_next::WireVector<'static, u8>,
8497 <___T as ::fidl_next::Transport>::SendBuffer,
8498 >,
8499 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
8500 where
8501 <___T as ::fidl_next::Transport>::SendBuffer:
8502 ::fidl_next::encoder::InternalHandleEncoder,
8503 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8504 {
8505 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
8506 name,
8507 })
8508 }
8509
8510 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
8511 pub fn get_extended_attribute_with<___R>(
8512 &self,
8513 request: ___R,
8514 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
8515 where
8516 ___R: ::fidl_next::Encode<
8517 crate::wire::NodeGetExtendedAttributeRequest<'static>,
8518 <___T as ::fidl_next::Transport>::SendBuffer,
8519 >,
8520 {
8521 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8522 5043930208506967771,
8523 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
8524 request,
8525 ))
8526 }
8527
8528 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
8529 pub fn set_extended_attribute(
8530 &self,
8531
8532 name: impl ::fidl_next::Encode<
8533 ::fidl_next::WireVector<'static, u8>,
8534 <___T as ::fidl_next::Transport>::SendBuffer,
8535 >,
8536
8537 value: impl ::fidl_next::Encode<
8538 crate::wire::ExtendedAttributeValue<'static>,
8539 <___T as ::fidl_next::Transport>::SendBuffer,
8540 >,
8541
8542 mode: impl ::fidl_next::Encode<
8543 crate::wire::SetExtendedAttributeMode,
8544 <___T as ::fidl_next::Transport>::SendBuffer,
8545 >,
8546 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
8547 where
8548 <___T as ::fidl_next::Transport>::SendBuffer:
8549 ::fidl_next::encoder::InternalHandleEncoder,
8550 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8551 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8552 {
8553 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
8554 name,
8555
8556 value,
8557
8558 mode,
8559 })
8560 }
8561
8562 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
8563 pub fn set_extended_attribute_with<___R>(
8564 &self,
8565 request: ___R,
8566 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
8567 where
8568 ___R: ::fidl_next::Encode<
8569 crate::wire::NodeSetExtendedAttributeRequest<'static>,
8570 <___T as ::fidl_next::Transport>::SendBuffer,
8571 >,
8572 {
8573 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8574 5374223046099989052,
8575 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
8576 request,
8577 ))
8578 }
8579
8580 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
8581 pub fn remove_extended_attribute(
8582 &self,
8583
8584 name: impl ::fidl_next::Encode<
8585 ::fidl_next::WireVector<'static, u8>,
8586 <___T as ::fidl_next::Transport>::SendBuffer,
8587 >,
8588 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
8589 where
8590 <___T as ::fidl_next::Transport>::SendBuffer:
8591 ::fidl_next::encoder::InternalHandleEncoder,
8592 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8593 {
8594 self.remove_extended_attribute_with(
8595 crate::generic::NodeRemoveExtendedAttributeRequest { name },
8596 )
8597 }
8598
8599 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
8600 pub fn remove_extended_attribute_with<___R>(
8601 &self,
8602 request: ___R,
8603 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
8604 where
8605 ___R: ::fidl_next::Encode<
8606 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
8607 <___T as ::fidl_next::Transport>::SendBuffer,
8608 >,
8609 {
8610 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8611 8794297771444732717,
8612 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
8613 request,
8614 ))
8615 }
8616
8617 #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
8618 pub fn deprecated_open(
8619 &self,
8620
8621 flags: impl ::fidl_next::Encode<
8622 crate::wire::OpenFlags,
8623 <___T as ::fidl_next::Transport>::SendBuffer,
8624 >,
8625
8626 mode: impl ::fidl_next::Encode<
8627 crate::wire::ModeType,
8628 <___T as ::fidl_next::Transport>::SendBuffer,
8629 >,
8630
8631 path: impl ::fidl_next::Encode<
8632 ::fidl_next::WireString<'static>,
8633 <___T as ::fidl_next::Transport>::SendBuffer,
8634 >,
8635
8636 object: impl ::fidl_next::Encode<
8637 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
8638 <___T as ::fidl_next::Transport>::SendBuffer,
8639 >,
8640 ) -> ::fidl_next::SendFuture<'_, ___T>
8641 where
8642 <___T as ::fidl_next::Transport>::SendBuffer:
8643 ::fidl_next::encoder::InternalHandleEncoder,
8644 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8645 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8646 {
8647 self.deprecated_open_with(crate::generic::DirectoryDeprecatedOpenRequest {
8648 flags,
8649
8650 mode,
8651
8652 path,
8653
8654 object,
8655 })
8656 }
8657
8658 #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
8659 pub fn deprecated_open_with<___R>(
8660 &self,
8661 request: ___R,
8662 ) -> ::fidl_next::SendFuture<'_, ___T>
8663 where
8664 ___R: ::fidl_next::Encode<
8665 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
8666 <___T as ::fidl_next::Transport>::SendBuffer,
8667 >,
8668 {
8669 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
8670 3193127272456937152,
8671 <super::DeprecatedOpen as ::fidl_next::Method>::FLEXIBILITY,
8672 request,
8673 ))
8674 }
8675
8676 #[doc = " Open (or create) a node relative to this directory. Any errors are communicated via an\n epitaph sent on the `object` channel.\n\n Errors:\n * `ZX_ERR_BAD_PATH` if `path` is invalid\n * See [`Flags`] for other errors which may be communicated based on `flags`\n"]
8677 pub fn open(
8678 &self,
8679
8680 path: impl ::fidl_next::Encode<
8681 ::fidl_next::WireString<'static>,
8682 <___T as ::fidl_next::Transport>::SendBuffer,
8683 >,
8684
8685 flags: impl ::fidl_next::Encode<
8686 crate::wire::Flags,
8687 <___T as ::fidl_next::Transport>::SendBuffer,
8688 >,
8689
8690 options: impl ::fidl_next::Encode<
8691 crate::wire::Options<'static>,
8692 <___T as ::fidl_next::Transport>::SendBuffer,
8693 >,
8694
8695 object: impl ::fidl_next::Encode<
8696 ::fidl_next::fuchsia::WireChannel,
8697 <___T as ::fidl_next::Transport>::SendBuffer,
8698 >,
8699 ) -> ::fidl_next::SendFuture<'_, ___T>
8700 where
8701 <___T as ::fidl_next::Transport>::SendBuffer:
8702 ::fidl_next::encoder::InternalHandleEncoder,
8703 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8704 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8705 {
8706 self.open_with(crate::generic::DirectoryOpenRequest {
8707 path,
8708
8709 flags,
8710
8711 options,
8712
8713 object,
8714 })
8715 }
8716
8717 #[doc = " Open (or create) a node relative to this directory. Any errors are communicated via an\n epitaph sent on the `object` channel.\n\n Errors:\n * `ZX_ERR_BAD_PATH` if `path` is invalid\n * See [`Flags`] for other errors which may be communicated based on `flags`\n"]
8718 pub fn open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
8719 where
8720 ___R: ::fidl_next::Encode<
8721 crate::wire::DirectoryOpenRequest<'static>,
8722 <___T as ::fidl_next::Transport>::SendBuffer,
8723 >,
8724 {
8725 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
8726 6236883748953765593,
8727 <super::Open as ::fidl_next::Method>::FLEXIBILITY,
8728 request,
8729 ))
8730 }
8731
8732 #[doc = " Reads a collection of variably sized dirents into a buffer.\n The number of dirents in a directory may be very large: akin to\n calling read multiple times on a file, directories have a seek\n offset which is updated on subsequent calls to ReadDirents.\n Each call to ReadDirents will only return whole dirent structures,\n they will not get split across ReadDirent calls. When the seek\n offset reaches the end, `dirents` will be empty.\n\n These dirents are of the form:\n ```\n struct dirent {\n // Describes the inode of the entry.\n uint64 ino;\n // Describes the length of the dirent name in bytes.\n uint8 size;\n // Describes the type of the entry. Aligned with the\n // POSIX d_type values. Use `DirentType` constants.\n uint8 type;\n // Unterminated name of entry.\n char name[0];\n }\n ```\n\n This method does not require any rights, since one could always probe for\n directory contents by triggering name conflicts during file creation.\n"]
8733 pub fn read_dirents(
8734 &self,
8735
8736 max_bytes: impl ::fidl_next::Encode<
8737 ::fidl_next::WireU64,
8738 <___T as ::fidl_next::Transport>::SendBuffer,
8739 >,
8740 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadDirents, ___T>
8741 where
8742 <___T as ::fidl_next::Transport>::SendBuffer:
8743 ::fidl_next::encoder::InternalHandleEncoder,
8744 {
8745 self.read_dirents_with(crate::generic::DirectoryReadDirentsRequest { max_bytes })
8746 }
8747
8748 #[doc = " Reads a collection of variably sized dirents into a buffer.\n The number of dirents in a directory may be very large: akin to\n calling read multiple times on a file, directories have a seek\n offset which is updated on subsequent calls to ReadDirents.\n Each call to ReadDirents will only return whole dirent structures,\n they will not get split across ReadDirent calls. When the seek\n offset reaches the end, `dirents` will be empty.\n\n These dirents are of the form:\n ```\n struct dirent {\n // Describes the inode of the entry.\n uint64 ino;\n // Describes the length of the dirent name in bytes.\n uint8 size;\n // Describes the type of the entry. Aligned with the\n // POSIX d_type values. Use `DirentType` constants.\n uint8 type;\n // Unterminated name of entry.\n char name[0];\n }\n ```\n\n This method does not require any rights, since one could always probe for\n directory contents by triggering name conflicts during file creation.\n"]
8749 pub fn read_dirents_with<___R>(
8750 &self,
8751 request: ___R,
8752 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadDirents, ___T>
8753 where
8754 ___R: ::fidl_next::Encode<
8755 crate::wire::DirectoryReadDirentsRequest,
8756 <___T as ::fidl_next::Transport>::SendBuffer,
8757 >,
8758 {
8759 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8760 3855785432100874762,
8761 <super::ReadDirents as ::fidl_next::Method>::FLEXIBILITY,
8762 request,
8763 ))
8764 }
8765
8766 #[doc = " Resets the directory seek offset.\n\n This method does not require any rights, similar to ReadDirents.\n"]
8767 pub fn rewind(&self) -> ::fidl_next::TwoWayFuture<'_, super::Rewind, ___T> {
8768 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8769 1635123508515392625,
8770 <super::Rewind as ::fidl_next::Method>::FLEXIBILITY,
8771 (),
8772 ))
8773 }
8774
8775 #[doc = " Acquires a token to a Directory which can be used to identify access to it at a later point\n in time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n"]
8776 pub fn get_token(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetToken, ___T> {
8777 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8778 2787337947777369685,
8779 <super::GetToken as ::fidl_next::Method>::FLEXIBILITY,
8780 (),
8781 ))
8782 }
8783
8784 #[doc = " Creates a link to an object named src by the name dst, within a directory represented by\n token.\n\n `src` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE` and\n `OpenFlags.RIGHT_READABLE`, otherwise returns `ZX_ERR_BAD_HANDLE`.\n\n This will be atomic with respect to renaming or unlinking the source concurrently e.g. if\n there are two actors operating concurrently, and one actor performs a rename that affects\n the source within this directory, and the other does a link, each will appear to occur\n atomically in an unspecified order.\n"]
8785 pub fn link(
8786 &self,
8787
8788 src: impl ::fidl_next::Encode<
8789 ::fidl_next::WireString<'static>,
8790 <___T as ::fidl_next::Transport>::SendBuffer,
8791 >,
8792
8793 dst_parent_token: impl ::fidl_next::Encode<
8794 ::fidl_next::fuchsia::WireHandle,
8795 <___T as ::fidl_next::Transport>::SendBuffer,
8796 >,
8797
8798 dst: impl ::fidl_next::Encode<
8799 ::fidl_next::WireString<'static>,
8800 <___T as ::fidl_next::Transport>::SendBuffer,
8801 >,
8802 ) -> ::fidl_next::TwoWayFuture<'_, super::Link, ___T>
8803 where
8804 <___T as ::fidl_next::Transport>::SendBuffer:
8805 ::fidl_next::encoder::InternalHandleEncoder,
8806 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8807 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8808 {
8809 self.link_with(crate::generic::DirectoryLinkRequest { src, dst_parent_token, dst })
8810 }
8811
8812 #[doc = " Creates a link to an object named src by the name dst, within a directory represented by\n token.\n\n `src` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE` and\n `OpenFlags.RIGHT_READABLE`, otherwise returns `ZX_ERR_BAD_HANDLE`.\n\n This will be atomic with respect to renaming or unlinking the source concurrently e.g. if\n there are two actors operating concurrently, and one actor performs a rename that affects\n the source within this directory, and the other does a link, each will appear to occur\n atomically in an unspecified order.\n"]
8813 pub fn link_with<___R>(
8814 &self,
8815 request: ___R,
8816 ) -> ::fidl_next::TwoWayFuture<'_, super::Link, ___T>
8817 where
8818 ___R: ::fidl_next::Encode<
8819 crate::wire::DirectoryLinkRequest<'static>,
8820 <___T as ::fidl_next::Transport>::SendBuffer,
8821 >,
8822 {
8823 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8824 8360374984291987687,
8825 <super::Link as ::fidl_next::Method>::FLEXIBILITY,
8826 request,
8827 ))
8828 }
8829
8830 #[doc = " Removes a child node from the this directory\'s list of entries.\n\n Note: this does not guarantee that the underlying object is destroyed.\n Although the link will be removed from the containing directory,\n objects with multiple references (such as files which are still open)\n will not actually be destroyed until all references are closed.\n\n * error `ZX_ERR_ACCESS_DENIED` if the connection does not have\n [`Rights.WRITE_BYTES`].\n * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not\n support writing.\n * error `ZX_ERR_BAD_PATH` if `name` is invalid.\n * error `ZX_ERR_NOT_EMPTY` if `name` refers to a non-empty directory.\n * error `ZX_ERR_UNAVAILABLE` if `name` refers to a mount point,\n containing a remote channel.\n * error `ZX_ERR_NOT_DIR` if the options requested a directory but\n something other than a directory was found.\n\n Other errors may be returned for filesystem-specific reasons.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n"]
8831 pub fn unlink(
8832 &self,
8833
8834 name: impl ::fidl_next::Encode<
8835 ::fidl_next::WireString<'static>,
8836 <___T as ::fidl_next::Transport>::SendBuffer,
8837 >,
8838
8839 options: impl ::fidl_next::Encode<
8840 crate::wire::UnlinkOptions<'static>,
8841 <___T as ::fidl_next::Transport>::SendBuffer,
8842 >,
8843 ) -> ::fidl_next::TwoWayFuture<'_, super::Unlink, ___T>
8844 where
8845 <___T as ::fidl_next::Transport>::SendBuffer:
8846 ::fidl_next::encoder::InternalHandleEncoder,
8847 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8848 {
8849 self.unlink_with(crate::generic::DirectoryUnlinkRequest { name, options })
8850 }
8851
8852 #[doc = " Removes a child node from the this directory\'s list of entries.\n\n Note: this does not guarantee that the underlying object is destroyed.\n Although the link will be removed from the containing directory,\n objects with multiple references (such as files which are still open)\n will not actually be destroyed until all references are closed.\n\n * error `ZX_ERR_ACCESS_DENIED` if the connection does not have\n [`Rights.WRITE_BYTES`].\n * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not\n support writing.\n * error `ZX_ERR_BAD_PATH` if `name` is invalid.\n * error `ZX_ERR_NOT_EMPTY` if `name` refers to a non-empty directory.\n * error `ZX_ERR_UNAVAILABLE` if `name` refers to a mount point,\n containing a remote channel.\n * error `ZX_ERR_NOT_DIR` if the options requested a directory but\n something other than a directory was found.\n\n Other errors may be returned for filesystem-specific reasons.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n"]
8853 pub fn unlink_with<___R>(
8854 &self,
8855 request: ___R,
8856 ) -> ::fidl_next::TwoWayFuture<'_, super::Unlink, ___T>
8857 where
8858 ___R: ::fidl_next::Encode<
8859 crate::wire::DirectoryUnlinkRequest<'static>,
8860 <___T as ::fidl_next::Transport>::SendBuffer,
8861 >,
8862 {
8863 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8864 8433556716759383021,
8865 <super::Unlink as ::fidl_next::Method>::FLEXIBILITY,
8866 request,
8867 ))
8868 }
8869
8870 #[doc = " Renames a node named `src` to the name `dst`, in a directory represented\n by `dst_parent_token`.\n\n `src` and `dst` must be valid node names.\n See [`Name`] for what constitutes a valid name.\n\n This method requires the following rights on both the current connection, and the connection\n identified by `dst_parent_token`:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n\n The following requirements are necessary to avoid rights escalations.\n\n If the source and destination directory differ, the source directory must also have the\n maximal set of abilities supported for files, which would typically be\n [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`], [`Rights.GET_ATTRIBUTES`] and\n [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also support the [`Rights.EXECUTE`]\n right.\n\n If `src` refers to a directory, and differs from the destination directory, then the source\n directory must have also have the [`Rights.CONNECT`] and [`Rights.TRAVERSE`] rights.\n\n * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.\n * error `ZX_ERR_ACCESS_DENIED` for insufficient rights.\n"]
8871 pub fn rename(
8872 &self,
8873
8874 src: impl ::fidl_next::Encode<
8875 ::fidl_next::WireString<'static>,
8876 <___T as ::fidl_next::Transport>::SendBuffer,
8877 >,
8878
8879 dst_parent_token: impl ::fidl_next::Encode<
8880 ::fidl_next::fuchsia::WireEvent,
8881 <___T as ::fidl_next::Transport>::SendBuffer,
8882 >,
8883
8884 dst: impl ::fidl_next::Encode<
8885 ::fidl_next::WireString<'static>,
8886 <___T as ::fidl_next::Transport>::SendBuffer,
8887 >,
8888 ) -> ::fidl_next::TwoWayFuture<'_, super::Rename, ___T>
8889 where
8890 <___T as ::fidl_next::Transport>::SendBuffer:
8891 ::fidl_next::encoder::InternalHandleEncoder,
8892 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8893 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8894 {
8895 self.rename_with(crate::generic::DirectoryRenameRequest {
8896 src,
8897
8898 dst_parent_token,
8899
8900 dst,
8901 })
8902 }
8903
8904 #[doc = " Renames a node named `src` to the name `dst`, in a directory represented\n by `dst_parent_token`.\n\n `src` and `dst` must be valid node names.\n See [`Name`] for what constitutes a valid name.\n\n This method requires the following rights on both the current connection, and the connection\n identified by `dst_parent_token`:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n\n The following requirements are necessary to avoid rights escalations.\n\n If the source and destination directory differ, the source directory must also have the\n maximal set of abilities supported for files, which would typically be\n [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`], [`Rights.GET_ATTRIBUTES`] and\n [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also support the [`Rights.EXECUTE`]\n right.\n\n If `src` refers to a directory, and differs from the destination directory, then the source\n directory must have also have the [`Rights.CONNECT`] and [`Rights.TRAVERSE`] rights.\n\n * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.\n * error `ZX_ERR_ACCESS_DENIED` for insufficient rights.\n"]
8905 pub fn rename_with<___R>(
8906 &self,
8907 request: ___R,
8908 ) -> ::fidl_next::TwoWayFuture<'_, super::Rename, ___T>
8909 where
8910 ___R: ::fidl_next::Encode<
8911 crate::wire::DirectoryRenameRequest<'static>,
8912 <___T as ::fidl_next::Transport>::SendBuffer,
8913 >,
8914 {
8915 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8916 8097726607824333022,
8917 <super::Rename as ::fidl_next::Method>::FLEXIBILITY,
8918 request,
8919 ))
8920 }
8921
8922 #[doc = " Creates a symbolic link.\n\n `name` is the name to be given to the created symbolic link.\n `target` is the target of the symbolic link, which has no meaning on the server. The server\n will perform no validation of `target` except for a server chosen maximum length.\n `connection` is an optional server end of a channel that will speak the Symlink protocol\n on the successfully created node.\n\n * [`Rights.MODIFY_DIRECTORY`]\n\n * error `ZX_ERR_ALREADY_EXISTS` if `name` already exists.\n * error `ZX_ERR_BAD_PATH` if `target` exceeds the server length limit for symbolic links.\n * error `ZX_ERR_INVALID_ARGS` if `name` is not a valid [`Name`].\n * error `ZX_ERR_NOT_SUPPORTED` if creating symbolic links is not supported by the server.\n"]
8923 pub fn create_symlink(
8924 &self,
8925
8926 name: impl ::fidl_next::Encode<
8927 ::fidl_next::WireString<'static>,
8928 <___T as ::fidl_next::Transport>::SendBuffer,
8929 >,
8930
8931 target: impl ::fidl_next::Encode<
8932 ::fidl_next::WireVector<'static, u8>,
8933 <___T as ::fidl_next::Transport>::SendBuffer,
8934 >,
8935
8936 connection: impl ::fidl_next::Encode<
8937 ::fidl_next::ServerEnd<
8938 crate::Symlink,
8939 ::fidl_next::fuchsia::WireOptionalChannel,
8940 >,
8941 <___T as ::fidl_next::Transport>::SendBuffer,
8942 >,
8943 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateSymlink, ___T>
8944 where
8945 <___T as ::fidl_next::Transport>::SendBuffer:
8946 ::fidl_next::encoder::InternalHandleEncoder,
8947 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8948 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8949 {
8950 self.create_symlink_with(crate::generic::DirectoryCreateSymlinkRequest {
8951 name,
8952
8953 target,
8954
8955 connection,
8956 })
8957 }
8958
8959 #[doc = " Creates a symbolic link.\n\n `name` is the name to be given to the created symbolic link.\n `target` is the target of the symbolic link, which has no meaning on the server. The server\n will perform no validation of `target` except for a server chosen maximum length.\n `connection` is an optional server end of a channel that will speak the Symlink protocol\n on the successfully created node.\n\n * [`Rights.MODIFY_DIRECTORY`]\n\n * error `ZX_ERR_ALREADY_EXISTS` if `name` already exists.\n * error `ZX_ERR_BAD_PATH` if `target` exceeds the server length limit for symbolic links.\n * error `ZX_ERR_INVALID_ARGS` if `name` is not a valid [`Name`].\n * error `ZX_ERR_NOT_SUPPORTED` if creating symbolic links is not supported by the server.\n"]
8960 pub fn create_symlink_with<___R>(
8961 &self,
8962 request: ___R,
8963 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateSymlink, ___T>
8964 where
8965 ___R: ::fidl_next::Encode<
8966 crate::wire::DirectoryCreateSymlinkRequest<'static>,
8967 <___T as ::fidl_next::Transport>::SendBuffer,
8968 >,
8969 {
8970 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8971 2435901052462315657,
8972 <super::CreateSymlink as ::fidl_next::Method>::FLEXIBILITY,
8973 request,
8974 ))
8975 }
8976
8977 #[doc = " Watches a directory, receiving events of added messages on the\n watcher request channel.\n\n Options must be zero; it is reserved.\n\n This method does not require any rights, similar to ReadDirents.\n"]
8978 pub fn watch(
8979 &self,
8980
8981 mask: impl ::fidl_next::Encode<
8982 crate::wire::WatchMask,
8983 <___T as ::fidl_next::Transport>::SendBuffer,
8984 >,
8985
8986 options: impl ::fidl_next::Encode<
8987 ::fidl_next::WireU32,
8988 <___T as ::fidl_next::Transport>::SendBuffer,
8989 >,
8990
8991 watcher: impl ::fidl_next::Encode<
8992 ::fidl_next::ServerEnd<
8993 crate::DirectoryWatcher,
8994 ::fidl_next::fuchsia::WireChannel,
8995 >,
8996 <___T as ::fidl_next::Transport>::SendBuffer,
8997 >,
8998 ) -> ::fidl_next::TwoWayFuture<'_, super::Watch, ___T>
8999 where
9000 <___T as ::fidl_next::Transport>::SendBuffer:
9001 ::fidl_next::encoder::InternalHandleEncoder,
9002 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9003 {
9004 self.watch_with(crate::generic::DirectoryWatchRequest { mask, options, watcher })
9005 }
9006
9007 #[doc = " Watches a directory, receiving events of added messages on the\n watcher request channel.\n\n Options must be zero; it is reserved.\n\n This method does not require any rights, similar to ReadDirents.\n"]
9008 pub fn watch_with<___R>(
9009 &self,
9010 request: ___R,
9011 ) -> ::fidl_next::TwoWayFuture<'_, super::Watch, ___T>
9012 where
9013 ___R: ::fidl_next::Encode<
9014 crate::wire::DirectoryWatchRequest,
9015 <___T as ::fidl_next::Transport>::SendBuffer,
9016 >,
9017 {
9018 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9019 6275512344170098065,
9020 <super::Watch as ::fidl_next::Method>::FLEXIBILITY,
9021 request,
9022 ))
9023 }
9024 }
9025
9026 #[repr(transparent)]
9028 pub struct DirectoryServer<___T: ::fidl_next::Transport> {
9029 server: ::fidl_next::protocol::Server<___T>,
9030 }
9031
9032 impl<___T> DirectoryServer<___T>
9033 where
9034 ___T: ::fidl_next::Transport,
9035 {
9036 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
9037 pub fn on_open(
9038 &self,
9039
9040 s: impl ::fidl_next::Encode<
9041 ::fidl_next::WireI32,
9042 <___T as ::fidl_next::Transport>::SendBuffer,
9043 >,
9044
9045 info: impl ::fidl_next::Encode<
9046 crate::wire_optional::NodeInfoDeprecated<'static>,
9047 <___T as ::fidl_next::Transport>::SendBuffer,
9048 >,
9049 ) -> ::fidl_next::SendFuture<'_, ___T>
9050 where
9051 <___T as ::fidl_next::Transport>::SendBuffer:
9052 ::fidl_next::encoder::InternalHandleEncoder,
9053 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9054 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9055 {
9056 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
9057 }
9058
9059 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
9060
9061 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
9062 where
9063 ___R: ::fidl_next::Encode<
9064 <super::OnOpen as ::fidl_next::Method>::Request,
9065 <___T as ::fidl_next::Transport>::SendBuffer,
9066 >,
9067 {
9068 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
9069 9207534335756671346,
9070 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
9071 request,
9072 ))
9073 }
9074
9075 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
9076
9077 pub fn on_representation_with<___R>(
9078 &self,
9079 request: ___R,
9080 ) -> ::fidl_next::SendFuture<'_, ___T>
9081 where
9082 ___R: ::fidl_next::Encode<
9083 <super::OnRepresentation as ::fidl_next::Method>::Request,
9084 <___T as ::fidl_next::Transport>::SendBuffer,
9085 >,
9086 {
9087 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
9088 6679970090861613324,
9089 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
9090 request,
9091 ))
9092 }
9093 }
9094 }
9095}
9096
9097pub trait DirectoryClientHandler<
9101 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9102 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9103>
9104{
9105 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
9106 fn on_open(
9107 &mut self,
9108
9109 request: ::fidl_next::Request<directory::OnOpen, ___T>,
9110 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9111
9112 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
9113 fn on_representation(
9114 &mut self,
9115
9116 request: ::fidl_next::Request<directory::OnRepresentation, ___T>,
9117 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9118
9119 fn on_unknown_interaction(
9120 &mut self,
9121 ordinal: u64,
9122 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9123 ::core::future::ready(())
9124 }
9125}
9126
9127impl<___T> DirectoryClientHandler<___T> for ::fidl_next::IgnoreEvents
9128where
9129 ___T: ::fidl_next::Transport,
9130{
9131 async fn on_open(&mut self, _: ::fidl_next::Request<directory::OnOpen, ___T>) {}
9132
9133 async fn on_representation(
9134 &mut self,
9135
9136 _: ::fidl_next::Request<directory::OnRepresentation, ___T>,
9137 ) {
9138 }
9139
9140 async fn on_unknown_interaction(&mut self, _: u64) {}
9141}
9142
9143impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Directory
9144where
9145 ___H: DirectoryClientHandler<___T> + ::core::marker::Send,
9146 ___T: ::fidl_next::Transport,
9147 <directory::OnOpen as ::fidl_next::Method>::Request:
9148 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9149 <directory::OnRepresentation as ::fidl_next::Method>::Request:
9150 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9151{
9152 async fn on_event(
9153 handler: &mut ___H,
9154 ordinal: u64,
9155 flexibility: ::fidl_next::protocol::Flexibility,
9156 buffer: ___T::RecvBuffer,
9157 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9158 match ordinal {
9159 9207534335756671346 => match ::fidl_next::DecoderExt::decode(buffer) {
9160 Ok(decoded) => {
9161 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
9162 Ok(())
9163 }
9164 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9165 ordinal: 9207534335756671346,
9166 error,
9167 }),
9168 },
9169
9170 6679970090861613324 => match ::fidl_next::DecoderExt::decode(buffer) {
9171 Ok(decoded) => {
9172 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
9173 Ok(())
9174 }
9175 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9176 ordinal: 6679970090861613324,
9177 error,
9178 }),
9179 },
9180
9181 ordinal => {
9182 handler.on_unknown_interaction(ordinal).await;
9183 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9184 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9185 } else {
9186 Ok(())
9187 }
9188 }
9189 }
9190 }
9191}
9192
9193pub trait DirectoryServerHandler<
9197 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9198 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9199>
9200{
9201 #[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"]
9202 fn advisory_lock(
9203 &mut self,
9204
9205 request: ::fidl_next::Request<directory::AdvisoryLock, ___T>,
9206
9207 responder: ::fidl_next::Responder<directory::AdvisoryLock, ___T>,
9208 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9209
9210 fn clone(
9211 &mut self,
9212
9213 request: ::fidl_next::Request<directory::Clone, ___T>,
9214 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9215
9216 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
9217 fn close(
9218 &mut self,
9219
9220 responder: ::fidl_next::Responder<directory::Close, ___T>,
9221 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9222
9223 fn query(
9224 &mut self,
9225
9226 responder: ::fidl_next::Responder<directory::Query, ___T>,
9227 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9228
9229 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
9230 fn deprecated_clone(
9231 &mut self,
9232
9233 request: ::fidl_next::Request<directory::DeprecatedClone, ___T>,
9234 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9235
9236 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
9237 fn deprecated_get_attr(
9238 &mut self,
9239
9240 responder: ::fidl_next::Responder<directory::DeprecatedGetAttr, ___T>,
9241 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9242
9243 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
9244 fn deprecated_set_attr(
9245 &mut self,
9246
9247 request: ::fidl_next::Request<directory::DeprecatedSetAttr, ___T>,
9248
9249 responder: ::fidl_next::Responder<directory::DeprecatedSetAttr, ___T>,
9250 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9251
9252 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
9253 fn deprecated_get_flags(
9254 &mut self,
9255
9256 responder: ::fidl_next::Responder<directory::DeprecatedGetFlags, ___T>,
9257 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9258
9259 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
9260 fn deprecated_set_flags(
9261 &mut self,
9262
9263 request: ::fidl_next::Request<directory::DeprecatedSetFlags, ___T>,
9264
9265 responder: ::fidl_next::Responder<directory::DeprecatedSetFlags, ___T>,
9266 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9267
9268 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
9269 fn get_flags(
9270 &mut self,
9271
9272 responder: ::fidl_next::Responder<directory::GetFlags, ___T>,
9273 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9274
9275 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
9276 fn set_flags(
9277 &mut self,
9278
9279 request: ::fidl_next::Request<directory::SetFlags, ___T>,
9280
9281 responder: ::fidl_next::Responder<directory::SetFlags, ___T>,
9282 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9283
9284 #[doc = " Query the filesystem for filesystem-specific information.\n"]
9285 fn query_filesystem(
9286 &mut self,
9287
9288 responder: ::fidl_next::Responder<directory::QueryFilesystem, ___T>,
9289 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9290
9291 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
9292 fn get_attributes(
9293 &mut self,
9294
9295 request: ::fidl_next::Request<directory::GetAttributes, ___T>,
9296
9297 responder: ::fidl_next::Responder<directory::GetAttributes, ___T>,
9298 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9299
9300 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
9301 fn update_attributes(
9302 &mut self,
9303
9304 request: ::fidl_next::Request<directory::UpdateAttributes, ___T>,
9305
9306 responder: ::fidl_next::Responder<directory::UpdateAttributes, ___T>,
9307 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9308
9309 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
9310 fn sync(
9311 &mut self,
9312
9313 responder: ::fidl_next::Responder<directory::Sync, ___T>,
9314 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9315
9316 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
9317 fn list_extended_attributes(
9318 &mut self,
9319
9320 request: ::fidl_next::Request<directory::ListExtendedAttributes, ___T>,
9321 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9322
9323 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
9324 fn get_extended_attribute(
9325 &mut self,
9326
9327 request: ::fidl_next::Request<directory::GetExtendedAttribute, ___T>,
9328
9329 responder: ::fidl_next::Responder<directory::GetExtendedAttribute, ___T>,
9330 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9331
9332 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
9333 fn set_extended_attribute(
9334 &mut self,
9335
9336 request: ::fidl_next::Request<directory::SetExtendedAttribute, ___T>,
9337
9338 responder: ::fidl_next::Responder<directory::SetExtendedAttribute, ___T>,
9339 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9340
9341 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
9342 fn remove_extended_attribute(
9343 &mut self,
9344
9345 request: ::fidl_next::Request<directory::RemoveExtendedAttribute, ___T>,
9346
9347 responder: ::fidl_next::Responder<directory::RemoveExtendedAttribute, ___T>,
9348 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9349
9350 #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
9351 fn deprecated_open(
9352 &mut self,
9353
9354 request: ::fidl_next::Request<directory::DeprecatedOpen, ___T>,
9355 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9356
9357 #[doc = " Open (or create) a node relative to this directory. Any errors are communicated via an\n epitaph sent on the `object` channel.\n\n Errors:\n * `ZX_ERR_BAD_PATH` if `path` is invalid\n * See [`Flags`] for other errors which may be communicated based on `flags`\n"]
9358 fn open(
9359 &mut self,
9360
9361 request: ::fidl_next::Request<directory::Open, ___T>,
9362 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9363
9364 #[doc = " Reads a collection of variably sized dirents into a buffer.\n The number of dirents in a directory may be very large: akin to\n calling read multiple times on a file, directories have a seek\n offset which is updated on subsequent calls to ReadDirents.\n Each call to ReadDirents will only return whole dirent structures,\n they will not get split across ReadDirent calls. When the seek\n offset reaches the end, `dirents` will be empty.\n\n These dirents are of the form:\n ```\n struct dirent {\n // Describes the inode of the entry.\n uint64 ino;\n // Describes the length of the dirent name in bytes.\n uint8 size;\n // Describes the type of the entry. Aligned with the\n // POSIX d_type values. Use `DirentType` constants.\n uint8 type;\n // Unterminated name of entry.\n char name[0];\n }\n ```\n\n This method does not require any rights, since one could always probe for\n directory contents by triggering name conflicts during file creation.\n"]
9365 fn read_dirents(
9366 &mut self,
9367
9368 request: ::fidl_next::Request<directory::ReadDirents, ___T>,
9369
9370 responder: ::fidl_next::Responder<directory::ReadDirents, ___T>,
9371 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9372
9373 #[doc = " Resets the directory seek offset.\n\n This method does not require any rights, similar to ReadDirents.\n"]
9374 fn rewind(
9375 &mut self,
9376
9377 responder: ::fidl_next::Responder<directory::Rewind, ___T>,
9378 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9379
9380 #[doc = " Acquires a token to a Directory which can be used to identify access to it at a later point\n in time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n"]
9381 fn get_token(
9382 &mut self,
9383
9384 responder: ::fidl_next::Responder<directory::GetToken, ___T>,
9385 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9386
9387 #[doc = " Creates a link to an object named src by the name dst, within a directory represented by\n token.\n\n `src` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE` and\n `OpenFlags.RIGHT_READABLE`, otherwise returns `ZX_ERR_BAD_HANDLE`.\n\n This will be atomic with respect to renaming or unlinking the source concurrently e.g. if\n there are two actors operating concurrently, and one actor performs a rename that affects\n the source within this directory, and the other does a link, each will appear to occur\n atomically in an unspecified order.\n"]
9388 fn link(
9389 &mut self,
9390
9391 request: ::fidl_next::Request<directory::Link, ___T>,
9392
9393 responder: ::fidl_next::Responder<directory::Link, ___T>,
9394 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9395
9396 #[doc = " Removes a child node from the this directory\'s list of entries.\n\n Note: this does not guarantee that the underlying object is destroyed.\n Although the link will be removed from the containing directory,\n objects with multiple references (such as files which are still open)\n will not actually be destroyed until all references are closed.\n\n * error `ZX_ERR_ACCESS_DENIED` if the connection does not have\n [`Rights.WRITE_BYTES`].\n * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not\n support writing.\n * error `ZX_ERR_BAD_PATH` if `name` is invalid.\n * error `ZX_ERR_NOT_EMPTY` if `name` refers to a non-empty directory.\n * error `ZX_ERR_UNAVAILABLE` if `name` refers to a mount point,\n containing a remote channel.\n * error `ZX_ERR_NOT_DIR` if the options requested a directory but\n something other than a directory was found.\n\n Other errors may be returned for filesystem-specific reasons.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n"]
9397 fn unlink(
9398 &mut self,
9399
9400 request: ::fidl_next::Request<directory::Unlink, ___T>,
9401
9402 responder: ::fidl_next::Responder<directory::Unlink, ___T>,
9403 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9404
9405 #[doc = " Renames a node named `src` to the name `dst`, in a directory represented\n by `dst_parent_token`.\n\n `src` and `dst` must be valid node names.\n See [`Name`] for what constitutes a valid name.\n\n This method requires the following rights on both the current connection, and the connection\n identified by `dst_parent_token`:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n\n The following requirements are necessary to avoid rights escalations.\n\n If the source and destination directory differ, the source directory must also have the\n maximal set of abilities supported for files, which would typically be\n [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`], [`Rights.GET_ATTRIBUTES`] and\n [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also support the [`Rights.EXECUTE`]\n right.\n\n If `src` refers to a directory, and differs from the destination directory, then the source\n directory must have also have the [`Rights.CONNECT`] and [`Rights.TRAVERSE`] rights.\n\n * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.\n * error `ZX_ERR_ACCESS_DENIED` for insufficient rights.\n"]
9406 fn rename(
9407 &mut self,
9408
9409 request: ::fidl_next::Request<directory::Rename, ___T>,
9410
9411 responder: ::fidl_next::Responder<directory::Rename, ___T>,
9412 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9413
9414 #[doc = " Creates a symbolic link.\n\n `name` is the name to be given to the created symbolic link.\n `target` is the target of the symbolic link, which has no meaning on the server. The server\n will perform no validation of `target` except for a server chosen maximum length.\n `connection` is an optional server end of a channel that will speak the Symlink protocol\n on the successfully created node.\n\n * [`Rights.MODIFY_DIRECTORY`]\n\n * error `ZX_ERR_ALREADY_EXISTS` if `name` already exists.\n * error `ZX_ERR_BAD_PATH` if `target` exceeds the server length limit for symbolic links.\n * error `ZX_ERR_INVALID_ARGS` if `name` is not a valid [`Name`].\n * error `ZX_ERR_NOT_SUPPORTED` if creating symbolic links is not supported by the server.\n"]
9415 fn create_symlink(
9416 &mut self,
9417
9418 request: ::fidl_next::Request<directory::CreateSymlink, ___T>,
9419
9420 responder: ::fidl_next::Responder<directory::CreateSymlink, ___T>,
9421 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9422
9423 #[doc = " Watches a directory, receiving events of added messages on the\n watcher request channel.\n\n Options must be zero; it is reserved.\n\n This method does not require any rights, similar to ReadDirents.\n"]
9424 fn watch(
9425 &mut self,
9426
9427 request: ::fidl_next::Request<directory::Watch, ___T>,
9428
9429 responder: ::fidl_next::Responder<directory::Watch, ___T>,
9430 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9431
9432 fn on_unknown_interaction(
9433 &mut self,
9434 ordinal: u64,
9435 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9436 ::core::future::ready(())
9437 }
9438}
9439
9440impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Directory
9441where
9442 ___H: DirectoryServerHandler<___T> + ::core::marker::Send,
9443 ___T: ::fidl_next::Transport,
9444 <directory::AdvisoryLock as ::fidl_next::Method>::Request:
9445 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9446 <directory::Clone as ::fidl_next::Method>::Request:
9447 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9448 <directory::DeprecatedClone as ::fidl_next::Method>::Request:
9449 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9450 <directory::DeprecatedSetAttr as ::fidl_next::Method>::Request:
9451 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9452 <directory::DeprecatedSetFlags as ::fidl_next::Method>::Request:
9453 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9454 <directory::SetFlags as ::fidl_next::Method>::Request:
9455 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9456 <directory::GetAttributes as ::fidl_next::Method>::Request:
9457 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9458 <directory::UpdateAttributes as ::fidl_next::Method>::Request:
9459 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9460 <directory::ListExtendedAttributes as ::fidl_next::Method>::Request:
9461 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9462 <directory::GetExtendedAttribute as ::fidl_next::Method>::Request:
9463 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9464 <directory::SetExtendedAttribute as ::fidl_next::Method>::Request:
9465 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9466 <directory::RemoveExtendedAttribute as ::fidl_next::Method>::Request:
9467 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9468 <directory::DeprecatedOpen as ::fidl_next::Method>::Request:
9469 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9470 <directory::Open as ::fidl_next::Method>::Request:
9471 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9472 <directory::ReadDirents as ::fidl_next::Method>::Request:
9473 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9474 <directory::Link as ::fidl_next::Method>::Request:
9475 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9476 <directory::Unlink as ::fidl_next::Method>::Request:
9477 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9478 <directory::Rename as ::fidl_next::Method>::Request:
9479 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9480 <directory::CreateSymlink as ::fidl_next::Method>::Request:
9481 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9482 <directory::Watch as ::fidl_next::Method>::Request:
9483 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9484{
9485 async fn on_one_way(
9486 handler: &mut ___H,
9487 ordinal: u64,
9488 flexibility: ::fidl_next::protocol::Flexibility,
9489 buffer: ___T::RecvBuffer,
9490 ) -> ::core::result::Result<
9491 (),
9492 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9493 > {
9494 match ordinal {
9495 2366825959783828089 => match ::fidl_next::DecoderExt::decode(buffer) {
9496 Ok(decoded) => {
9497 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
9498 Ok(())
9499 }
9500 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9501 ordinal: 2366825959783828089,
9502 error,
9503 }),
9504 },
9505
9506 6512600400724287855 => match ::fidl_next::DecoderExt::decode(buffer) {
9507 Ok(decoded) => {
9508 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
9509 Ok(())
9510 }
9511 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9512 ordinal: 6512600400724287855,
9513 error,
9514 }),
9515 },
9516
9517 5431626189872037072 => match ::fidl_next::DecoderExt::decode(buffer) {
9518 Ok(decoded) => {
9519 handler
9520 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
9521 .await;
9522 Ok(())
9523 }
9524 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9525 ordinal: 5431626189872037072,
9526 error,
9527 }),
9528 },
9529
9530 3193127272456937152 => match ::fidl_next::DecoderExt::decode(buffer) {
9531 Ok(decoded) => {
9532 handler.deprecated_open(::fidl_next::Request::from_decoded(decoded)).await;
9533 Ok(())
9534 }
9535 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9536 ordinal: 3193127272456937152,
9537 error,
9538 }),
9539 },
9540
9541 6236883748953765593 => match ::fidl_next::DecoderExt::decode(buffer) {
9542 Ok(decoded) => {
9543 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
9544 Ok(())
9545 }
9546 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9547 ordinal: 6236883748953765593,
9548 error,
9549 }),
9550 },
9551
9552 ordinal => {
9553 handler.on_unknown_interaction(ordinal).await;
9554 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9555 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9556 } else {
9557 Ok(())
9558 }
9559 }
9560 }
9561 }
9562
9563 async fn on_two_way(
9564 handler: &mut ___H,
9565 ordinal: u64,
9566 flexibility: ::fidl_next::protocol::Flexibility,
9567 buffer: ___T::RecvBuffer,
9568 responder: ::fidl_next::protocol::Responder<___T>,
9569 ) -> ::core::result::Result<
9570 (),
9571 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9572 > {
9573 match ordinal {
9574 7992130864415541162 => {
9575 let responder = ::fidl_next::Responder::from_untyped(responder);
9576
9577 match ::fidl_next::DecoderExt::decode(buffer) {
9578 Ok(decoded) => {
9579 handler
9580 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
9581 .await;
9582 Ok(())
9583 }
9584 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9585 ordinal: 7992130864415541162,
9586 error,
9587 }),
9588 }
9589 }
9590
9591 6540867515453498750 => {
9592 let responder = ::fidl_next::Responder::from_untyped(responder);
9593
9594 handler.close(responder).await;
9595 Ok(())
9596 }
9597
9598 2763219980499352582 => {
9599 let responder = ::fidl_next::Responder::from_untyped(responder);
9600
9601 handler.query(responder).await;
9602 Ok(())
9603 }
9604
9605 8689798978500614909 => {
9606 let responder = ::fidl_next::Responder::from_untyped(responder);
9607
9608 handler.deprecated_get_attr(responder).await;
9609 Ok(())
9610 }
9611
9612 4721673413776871238 => {
9613 let responder = ::fidl_next::Responder::from_untyped(responder);
9614
9615 match ::fidl_next::DecoderExt::decode(buffer) {
9616 Ok(decoded) => {
9617 handler
9618 .deprecated_set_attr(
9619 ::fidl_next::Request::from_decoded(decoded),
9620 responder,
9621 )
9622 .await;
9623 Ok(())
9624 }
9625 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9626 ordinal: 4721673413776871238,
9627 error,
9628 }),
9629 }
9630 }
9631
9632 6595803110182632097 => {
9633 let responder = ::fidl_next::Responder::from_untyped(responder);
9634
9635 handler.deprecated_get_flags(responder).await;
9636 Ok(())
9637 }
9638
9639 5950864159036794675 => {
9640 let responder = ::fidl_next::Responder::from_untyped(responder);
9641
9642 match ::fidl_next::DecoderExt::decode(buffer) {
9643 Ok(decoded) => {
9644 handler
9645 .deprecated_set_flags(
9646 ::fidl_next::Request::from_decoded(decoded),
9647 responder,
9648 )
9649 .await;
9650 Ok(())
9651 }
9652 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9653 ordinal: 5950864159036794675,
9654 error,
9655 }),
9656 }
9657 }
9658
9659 105530239381466147 => {
9660 let responder = ::fidl_next::Responder::from_untyped(responder);
9661
9662 handler.get_flags(responder).await;
9663 Ok(())
9664 }
9665
9666 6172186066099445416 => {
9667 let responder = ::fidl_next::Responder::from_untyped(responder);
9668
9669 match ::fidl_next::DecoderExt::decode(buffer) {
9670 Ok(decoded) => {
9671 handler
9672 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
9673 .await;
9674 Ok(())
9675 }
9676 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9677 ordinal: 6172186066099445416,
9678 error,
9679 }),
9680 }
9681 }
9682
9683 8013111122914313744 => {
9684 let responder = ::fidl_next::Responder::from_untyped(responder);
9685
9686 handler.query_filesystem(responder).await;
9687 Ok(())
9688 }
9689
9690 4414537700416816443 => {
9691 let responder = ::fidl_next::Responder::from_untyped(responder);
9692
9693 match ::fidl_next::DecoderExt::decode(buffer) {
9694 Ok(decoded) => {
9695 handler
9696 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
9697 .await;
9698 Ok(())
9699 }
9700 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9701 ordinal: 4414537700416816443,
9702 error,
9703 }),
9704 }
9705 }
9706
9707 3677402239314018056 => {
9708 let responder = ::fidl_next::Responder::from_untyped(responder);
9709
9710 match ::fidl_next::DecoderExt::decode(buffer) {
9711 Ok(decoded) => {
9712 handler
9713 .update_attributes(
9714 ::fidl_next::Request::from_decoded(decoded),
9715 responder,
9716 )
9717 .await;
9718 Ok(())
9719 }
9720 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9721 ordinal: 3677402239314018056,
9722 error,
9723 }),
9724 }
9725 }
9726
9727 3196473584242777161 => {
9728 let responder = ::fidl_next::Responder::from_untyped(responder);
9729
9730 handler.sync(responder).await;
9731 Ok(())
9732 }
9733
9734 5043930208506967771 => {
9735 let responder = ::fidl_next::Responder::from_untyped(responder);
9736
9737 match ::fidl_next::DecoderExt::decode(buffer) {
9738 Ok(decoded) => {
9739 handler
9740 .get_extended_attribute(
9741 ::fidl_next::Request::from_decoded(decoded),
9742 responder,
9743 )
9744 .await;
9745 Ok(())
9746 }
9747 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9748 ordinal: 5043930208506967771,
9749 error,
9750 }),
9751 }
9752 }
9753
9754 5374223046099989052 => {
9755 let responder = ::fidl_next::Responder::from_untyped(responder);
9756
9757 match ::fidl_next::DecoderExt::decode(buffer) {
9758 Ok(decoded) => {
9759 handler
9760 .set_extended_attribute(
9761 ::fidl_next::Request::from_decoded(decoded),
9762 responder,
9763 )
9764 .await;
9765 Ok(())
9766 }
9767 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9768 ordinal: 5374223046099989052,
9769 error,
9770 }),
9771 }
9772 }
9773
9774 8794297771444732717 => {
9775 let responder = ::fidl_next::Responder::from_untyped(responder);
9776
9777 match ::fidl_next::DecoderExt::decode(buffer) {
9778 Ok(decoded) => {
9779 handler
9780 .remove_extended_attribute(
9781 ::fidl_next::Request::from_decoded(decoded),
9782 responder,
9783 )
9784 .await;
9785 Ok(())
9786 }
9787 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9788 ordinal: 8794297771444732717,
9789 error,
9790 }),
9791 }
9792 }
9793
9794 3855785432100874762 => {
9795 let responder = ::fidl_next::Responder::from_untyped(responder);
9796
9797 match ::fidl_next::DecoderExt::decode(buffer) {
9798 Ok(decoded) => {
9799 handler
9800 .read_dirents(::fidl_next::Request::from_decoded(decoded), responder)
9801 .await;
9802 Ok(())
9803 }
9804 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9805 ordinal: 3855785432100874762,
9806 error,
9807 }),
9808 }
9809 }
9810
9811 1635123508515392625 => {
9812 let responder = ::fidl_next::Responder::from_untyped(responder);
9813
9814 handler.rewind(responder).await;
9815 Ok(())
9816 }
9817
9818 2787337947777369685 => {
9819 let responder = ::fidl_next::Responder::from_untyped(responder);
9820
9821 handler.get_token(responder).await;
9822 Ok(())
9823 }
9824
9825 8360374984291987687 => {
9826 let responder = ::fidl_next::Responder::from_untyped(responder);
9827
9828 match ::fidl_next::DecoderExt::decode(buffer) {
9829 Ok(decoded) => {
9830 handler.link(::fidl_next::Request::from_decoded(decoded), responder).await;
9831 Ok(())
9832 }
9833 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9834 ordinal: 8360374984291987687,
9835 error,
9836 }),
9837 }
9838 }
9839
9840 8433556716759383021 => {
9841 let responder = ::fidl_next::Responder::from_untyped(responder);
9842
9843 match ::fidl_next::DecoderExt::decode(buffer) {
9844 Ok(decoded) => {
9845 handler
9846 .unlink(::fidl_next::Request::from_decoded(decoded), responder)
9847 .await;
9848 Ok(())
9849 }
9850 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9851 ordinal: 8433556716759383021,
9852 error,
9853 }),
9854 }
9855 }
9856
9857 8097726607824333022 => {
9858 let responder = ::fidl_next::Responder::from_untyped(responder);
9859
9860 match ::fidl_next::DecoderExt::decode(buffer) {
9861 Ok(decoded) => {
9862 handler
9863 .rename(::fidl_next::Request::from_decoded(decoded), responder)
9864 .await;
9865 Ok(())
9866 }
9867 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9868 ordinal: 8097726607824333022,
9869 error,
9870 }),
9871 }
9872 }
9873
9874 2435901052462315657 => {
9875 let responder = ::fidl_next::Responder::from_untyped(responder);
9876
9877 match ::fidl_next::DecoderExt::decode(buffer) {
9878 Ok(decoded) => {
9879 handler
9880 .create_symlink(::fidl_next::Request::from_decoded(decoded), responder)
9881 .await;
9882 Ok(())
9883 }
9884 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9885 ordinal: 2435901052462315657,
9886 error,
9887 }),
9888 }
9889 }
9890
9891 6275512344170098065 => {
9892 let responder = ::fidl_next::Responder::from_untyped(responder);
9893
9894 match ::fidl_next::DecoderExt::decode(buffer) {
9895 Ok(decoded) => {
9896 handler.watch(::fidl_next::Request::from_decoded(decoded), responder).await;
9897 Ok(())
9898 }
9899 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9900 ordinal: 6275512344170098065,
9901 error,
9902 }),
9903 }
9904 }
9905
9906 ordinal => {
9907 handler.on_unknown_interaction(ordinal).await;
9908 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9909 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9910 } else {
9911 responder
9912 .respond(
9913 ordinal,
9914 flexibility,
9915 ::fidl_next::Flexible::<()>::FrameworkErr(
9916 ::fidl_next::FrameworkError::UnknownMethod,
9917 ),
9918 )
9919 .expect("encoding a framework error should never fail")
9920 .await?;
9921 Ok(())
9922 }
9923 }
9924 }
9925 }
9926}
9927
9928#[derive(PartialEq, Debug)]
9930pub struct Linkable;
9931
9932#[cfg(target_os = "fuchsia")]
9933impl ::fidl_next::HasTransport for Linkable {
9934 type Transport = ::fidl_next::fuchsia::zx::Channel;
9935}
9936
9937pub mod linkable {
9938 pub mod prelude {
9939 pub use crate::{Linkable, LinkableClientHandler, LinkableServerHandler, linkable};
9940
9941 pub use crate::natural::LinkableLinkIntoRequest;
9942
9943 pub use crate::natural::LinkableLinkIntoResponse;
9944 }
9945
9946 pub struct LinkInto;
9947
9948 impl ::fidl_next::Method for LinkInto {
9949 const ORDINAL: u64 = 6121399674497678964;
9950 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9951 ::fidl_next::protocol::Flexibility::Strict;
9952
9953 type Protocol = crate::Linkable;
9954
9955 type Request = crate::wire::LinkableLinkIntoRequest<'static>;
9956 }
9957
9958 impl ::fidl_next::TwoWayMethod for LinkInto {
9959 type Response = ::fidl_next::WireResult<
9960 'static,
9961 crate::wire::LinkableLinkIntoResponse,
9962 ::fidl_next::WireI32,
9963 >;
9964 }
9965
9966 impl<___R> ::fidl_next::Respond<___R> for LinkInto {
9967 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9968
9969 fn respond(response: ___R) -> Self::Output {
9970 ::core::result::Result::Ok(response)
9971 }
9972 }
9973
9974 impl<___R> ::fidl_next::RespondErr<___R> for LinkInto {
9975 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9976
9977 fn respond_err(response: ___R) -> Self::Output {
9978 ::core::result::Result::Err(response)
9979 }
9980 }
9981
9982 mod ___detail {
9983 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Linkable
9984 where
9985 ___T: ::fidl_next::Transport,
9986 {
9987 type Client = LinkableClient<___T>;
9988 type Server = LinkableServer<___T>;
9989 }
9990
9991 #[repr(transparent)]
9993 pub struct LinkableClient<___T: ::fidl_next::Transport> {
9994 #[allow(dead_code)]
9995 client: ::fidl_next::protocol::Client<___T>,
9996 }
9997
9998 impl<___T> LinkableClient<___T>
9999 where
10000 ___T: ::fidl_next::Transport,
10001 {
10002 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
10003 pub fn link_into(
10004 &self,
10005
10006 dst_parent_token: impl ::fidl_next::Encode<
10007 ::fidl_next::fuchsia::WireEvent,
10008 <___T as ::fidl_next::Transport>::SendBuffer,
10009 >,
10010
10011 dst: impl ::fidl_next::Encode<
10012 ::fidl_next::WireString<'static>,
10013 <___T as ::fidl_next::Transport>::SendBuffer,
10014 >,
10015 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
10016 where
10017 <___T as ::fidl_next::Transport>::SendBuffer:
10018 ::fidl_next::encoder::InternalHandleEncoder,
10019 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10020 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10021 {
10022 self.link_into_with(crate::generic::LinkableLinkIntoRequest {
10023 dst_parent_token,
10024
10025 dst,
10026 })
10027 }
10028
10029 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
10030 pub fn link_into_with<___R>(
10031 &self,
10032 request: ___R,
10033 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
10034 where
10035 ___R: ::fidl_next::Encode<
10036 crate::wire::LinkableLinkIntoRequest<'static>,
10037 <___T as ::fidl_next::Transport>::SendBuffer,
10038 >,
10039 {
10040 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10041 6121399674497678964,
10042 <super::LinkInto as ::fidl_next::Method>::FLEXIBILITY,
10043 request,
10044 ))
10045 }
10046 }
10047
10048 #[repr(transparent)]
10050 pub struct LinkableServer<___T: ::fidl_next::Transport> {
10051 server: ::fidl_next::protocol::Server<___T>,
10052 }
10053
10054 impl<___T> LinkableServer<___T> where ___T: ::fidl_next::Transport {}
10055 }
10056}
10057
10058pub trait LinkableClientHandler<
10062 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10063 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10064>
10065{
10066}
10067
10068impl<___T> LinkableClientHandler<___T> for ::fidl_next::IgnoreEvents where
10069 ___T: ::fidl_next::Transport
10070{
10071}
10072
10073impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Linkable
10074where
10075 ___H: LinkableClientHandler<___T> + ::core::marker::Send,
10076 ___T: ::fidl_next::Transport,
10077{
10078 async fn on_event(
10079 handler: &mut ___H,
10080 ordinal: u64,
10081 flexibility: ::fidl_next::protocol::Flexibility,
10082 buffer: ___T::RecvBuffer,
10083 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10084 match ordinal {
10085 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
10086 }
10087 }
10088}
10089
10090pub trait LinkableServerHandler<
10094 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10095 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10096>
10097{
10098 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
10099 fn link_into(
10100 &mut self,
10101
10102 request: ::fidl_next::Request<linkable::LinkInto, ___T>,
10103
10104 responder: ::fidl_next::Responder<linkable::LinkInto, ___T>,
10105 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10106}
10107
10108impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Linkable
10109where
10110 ___H: LinkableServerHandler<___T> + ::core::marker::Send,
10111 ___T: ::fidl_next::Transport,
10112 <linkable::LinkInto as ::fidl_next::Method>::Request:
10113 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10114{
10115 async fn on_one_way(
10116 handler: &mut ___H,
10117 ordinal: u64,
10118 flexibility: ::fidl_next::protocol::Flexibility,
10119 buffer: ___T::RecvBuffer,
10120 ) -> ::core::result::Result<
10121 (),
10122 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10123 > {
10124 match ordinal {
10125 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
10126 }
10127 }
10128
10129 async fn on_two_way(
10130 handler: &mut ___H,
10131 ordinal: u64,
10132 flexibility: ::fidl_next::protocol::Flexibility,
10133 buffer: ___T::RecvBuffer,
10134 responder: ::fidl_next::protocol::Responder<___T>,
10135 ) -> ::core::result::Result<
10136 (),
10137 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10138 > {
10139 match ordinal {
10140 6121399674497678964 => {
10141 let responder = ::fidl_next::Responder::from_untyped(responder);
10142
10143 match ::fidl_next::DecoderExt::decode(buffer) {
10144 Ok(decoded) => {
10145 handler
10146 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
10147 .await;
10148 Ok(())
10149 }
10150 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10151 ordinal: 6121399674497678964,
10152 error,
10153 }),
10154 }
10155 }
10156
10157 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
10158 }
10159 }
10160}
10161
10162#[doc = " A [`Node`] which contains a sequence of bytes of definite length.\n\n NOTE: cloned connections do not share their seek offset with their source\n connection.\n"]
10164#[derive(PartialEq, Debug)]
10165pub struct File;
10166
10167impl ::fidl_next::Discoverable for File {
10168 const PROTOCOL_NAME: &'static str = "fuchsia.io.File";
10169}
10170
10171#[cfg(target_os = "fuchsia")]
10172impl ::fidl_next::HasTransport for File {
10173 type Transport = ::fidl_next::fuchsia::zx::Channel;
10174}
10175
10176pub mod file {
10177 pub mod prelude {
10178 pub use crate::{File, FileClientHandler, FileServerHandler, file};
10179
10180 pub use crate::natural::AdvisoryLockingAdvisoryLockRequest;
10181
10182 pub use crate::natural::AdvisoryLockingAdvisoryLockResponse;
10183
10184 pub use crate::natural::ExtendedAttributeValue;
10185
10186 pub use crate::natural::FileAllocateRequest;
10187
10188 pub use crate::natural::FileEnableVerityRequest;
10189
10190 pub use crate::natural::FileGetBackingMemoryRequest;
10191
10192 pub use crate::natural::FileInfo;
10193
10194 pub use crate::natural::FileReadAtRequest;
10195
10196 pub use crate::natural::FileResizeRequest;
10197
10198 pub use crate::natural::FileSeekRequest;
10199
10200 pub use crate::natural::FileWriteAtRequest;
10201
10202 pub use crate::natural::FileAllocateResponse;
10203
10204 pub use crate::natural::FileEnableVerityResponse;
10205
10206 pub use crate::natural::FileGetBackingMemoryResponse;
10207
10208 pub use crate::natural::FileReadAtResponse;
10209
10210 pub use crate::natural::FileResizeResponse;
10211
10212 pub use crate::natural::FileSeekResponse;
10213
10214 pub use crate::natural::FileWriteAtResponse;
10215
10216 pub use crate::natural::LinkableLinkIntoRequest;
10217
10218 pub use crate::natural::LinkableLinkIntoResponse;
10219
10220 pub use crate::natural::MutableNodeAttributes;
10221
10222 pub use crate::natural::NodeAttributes2;
10223
10224 pub use crate::natural::NodeDeprecatedCloneRequest;
10225
10226 pub use crate::natural::NodeDeprecatedGetAttrResponse;
10227
10228 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
10229
10230 pub use crate::natural::NodeDeprecatedSetAttrRequest;
10231
10232 pub use crate::natural::NodeDeprecatedSetAttrResponse;
10233
10234 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
10235
10236 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
10237
10238 pub use crate::natural::NodeGetAttributesRequest;
10239
10240 pub use crate::natural::NodeGetExtendedAttributeRequest;
10241
10242 pub use crate::natural::NodeListExtendedAttributesRequest;
10243
10244 pub use crate::natural::NodeOnOpenRequest;
10245
10246 pub use crate::natural::NodeQueryFilesystemResponse;
10247
10248 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
10249
10250 pub use crate::natural::NodeSetExtendedAttributeRequest;
10251
10252 pub use crate::natural::NodeSetFlagsRequest;
10253
10254 pub use crate::natural::NodeGetFlagsResponse;
10255
10256 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
10257
10258 pub use crate::natural::NodeSetExtendedAttributeResponse;
10259
10260 pub use crate::natural::NodeSetFlagsResponse;
10261
10262 pub use crate::natural::NodeSyncResponse;
10263
10264 pub use crate::natural::NodeUpdateAttributesResponse;
10265
10266 pub use crate::natural::ReadableReadRequest;
10267
10268 pub use crate::natural::ReadableReadResponse;
10269
10270 pub use crate::natural::Representation;
10271
10272 pub use crate::natural::WritableWriteRequest;
10273
10274 pub use crate::natural::WritableWriteResponse;
10275
10276 pub use ::fidl_next_fuchsia_unknown::natural::CloneableCloneRequest;
10277
10278 pub use ::fidl_next_fuchsia_unknown::natural::CloseableCloseResponse;
10279
10280 pub use ::fidl_next_fuchsia_unknown::natural::QueryableQueryResponse;
10281 }
10282
10283 pub struct AdvisoryLock;
10284
10285 impl ::fidl_next::Method for AdvisoryLock {
10286 const ORDINAL: u64 = 7992130864415541162;
10287 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10288 ::fidl_next::protocol::Flexibility::Strict;
10289
10290 type Protocol = crate::File;
10291
10292 type Request = crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>;
10293 }
10294
10295 impl ::fidl_next::TwoWayMethod for AdvisoryLock {
10296 type Response = ::fidl_next::WireResult<
10297 'static,
10298 crate::wire::AdvisoryLockingAdvisoryLockResponse,
10299 ::fidl_next::WireI32,
10300 >;
10301 }
10302
10303 impl<___R> ::fidl_next::Respond<___R> for AdvisoryLock {
10304 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10305
10306 fn respond(response: ___R) -> Self::Output {
10307 ::core::result::Result::Ok(response)
10308 }
10309 }
10310
10311 impl<___R> ::fidl_next::RespondErr<___R> for AdvisoryLock {
10312 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10313
10314 fn respond_err(response: ___R) -> Self::Output {
10315 ::core::result::Result::Err(response)
10316 }
10317 }
10318
10319 pub struct LinkInto;
10320
10321 impl ::fidl_next::Method for LinkInto {
10322 const ORDINAL: u64 = 6121399674497678964;
10323 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10324 ::fidl_next::protocol::Flexibility::Strict;
10325
10326 type Protocol = crate::File;
10327
10328 type Request = crate::wire::LinkableLinkIntoRequest<'static>;
10329 }
10330
10331 impl ::fidl_next::TwoWayMethod for LinkInto {
10332 type Response = ::fidl_next::WireResult<
10333 'static,
10334 crate::wire::LinkableLinkIntoResponse,
10335 ::fidl_next::WireI32,
10336 >;
10337 }
10338
10339 impl<___R> ::fidl_next::Respond<___R> for LinkInto {
10340 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10341
10342 fn respond(response: ___R) -> Self::Output {
10343 ::core::result::Result::Ok(response)
10344 }
10345 }
10346
10347 impl<___R> ::fidl_next::RespondErr<___R> for LinkInto {
10348 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10349
10350 fn respond_err(response: ___R) -> Self::Output {
10351 ::core::result::Result::Err(response)
10352 }
10353 }
10354
10355 pub struct Clone;
10356
10357 impl ::fidl_next::Method for Clone {
10358 const ORDINAL: u64 = 2366825959783828089;
10359 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10360 ::fidl_next::protocol::Flexibility::Strict;
10361
10362 type Protocol = crate::File;
10363
10364 type Request = ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest;
10365 }
10366
10367 pub struct Close;
10368
10369 impl ::fidl_next::Method for Close {
10370 const ORDINAL: u64 = 6540867515453498750;
10371 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10372 ::fidl_next::protocol::Flexibility::Strict;
10373
10374 type Protocol = crate::File;
10375
10376 type Request = ();
10377 }
10378
10379 impl ::fidl_next::TwoWayMethod for Close {
10380 type Response = ::fidl_next::WireResult<
10381 'static,
10382 ::fidl_next_fuchsia_unknown::wire::CloseableCloseResponse,
10383 ::fidl_next::WireI32,
10384 >;
10385 }
10386
10387 impl<___R> ::fidl_next::Respond<___R> for Close {
10388 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10389
10390 fn respond(response: ___R) -> Self::Output {
10391 ::core::result::Result::Ok(response)
10392 }
10393 }
10394
10395 impl<___R> ::fidl_next::RespondErr<___R> for Close {
10396 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10397
10398 fn respond_err(response: ___R) -> Self::Output {
10399 ::core::result::Result::Err(response)
10400 }
10401 }
10402
10403 pub struct Query;
10404
10405 impl ::fidl_next::Method for Query {
10406 const ORDINAL: u64 = 2763219980499352582;
10407 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10408 ::fidl_next::protocol::Flexibility::Strict;
10409
10410 type Protocol = crate::File;
10411
10412 type Request = ();
10413 }
10414
10415 impl ::fidl_next::TwoWayMethod for Query {
10416 type Response = ::fidl_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>;
10417 }
10418
10419 impl<___R> ::fidl_next::Respond<___R> for Query {
10420 type Output = ::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>;
10421
10422 fn respond(response: ___R) -> Self::Output {
10423 ::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse { protocol: response }
10424 }
10425 }
10426
10427 pub struct DeprecatedClone;
10428
10429 impl ::fidl_next::Method for DeprecatedClone {
10430 const ORDINAL: u64 = 6512600400724287855;
10431 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10432 ::fidl_next::protocol::Flexibility::Flexible;
10433
10434 type Protocol = crate::File;
10435
10436 type Request = crate::wire::NodeDeprecatedCloneRequest;
10437 }
10438
10439 pub struct OnOpen;
10440
10441 impl ::fidl_next::Method for OnOpen {
10442 const ORDINAL: u64 = 9207534335756671346;
10443 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10444 ::fidl_next::protocol::Flexibility::Flexible;
10445
10446 type Protocol = crate::File;
10447
10448 type Request = crate::wire::NodeOnOpenRequest<'static>;
10449 }
10450
10451 pub struct DeprecatedGetAttr;
10452
10453 impl ::fidl_next::Method for DeprecatedGetAttr {
10454 const ORDINAL: u64 = 8689798978500614909;
10455 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10456 ::fidl_next::protocol::Flexibility::Strict;
10457
10458 type Protocol = crate::File;
10459
10460 type Request = ();
10461 }
10462
10463 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
10464 type Response = crate::wire::NodeDeprecatedGetAttrResponse;
10465 }
10466
10467 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
10468 type Output = ___R;
10469
10470 fn respond(response: ___R) -> Self::Output {
10471 response
10472 }
10473 }
10474
10475 pub struct DeprecatedSetAttr;
10476
10477 impl ::fidl_next::Method for DeprecatedSetAttr {
10478 const ORDINAL: u64 = 4721673413776871238;
10479 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10480 ::fidl_next::protocol::Flexibility::Strict;
10481
10482 type Protocol = crate::File;
10483
10484 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
10485 }
10486
10487 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
10488 type Response = crate::wire::NodeDeprecatedSetAttrResponse;
10489 }
10490
10491 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
10492 type Output = crate::generic::NodeDeprecatedSetAttrResponse<___R>;
10493
10494 fn respond(response: ___R) -> Self::Output {
10495 crate::generic::NodeDeprecatedSetAttrResponse { s: response }
10496 }
10497 }
10498
10499 pub struct DeprecatedGetFlags;
10500
10501 impl ::fidl_next::Method for DeprecatedGetFlags {
10502 const ORDINAL: u64 = 6595803110182632097;
10503 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10504 ::fidl_next::protocol::Flexibility::Strict;
10505
10506 type Protocol = crate::File;
10507
10508 type Request = ();
10509 }
10510
10511 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
10512 type Response = crate::wire::NodeDeprecatedGetFlagsResponse;
10513 }
10514
10515 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
10516 type Output = ___R;
10517
10518 fn respond(response: ___R) -> Self::Output {
10519 response
10520 }
10521 }
10522
10523 pub struct DeprecatedSetFlags;
10524
10525 impl ::fidl_next::Method for DeprecatedSetFlags {
10526 const ORDINAL: u64 = 5950864159036794675;
10527 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10528 ::fidl_next::protocol::Flexibility::Strict;
10529
10530 type Protocol = crate::File;
10531
10532 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
10533 }
10534
10535 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
10536 type Response = crate::wire::NodeDeprecatedSetFlagsResponse;
10537 }
10538
10539 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
10540 type Output = crate::generic::NodeDeprecatedSetFlagsResponse<___R>;
10541
10542 fn respond(response: ___R) -> Self::Output {
10543 crate::generic::NodeDeprecatedSetFlagsResponse { s: response }
10544 }
10545 }
10546
10547 pub struct GetFlags;
10548
10549 impl ::fidl_next::Method for GetFlags {
10550 const ORDINAL: u64 = 105530239381466147;
10551 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10552 ::fidl_next::protocol::Flexibility::Flexible;
10553
10554 type Protocol = crate::File;
10555
10556 type Request = ();
10557 }
10558
10559 impl ::fidl_next::TwoWayMethod for GetFlags {
10560 type Response = ::fidl_next::WireFlexibleResult<
10561 'static,
10562 crate::wire::NodeGetFlagsResponse,
10563 ::fidl_next::WireI32,
10564 >;
10565 }
10566
10567 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
10568 type Output = ::fidl_next::FlexibleResult<
10569 crate::generic::NodeGetFlagsResponse<___R>,
10570 ::fidl_next::util::Never,
10571 >;
10572
10573 fn respond(response: ___R) -> Self::Output {
10574 ::fidl_next::FlexibleResult::Ok(crate::generic::NodeGetFlagsResponse {
10575 flags: response,
10576 })
10577 }
10578 }
10579
10580 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
10581 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
10582
10583 fn respond_err(response: ___R) -> Self::Output {
10584 ::fidl_next::FlexibleResult::Err(response)
10585 }
10586 }
10587
10588 pub struct SetFlags;
10589
10590 impl ::fidl_next::Method for SetFlags {
10591 const ORDINAL: u64 = 6172186066099445416;
10592 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10593 ::fidl_next::protocol::Flexibility::Flexible;
10594
10595 type Protocol = crate::File;
10596
10597 type Request = crate::wire::NodeSetFlagsRequest;
10598 }
10599
10600 impl ::fidl_next::TwoWayMethod for SetFlags {
10601 type Response = ::fidl_next::WireFlexibleResult<
10602 'static,
10603 crate::wire::NodeSetFlagsResponse,
10604 ::fidl_next::WireI32,
10605 >;
10606 }
10607
10608 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
10609 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
10610
10611 fn respond(response: ___R) -> Self::Output {
10612 ::fidl_next::FlexibleResult::Ok(response)
10613 }
10614 }
10615
10616 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
10617 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
10618
10619 fn respond_err(response: ___R) -> Self::Output {
10620 ::fidl_next::FlexibleResult::Err(response)
10621 }
10622 }
10623
10624 pub struct QueryFilesystem;
10625
10626 impl ::fidl_next::Method for QueryFilesystem {
10627 const ORDINAL: u64 = 8013111122914313744;
10628 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10629 ::fidl_next::protocol::Flexibility::Strict;
10630
10631 type Protocol = crate::File;
10632
10633 type Request = ();
10634 }
10635
10636 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
10637 type Response = crate::wire::NodeQueryFilesystemResponse<'static>;
10638 }
10639
10640 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
10641 type Output = ___R;
10642
10643 fn respond(response: ___R) -> Self::Output {
10644 response
10645 }
10646 }
10647
10648 pub struct OnRepresentation;
10649
10650 impl ::fidl_next::Method for OnRepresentation {
10651 const ORDINAL: u64 = 6679970090861613324;
10652 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10653 ::fidl_next::protocol::Flexibility::Strict;
10654
10655 type Protocol = crate::File;
10656
10657 type Request = crate::wire::Representation<'static>;
10658 }
10659
10660 pub struct GetAttributes;
10661
10662 impl ::fidl_next::Method for GetAttributes {
10663 const ORDINAL: u64 = 4414537700416816443;
10664 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10665 ::fidl_next::protocol::Flexibility::Strict;
10666
10667 type Protocol = crate::File;
10668
10669 type Request = crate::wire::NodeGetAttributesRequest;
10670 }
10671
10672 impl ::fidl_next::TwoWayMethod for GetAttributes {
10673 type Response = ::fidl_next::WireResult<
10674 'static,
10675 crate::wire::NodeAttributes2<'static>,
10676 ::fidl_next::WireI32,
10677 >;
10678 }
10679
10680 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
10681 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10682
10683 fn respond(response: ___R) -> Self::Output {
10684 ::core::result::Result::Ok(response)
10685 }
10686 }
10687
10688 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
10689 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10690
10691 fn respond_err(response: ___R) -> Self::Output {
10692 ::core::result::Result::Err(response)
10693 }
10694 }
10695
10696 pub struct UpdateAttributes;
10697
10698 impl ::fidl_next::Method for UpdateAttributes {
10699 const ORDINAL: u64 = 3677402239314018056;
10700 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10701 ::fidl_next::protocol::Flexibility::Strict;
10702
10703 type Protocol = crate::File;
10704
10705 type Request = crate::wire::MutableNodeAttributes<'static>;
10706 }
10707
10708 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
10709 type Response = ::fidl_next::WireResult<
10710 'static,
10711 crate::wire::NodeUpdateAttributesResponse,
10712 ::fidl_next::WireI32,
10713 >;
10714 }
10715
10716 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
10717 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10718
10719 fn respond(response: ___R) -> Self::Output {
10720 ::core::result::Result::Ok(response)
10721 }
10722 }
10723
10724 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
10725 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10726
10727 fn respond_err(response: ___R) -> Self::Output {
10728 ::core::result::Result::Err(response)
10729 }
10730 }
10731
10732 pub struct Sync;
10733
10734 impl ::fidl_next::Method for Sync {
10735 const ORDINAL: u64 = 3196473584242777161;
10736 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10737 ::fidl_next::protocol::Flexibility::Strict;
10738
10739 type Protocol = crate::File;
10740
10741 type Request = ();
10742 }
10743
10744 impl ::fidl_next::TwoWayMethod for Sync {
10745 type Response =
10746 ::fidl_next::WireResult<'static, crate::wire::NodeSyncResponse, ::fidl_next::WireI32>;
10747 }
10748
10749 impl<___R> ::fidl_next::Respond<___R> for Sync {
10750 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10751
10752 fn respond(response: ___R) -> Self::Output {
10753 ::core::result::Result::Ok(response)
10754 }
10755 }
10756
10757 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
10758 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10759
10760 fn respond_err(response: ___R) -> Self::Output {
10761 ::core::result::Result::Err(response)
10762 }
10763 }
10764
10765 pub struct ListExtendedAttributes;
10766
10767 impl ::fidl_next::Method for ListExtendedAttributes {
10768 const ORDINAL: u64 = 5431626189872037072;
10769 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10770 ::fidl_next::protocol::Flexibility::Strict;
10771
10772 type Protocol = crate::File;
10773
10774 type Request = crate::wire::NodeListExtendedAttributesRequest;
10775 }
10776
10777 pub struct GetExtendedAttribute;
10778
10779 impl ::fidl_next::Method for GetExtendedAttribute {
10780 const ORDINAL: u64 = 5043930208506967771;
10781 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10782 ::fidl_next::protocol::Flexibility::Strict;
10783
10784 type Protocol = crate::File;
10785
10786 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
10787 }
10788
10789 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
10790 type Response = ::fidl_next::WireResult<
10791 'static,
10792 crate::wire::ExtendedAttributeValue<'static>,
10793 ::fidl_next::WireI32,
10794 >;
10795 }
10796
10797 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
10798 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10799
10800 fn respond(response: ___R) -> Self::Output {
10801 ::core::result::Result::Ok(response)
10802 }
10803 }
10804
10805 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
10806 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10807
10808 fn respond_err(response: ___R) -> Self::Output {
10809 ::core::result::Result::Err(response)
10810 }
10811 }
10812
10813 pub struct SetExtendedAttribute;
10814
10815 impl ::fidl_next::Method for SetExtendedAttribute {
10816 const ORDINAL: u64 = 5374223046099989052;
10817 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10818 ::fidl_next::protocol::Flexibility::Strict;
10819
10820 type Protocol = crate::File;
10821
10822 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
10823 }
10824
10825 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
10826 type Response = ::fidl_next::WireResult<
10827 'static,
10828 crate::wire::NodeSetExtendedAttributeResponse,
10829 ::fidl_next::WireI32,
10830 >;
10831 }
10832
10833 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
10834 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10835
10836 fn respond(response: ___R) -> Self::Output {
10837 ::core::result::Result::Ok(response)
10838 }
10839 }
10840
10841 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
10842 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10843
10844 fn respond_err(response: ___R) -> Self::Output {
10845 ::core::result::Result::Err(response)
10846 }
10847 }
10848
10849 pub struct RemoveExtendedAttribute;
10850
10851 impl ::fidl_next::Method for RemoveExtendedAttribute {
10852 const ORDINAL: u64 = 8794297771444732717;
10853 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10854 ::fidl_next::protocol::Flexibility::Strict;
10855
10856 type Protocol = crate::File;
10857
10858 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
10859 }
10860
10861 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
10862 type Response = ::fidl_next::WireResult<
10863 'static,
10864 crate::wire::NodeRemoveExtendedAttributeResponse,
10865 ::fidl_next::WireI32,
10866 >;
10867 }
10868
10869 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
10870 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10871
10872 fn respond(response: ___R) -> Self::Output {
10873 ::core::result::Result::Ok(response)
10874 }
10875 }
10876
10877 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
10878 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10879
10880 fn respond_err(response: ___R) -> Self::Output {
10881 ::core::result::Result::Err(response)
10882 }
10883 }
10884
10885 pub struct Read;
10886
10887 impl ::fidl_next::Method for Read {
10888 const ORDINAL: u64 = 395825947633028830;
10889 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10890 ::fidl_next::protocol::Flexibility::Strict;
10891
10892 type Protocol = crate::File;
10893
10894 type Request = crate::wire::ReadableReadRequest;
10895 }
10896
10897 impl ::fidl_next::TwoWayMethod for Read {
10898 type Response = ::fidl_next::WireResult<
10899 'static,
10900 crate::wire::ReadableReadResponse<'static>,
10901 ::fidl_next::WireI32,
10902 >;
10903 }
10904
10905 impl<___R> ::fidl_next::Respond<___R> for Read {
10906 type Output = ::core::result::Result<
10907 crate::generic::ReadableReadResponse<___R>,
10908 ::fidl_next::util::Never,
10909 >;
10910
10911 fn respond(response: ___R) -> Self::Output {
10912 ::core::result::Result::Ok(crate::generic::ReadableReadResponse { data: response })
10913 }
10914 }
10915
10916 impl<___R> ::fidl_next::RespondErr<___R> for Read {
10917 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10918
10919 fn respond_err(response: ___R) -> Self::Output {
10920 ::core::result::Result::Err(response)
10921 }
10922 }
10923
10924 pub struct Write;
10925
10926 impl ::fidl_next::Method for Write {
10927 const ORDINAL: u64 = 7651971425397809026;
10928 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10929 ::fidl_next::protocol::Flexibility::Strict;
10930
10931 type Protocol = crate::File;
10932
10933 type Request = crate::wire::WritableWriteRequest<'static>;
10934 }
10935
10936 impl ::fidl_next::TwoWayMethod for Write {
10937 type Response = ::fidl_next::WireResult<
10938 'static,
10939 crate::wire::WritableWriteResponse,
10940 ::fidl_next::WireI32,
10941 >;
10942 }
10943
10944 impl<___R> ::fidl_next::Respond<___R> for Write {
10945 type Output = ::core::result::Result<
10946 crate::generic::WritableWriteResponse<___R>,
10947 ::fidl_next::util::Never,
10948 >;
10949
10950 fn respond(response: ___R) -> Self::Output {
10951 ::core::result::Result::Ok(crate::generic::WritableWriteResponse {
10952 actual_count: response,
10953 })
10954 }
10955 }
10956
10957 impl<___R> ::fidl_next::RespondErr<___R> for Write {
10958 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10959
10960 fn respond_err(response: ___R) -> Self::Output {
10961 ::core::result::Result::Err(response)
10962 }
10963 }
10964
10965 pub struct Describe;
10966
10967 impl ::fidl_next::Method for Describe {
10968 const ORDINAL: u64 = 7545125870053689020;
10969 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10970 ::fidl_next::protocol::Flexibility::Strict;
10971
10972 type Protocol = crate::File;
10973
10974 type Request = ();
10975 }
10976
10977 impl ::fidl_next::TwoWayMethod for Describe {
10978 type Response = crate::wire::FileInfo<'static>;
10979 }
10980
10981 impl<___R> ::fidl_next::Respond<___R> for Describe {
10982 type Output = ___R;
10983
10984 fn respond(response: ___R) -> Self::Output {
10985 response
10986 }
10987 }
10988
10989 pub struct Seek;
10990
10991 impl ::fidl_next::Method for Seek {
10992 const ORDINAL: u64 = 8649041485622956551;
10993 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10994 ::fidl_next::protocol::Flexibility::Strict;
10995
10996 type Protocol = crate::File;
10997
10998 type Request = crate::wire::FileSeekRequest;
10999 }
11000
11001 impl ::fidl_next::TwoWayMethod for Seek {
11002 type Response =
11003 ::fidl_next::WireResult<'static, crate::wire::FileSeekResponse, ::fidl_next::WireI32>;
11004 }
11005
11006 impl<___R> ::fidl_next::Respond<___R> for Seek {
11007 type Output = ::core::result::Result<
11008 crate::generic::FileSeekResponse<___R>,
11009 ::fidl_next::util::Never,
11010 >;
11011
11012 fn respond(response: ___R) -> Self::Output {
11013 ::core::result::Result::Ok(crate::generic::FileSeekResponse {
11014 offset_from_start: response,
11015 })
11016 }
11017 }
11018
11019 impl<___R> ::fidl_next::RespondErr<___R> for Seek {
11020 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
11021
11022 fn respond_err(response: ___R) -> Self::Output {
11023 ::core::result::Result::Err(response)
11024 }
11025 }
11026
11027 pub struct ReadAt;
11028
11029 impl ::fidl_next::Method for ReadAt {
11030 const ORDINAL: u64 = 1587416148701180478;
11031 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11032 ::fidl_next::protocol::Flexibility::Strict;
11033
11034 type Protocol = crate::File;
11035
11036 type Request = crate::wire::FileReadAtRequest;
11037 }
11038
11039 impl ::fidl_next::TwoWayMethod for ReadAt {
11040 type Response = ::fidl_next::WireResult<
11041 'static,
11042 crate::wire::FileReadAtResponse<'static>,
11043 ::fidl_next::WireI32,
11044 >;
11045 }
11046
11047 impl<___R> ::fidl_next::Respond<___R> for ReadAt {
11048 type Output = ::core::result::Result<
11049 crate::generic::FileReadAtResponse<___R>,
11050 ::fidl_next::util::Never,
11051 >;
11052
11053 fn respond(response: ___R) -> Self::Output {
11054 ::core::result::Result::Ok(crate::generic::FileReadAtResponse { data: response })
11055 }
11056 }
11057
11058 impl<___R> ::fidl_next::RespondErr<___R> for ReadAt {
11059 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
11060
11061 fn respond_err(response: ___R) -> Self::Output {
11062 ::core::result::Result::Err(response)
11063 }
11064 }
11065
11066 pub struct WriteAt;
11067
11068 impl ::fidl_next::Method for WriteAt {
11069 const ORDINAL: u64 = 8736683935131400491;
11070 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11071 ::fidl_next::protocol::Flexibility::Strict;
11072
11073 type Protocol = crate::File;
11074
11075 type Request = crate::wire::FileWriteAtRequest<'static>;
11076 }
11077
11078 impl ::fidl_next::TwoWayMethod for WriteAt {
11079 type Response = ::fidl_next::WireResult<
11080 'static,
11081 crate::wire::FileWriteAtResponse,
11082 ::fidl_next::WireI32,
11083 >;
11084 }
11085
11086 impl<___R> ::fidl_next::Respond<___R> for WriteAt {
11087 type Output = ::core::result::Result<
11088 crate::generic::FileWriteAtResponse<___R>,
11089 ::fidl_next::util::Never,
11090 >;
11091
11092 fn respond(response: ___R) -> Self::Output {
11093 ::core::result::Result::Ok(crate::generic::FileWriteAtResponse {
11094 actual_count: response,
11095 })
11096 }
11097 }
11098
11099 impl<___R> ::fidl_next::RespondErr<___R> for WriteAt {
11100 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
11101
11102 fn respond_err(response: ___R) -> Self::Output {
11103 ::core::result::Result::Err(response)
11104 }
11105 }
11106
11107 pub struct Resize;
11108
11109 impl ::fidl_next::Method for Resize {
11110 const ORDINAL: u64 = 3134648685270758458;
11111 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11112 ::fidl_next::protocol::Flexibility::Strict;
11113
11114 type Protocol = crate::File;
11115
11116 type Request = crate::wire::FileResizeRequest;
11117 }
11118
11119 impl ::fidl_next::TwoWayMethod for Resize {
11120 type Response =
11121 ::fidl_next::WireResult<'static, crate::wire::FileResizeResponse, ::fidl_next::WireI32>;
11122 }
11123
11124 impl<___R> ::fidl_next::Respond<___R> for Resize {
11125 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
11126
11127 fn respond(response: ___R) -> Self::Output {
11128 ::core::result::Result::Ok(response)
11129 }
11130 }
11131
11132 impl<___R> ::fidl_next::RespondErr<___R> for Resize {
11133 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
11134
11135 fn respond_err(response: ___R) -> Self::Output {
11136 ::core::result::Result::Err(response)
11137 }
11138 }
11139
11140 pub struct GetBackingMemory;
11141
11142 impl ::fidl_next::Method for GetBackingMemory {
11143 const ORDINAL: u64 = 46911652864194091;
11144 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11145 ::fidl_next::protocol::Flexibility::Strict;
11146
11147 type Protocol = crate::File;
11148
11149 type Request = crate::wire::FileGetBackingMemoryRequest;
11150 }
11151
11152 impl ::fidl_next::TwoWayMethod for GetBackingMemory {
11153 type Response = ::fidl_next::WireResult<
11154 'static,
11155 crate::wire::FileGetBackingMemoryResponse,
11156 ::fidl_next::WireI32,
11157 >;
11158 }
11159
11160 impl<___R> ::fidl_next::Respond<___R> for GetBackingMemory {
11161 type Output = ::core::result::Result<
11162 crate::generic::FileGetBackingMemoryResponse<___R>,
11163 ::fidl_next::util::Never,
11164 >;
11165
11166 fn respond(response: ___R) -> Self::Output {
11167 ::core::result::Result::Ok(crate::generic::FileGetBackingMemoryResponse {
11168 vmo: response,
11169 })
11170 }
11171 }
11172
11173 impl<___R> ::fidl_next::RespondErr<___R> for GetBackingMemory {
11174 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
11175
11176 fn respond_err(response: ___R) -> Self::Output {
11177 ::core::result::Result::Err(response)
11178 }
11179 }
11180
11181 pub struct Allocate;
11182
11183 impl ::fidl_next::Method for Allocate {
11184 const ORDINAL: u64 = 8645235848064269614;
11185 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11186 ::fidl_next::protocol::Flexibility::Flexible;
11187
11188 type Protocol = crate::File;
11189
11190 type Request = crate::wire::FileAllocateRequest;
11191 }
11192
11193 impl ::fidl_next::TwoWayMethod for Allocate {
11194 type Response = ::fidl_next::WireFlexibleResult<
11195 'static,
11196 crate::wire::FileAllocateResponse,
11197 ::fidl_next::WireI32,
11198 >;
11199 }
11200
11201 impl<___R> ::fidl_next::Respond<___R> for Allocate {
11202 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
11203
11204 fn respond(response: ___R) -> Self::Output {
11205 ::fidl_next::FlexibleResult::Ok(response)
11206 }
11207 }
11208
11209 impl<___R> ::fidl_next::RespondErr<___R> for Allocate {
11210 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
11211
11212 fn respond_err(response: ___R) -> Self::Output {
11213 ::fidl_next::FlexibleResult::Err(response)
11214 }
11215 }
11216
11217 pub struct EnableVerity;
11218
11219 impl ::fidl_next::Method for EnableVerity {
11220 const ORDINAL: u64 = 3189145313204943035;
11221 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11222 ::fidl_next::protocol::Flexibility::Flexible;
11223
11224 type Protocol = crate::File;
11225
11226 type Request = crate::wire::FileEnableVerityRequest<'static>;
11227 }
11228
11229 impl ::fidl_next::TwoWayMethod for EnableVerity {
11230 type Response = ::fidl_next::WireFlexibleResult<
11231 'static,
11232 crate::wire::FileEnableVerityResponse,
11233 ::fidl_next::WireI32,
11234 >;
11235 }
11236
11237 impl<___R> ::fidl_next::Respond<___R> for EnableVerity {
11238 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
11239
11240 fn respond(response: ___R) -> Self::Output {
11241 ::fidl_next::FlexibleResult::Ok(response)
11242 }
11243 }
11244
11245 impl<___R> ::fidl_next::RespondErr<___R> for EnableVerity {
11246 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
11247
11248 fn respond_err(response: ___R) -> Self::Output {
11249 ::fidl_next::FlexibleResult::Err(response)
11250 }
11251 }
11252
11253 mod ___detail {
11254 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::File
11255 where
11256 ___T: ::fidl_next::Transport,
11257 {
11258 type Client = FileClient<___T>;
11259 type Server = FileServer<___T>;
11260 }
11261
11262 #[repr(transparent)]
11264 pub struct FileClient<___T: ::fidl_next::Transport> {
11265 #[allow(dead_code)]
11266 client: ::fidl_next::protocol::Client<___T>,
11267 }
11268
11269 impl<___T> FileClient<___T>
11270 where
11271 ___T: ::fidl_next::Transport,
11272 {
11273 #[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"]
11274 pub fn advisory_lock(
11275 &self,
11276
11277 request: impl ::fidl_next::Encode<
11278 crate::wire::AdvisoryLockRequest<'static>,
11279 <___T as ::fidl_next::Transport>::SendBuffer,
11280 >,
11281 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
11282 where
11283 <___T as ::fidl_next::Transport>::SendBuffer:
11284 ::fidl_next::encoder::InternalHandleEncoder,
11285 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11286 {
11287 self.advisory_lock_with(crate::generic::AdvisoryLockingAdvisoryLockRequest {
11288 request,
11289 })
11290 }
11291
11292 #[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"]
11293 pub fn advisory_lock_with<___R>(
11294 &self,
11295 request: ___R,
11296 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
11297 where
11298 ___R: ::fidl_next::Encode<
11299 crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
11300 <___T as ::fidl_next::Transport>::SendBuffer,
11301 >,
11302 {
11303 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11304 7992130864415541162,
11305 <super::AdvisoryLock as ::fidl_next::Method>::FLEXIBILITY,
11306 request,
11307 ))
11308 }
11309
11310 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
11311 pub fn link_into(
11312 &self,
11313
11314 dst_parent_token: impl ::fidl_next::Encode<
11315 ::fidl_next::fuchsia::WireEvent,
11316 <___T as ::fidl_next::Transport>::SendBuffer,
11317 >,
11318
11319 dst: impl ::fidl_next::Encode<
11320 ::fidl_next::WireString<'static>,
11321 <___T as ::fidl_next::Transport>::SendBuffer,
11322 >,
11323 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
11324 where
11325 <___T as ::fidl_next::Transport>::SendBuffer:
11326 ::fidl_next::encoder::InternalHandleEncoder,
11327 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11328 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11329 {
11330 self.link_into_with(crate::generic::LinkableLinkIntoRequest {
11331 dst_parent_token,
11332
11333 dst,
11334 })
11335 }
11336
11337 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
11338 pub fn link_into_with<___R>(
11339 &self,
11340 request: ___R,
11341 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
11342 where
11343 ___R: ::fidl_next::Encode<
11344 crate::wire::LinkableLinkIntoRequest<'static>,
11345 <___T as ::fidl_next::Transport>::SendBuffer,
11346 >,
11347 {
11348 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11349 6121399674497678964,
11350 <super::LinkInto as ::fidl_next::Method>::FLEXIBILITY,
11351 request,
11352 ))
11353 }
11354
11355 pub fn clone(
11356 &self,
11357
11358 request: impl ::fidl_next::Encode<
11359 ::fidl_next::ServerEnd<
11360 ::fidl_next_fuchsia_unknown::Cloneable,
11361 ::fidl_next::fuchsia::WireChannel,
11362 >,
11363 <___T as ::fidl_next::Transport>::SendBuffer,
11364 >,
11365 ) -> ::fidl_next::SendFuture<'_, ___T>
11366 where
11367 <___T as ::fidl_next::Transport>::SendBuffer:
11368 ::fidl_next::encoder::InternalHandleEncoder,
11369 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11370 {
11371 self.clone_with(::fidl_next_fuchsia_unknown::generic::CloneableCloneRequest {
11372 request,
11373 })
11374 }
11375
11376 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
11377 where
11378 ___R: ::fidl_next::Encode<
11379 ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest,
11380 <___T as ::fidl_next::Transport>::SendBuffer,
11381 >,
11382 {
11383 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
11384 2366825959783828089,
11385 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
11386 request,
11387 ))
11388 }
11389
11390 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
11391 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
11392 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11393 6540867515453498750,
11394 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
11395 (),
11396 ))
11397 }
11398
11399 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
11400 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11401 2763219980499352582,
11402 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
11403 (),
11404 ))
11405 }
11406
11407 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
11408 pub fn deprecated_clone(
11409 &self,
11410
11411 flags: impl ::fidl_next::Encode<
11412 crate::wire::OpenFlags,
11413 <___T as ::fidl_next::Transport>::SendBuffer,
11414 >,
11415
11416 object: impl ::fidl_next::Encode<
11417 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
11418 <___T as ::fidl_next::Transport>::SendBuffer,
11419 >,
11420 ) -> ::fidl_next::SendFuture<'_, ___T>
11421 where
11422 <___T as ::fidl_next::Transport>::SendBuffer:
11423 ::fidl_next::encoder::InternalHandleEncoder,
11424 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11425 {
11426 self.deprecated_clone_with(crate::generic::NodeDeprecatedCloneRequest {
11427 flags,
11428
11429 object,
11430 })
11431 }
11432
11433 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
11434 pub fn deprecated_clone_with<___R>(
11435 &self,
11436 request: ___R,
11437 ) -> ::fidl_next::SendFuture<'_, ___T>
11438 where
11439 ___R: ::fidl_next::Encode<
11440 crate::wire::NodeDeprecatedCloneRequest,
11441 <___T as ::fidl_next::Transport>::SendBuffer,
11442 >,
11443 {
11444 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
11445 6512600400724287855,
11446 <super::DeprecatedClone as ::fidl_next::Method>::FLEXIBILITY,
11447 request,
11448 ))
11449 }
11450
11451 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
11452 pub fn deprecated_get_attr(
11453 &self,
11454 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
11455 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11456 8689798978500614909,
11457 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
11458 (),
11459 ))
11460 }
11461
11462 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
11463 pub fn deprecated_set_attr(
11464 &self,
11465
11466 flags: impl ::fidl_next::Encode<
11467 crate::wire::NodeAttributeFlags,
11468 <___T as ::fidl_next::Transport>::SendBuffer,
11469 >,
11470
11471 attributes: impl ::fidl_next::Encode<
11472 crate::wire::NodeAttributes,
11473 <___T as ::fidl_next::Transport>::SendBuffer,
11474 >,
11475 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
11476 where
11477 <___T as ::fidl_next::Transport>::SendBuffer:
11478 ::fidl_next::encoder::InternalHandleEncoder,
11479 {
11480 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
11481 flags,
11482
11483 attributes,
11484 })
11485 }
11486
11487 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
11488 pub fn deprecated_set_attr_with<___R>(
11489 &self,
11490 request: ___R,
11491 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
11492 where
11493 ___R: ::fidl_next::Encode<
11494 crate::wire::NodeDeprecatedSetAttrRequest,
11495 <___T as ::fidl_next::Transport>::SendBuffer,
11496 >,
11497 {
11498 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11499 4721673413776871238,
11500 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
11501 request,
11502 ))
11503 }
11504
11505 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
11506 pub fn deprecated_get_flags(
11507 &self,
11508 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
11509 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11510 6595803110182632097,
11511 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
11512 (),
11513 ))
11514 }
11515
11516 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
11517 pub fn deprecated_set_flags(
11518 &self,
11519
11520 flags: impl ::fidl_next::Encode<
11521 crate::wire::OpenFlags,
11522 <___T as ::fidl_next::Transport>::SendBuffer,
11523 >,
11524 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
11525 where
11526 <___T as ::fidl_next::Transport>::SendBuffer:
11527 ::fidl_next::encoder::InternalHandleEncoder,
11528 {
11529 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
11530 flags,
11531 })
11532 }
11533
11534 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
11535 pub fn deprecated_set_flags_with<___R>(
11536 &self,
11537 request: ___R,
11538 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
11539 where
11540 ___R: ::fidl_next::Encode<
11541 crate::wire::NodeDeprecatedSetFlagsRequest,
11542 <___T as ::fidl_next::Transport>::SendBuffer,
11543 >,
11544 {
11545 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11546 5950864159036794675,
11547 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
11548 request,
11549 ))
11550 }
11551
11552 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
11553 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
11554 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11555 105530239381466147,
11556 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
11557 (),
11558 ))
11559 }
11560
11561 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
11562 pub fn set_flags(
11563 &self,
11564
11565 flags: impl ::fidl_next::Encode<
11566 crate::wire::Flags,
11567 <___T as ::fidl_next::Transport>::SendBuffer,
11568 >,
11569 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
11570 where
11571 <___T as ::fidl_next::Transport>::SendBuffer:
11572 ::fidl_next::encoder::InternalHandleEncoder,
11573 {
11574 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
11575 }
11576
11577 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
11578 pub fn set_flags_with<___R>(
11579 &self,
11580 request: ___R,
11581 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
11582 where
11583 ___R: ::fidl_next::Encode<
11584 crate::wire::NodeSetFlagsRequest,
11585 <___T as ::fidl_next::Transport>::SendBuffer,
11586 >,
11587 {
11588 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11589 6172186066099445416,
11590 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
11591 request,
11592 ))
11593 }
11594
11595 #[doc = " Query the filesystem for filesystem-specific information.\n"]
11596 pub fn query_filesystem(
11597 &self,
11598 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
11599 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11600 8013111122914313744,
11601 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
11602 (),
11603 ))
11604 }
11605
11606 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
11607 pub fn get_attributes(
11608 &self,
11609
11610 query: impl ::fidl_next::Encode<
11611 crate::wire::NodeAttributesQuery,
11612 <___T as ::fidl_next::Transport>::SendBuffer,
11613 >,
11614 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
11615 where
11616 <___T as ::fidl_next::Transport>::SendBuffer:
11617 ::fidl_next::encoder::InternalHandleEncoder,
11618 {
11619 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
11620 }
11621
11622 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
11623 pub fn get_attributes_with<___R>(
11624 &self,
11625 request: ___R,
11626 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
11627 where
11628 ___R: ::fidl_next::Encode<
11629 crate::wire::NodeGetAttributesRequest,
11630 <___T as ::fidl_next::Transport>::SendBuffer,
11631 >,
11632 {
11633 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11634 4414537700416816443,
11635 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
11636 request,
11637 ))
11638 }
11639
11640 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
11641 pub fn update_attributes_with<___R>(
11642 &self,
11643 request: ___R,
11644 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
11645 where
11646 ___R: ::fidl_next::Encode<
11647 crate::wire::MutableNodeAttributes<'static>,
11648 <___T as ::fidl_next::Transport>::SendBuffer,
11649 >,
11650 {
11651 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11652 3677402239314018056,
11653 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
11654 request,
11655 ))
11656 }
11657
11658 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
11659 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
11660 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11661 3196473584242777161,
11662 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
11663 (),
11664 ))
11665 }
11666
11667 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
11668 pub fn list_extended_attributes(
11669 &self,
11670
11671 iterator: impl ::fidl_next::Encode<
11672 ::fidl_next::ServerEnd<
11673 crate::ExtendedAttributeIterator,
11674 ::fidl_next::fuchsia::WireChannel,
11675 >,
11676 <___T as ::fidl_next::Transport>::SendBuffer,
11677 >,
11678 ) -> ::fidl_next::SendFuture<'_, ___T>
11679 where
11680 <___T as ::fidl_next::Transport>::SendBuffer:
11681 ::fidl_next::encoder::InternalHandleEncoder,
11682 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11683 {
11684 self.list_extended_attributes_with(
11685 crate::generic::NodeListExtendedAttributesRequest { iterator },
11686 )
11687 }
11688
11689 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
11690 pub fn list_extended_attributes_with<___R>(
11691 &self,
11692 request: ___R,
11693 ) -> ::fidl_next::SendFuture<'_, ___T>
11694 where
11695 ___R: ::fidl_next::Encode<
11696 crate::wire::NodeListExtendedAttributesRequest,
11697 <___T as ::fidl_next::Transport>::SendBuffer,
11698 >,
11699 {
11700 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
11701 5431626189872037072,
11702 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
11703 request,
11704 ))
11705 }
11706
11707 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
11708 pub fn get_extended_attribute(
11709 &self,
11710
11711 name: impl ::fidl_next::Encode<
11712 ::fidl_next::WireVector<'static, u8>,
11713 <___T as ::fidl_next::Transport>::SendBuffer,
11714 >,
11715 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
11716 where
11717 <___T as ::fidl_next::Transport>::SendBuffer:
11718 ::fidl_next::encoder::InternalHandleEncoder,
11719 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11720 {
11721 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
11722 name,
11723 })
11724 }
11725
11726 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
11727 pub fn get_extended_attribute_with<___R>(
11728 &self,
11729 request: ___R,
11730 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
11731 where
11732 ___R: ::fidl_next::Encode<
11733 crate::wire::NodeGetExtendedAttributeRequest<'static>,
11734 <___T as ::fidl_next::Transport>::SendBuffer,
11735 >,
11736 {
11737 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11738 5043930208506967771,
11739 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
11740 request,
11741 ))
11742 }
11743
11744 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
11745 pub fn set_extended_attribute(
11746 &self,
11747
11748 name: impl ::fidl_next::Encode<
11749 ::fidl_next::WireVector<'static, u8>,
11750 <___T as ::fidl_next::Transport>::SendBuffer,
11751 >,
11752
11753 value: impl ::fidl_next::Encode<
11754 crate::wire::ExtendedAttributeValue<'static>,
11755 <___T as ::fidl_next::Transport>::SendBuffer,
11756 >,
11757
11758 mode: impl ::fidl_next::Encode<
11759 crate::wire::SetExtendedAttributeMode,
11760 <___T as ::fidl_next::Transport>::SendBuffer,
11761 >,
11762 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
11763 where
11764 <___T as ::fidl_next::Transport>::SendBuffer:
11765 ::fidl_next::encoder::InternalHandleEncoder,
11766 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11767 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11768 {
11769 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
11770 name,
11771
11772 value,
11773
11774 mode,
11775 })
11776 }
11777
11778 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
11779 pub fn set_extended_attribute_with<___R>(
11780 &self,
11781 request: ___R,
11782 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
11783 where
11784 ___R: ::fidl_next::Encode<
11785 crate::wire::NodeSetExtendedAttributeRequest<'static>,
11786 <___T as ::fidl_next::Transport>::SendBuffer,
11787 >,
11788 {
11789 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11790 5374223046099989052,
11791 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
11792 request,
11793 ))
11794 }
11795
11796 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
11797 pub fn remove_extended_attribute(
11798 &self,
11799
11800 name: impl ::fidl_next::Encode<
11801 ::fidl_next::WireVector<'static, u8>,
11802 <___T as ::fidl_next::Transport>::SendBuffer,
11803 >,
11804 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
11805 where
11806 <___T as ::fidl_next::Transport>::SendBuffer:
11807 ::fidl_next::encoder::InternalHandleEncoder,
11808 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11809 {
11810 self.remove_extended_attribute_with(
11811 crate::generic::NodeRemoveExtendedAttributeRequest { name },
11812 )
11813 }
11814
11815 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
11816 pub fn remove_extended_attribute_with<___R>(
11817 &self,
11818 request: ___R,
11819 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
11820 where
11821 ___R: ::fidl_next::Encode<
11822 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
11823 <___T as ::fidl_next::Transport>::SendBuffer,
11824 >,
11825 {
11826 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11827 8794297771444732717,
11828 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
11829 request,
11830 ))
11831 }
11832
11833 #[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"]
11834 pub fn read(
11835 &self,
11836
11837 count: impl ::fidl_next::Encode<
11838 ::fidl_next::WireU64,
11839 <___T as ::fidl_next::Transport>::SendBuffer,
11840 >,
11841 ) -> ::fidl_next::TwoWayFuture<'_, super::Read, ___T>
11842 where
11843 <___T as ::fidl_next::Transport>::SendBuffer:
11844 ::fidl_next::encoder::InternalHandleEncoder,
11845 {
11846 self.read_with(crate::generic::ReadableReadRequest { count })
11847 }
11848
11849 #[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"]
11850 pub fn read_with<___R>(
11851 &self,
11852 request: ___R,
11853 ) -> ::fidl_next::TwoWayFuture<'_, super::Read, ___T>
11854 where
11855 ___R: ::fidl_next::Encode<
11856 crate::wire::ReadableReadRequest,
11857 <___T as ::fidl_next::Transport>::SendBuffer,
11858 >,
11859 {
11860 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11861 395825947633028830,
11862 <super::Read as ::fidl_next::Method>::FLEXIBILITY,
11863 request,
11864 ))
11865 }
11866
11867 #[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"]
11868 pub fn write(
11869 &self,
11870
11871 data: impl ::fidl_next::Encode<
11872 ::fidl_next::WireVector<'static, u8>,
11873 <___T as ::fidl_next::Transport>::SendBuffer,
11874 >,
11875 ) -> ::fidl_next::TwoWayFuture<'_, super::Write, ___T>
11876 where
11877 <___T as ::fidl_next::Transport>::SendBuffer:
11878 ::fidl_next::encoder::InternalHandleEncoder,
11879 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11880 {
11881 self.write_with(crate::generic::WritableWriteRequest { data })
11882 }
11883
11884 #[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"]
11885 pub fn write_with<___R>(
11886 &self,
11887 request: ___R,
11888 ) -> ::fidl_next::TwoWayFuture<'_, super::Write, ___T>
11889 where
11890 ___R: ::fidl_next::Encode<
11891 crate::wire::WritableWriteRequest<'static>,
11892 <___T as ::fidl_next::Transport>::SendBuffer,
11893 >,
11894 {
11895 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11896 7651971425397809026,
11897 <super::Write as ::fidl_next::Method>::FLEXIBILITY,
11898 request,
11899 ))
11900 }
11901
11902 pub fn describe(&self) -> ::fidl_next::TwoWayFuture<'_, super::Describe, ___T> {
11903 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11904 7545125870053689020,
11905 <super::Describe as ::fidl_next::Method>::FLEXIBILITY,
11906 (),
11907 ))
11908 }
11909
11910 #[doc = " Moves the offset at which the next invocation of [`Read`] or [`Write`]\n will occur. The seek offset is specific to each file connection.\n\n + request `origin` the reference point where `offset` will be based on.\n + request `offset` the number of bytes to seek.\n - response `offset_from_start` the adjusted seek offset, from the start\n of the file.\n\n This method does not require any rights.\n"]
11911 pub fn seek(
11912 &self,
11913
11914 origin: impl ::fidl_next::Encode<
11915 crate::wire::SeekOrigin,
11916 <___T as ::fidl_next::Transport>::SendBuffer,
11917 >,
11918
11919 offset: impl ::fidl_next::Encode<
11920 ::fidl_next::WireI64,
11921 <___T as ::fidl_next::Transport>::SendBuffer,
11922 >,
11923 ) -> ::fidl_next::TwoWayFuture<'_, super::Seek, ___T>
11924 where
11925 <___T as ::fidl_next::Transport>::SendBuffer:
11926 ::fidl_next::encoder::InternalHandleEncoder,
11927 {
11928 self.seek_with(crate::generic::FileSeekRequest { origin, offset })
11929 }
11930
11931 #[doc = " Moves the offset at which the next invocation of [`Read`] or [`Write`]\n will occur. The seek offset is specific to each file connection.\n\n + request `origin` the reference point where `offset` will be based on.\n + request `offset` the number of bytes to seek.\n - response `offset_from_start` the adjusted seek offset, from the start\n of the file.\n\n This method does not require any rights.\n"]
11932 pub fn seek_with<___R>(
11933 &self,
11934 request: ___R,
11935 ) -> ::fidl_next::TwoWayFuture<'_, super::Seek, ___T>
11936 where
11937 ___R: ::fidl_next::Encode<
11938 crate::wire::FileSeekRequest,
11939 <___T as ::fidl_next::Transport>::SendBuffer,
11940 >,
11941 {
11942 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11943 8649041485622956551,
11944 <super::Seek as ::fidl_next::Method>::FLEXIBILITY,
11945 request,
11946 ))
11947 }
11948
11949 #[doc = " Reads up to \'count\' bytes at the provided offset.\n Does not affect the seek offset.\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 `ReadAt` has hit\n the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that `offset`\n is at or past the end of file, and no data can be read.\n * If `count` is zero, the server should perform all the checks ensuring\n read access without actually reading 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"]
11950 pub fn read_at(
11951 &self,
11952
11953 count: impl ::fidl_next::Encode<
11954 ::fidl_next::WireU64,
11955 <___T as ::fidl_next::Transport>::SendBuffer,
11956 >,
11957
11958 offset: impl ::fidl_next::Encode<
11959 ::fidl_next::WireU64,
11960 <___T as ::fidl_next::Transport>::SendBuffer,
11961 >,
11962 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadAt, ___T>
11963 where
11964 <___T as ::fidl_next::Transport>::SendBuffer:
11965 ::fidl_next::encoder::InternalHandleEncoder,
11966 {
11967 self.read_at_with(crate::generic::FileReadAtRequest { count, offset })
11968 }
11969
11970 #[doc = " Reads up to \'count\' bytes at the provided offset.\n Does not affect the seek offset.\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 `ReadAt` has hit\n the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that `offset`\n is at or past the end of file, and no data can be read.\n * If `count` is zero, the server should perform all the checks ensuring\n read access without actually reading 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"]
11971 pub fn read_at_with<___R>(
11972 &self,
11973 request: ___R,
11974 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadAt, ___T>
11975 where
11976 ___R: ::fidl_next::Encode<
11977 crate::wire::FileReadAtRequest,
11978 <___T as ::fidl_next::Transport>::SendBuffer,
11979 >,
11980 {
11981 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11982 1587416148701180478,
11983 <super::ReadAt as ::fidl_next::Method>::FLEXIBILITY,
11984 request,
11985 ))
11986 }
11987
11988 #[doc = " Writes data at the provided offset.\n Does not affect the seek offset.\n\n The file size may grow if `offset` plus `data.length` is past the\n current end of file.\n\n + request `data` the byte buffer to write to the file.\n + request `offset` the offset from start of the file to begin writing.\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 will return a\n successful write of zero bytes.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
11989 pub fn write_at(
11990 &self,
11991
11992 data: impl ::fidl_next::Encode<
11993 ::fidl_next::WireVector<'static, u8>,
11994 <___T as ::fidl_next::Transport>::SendBuffer,
11995 >,
11996
11997 offset: impl ::fidl_next::Encode<
11998 ::fidl_next::WireU64,
11999 <___T as ::fidl_next::Transport>::SendBuffer,
12000 >,
12001 ) -> ::fidl_next::TwoWayFuture<'_, super::WriteAt, ___T>
12002 where
12003 <___T as ::fidl_next::Transport>::SendBuffer:
12004 ::fidl_next::encoder::InternalHandleEncoder,
12005 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
12006 {
12007 self.write_at_with(crate::generic::FileWriteAtRequest { data, offset })
12008 }
12009
12010 #[doc = " Writes data at the provided offset.\n Does not affect the seek offset.\n\n The file size may grow if `offset` plus `data.length` is past the\n current end of file.\n\n + request `data` the byte buffer to write to the file.\n + request `offset` the offset from start of the file to begin writing.\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 will return a\n successful write of zero bytes.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
12011 pub fn write_at_with<___R>(
12012 &self,
12013 request: ___R,
12014 ) -> ::fidl_next::TwoWayFuture<'_, super::WriteAt, ___T>
12015 where
12016 ___R: ::fidl_next::Encode<
12017 crate::wire::FileWriteAtRequest<'static>,
12018 <___T as ::fidl_next::Transport>::SendBuffer,
12019 >,
12020 {
12021 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12022 8736683935131400491,
12023 <super::WriteAt as ::fidl_next::Method>::FLEXIBILITY,
12024 request,
12025 ))
12026 }
12027
12028 #[doc = " Shrinks or grows the file size to \'length\' bytes.\n\n If file size is reduced by this operation, the extra trailing data\'\n is discarded.\n If file size is increased by this operation, the extended area appears\n as if it was zeroed.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
12029 pub fn resize(
12030 &self,
12031
12032 length: impl ::fidl_next::Encode<
12033 ::fidl_next::WireU64,
12034 <___T as ::fidl_next::Transport>::SendBuffer,
12035 >,
12036 ) -> ::fidl_next::TwoWayFuture<'_, super::Resize, ___T>
12037 where
12038 <___T as ::fidl_next::Transport>::SendBuffer:
12039 ::fidl_next::encoder::InternalHandleEncoder,
12040 {
12041 self.resize_with(crate::generic::FileResizeRequest { length })
12042 }
12043
12044 #[doc = " Shrinks or grows the file size to \'length\' bytes.\n\n If file size is reduced by this operation, the extra trailing data\'\n is discarded.\n If file size is increased by this operation, the extended area appears\n as if it was zeroed.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
12045 pub fn resize_with<___R>(
12046 &self,
12047 request: ___R,
12048 ) -> ::fidl_next::TwoWayFuture<'_, super::Resize, ___T>
12049 where
12050 ___R: ::fidl_next::Encode<
12051 crate::wire::FileResizeRequest,
12052 <___T as ::fidl_next::Transport>::SendBuffer,
12053 >,
12054 {
12055 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12056 3134648685270758458,
12057 <super::Resize as ::fidl_next::Method>::FLEXIBILITY,
12058 request,
12059 ))
12060 }
12061
12062 #[doc = " Acquires a [`zx.Handle:VMO`] representing this file, if there is one,\n with the requested access rights.\n\n Implementations are not required to implement files backed by VMOs so\n this request may fail. Additionally, implementations may only support\n a certain subset of the flags. Clients should be prepared with fallback\n behavior if this request fails.\n\n If a client specifies neither `PRIVATE_CLONE` nor `SHARED_BUFFER`, the\n implementation is free to choose the semantics of the returned VMO.\n\n + request `flags` a [`VmoFlags`] indicating the desired mode of access.\n - response `vmo` the requested [`zx.Handle:VMO`].\n * error a [`zx.Status`] value indicating the failure.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].\n * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].\n * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].\n"]
12063 pub fn get_backing_memory(
12064 &self,
12065
12066 flags: impl ::fidl_next::Encode<
12067 crate::wire::VmoFlags,
12068 <___T as ::fidl_next::Transport>::SendBuffer,
12069 >,
12070 ) -> ::fidl_next::TwoWayFuture<'_, super::GetBackingMemory, ___T>
12071 where
12072 <___T as ::fidl_next::Transport>::SendBuffer:
12073 ::fidl_next::encoder::InternalHandleEncoder,
12074 {
12075 self.get_backing_memory_with(crate::generic::FileGetBackingMemoryRequest { flags })
12076 }
12077
12078 #[doc = " Acquires a [`zx.Handle:VMO`] representing this file, if there is one,\n with the requested access rights.\n\n Implementations are not required to implement files backed by VMOs so\n this request may fail. Additionally, implementations may only support\n a certain subset of the flags. Clients should be prepared with fallback\n behavior if this request fails.\n\n If a client specifies neither `PRIVATE_CLONE` nor `SHARED_BUFFER`, the\n implementation is free to choose the semantics of the returned VMO.\n\n + request `flags` a [`VmoFlags`] indicating the desired mode of access.\n - response `vmo` the requested [`zx.Handle:VMO`].\n * error a [`zx.Status`] value indicating the failure.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].\n * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].\n * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].\n"]
12079 pub fn get_backing_memory_with<___R>(
12080 &self,
12081 request: ___R,
12082 ) -> ::fidl_next::TwoWayFuture<'_, super::GetBackingMemory, ___T>
12083 where
12084 ___R: ::fidl_next::Encode<
12085 crate::wire::FileGetBackingMemoryRequest,
12086 <___T as ::fidl_next::Transport>::SendBuffer,
12087 >,
12088 {
12089 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12090 46911652864194091,
12091 <super::GetBackingMemory as ::fidl_next::Method>::FLEXIBILITY,
12092 request,
12093 ))
12094 }
12095
12096 #[doc = " Pre-allocate on-disk space for this file.\n"]
12097 pub fn allocate(
12098 &self,
12099
12100 offset: impl ::fidl_next::Encode<
12101 ::fidl_next::WireU64,
12102 <___T as ::fidl_next::Transport>::SendBuffer,
12103 >,
12104
12105 length: impl ::fidl_next::Encode<
12106 ::fidl_next::WireU64,
12107 <___T as ::fidl_next::Transport>::SendBuffer,
12108 >,
12109
12110 mode: impl ::fidl_next::Encode<
12111 crate::wire::AllocateMode,
12112 <___T as ::fidl_next::Transport>::SendBuffer,
12113 >,
12114 ) -> ::fidl_next::TwoWayFuture<'_, super::Allocate, ___T>
12115 where
12116 <___T as ::fidl_next::Transport>::SendBuffer:
12117 ::fidl_next::encoder::InternalHandleEncoder,
12118 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
12119 {
12120 self.allocate_with(crate::generic::FileAllocateRequest { offset, length, mode })
12121 }
12122
12123 #[doc = " Pre-allocate on-disk space for this file.\n"]
12124 pub fn allocate_with<___R>(
12125 &self,
12126 request: ___R,
12127 ) -> ::fidl_next::TwoWayFuture<'_, super::Allocate, ___T>
12128 where
12129 ___R: ::fidl_next::Encode<
12130 crate::wire::FileAllocateRequest,
12131 <___T as ::fidl_next::Transport>::SendBuffer,
12132 >,
12133 {
12134 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12135 8645235848064269614,
12136 <super::Allocate as ::fidl_next::Method>::FLEXIBILITY,
12137 request,
12138 ))
12139 }
12140
12141 #[doc = " Enables verification for the file (permanently) which involves computing a merkle tree for\n the file. Forces a flush prior to building the merkle tree to ensure cached data is\n captured. Future reads will be verified against the computed merkle tree and writes will be\n rejected. This method can take some time to complete as it depends on the size of the file.\n This method can be aborted by closing the connection that this method was issued on.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n Returns `ZX_ERR_NOT_SUPPORTED` if the filesystem does not support verity.\n Returns `ZX_ERR_ALREADY_EXISTS` if the file was already fsverity-enabled.\n Also returns any error that might arise from reading the file, or from flushing the file,\n such as `ZX_ERR_IO`.\n"]
12142 pub fn enable_verity(
12143 &self,
12144
12145 options: impl ::fidl_next::Encode<
12146 crate::wire::VerificationOptions<'static>,
12147 <___T as ::fidl_next::Transport>::SendBuffer,
12148 >,
12149 ) -> ::fidl_next::TwoWayFuture<'_, super::EnableVerity, ___T>
12150 where
12151 <___T as ::fidl_next::Transport>::SendBuffer:
12152 ::fidl_next::encoder::InternalHandleEncoder,
12153 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
12154 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
12155 {
12156 self.enable_verity_with(crate::generic::FileEnableVerityRequest { options })
12157 }
12158
12159 #[doc = " Enables verification for the file (permanently) which involves computing a merkle tree for\n the file. Forces a flush prior to building the merkle tree to ensure cached data is\n captured. Future reads will be verified against the computed merkle tree and writes will be\n rejected. This method can take some time to complete as it depends on the size of the file.\n This method can be aborted by closing the connection that this method was issued on.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n Returns `ZX_ERR_NOT_SUPPORTED` if the filesystem does not support verity.\n Returns `ZX_ERR_ALREADY_EXISTS` if the file was already fsverity-enabled.\n Also returns any error that might arise from reading the file, or from flushing the file,\n such as `ZX_ERR_IO`.\n"]
12160 pub fn enable_verity_with<___R>(
12161 &self,
12162 request: ___R,
12163 ) -> ::fidl_next::TwoWayFuture<'_, super::EnableVerity, ___T>
12164 where
12165 ___R: ::fidl_next::Encode<
12166 crate::wire::FileEnableVerityRequest<'static>,
12167 <___T as ::fidl_next::Transport>::SendBuffer,
12168 >,
12169 {
12170 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12171 3189145313204943035,
12172 <super::EnableVerity as ::fidl_next::Method>::FLEXIBILITY,
12173 request,
12174 ))
12175 }
12176 }
12177
12178 #[repr(transparent)]
12180 pub struct FileServer<___T: ::fidl_next::Transport> {
12181 server: ::fidl_next::protocol::Server<___T>,
12182 }
12183
12184 impl<___T> FileServer<___T>
12185 where
12186 ___T: ::fidl_next::Transport,
12187 {
12188 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
12189 pub fn on_open(
12190 &self,
12191
12192 s: impl ::fidl_next::Encode<
12193 ::fidl_next::WireI32,
12194 <___T as ::fidl_next::Transport>::SendBuffer,
12195 >,
12196
12197 info: impl ::fidl_next::Encode<
12198 crate::wire_optional::NodeInfoDeprecated<'static>,
12199 <___T as ::fidl_next::Transport>::SendBuffer,
12200 >,
12201 ) -> ::fidl_next::SendFuture<'_, ___T>
12202 where
12203 <___T as ::fidl_next::Transport>::SendBuffer:
12204 ::fidl_next::encoder::InternalHandleEncoder,
12205 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
12206 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
12207 {
12208 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
12209 }
12210
12211 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
12212
12213 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
12214 where
12215 ___R: ::fidl_next::Encode<
12216 <super::OnOpen as ::fidl_next::Method>::Request,
12217 <___T as ::fidl_next::Transport>::SendBuffer,
12218 >,
12219 {
12220 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
12221 9207534335756671346,
12222 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
12223 request,
12224 ))
12225 }
12226
12227 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
12228
12229 pub fn on_representation_with<___R>(
12230 &self,
12231 request: ___R,
12232 ) -> ::fidl_next::SendFuture<'_, ___T>
12233 where
12234 ___R: ::fidl_next::Encode<
12235 <super::OnRepresentation as ::fidl_next::Method>::Request,
12236 <___T as ::fidl_next::Transport>::SendBuffer,
12237 >,
12238 {
12239 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
12240 6679970090861613324,
12241 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
12242 request,
12243 ))
12244 }
12245 }
12246 }
12247}
12248
12249pub trait FileClientHandler<
12253 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12254 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12255>
12256{
12257 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
12258 fn on_open(
12259 &mut self,
12260
12261 request: ::fidl_next::Request<file::OnOpen, ___T>,
12262 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12263
12264 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
12265 fn on_representation(
12266 &mut self,
12267
12268 request: ::fidl_next::Request<file::OnRepresentation, ___T>,
12269 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12270
12271 fn on_unknown_interaction(
12272 &mut self,
12273 ordinal: u64,
12274 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12275 ::core::future::ready(())
12276 }
12277}
12278
12279impl<___T> FileClientHandler<___T> for ::fidl_next::IgnoreEvents
12280where
12281 ___T: ::fidl_next::Transport,
12282{
12283 async fn on_open(&mut self, _: ::fidl_next::Request<file::OnOpen, ___T>) {}
12284
12285 async fn on_representation(&mut self, _: ::fidl_next::Request<file::OnRepresentation, ___T>) {}
12286
12287 async fn on_unknown_interaction(&mut self, _: u64) {}
12288}
12289
12290impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for File
12291where
12292 ___H: FileClientHandler<___T> + ::core::marker::Send,
12293 ___T: ::fidl_next::Transport,
12294 <file::OnOpen as ::fidl_next::Method>::Request:
12295 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12296 <file::OnRepresentation as ::fidl_next::Method>::Request:
12297 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12298{
12299 async fn on_event(
12300 handler: &mut ___H,
12301 ordinal: u64,
12302 flexibility: ::fidl_next::protocol::Flexibility,
12303 buffer: ___T::RecvBuffer,
12304 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12305 match ordinal {
12306 9207534335756671346 => match ::fidl_next::DecoderExt::decode(buffer) {
12307 Ok(decoded) => {
12308 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
12309 Ok(())
12310 }
12311 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12312 ordinal: 9207534335756671346,
12313 error,
12314 }),
12315 },
12316
12317 6679970090861613324 => match ::fidl_next::DecoderExt::decode(buffer) {
12318 Ok(decoded) => {
12319 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
12320 Ok(())
12321 }
12322 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12323 ordinal: 6679970090861613324,
12324 error,
12325 }),
12326 },
12327
12328 ordinal => {
12329 handler.on_unknown_interaction(ordinal).await;
12330 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12331 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12332 } else {
12333 Ok(())
12334 }
12335 }
12336 }
12337 }
12338}
12339
12340pub trait FileServerHandler<
12344 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12345 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12346>
12347{
12348 #[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"]
12349 fn advisory_lock(
12350 &mut self,
12351
12352 request: ::fidl_next::Request<file::AdvisoryLock, ___T>,
12353
12354 responder: ::fidl_next::Responder<file::AdvisoryLock, ___T>,
12355 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12356
12357 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
12358 fn link_into(
12359 &mut self,
12360
12361 request: ::fidl_next::Request<file::LinkInto, ___T>,
12362
12363 responder: ::fidl_next::Responder<file::LinkInto, ___T>,
12364 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12365
12366 fn clone(
12367 &mut self,
12368
12369 request: ::fidl_next::Request<file::Clone, ___T>,
12370 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12371
12372 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
12373 fn close(
12374 &mut self,
12375
12376 responder: ::fidl_next::Responder<file::Close, ___T>,
12377 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12378
12379 fn query(
12380 &mut self,
12381
12382 responder: ::fidl_next::Responder<file::Query, ___T>,
12383 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12384
12385 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
12386 fn deprecated_clone(
12387 &mut self,
12388
12389 request: ::fidl_next::Request<file::DeprecatedClone, ___T>,
12390 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12391
12392 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
12393 fn deprecated_get_attr(
12394 &mut self,
12395
12396 responder: ::fidl_next::Responder<file::DeprecatedGetAttr, ___T>,
12397 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12398
12399 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
12400 fn deprecated_set_attr(
12401 &mut self,
12402
12403 request: ::fidl_next::Request<file::DeprecatedSetAttr, ___T>,
12404
12405 responder: ::fidl_next::Responder<file::DeprecatedSetAttr, ___T>,
12406 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12407
12408 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
12409 fn deprecated_get_flags(
12410 &mut self,
12411
12412 responder: ::fidl_next::Responder<file::DeprecatedGetFlags, ___T>,
12413 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12414
12415 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
12416 fn deprecated_set_flags(
12417 &mut self,
12418
12419 request: ::fidl_next::Request<file::DeprecatedSetFlags, ___T>,
12420
12421 responder: ::fidl_next::Responder<file::DeprecatedSetFlags, ___T>,
12422 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12423
12424 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
12425 fn get_flags(
12426 &mut self,
12427
12428 responder: ::fidl_next::Responder<file::GetFlags, ___T>,
12429 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12430
12431 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
12432 fn set_flags(
12433 &mut self,
12434
12435 request: ::fidl_next::Request<file::SetFlags, ___T>,
12436
12437 responder: ::fidl_next::Responder<file::SetFlags, ___T>,
12438 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12439
12440 #[doc = " Query the filesystem for filesystem-specific information.\n"]
12441 fn query_filesystem(
12442 &mut self,
12443
12444 responder: ::fidl_next::Responder<file::QueryFilesystem, ___T>,
12445 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12446
12447 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
12448 fn get_attributes(
12449 &mut self,
12450
12451 request: ::fidl_next::Request<file::GetAttributes, ___T>,
12452
12453 responder: ::fidl_next::Responder<file::GetAttributes, ___T>,
12454 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12455
12456 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
12457 fn update_attributes(
12458 &mut self,
12459
12460 request: ::fidl_next::Request<file::UpdateAttributes, ___T>,
12461
12462 responder: ::fidl_next::Responder<file::UpdateAttributes, ___T>,
12463 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12464
12465 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
12466 fn sync(
12467 &mut self,
12468
12469 responder: ::fidl_next::Responder<file::Sync, ___T>,
12470 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12471
12472 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
12473 fn list_extended_attributes(
12474 &mut self,
12475
12476 request: ::fidl_next::Request<file::ListExtendedAttributes, ___T>,
12477 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12478
12479 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
12480 fn get_extended_attribute(
12481 &mut self,
12482
12483 request: ::fidl_next::Request<file::GetExtendedAttribute, ___T>,
12484
12485 responder: ::fidl_next::Responder<file::GetExtendedAttribute, ___T>,
12486 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12487
12488 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
12489 fn set_extended_attribute(
12490 &mut self,
12491
12492 request: ::fidl_next::Request<file::SetExtendedAttribute, ___T>,
12493
12494 responder: ::fidl_next::Responder<file::SetExtendedAttribute, ___T>,
12495 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12496
12497 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
12498 fn remove_extended_attribute(
12499 &mut self,
12500
12501 request: ::fidl_next::Request<file::RemoveExtendedAttribute, ___T>,
12502
12503 responder: ::fidl_next::Responder<file::RemoveExtendedAttribute, ___T>,
12504 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12505
12506 #[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"]
12507 fn read(
12508 &mut self,
12509
12510 request: ::fidl_next::Request<file::Read, ___T>,
12511
12512 responder: ::fidl_next::Responder<file::Read, ___T>,
12513 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12514
12515 #[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"]
12516 fn write(
12517 &mut self,
12518
12519 request: ::fidl_next::Request<file::Write, ___T>,
12520
12521 responder: ::fidl_next::Responder<file::Write, ___T>,
12522 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12523
12524 fn describe(
12525 &mut self,
12526
12527 responder: ::fidl_next::Responder<file::Describe, ___T>,
12528 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12529
12530 #[doc = " Moves the offset at which the next invocation of [`Read`] or [`Write`]\n will occur. The seek offset is specific to each file connection.\n\n + request `origin` the reference point where `offset` will be based on.\n + request `offset` the number of bytes to seek.\n - response `offset_from_start` the adjusted seek offset, from the start\n of the file.\n\n This method does not require any rights.\n"]
12531 fn seek(
12532 &mut self,
12533
12534 request: ::fidl_next::Request<file::Seek, ___T>,
12535
12536 responder: ::fidl_next::Responder<file::Seek, ___T>,
12537 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12538
12539 #[doc = " Reads up to \'count\' bytes at the provided offset.\n Does not affect the seek offset.\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 `ReadAt` has hit\n the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that `offset`\n is at or past the end of file, and no data can be read.\n * If `count` is zero, the server should perform all the checks ensuring\n read access without actually reading 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"]
12540 fn read_at(
12541 &mut self,
12542
12543 request: ::fidl_next::Request<file::ReadAt, ___T>,
12544
12545 responder: ::fidl_next::Responder<file::ReadAt, ___T>,
12546 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12547
12548 #[doc = " Writes data at the provided offset.\n Does not affect the seek offset.\n\n The file size may grow if `offset` plus `data.length` is past the\n current end of file.\n\n + request `data` the byte buffer to write to the file.\n + request `offset` the offset from start of the file to begin writing.\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 will return a\n successful write of zero bytes.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
12549 fn write_at(
12550 &mut self,
12551
12552 request: ::fidl_next::Request<file::WriteAt, ___T>,
12553
12554 responder: ::fidl_next::Responder<file::WriteAt, ___T>,
12555 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12556
12557 #[doc = " Shrinks or grows the file size to \'length\' bytes.\n\n If file size is reduced by this operation, the extra trailing data\'\n is discarded.\n If file size is increased by this operation, the extended area appears\n as if it was zeroed.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
12558 fn resize(
12559 &mut self,
12560
12561 request: ::fidl_next::Request<file::Resize, ___T>,
12562
12563 responder: ::fidl_next::Responder<file::Resize, ___T>,
12564 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12565
12566 #[doc = " Acquires a [`zx.Handle:VMO`] representing this file, if there is one,\n with the requested access rights.\n\n Implementations are not required to implement files backed by VMOs so\n this request may fail. Additionally, implementations may only support\n a certain subset of the flags. Clients should be prepared with fallback\n behavior if this request fails.\n\n If a client specifies neither `PRIVATE_CLONE` nor `SHARED_BUFFER`, the\n implementation is free to choose the semantics of the returned VMO.\n\n + request `flags` a [`VmoFlags`] indicating the desired mode of access.\n - response `vmo` the requested [`zx.Handle:VMO`].\n * error a [`zx.Status`] value indicating the failure.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].\n * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].\n * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].\n"]
12567 fn get_backing_memory(
12568 &mut self,
12569
12570 request: ::fidl_next::Request<file::GetBackingMemory, ___T>,
12571
12572 responder: ::fidl_next::Responder<file::GetBackingMemory, ___T>,
12573 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12574
12575 #[doc = " Pre-allocate on-disk space for this file.\n"]
12576 fn allocate(
12577 &mut self,
12578
12579 request: ::fidl_next::Request<file::Allocate, ___T>,
12580
12581 responder: ::fidl_next::Responder<file::Allocate, ___T>,
12582 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12583
12584 #[doc = " Enables verification for the file (permanently) which involves computing a merkle tree for\n the file. Forces a flush prior to building the merkle tree to ensure cached data is\n captured. Future reads will be verified against the computed merkle tree and writes will be\n rejected. This method can take some time to complete as it depends on the size of the file.\n This method can be aborted by closing the connection that this method was issued on.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n Returns `ZX_ERR_NOT_SUPPORTED` if the filesystem does not support verity.\n Returns `ZX_ERR_ALREADY_EXISTS` if the file was already fsverity-enabled.\n Also returns any error that might arise from reading the file, or from flushing the file,\n such as `ZX_ERR_IO`.\n"]
12585 fn enable_verity(
12586 &mut self,
12587
12588 request: ::fidl_next::Request<file::EnableVerity, ___T>,
12589
12590 responder: ::fidl_next::Responder<file::EnableVerity, ___T>,
12591 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12592
12593 fn on_unknown_interaction(
12594 &mut self,
12595 ordinal: u64,
12596 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12597 ::core::future::ready(())
12598 }
12599}
12600
12601impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for File
12602where
12603 ___H: FileServerHandler<___T> + ::core::marker::Send,
12604 ___T: ::fidl_next::Transport,
12605 <file::AdvisoryLock as ::fidl_next::Method>::Request:
12606 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12607 <file::LinkInto as ::fidl_next::Method>::Request:
12608 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12609 <file::Clone as ::fidl_next::Method>::Request:
12610 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12611 <file::DeprecatedClone as ::fidl_next::Method>::Request:
12612 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12613 <file::DeprecatedSetAttr as ::fidl_next::Method>::Request:
12614 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12615 <file::DeprecatedSetFlags as ::fidl_next::Method>::Request:
12616 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12617 <file::SetFlags as ::fidl_next::Method>::Request:
12618 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12619 <file::GetAttributes as ::fidl_next::Method>::Request:
12620 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12621 <file::UpdateAttributes as ::fidl_next::Method>::Request:
12622 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12623 <file::ListExtendedAttributes as ::fidl_next::Method>::Request:
12624 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12625 <file::GetExtendedAttribute as ::fidl_next::Method>::Request:
12626 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12627 <file::SetExtendedAttribute as ::fidl_next::Method>::Request:
12628 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12629 <file::RemoveExtendedAttribute as ::fidl_next::Method>::Request:
12630 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12631 <file::Read as ::fidl_next::Method>::Request:
12632 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12633 <file::Write as ::fidl_next::Method>::Request:
12634 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12635 <file::Seek as ::fidl_next::Method>::Request:
12636 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12637 <file::ReadAt as ::fidl_next::Method>::Request:
12638 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12639 <file::WriteAt as ::fidl_next::Method>::Request:
12640 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12641 <file::Resize as ::fidl_next::Method>::Request:
12642 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12643 <file::GetBackingMemory as ::fidl_next::Method>::Request:
12644 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12645 <file::Allocate as ::fidl_next::Method>::Request:
12646 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12647 <file::EnableVerity as ::fidl_next::Method>::Request:
12648 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12649{
12650 async fn on_one_way(
12651 handler: &mut ___H,
12652 ordinal: u64,
12653 flexibility: ::fidl_next::protocol::Flexibility,
12654 buffer: ___T::RecvBuffer,
12655 ) -> ::core::result::Result<
12656 (),
12657 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12658 > {
12659 match ordinal {
12660 2366825959783828089 => match ::fidl_next::DecoderExt::decode(buffer) {
12661 Ok(decoded) => {
12662 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
12663 Ok(())
12664 }
12665 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12666 ordinal: 2366825959783828089,
12667 error,
12668 }),
12669 },
12670
12671 6512600400724287855 => match ::fidl_next::DecoderExt::decode(buffer) {
12672 Ok(decoded) => {
12673 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
12674 Ok(())
12675 }
12676 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12677 ordinal: 6512600400724287855,
12678 error,
12679 }),
12680 },
12681
12682 5431626189872037072 => match ::fidl_next::DecoderExt::decode(buffer) {
12683 Ok(decoded) => {
12684 handler
12685 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
12686 .await;
12687 Ok(())
12688 }
12689 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12690 ordinal: 5431626189872037072,
12691 error,
12692 }),
12693 },
12694
12695 ordinal => {
12696 handler.on_unknown_interaction(ordinal).await;
12697 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12698 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12699 } else {
12700 Ok(())
12701 }
12702 }
12703 }
12704 }
12705
12706 async fn on_two_way(
12707 handler: &mut ___H,
12708 ordinal: u64,
12709 flexibility: ::fidl_next::protocol::Flexibility,
12710 buffer: ___T::RecvBuffer,
12711 responder: ::fidl_next::protocol::Responder<___T>,
12712 ) -> ::core::result::Result<
12713 (),
12714 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12715 > {
12716 match ordinal {
12717 7992130864415541162 => {
12718 let responder = ::fidl_next::Responder::from_untyped(responder);
12719
12720 match ::fidl_next::DecoderExt::decode(buffer) {
12721 Ok(decoded) => {
12722 handler
12723 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
12724 .await;
12725 Ok(())
12726 }
12727 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12728 ordinal: 7992130864415541162,
12729 error,
12730 }),
12731 }
12732 }
12733
12734 6121399674497678964 => {
12735 let responder = ::fidl_next::Responder::from_untyped(responder);
12736
12737 match ::fidl_next::DecoderExt::decode(buffer) {
12738 Ok(decoded) => {
12739 handler
12740 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
12741 .await;
12742 Ok(())
12743 }
12744 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12745 ordinal: 6121399674497678964,
12746 error,
12747 }),
12748 }
12749 }
12750
12751 6540867515453498750 => {
12752 let responder = ::fidl_next::Responder::from_untyped(responder);
12753
12754 handler.close(responder).await;
12755 Ok(())
12756 }
12757
12758 2763219980499352582 => {
12759 let responder = ::fidl_next::Responder::from_untyped(responder);
12760
12761 handler.query(responder).await;
12762 Ok(())
12763 }
12764
12765 8689798978500614909 => {
12766 let responder = ::fidl_next::Responder::from_untyped(responder);
12767
12768 handler.deprecated_get_attr(responder).await;
12769 Ok(())
12770 }
12771
12772 4721673413776871238 => {
12773 let responder = ::fidl_next::Responder::from_untyped(responder);
12774
12775 match ::fidl_next::DecoderExt::decode(buffer) {
12776 Ok(decoded) => {
12777 handler
12778 .deprecated_set_attr(
12779 ::fidl_next::Request::from_decoded(decoded),
12780 responder,
12781 )
12782 .await;
12783 Ok(())
12784 }
12785 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12786 ordinal: 4721673413776871238,
12787 error,
12788 }),
12789 }
12790 }
12791
12792 6595803110182632097 => {
12793 let responder = ::fidl_next::Responder::from_untyped(responder);
12794
12795 handler.deprecated_get_flags(responder).await;
12796 Ok(())
12797 }
12798
12799 5950864159036794675 => {
12800 let responder = ::fidl_next::Responder::from_untyped(responder);
12801
12802 match ::fidl_next::DecoderExt::decode(buffer) {
12803 Ok(decoded) => {
12804 handler
12805 .deprecated_set_flags(
12806 ::fidl_next::Request::from_decoded(decoded),
12807 responder,
12808 )
12809 .await;
12810 Ok(())
12811 }
12812 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12813 ordinal: 5950864159036794675,
12814 error,
12815 }),
12816 }
12817 }
12818
12819 105530239381466147 => {
12820 let responder = ::fidl_next::Responder::from_untyped(responder);
12821
12822 handler.get_flags(responder).await;
12823 Ok(())
12824 }
12825
12826 6172186066099445416 => {
12827 let responder = ::fidl_next::Responder::from_untyped(responder);
12828
12829 match ::fidl_next::DecoderExt::decode(buffer) {
12830 Ok(decoded) => {
12831 handler
12832 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
12833 .await;
12834 Ok(())
12835 }
12836 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12837 ordinal: 6172186066099445416,
12838 error,
12839 }),
12840 }
12841 }
12842
12843 8013111122914313744 => {
12844 let responder = ::fidl_next::Responder::from_untyped(responder);
12845
12846 handler.query_filesystem(responder).await;
12847 Ok(())
12848 }
12849
12850 4414537700416816443 => {
12851 let responder = ::fidl_next::Responder::from_untyped(responder);
12852
12853 match ::fidl_next::DecoderExt::decode(buffer) {
12854 Ok(decoded) => {
12855 handler
12856 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
12857 .await;
12858 Ok(())
12859 }
12860 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12861 ordinal: 4414537700416816443,
12862 error,
12863 }),
12864 }
12865 }
12866
12867 3677402239314018056 => {
12868 let responder = ::fidl_next::Responder::from_untyped(responder);
12869
12870 match ::fidl_next::DecoderExt::decode(buffer) {
12871 Ok(decoded) => {
12872 handler
12873 .update_attributes(
12874 ::fidl_next::Request::from_decoded(decoded),
12875 responder,
12876 )
12877 .await;
12878 Ok(())
12879 }
12880 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12881 ordinal: 3677402239314018056,
12882 error,
12883 }),
12884 }
12885 }
12886
12887 3196473584242777161 => {
12888 let responder = ::fidl_next::Responder::from_untyped(responder);
12889
12890 handler.sync(responder).await;
12891 Ok(())
12892 }
12893
12894 5043930208506967771 => {
12895 let responder = ::fidl_next::Responder::from_untyped(responder);
12896
12897 match ::fidl_next::DecoderExt::decode(buffer) {
12898 Ok(decoded) => {
12899 handler
12900 .get_extended_attribute(
12901 ::fidl_next::Request::from_decoded(decoded),
12902 responder,
12903 )
12904 .await;
12905 Ok(())
12906 }
12907 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12908 ordinal: 5043930208506967771,
12909 error,
12910 }),
12911 }
12912 }
12913
12914 5374223046099989052 => {
12915 let responder = ::fidl_next::Responder::from_untyped(responder);
12916
12917 match ::fidl_next::DecoderExt::decode(buffer) {
12918 Ok(decoded) => {
12919 handler
12920 .set_extended_attribute(
12921 ::fidl_next::Request::from_decoded(decoded),
12922 responder,
12923 )
12924 .await;
12925 Ok(())
12926 }
12927 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12928 ordinal: 5374223046099989052,
12929 error,
12930 }),
12931 }
12932 }
12933
12934 8794297771444732717 => {
12935 let responder = ::fidl_next::Responder::from_untyped(responder);
12936
12937 match ::fidl_next::DecoderExt::decode(buffer) {
12938 Ok(decoded) => {
12939 handler
12940 .remove_extended_attribute(
12941 ::fidl_next::Request::from_decoded(decoded),
12942 responder,
12943 )
12944 .await;
12945 Ok(())
12946 }
12947 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12948 ordinal: 8794297771444732717,
12949 error,
12950 }),
12951 }
12952 }
12953
12954 395825947633028830 => {
12955 let responder = ::fidl_next::Responder::from_untyped(responder);
12956
12957 match ::fidl_next::DecoderExt::decode(buffer) {
12958 Ok(decoded) => {
12959 handler.read(::fidl_next::Request::from_decoded(decoded), responder).await;
12960 Ok(())
12961 }
12962 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12963 ordinal: 395825947633028830,
12964 error,
12965 }),
12966 }
12967 }
12968
12969 7651971425397809026 => {
12970 let responder = ::fidl_next::Responder::from_untyped(responder);
12971
12972 match ::fidl_next::DecoderExt::decode(buffer) {
12973 Ok(decoded) => {
12974 handler.write(::fidl_next::Request::from_decoded(decoded), responder).await;
12975 Ok(())
12976 }
12977 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12978 ordinal: 7651971425397809026,
12979 error,
12980 }),
12981 }
12982 }
12983
12984 7545125870053689020 => {
12985 let responder = ::fidl_next::Responder::from_untyped(responder);
12986
12987 handler.describe(responder).await;
12988 Ok(())
12989 }
12990
12991 8649041485622956551 => {
12992 let responder = ::fidl_next::Responder::from_untyped(responder);
12993
12994 match ::fidl_next::DecoderExt::decode(buffer) {
12995 Ok(decoded) => {
12996 handler.seek(::fidl_next::Request::from_decoded(decoded), responder).await;
12997 Ok(())
12998 }
12999 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13000 ordinal: 8649041485622956551,
13001 error,
13002 }),
13003 }
13004 }
13005
13006 1587416148701180478 => {
13007 let responder = ::fidl_next::Responder::from_untyped(responder);
13008
13009 match ::fidl_next::DecoderExt::decode(buffer) {
13010 Ok(decoded) => {
13011 handler
13012 .read_at(::fidl_next::Request::from_decoded(decoded), responder)
13013 .await;
13014 Ok(())
13015 }
13016 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13017 ordinal: 1587416148701180478,
13018 error,
13019 }),
13020 }
13021 }
13022
13023 8736683935131400491 => {
13024 let responder = ::fidl_next::Responder::from_untyped(responder);
13025
13026 match ::fidl_next::DecoderExt::decode(buffer) {
13027 Ok(decoded) => {
13028 handler
13029 .write_at(::fidl_next::Request::from_decoded(decoded), responder)
13030 .await;
13031 Ok(())
13032 }
13033 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13034 ordinal: 8736683935131400491,
13035 error,
13036 }),
13037 }
13038 }
13039
13040 3134648685270758458 => {
13041 let responder = ::fidl_next::Responder::from_untyped(responder);
13042
13043 match ::fidl_next::DecoderExt::decode(buffer) {
13044 Ok(decoded) => {
13045 handler
13046 .resize(::fidl_next::Request::from_decoded(decoded), responder)
13047 .await;
13048 Ok(())
13049 }
13050 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13051 ordinal: 3134648685270758458,
13052 error,
13053 }),
13054 }
13055 }
13056
13057 46911652864194091 => {
13058 let responder = ::fidl_next::Responder::from_untyped(responder);
13059
13060 match ::fidl_next::DecoderExt::decode(buffer) {
13061 Ok(decoded) => {
13062 handler
13063 .get_backing_memory(
13064 ::fidl_next::Request::from_decoded(decoded),
13065 responder,
13066 )
13067 .await;
13068 Ok(())
13069 }
13070 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13071 ordinal: 46911652864194091,
13072 error,
13073 }),
13074 }
13075 }
13076
13077 8645235848064269614 => {
13078 let responder = ::fidl_next::Responder::from_untyped(responder);
13079
13080 match ::fidl_next::DecoderExt::decode(buffer) {
13081 Ok(decoded) => {
13082 handler
13083 .allocate(::fidl_next::Request::from_decoded(decoded), responder)
13084 .await;
13085 Ok(())
13086 }
13087 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13088 ordinal: 8645235848064269614,
13089 error,
13090 }),
13091 }
13092 }
13093
13094 3189145313204943035 => {
13095 let responder = ::fidl_next::Responder::from_untyped(responder);
13096
13097 match ::fidl_next::DecoderExt::decode(buffer) {
13098 Ok(decoded) => {
13099 handler
13100 .enable_verity(::fidl_next::Request::from_decoded(decoded), responder)
13101 .await;
13102 Ok(())
13103 }
13104 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13105 ordinal: 3189145313204943035,
13106 error,
13107 }),
13108 }
13109 }
13110
13111 ordinal => {
13112 handler.on_unknown_interaction(ordinal).await;
13113 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13114 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13115 } else {
13116 responder
13117 .respond(
13118 ordinal,
13119 flexibility,
13120 ::fidl_next::Flexible::<()>::FrameworkErr(
13121 ::fidl_next::FrameworkError::UnknownMethod,
13122 ),
13123 )
13124 .expect("encoding a framework error should never fail")
13125 .await?;
13126 Ok(())
13127 }
13128 }
13129 }
13130 }
13131}
13132
13133#[doc = " A [\'Node\'] which contains a symbolic link.\n"]
13135#[derive(PartialEq, Debug)]
13136pub struct Symlink;
13137
13138impl ::fidl_next::Discoverable for Symlink {
13139 const PROTOCOL_NAME: &'static str = "fuchsia.io.Symlink";
13140}
13141
13142#[cfg(target_os = "fuchsia")]
13143impl ::fidl_next::HasTransport for Symlink {
13144 type Transport = ::fidl_next::fuchsia::zx::Channel;
13145}
13146
13147pub mod symlink {
13148 pub mod prelude {
13149 pub use crate::{Symlink, SymlinkClientHandler, SymlinkServerHandler, symlink};
13150
13151 pub use crate::natural::ExtendedAttributeValue;
13152
13153 pub use crate::natural::LinkableLinkIntoRequest;
13154
13155 pub use crate::natural::LinkableLinkIntoResponse;
13156
13157 pub use crate::natural::MutableNodeAttributes;
13158
13159 pub use crate::natural::NodeAttributes2;
13160
13161 pub use crate::natural::NodeDeprecatedCloneRequest;
13162
13163 pub use crate::natural::NodeDeprecatedGetAttrResponse;
13164
13165 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
13166
13167 pub use crate::natural::NodeDeprecatedSetAttrRequest;
13168
13169 pub use crate::natural::NodeDeprecatedSetAttrResponse;
13170
13171 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
13172
13173 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
13174
13175 pub use crate::natural::NodeGetAttributesRequest;
13176
13177 pub use crate::natural::NodeGetExtendedAttributeRequest;
13178
13179 pub use crate::natural::NodeListExtendedAttributesRequest;
13180
13181 pub use crate::natural::NodeOnOpenRequest;
13182
13183 pub use crate::natural::NodeQueryFilesystemResponse;
13184
13185 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
13186
13187 pub use crate::natural::NodeSetExtendedAttributeRequest;
13188
13189 pub use crate::natural::NodeSetFlagsRequest;
13190
13191 pub use crate::natural::NodeGetFlagsResponse;
13192
13193 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
13194
13195 pub use crate::natural::NodeSetExtendedAttributeResponse;
13196
13197 pub use crate::natural::NodeSetFlagsResponse;
13198
13199 pub use crate::natural::NodeSyncResponse;
13200
13201 pub use crate::natural::NodeUpdateAttributesResponse;
13202
13203 pub use crate::natural::Representation;
13204
13205 pub use crate::natural::SymlinkInfo;
13206
13207 pub use ::fidl_next_fuchsia_unknown::natural::CloneableCloneRequest;
13208
13209 pub use ::fidl_next_fuchsia_unknown::natural::CloseableCloseResponse;
13210
13211 pub use ::fidl_next_fuchsia_unknown::natural::QueryableQueryResponse;
13212 }
13213
13214 pub struct LinkInto;
13215
13216 impl ::fidl_next::Method for LinkInto {
13217 const ORDINAL: u64 = 6121399674497678964;
13218 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13219 ::fidl_next::protocol::Flexibility::Strict;
13220
13221 type Protocol = crate::Symlink;
13222
13223 type Request = crate::wire::LinkableLinkIntoRequest<'static>;
13224 }
13225
13226 impl ::fidl_next::TwoWayMethod for LinkInto {
13227 type Response = ::fidl_next::WireResult<
13228 'static,
13229 crate::wire::LinkableLinkIntoResponse,
13230 ::fidl_next::WireI32,
13231 >;
13232 }
13233
13234 impl<___R> ::fidl_next::Respond<___R> for LinkInto {
13235 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13236
13237 fn respond(response: ___R) -> Self::Output {
13238 ::core::result::Result::Ok(response)
13239 }
13240 }
13241
13242 impl<___R> ::fidl_next::RespondErr<___R> for LinkInto {
13243 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13244
13245 fn respond_err(response: ___R) -> Self::Output {
13246 ::core::result::Result::Err(response)
13247 }
13248 }
13249
13250 pub struct Clone;
13251
13252 impl ::fidl_next::Method for Clone {
13253 const ORDINAL: u64 = 2366825959783828089;
13254 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13255 ::fidl_next::protocol::Flexibility::Strict;
13256
13257 type Protocol = crate::Symlink;
13258
13259 type Request = ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest;
13260 }
13261
13262 pub struct Close;
13263
13264 impl ::fidl_next::Method for Close {
13265 const ORDINAL: u64 = 6540867515453498750;
13266 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13267 ::fidl_next::protocol::Flexibility::Strict;
13268
13269 type Protocol = crate::Symlink;
13270
13271 type Request = ();
13272 }
13273
13274 impl ::fidl_next::TwoWayMethod for Close {
13275 type Response = ::fidl_next::WireResult<
13276 'static,
13277 ::fidl_next_fuchsia_unknown::wire::CloseableCloseResponse,
13278 ::fidl_next::WireI32,
13279 >;
13280 }
13281
13282 impl<___R> ::fidl_next::Respond<___R> for Close {
13283 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13284
13285 fn respond(response: ___R) -> Self::Output {
13286 ::core::result::Result::Ok(response)
13287 }
13288 }
13289
13290 impl<___R> ::fidl_next::RespondErr<___R> for Close {
13291 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13292
13293 fn respond_err(response: ___R) -> Self::Output {
13294 ::core::result::Result::Err(response)
13295 }
13296 }
13297
13298 pub struct Query;
13299
13300 impl ::fidl_next::Method for Query {
13301 const ORDINAL: u64 = 2763219980499352582;
13302 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13303 ::fidl_next::protocol::Flexibility::Strict;
13304
13305 type Protocol = crate::Symlink;
13306
13307 type Request = ();
13308 }
13309
13310 impl ::fidl_next::TwoWayMethod for Query {
13311 type Response = ::fidl_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>;
13312 }
13313
13314 impl<___R> ::fidl_next::Respond<___R> for Query {
13315 type Output = ::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>;
13316
13317 fn respond(response: ___R) -> Self::Output {
13318 ::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse { protocol: response }
13319 }
13320 }
13321
13322 pub struct DeprecatedClone;
13323
13324 impl ::fidl_next::Method for DeprecatedClone {
13325 const ORDINAL: u64 = 6512600400724287855;
13326 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13327 ::fidl_next::protocol::Flexibility::Flexible;
13328
13329 type Protocol = crate::Symlink;
13330
13331 type Request = crate::wire::NodeDeprecatedCloneRequest;
13332 }
13333
13334 pub struct OnOpen;
13335
13336 impl ::fidl_next::Method for OnOpen {
13337 const ORDINAL: u64 = 9207534335756671346;
13338 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13339 ::fidl_next::protocol::Flexibility::Flexible;
13340
13341 type Protocol = crate::Symlink;
13342
13343 type Request = crate::wire::NodeOnOpenRequest<'static>;
13344 }
13345
13346 pub struct DeprecatedGetAttr;
13347
13348 impl ::fidl_next::Method for DeprecatedGetAttr {
13349 const ORDINAL: u64 = 8689798978500614909;
13350 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13351 ::fidl_next::protocol::Flexibility::Strict;
13352
13353 type Protocol = crate::Symlink;
13354
13355 type Request = ();
13356 }
13357
13358 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
13359 type Response = crate::wire::NodeDeprecatedGetAttrResponse;
13360 }
13361
13362 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
13363 type Output = ___R;
13364
13365 fn respond(response: ___R) -> Self::Output {
13366 response
13367 }
13368 }
13369
13370 pub struct DeprecatedSetAttr;
13371
13372 impl ::fidl_next::Method for DeprecatedSetAttr {
13373 const ORDINAL: u64 = 4721673413776871238;
13374 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13375 ::fidl_next::protocol::Flexibility::Strict;
13376
13377 type Protocol = crate::Symlink;
13378
13379 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
13380 }
13381
13382 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
13383 type Response = crate::wire::NodeDeprecatedSetAttrResponse;
13384 }
13385
13386 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
13387 type Output = crate::generic::NodeDeprecatedSetAttrResponse<___R>;
13388
13389 fn respond(response: ___R) -> Self::Output {
13390 crate::generic::NodeDeprecatedSetAttrResponse { s: response }
13391 }
13392 }
13393
13394 pub struct DeprecatedGetFlags;
13395
13396 impl ::fidl_next::Method for DeprecatedGetFlags {
13397 const ORDINAL: u64 = 6595803110182632097;
13398 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13399 ::fidl_next::protocol::Flexibility::Strict;
13400
13401 type Protocol = crate::Symlink;
13402
13403 type Request = ();
13404 }
13405
13406 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
13407 type Response = crate::wire::NodeDeprecatedGetFlagsResponse;
13408 }
13409
13410 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
13411 type Output = ___R;
13412
13413 fn respond(response: ___R) -> Self::Output {
13414 response
13415 }
13416 }
13417
13418 pub struct DeprecatedSetFlags;
13419
13420 impl ::fidl_next::Method for DeprecatedSetFlags {
13421 const ORDINAL: u64 = 5950864159036794675;
13422 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13423 ::fidl_next::protocol::Flexibility::Strict;
13424
13425 type Protocol = crate::Symlink;
13426
13427 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
13428 }
13429
13430 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
13431 type Response = crate::wire::NodeDeprecatedSetFlagsResponse;
13432 }
13433
13434 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
13435 type Output = crate::generic::NodeDeprecatedSetFlagsResponse<___R>;
13436
13437 fn respond(response: ___R) -> Self::Output {
13438 crate::generic::NodeDeprecatedSetFlagsResponse { s: response }
13439 }
13440 }
13441
13442 pub struct GetFlags;
13443
13444 impl ::fidl_next::Method for GetFlags {
13445 const ORDINAL: u64 = 105530239381466147;
13446 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13447 ::fidl_next::protocol::Flexibility::Flexible;
13448
13449 type Protocol = crate::Symlink;
13450
13451 type Request = ();
13452 }
13453
13454 impl ::fidl_next::TwoWayMethod for GetFlags {
13455 type Response = ::fidl_next::WireFlexibleResult<
13456 'static,
13457 crate::wire::NodeGetFlagsResponse,
13458 ::fidl_next::WireI32,
13459 >;
13460 }
13461
13462 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
13463 type Output = ::fidl_next::FlexibleResult<
13464 crate::generic::NodeGetFlagsResponse<___R>,
13465 ::fidl_next::util::Never,
13466 >;
13467
13468 fn respond(response: ___R) -> Self::Output {
13469 ::fidl_next::FlexibleResult::Ok(crate::generic::NodeGetFlagsResponse {
13470 flags: response,
13471 })
13472 }
13473 }
13474
13475 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
13476 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
13477
13478 fn respond_err(response: ___R) -> Self::Output {
13479 ::fidl_next::FlexibleResult::Err(response)
13480 }
13481 }
13482
13483 pub struct SetFlags;
13484
13485 impl ::fidl_next::Method for SetFlags {
13486 const ORDINAL: u64 = 6172186066099445416;
13487 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13488 ::fidl_next::protocol::Flexibility::Flexible;
13489
13490 type Protocol = crate::Symlink;
13491
13492 type Request = crate::wire::NodeSetFlagsRequest;
13493 }
13494
13495 impl ::fidl_next::TwoWayMethod for SetFlags {
13496 type Response = ::fidl_next::WireFlexibleResult<
13497 'static,
13498 crate::wire::NodeSetFlagsResponse,
13499 ::fidl_next::WireI32,
13500 >;
13501 }
13502
13503 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
13504 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
13505
13506 fn respond(response: ___R) -> Self::Output {
13507 ::fidl_next::FlexibleResult::Ok(response)
13508 }
13509 }
13510
13511 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
13512 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
13513
13514 fn respond_err(response: ___R) -> Self::Output {
13515 ::fidl_next::FlexibleResult::Err(response)
13516 }
13517 }
13518
13519 pub struct QueryFilesystem;
13520
13521 impl ::fidl_next::Method for QueryFilesystem {
13522 const ORDINAL: u64 = 8013111122914313744;
13523 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13524 ::fidl_next::protocol::Flexibility::Strict;
13525
13526 type Protocol = crate::Symlink;
13527
13528 type Request = ();
13529 }
13530
13531 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
13532 type Response = crate::wire::NodeQueryFilesystemResponse<'static>;
13533 }
13534
13535 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
13536 type Output = ___R;
13537
13538 fn respond(response: ___R) -> Self::Output {
13539 response
13540 }
13541 }
13542
13543 pub struct OnRepresentation;
13544
13545 impl ::fidl_next::Method for OnRepresentation {
13546 const ORDINAL: u64 = 6679970090861613324;
13547 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13548 ::fidl_next::protocol::Flexibility::Strict;
13549
13550 type Protocol = crate::Symlink;
13551
13552 type Request = crate::wire::Representation<'static>;
13553 }
13554
13555 pub struct GetAttributes;
13556
13557 impl ::fidl_next::Method for GetAttributes {
13558 const ORDINAL: u64 = 4414537700416816443;
13559 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13560 ::fidl_next::protocol::Flexibility::Strict;
13561
13562 type Protocol = crate::Symlink;
13563
13564 type Request = crate::wire::NodeGetAttributesRequest;
13565 }
13566
13567 impl ::fidl_next::TwoWayMethod for GetAttributes {
13568 type Response = ::fidl_next::WireResult<
13569 'static,
13570 crate::wire::NodeAttributes2<'static>,
13571 ::fidl_next::WireI32,
13572 >;
13573 }
13574
13575 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
13576 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13577
13578 fn respond(response: ___R) -> Self::Output {
13579 ::core::result::Result::Ok(response)
13580 }
13581 }
13582
13583 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
13584 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13585
13586 fn respond_err(response: ___R) -> Self::Output {
13587 ::core::result::Result::Err(response)
13588 }
13589 }
13590
13591 pub struct UpdateAttributes;
13592
13593 impl ::fidl_next::Method for UpdateAttributes {
13594 const ORDINAL: u64 = 3677402239314018056;
13595 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13596 ::fidl_next::protocol::Flexibility::Strict;
13597
13598 type Protocol = crate::Symlink;
13599
13600 type Request = crate::wire::MutableNodeAttributes<'static>;
13601 }
13602
13603 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
13604 type Response = ::fidl_next::WireResult<
13605 'static,
13606 crate::wire::NodeUpdateAttributesResponse,
13607 ::fidl_next::WireI32,
13608 >;
13609 }
13610
13611 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
13612 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13613
13614 fn respond(response: ___R) -> Self::Output {
13615 ::core::result::Result::Ok(response)
13616 }
13617 }
13618
13619 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
13620 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13621
13622 fn respond_err(response: ___R) -> Self::Output {
13623 ::core::result::Result::Err(response)
13624 }
13625 }
13626
13627 pub struct Sync;
13628
13629 impl ::fidl_next::Method for Sync {
13630 const ORDINAL: u64 = 3196473584242777161;
13631 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13632 ::fidl_next::protocol::Flexibility::Strict;
13633
13634 type Protocol = crate::Symlink;
13635
13636 type Request = ();
13637 }
13638
13639 impl ::fidl_next::TwoWayMethod for Sync {
13640 type Response =
13641 ::fidl_next::WireResult<'static, crate::wire::NodeSyncResponse, ::fidl_next::WireI32>;
13642 }
13643
13644 impl<___R> ::fidl_next::Respond<___R> for Sync {
13645 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13646
13647 fn respond(response: ___R) -> Self::Output {
13648 ::core::result::Result::Ok(response)
13649 }
13650 }
13651
13652 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
13653 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13654
13655 fn respond_err(response: ___R) -> Self::Output {
13656 ::core::result::Result::Err(response)
13657 }
13658 }
13659
13660 pub struct ListExtendedAttributes;
13661
13662 impl ::fidl_next::Method for ListExtendedAttributes {
13663 const ORDINAL: u64 = 5431626189872037072;
13664 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13665 ::fidl_next::protocol::Flexibility::Strict;
13666
13667 type Protocol = crate::Symlink;
13668
13669 type Request = crate::wire::NodeListExtendedAttributesRequest;
13670 }
13671
13672 pub struct GetExtendedAttribute;
13673
13674 impl ::fidl_next::Method for GetExtendedAttribute {
13675 const ORDINAL: u64 = 5043930208506967771;
13676 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13677 ::fidl_next::protocol::Flexibility::Strict;
13678
13679 type Protocol = crate::Symlink;
13680
13681 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
13682 }
13683
13684 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
13685 type Response = ::fidl_next::WireResult<
13686 'static,
13687 crate::wire::ExtendedAttributeValue<'static>,
13688 ::fidl_next::WireI32,
13689 >;
13690 }
13691
13692 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
13693 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13694
13695 fn respond(response: ___R) -> Self::Output {
13696 ::core::result::Result::Ok(response)
13697 }
13698 }
13699
13700 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
13701 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13702
13703 fn respond_err(response: ___R) -> Self::Output {
13704 ::core::result::Result::Err(response)
13705 }
13706 }
13707
13708 pub struct SetExtendedAttribute;
13709
13710 impl ::fidl_next::Method for SetExtendedAttribute {
13711 const ORDINAL: u64 = 5374223046099989052;
13712 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13713 ::fidl_next::protocol::Flexibility::Strict;
13714
13715 type Protocol = crate::Symlink;
13716
13717 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
13718 }
13719
13720 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
13721 type Response = ::fidl_next::WireResult<
13722 'static,
13723 crate::wire::NodeSetExtendedAttributeResponse,
13724 ::fidl_next::WireI32,
13725 >;
13726 }
13727
13728 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
13729 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13730
13731 fn respond(response: ___R) -> Self::Output {
13732 ::core::result::Result::Ok(response)
13733 }
13734 }
13735
13736 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
13737 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13738
13739 fn respond_err(response: ___R) -> Self::Output {
13740 ::core::result::Result::Err(response)
13741 }
13742 }
13743
13744 pub struct RemoveExtendedAttribute;
13745
13746 impl ::fidl_next::Method for RemoveExtendedAttribute {
13747 const ORDINAL: u64 = 8794297771444732717;
13748 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13749 ::fidl_next::protocol::Flexibility::Strict;
13750
13751 type Protocol = crate::Symlink;
13752
13753 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
13754 }
13755
13756 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
13757 type Response = ::fidl_next::WireResult<
13758 'static,
13759 crate::wire::NodeRemoveExtendedAttributeResponse,
13760 ::fidl_next::WireI32,
13761 >;
13762 }
13763
13764 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
13765 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13766
13767 fn respond(response: ___R) -> Self::Output {
13768 ::core::result::Result::Ok(response)
13769 }
13770 }
13771
13772 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
13773 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13774
13775 fn respond_err(response: ___R) -> Self::Output {
13776 ::core::result::Result::Err(response)
13777 }
13778 }
13779
13780 pub struct Describe;
13781
13782 impl ::fidl_next::Method for Describe {
13783 const ORDINAL: u64 = 8371117097481679347;
13784 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13785 ::fidl_next::protocol::Flexibility::Flexible;
13786
13787 type Protocol = crate::Symlink;
13788
13789 type Request = ();
13790 }
13791
13792 impl ::fidl_next::TwoWayMethod for Describe {
13793 type Response = ::fidl_next::WireFlexible<'static, crate::wire::SymlinkInfo<'static>>;
13794 }
13795
13796 impl<___R> ::fidl_next::Respond<___R> for Describe {
13797 type Output = ___R;
13798
13799 fn respond(response: ___R) -> Self::Output {
13800 response
13801 }
13802 }
13803
13804 mod ___detail {
13805 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Symlink
13806 where
13807 ___T: ::fidl_next::Transport,
13808 {
13809 type Client = SymlinkClient<___T>;
13810 type Server = SymlinkServer<___T>;
13811 }
13812
13813 #[repr(transparent)]
13815 pub struct SymlinkClient<___T: ::fidl_next::Transport> {
13816 #[allow(dead_code)]
13817 client: ::fidl_next::protocol::Client<___T>,
13818 }
13819
13820 impl<___T> SymlinkClient<___T>
13821 where
13822 ___T: ::fidl_next::Transport,
13823 {
13824 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
13825 pub fn link_into(
13826 &self,
13827
13828 dst_parent_token: impl ::fidl_next::Encode<
13829 ::fidl_next::fuchsia::WireEvent,
13830 <___T as ::fidl_next::Transport>::SendBuffer,
13831 >,
13832
13833 dst: impl ::fidl_next::Encode<
13834 ::fidl_next::WireString<'static>,
13835 <___T as ::fidl_next::Transport>::SendBuffer,
13836 >,
13837 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
13838 where
13839 <___T as ::fidl_next::Transport>::SendBuffer:
13840 ::fidl_next::encoder::InternalHandleEncoder,
13841 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
13842 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
13843 {
13844 self.link_into_with(crate::generic::LinkableLinkIntoRequest {
13845 dst_parent_token,
13846
13847 dst,
13848 })
13849 }
13850
13851 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
13852 pub fn link_into_with<___R>(
13853 &self,
13854 request: ___R,
13855 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
13856 where
13857 ___R: ::fidl_next::Encode<
13858 crate::wire::LinkableLinkIntoRequest<'static>,
13859 <___T as ::fidl_next::Transport>::SendBuffer,
13860 >,
13861 {
13862 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
13863 6121399674497678964,
13864 <super::LinkInto as ::fidl_next::Method>::FLEXIBILITY,
13865 request,
13866 ))
13867 }
13868
13869 pub fn clone(
13870 &self,
13871
13872 request: impl ::fidl_next::Encode<
13873 ::fidl_next::ServerEnd<
13874 ::fidl_next_fuchsia_unknown::Cloneable,
13875 ::fidl_next::fuchsia::WireChannel,
13876 >,
13877 <___T as ::fidl_next::Transport>::SendBuffer,
13878 >,
13879 ) -> ::fidl_next::SendFuture<'_, ___T>
13880 where
13881 <___T as ::fidl_next::Transport>::SendBuffer:
13882 ::fidl_next::encoder::InternalHandleEncoder,
13883 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
13884 {
13885 self.clone_with(::fidl_next_fuchsia_unknown::generic::CloneableCloneRequest {
13886 request,
13887 })
13888 }
13889
13890 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
13891 where
13892 ___R: ::fidl_next::Encode<
13893 ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest,
13894 <___T as ::fidl_next::Transport>::SendBuffer,
13895 >,
13896 {
13897 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
13898 2366825959783828089,
13899 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
13900 request,
13901 ))
13902 }
13903
13904 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
13905 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
13906 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
13907 6540867515453498750,
13908 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
13909 (),
13910 ))
13911 }
13912
13913 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
13914 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
13915 2763219980499352582,
13916 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
13917 (),
13918 ))
13919 }
13920
13921 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
13922 pub fn deprecated_clone(
13923 &self,
13924
13925 flags: impl ::fidl_next::Encode<
13926 crate::wire::OpenFlags,
13927 <___T as ::fidl_next::Transport>::SendBuffer,
13928 >,
13929
13930 object: impl ::fidl_next::Encode<
13931 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
13932 <___T as ::fidl_next::Transport>::SendBuffer,
13933 >,
13934 ) -> ::fidl_next::SendFuture<'_, ___T>
13935 where
13936 <___T as ::fidl_next::Transport>::SendBuffer:
13937 ::fidl_next::encoder::InternalHandleEncoder,
13938 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
13939 {
13940 self.deprecated_clone_with(crate::generic::NodeDeprecatedCloneRequest {
13941 flags,
13942
13943 object,
13944 })
13945 }
13946
13947 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
13948 pub fn deprecated_clone_with<___R>(
13949 &self,
13950 request: ___R,
13951 ) -> ::fidl_next::SendFuture<'_, ___T>
13952 where
13953 ___R: ::fidl_next::Encode<
13954 crate::wire::NodeDeprecatedCloneRequest,
13955 <___T as ::fidl_next::Transport>::SendBuffer,
13956 >,
13957 {
13958 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
13959 6512600400724287855,
13960 <super::DeprecatedClone as ::fidl_next::Method>::FLEXIBILITY,
13961 request,
13962 ))
13963 }
13964
13965 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
13966 pub fn deprecated_get_attr(
13967 &self,
13968 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
13969 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
13970 8689798978500614909,
13971 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
13972 (),
13973 ))
13974 }
13975
13976 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
13977 pub fn deprecated_set_attr(
13978 &self,
13979
13980 flags: impl ::fidl_next::Encode<
13981 crate::wire::NodeAttributeFlags,
13982 <___T as ::fidl_next::Transport>::SendBuffer,
13983 >,
13984
13985 attributes: impl ::fidl_next::Encode<
13986 crate::wire::NodeAttributes,
13987 <___T as ::fidl_next::Transport>::SendBuffer,
13988 >,
13989 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
13990 where
13991 <___T as ::fidl_next::Transport>::SendBuffer:
13992 ::fidl_next::encoder::InternalHandleEncoder,
13993 {
13994 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
13995 flags,
13996
13997 attributes,
13998 })
13999 }
14000
14001 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
14002 pub fn deprecated_set_attr_with<___R>(
14003 &self,
14004 request: ___R,
14005 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
14006 where
14007 ___R: ::fidl_next::Encode<
14008 crate::wire::NodeDeprecatedSetAttrRequest,
14009 <___T as ::fidl_next::Transport>::SendBuffer,
14010 >,
14011 {
14012 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14013 4721673413776871238,
14014 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
14015 request,
14016 ))
14017 }
14018
14019 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
14020 pub fn deprecated_get_flags(
14021 &self,
14022 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
14023 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14024 6595803110182632097,
14025 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
14026 (),
14027 ))
14028 }
14029
14030 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
14031 pub fn deprecated_set_flags(
14032 &self,
14033
14034 flags: impl ::fidl_next::Encode<
14035 crate::wire::OpenFlags,
14036 <___T as ::fidl_next::Transport>::SendBuffer,
14037 >,
14038 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
14039 where
14040 <___T as ::fidl_next::Transport>::SendBuffer:
14041 ::fidl_next::encoder::InternalHandleEncoder,
14042 {
14043 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
14044 flags,
14045 })
14046 }
14047
14048 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
14049 pub fn deprecated_set_flags_with<___R>(
14050 &self,
14051 request: ___R,
14052 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
14053 where
14054 ___R: ::fidl_next::Encode<
14055 crate::wire::NodeDeprecatedSetFlagsRequest,
14056 <___T as ::fidl_next::Transport>::SendBuffer,
14057 >,
14058 {
14059 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14060 5950864159036794675,
14061 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
14062 request,
14063 ))
14064 }
14065
14066 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
14067 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
14068 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14069 105530239381466147,
14070 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
14071 (),
14072 ))
14073 }
14074
14075 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
14076 pub fn set_flags(
14077 &self,
14078
14079 flags: impl ::fidl_next::Encode<
14080 crate::wire::Flags,
14081 <___T as ::fidl_next::Transport>::SendBuffer,
14082 >,
14083 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
14084 where
14085 <___T as ::fidl_next::Transport>::SendBuffer:
14086 ::fidl_next::encoder::InternalHandleEncoder,
14087 {
14088 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
14089 }
14090
14091 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
14092 pub fn set_flags_with<___R>(
14093 &self,
14094 request: ___R,
14095 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
14096 where
14097 ___R: ::fidl_next::Encode<
14098 crate::wire::NodeSetFlagsRequest,
14099 <___T as ::fidl_next::Transport>::SendBuffer,
14100 >,
14101 {
14102 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14103 6172186066099445416,
14104 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
14105 request,
14106 ))
14107 }
14108
14109 #[doc = " Query the filesystem for filesystem-specific information.\n"]
14110 pub fn query_filesystem(
14111 &self,
14112 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
14113 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14114 8013111122914313744,
14115 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
14116 (),
14117 ))
14118 }
14119
14120 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
14121 pub fn get_attributes(
14122 &self,
14123
14124 query: impl ::fidl_next::Encode<
14125 crate::wire::NodeAttributesQuery,
14126 <___T as ::fidl_next::Transport>::SendBuffer,
14127 >,
14128 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
14129 where
14130 <___T as ::fidl_next::Transport>::SendBuffer:
14131 ::fidl_next::encoder::InternalHandleEncoder,
14132 {
14133 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
14134 }
14135
14136 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
14137 pub fn get_attributes_with<___R>(
14138 &self,
14139 request: ___R,
14140 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
14141 where
14142 ___R: ::fidl_next::Encode<
14143 crate::wire::NodeGetAttributesRequest,
14144 <___T as ::fidl_next::Transport>::SendBuffer,
14145 >,
14146 {
14147 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14148 4414537700416816443,
14149 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
14150 request,
14151 ))
14152 }
14153
14154 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
14155 pub fn update_attributes_with<___R>(
14156 &self,
14157 request: ___R,
14158 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
14159 where
14160 ___R: ::fidl_next::Encode<
14161 crate::wire::MutableNodeAttributes<'static>,
14162 <___T as ::fidl_next::Transport>::SendBuffer,
14163 >,
14164 {
14165 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14166 3677402239314018056,
14167 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
14168 request,
14169 ))
14170 }
14171
14172 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
14173 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
14174 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14175 3196473584242777161,
14176 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
14177 (),
14178 ))
14179 }
14180
14181 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
14182 pub fn list_extended_attributes(
14183 &self,
14184
14185 iterator: impl ::fidl_next::Encode<
14186 ::fidl_next::ServerEnd<
14187 crate::ExtendedAttributeIterator,
14188 ::fidl_next::fuchsia::WireChannel,
14189 >,
14190 <___T as ::fidl_next::Transport>::SendBuffer,
14191 >,
14192 ) -> ::fidl_next::SendFuture<'_, ___T>
14193 where
14194 <___T as ::fidl_next::Transport>::SendBuffer:
14195 ::fidl_next::encoder::InternalHandleEncoder,
14196 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
14197 {
14198 self.list_extended_attributes_with(
14199 crate::generic::NodeListExtendedAttributesRequest { iterator },
14200 )
14201 }
14202
14203 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
14204 pub fn list_extended_attributes_with<___R>(
14205 &self,
14206 request: ___R,
14207 ) -> ::fidl_next::SendFuture<'_, ___T>
14208 where
14209 ___R: ::fidl_next::Encode<
14210 crate::wire::NodeListExtendedAttributesRequest,
14211 <___T as ::fidl_next::Transport>::SendBuffer,
14212 >,
14213 {
14214 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
14215 5431626189872037072,
14216 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
14217 request,
14218 ))
14219 }
14220
14221 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
14222 pub fn get_extended_attribute(
14223 &self,
14224
14225 name: impl ::fidl_next::Encode<
14226 ::fidl_next::WireVector<'static, u8>,
14227 <___T as ::fidl_next::Transport>::SendBuffer,
14228 >,
14229 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
14230 where
14231 <___T as ::fidl_next::Transport>::SendBuffer:
14232 ::fidl_next::encoder::InternalHandleEncoder,
14233 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14234 {
14235 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
14236 name,
14237 })
14238 }
14239
14240 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
14241 pub fn get_extended_attribute_with<___R>(
14242 &self,
14243 request: ___R,
14244 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
14245 where
14246 ___R: ::fidl_next::Encode<
14247 crate::wire::NodeGetExtendedAttributeRequest<'static>,
14248 <___T as ::fidl_next::Transport>::SendBuffer,
14249 >,
14250 {
14251 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14252 5043930208506967771,
14253 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
14254 request,
14255 ))
14256 }
14257
14258 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
14259 pub fn set_extended_attribute(
14260 &self,
14261
14262 name: impl ::fidl_next::Encode<
14263 ::fidl_next::WireVector<'static, u8>,
14264 <___T as ::fidl_next::Transport>::SendBuffer,
14265 >,
14266
14267 value: impl ::fidl_next::Encode<
14268 crate::wire::ExtendedAttributeValue<'static>,
14269 <___T as ::fidl_next::Transport>::SendBuffer,
14270 >,
14271
14272 mode: impl ::fidl_next::Encode<
14273 crate::wire::SetExtendedAttributeMode,
14274 <___T as ::fidl_next::Transport>::SendBuffer,
14275 >,
14276 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
14277 where
14278 <___T as ::fidl_next::Transport>::SendBuffer:
14279 ::fidl_next::encoder::InternalHandleEncoder,
14280 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14281 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
14282 {
14283 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
14284 name,
14285
14286 value,
14287
14288 mode,
14289 })
14290 }
14291
14292 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
14293 pub fn set_extended_attribute_with<___R>(
14294 &self,
14295 request: ___R,
14296 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
14297 where
14298 ___R: ::fidl_next::Encode<
14299 crate::wire::NodeSetExtendedAttributeRequest<'static>,
14300 <___T as ::fidl_next::Transport>::SendBuffer,
14301 >,
14302 {
14303 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14304 5374223046099989052,
14305 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
14306 request,
14307 ))
14308 }
14309
14310 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
14311 pub fn remove_extended_attribute(
14312 &self,
14313
14314 name: impl ::fidl_next::Encode<
14315 ::fidl_next::WireVector<'static, u8>,
14316 <___T as ::fidl_next::Transport>::SendBuffer,
14317 >,
14318 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
14319 where
14320 <___T as ::fidl_next::Transport>::SendBuffer:
14321 ::fidl_next::encoder::InternalHandleEncoder,
14322 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14323 {
14324 self.remove_extended_attribute_with(
14325 crate::generic::NodeRemoveExtendedAttributeRequest { name },
14326 )
14327 }
14328
14329 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
14330 pub fn remove_extended_attribute_with<___R>(
14331 &self,
14332 request: ___R,
14333 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
14334 where
14335 ___R: ::fidl_next::Encode<
14336 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
14337 <___T as ::fidl_next::Transport>::SendBuffer,
14338 >,
14339 {
14340 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14341 8794297771444732717,
14342 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
14343 request,
14344 ))
14345 }
14346
14347 pub fn describe(&self) -> ::fidl_next::TwoWayFuture<'_, super::Describe, ___T> {
14348 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14349 8371117097481679347,
14350 <super::Describe as ::fidl_next::Method>::FLEXIBILITY,
14351 (),
14352 ))
14353 }
14354 }
14355
14356 #[repr(transparent)]
14358 pub struct SymlinkServer<___T: ::fidl_next::Transport> {
14359 server: ::fidl_next::protocol::Server<___T>,
14360 }
14361
14362 impl<___T> SymlinkServer<___T>
14363 where
14364 ___T: ::fidl_next::Transport,
14365 {
14366 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
14367 pub fn on_open(
14368 &self,
14369
14370 s: impl ::fidl_next::Encode<
14371 ::fidl_next::WireI32,
14372 <___T as ::fidl_next::Transport>::SendBuffer,
14373 >,
14374
14375 info: impl ::fidl_next::Encode<
14376 crate::wire_optional::NodeInfoDeprecated<'static>,
14377 <___T as ::fidl_next::Transport>::SendBuffer,
14378 >,
14379 ) -> ::fidl_next::SendFuture<'_, ___T>
14380 where
14381 <___T as ::fidl_next::Transport>::SendBuffer:
14382 ::fidl_next::encoder::InternalHandleEncoder,
14383 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14384 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
14385 {
14386 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
14387 }
14388
14389 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
14390
14391 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
14392 where
14393 ___R: ::fidl_next::Encode<
14394 <super::OnOpen as ::fidl_next::Method>::Request,
14395 <___T as ::fidl_next::Transport>::SendBuffer,
14396 >,
14397 {
14398 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
14399 9207534335756671346,
14400 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
14401 request,
14402 ))
14403 }
14404
14405 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
14406
14407 pub fn on_representation_with<___R>(
14408 &self,
14409 request: ___R,
14410 ) -> ::fidl_next::SendFuture<'_, ___T>
14411 where
14412 ___R: ::fidl_next::Encode<
14413 <super::OnRepresentation as ::fidl_next::Method>::Request,
14414 <___T as ::fidl_next::Transport>::SendBuffer,
14415 >,
14416 {
14417 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
14418 6679970090861613324,
14419 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
14420 request,
14421 ))
14422 }
14423 }
14424 }
14425}
14426
14427pub trait SymlinkClientHandler<
14431 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14432 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
14433>
14434{
14435 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
14436 fn on_open(
14437 &mut self,
14438
14439 request: ::fidl_next::Request<symlink::OnOpen, ___T>,
14440 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14441
14442 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
14443 fn on_representation(
14444 &mut self,
14445
14446 request: ::fidl_next::Request<symlink::OnRepresentation, ___T>,
14447 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14448
14449 fn on_unknown_interaction(
14450 &mut self,
14451 ordinal: u64,
14452 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
14453 ::core::future::ready(())
14454 }
14455}
14456
14457impl<___T> SymlinkClientHandler<___T> for ::fidl_next::IgnoreEvents
14458where
14459 ___T: ::fidl_next::Transport,
14460{
14461 async fn on_open(&mut self, _: ::fidl_next::Request<symlink::OnOpen, ___T>) {}
14462
14463 async fn on_representation(
14464 &mut self,
14465
14466 _: ::fidl_next::Request<symlink::OnRepresentation, ___T>,
14467 ) {
14468 }
14469
14470 async fn on_unknown_interaction(&mut self, _: u64) {}
14471}
14472
14473impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Symlink
14474where
14475 ___H: SymlinkClientHandler<___T> + ::core::marker::Send,
14476 ___T: ::fidl_next::Transport,
14477 <symlink::OnOpen as ::fidl_next::Method>::Request:
14478 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14479 <symlink::OnRepresentation as ::fidl_next::Method>::Request:
14480 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14481{
14482 async fn on_event(
14483 handler: &mut ___H,
14484 ordinal: u64,
14485 flexibility: ::fidl_next::protocol::Flexibility,
14486 buffer: ___T::RecvBuffer,
14487 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
14488 match ordinal {
14489 9207534335756671346 => match ::fidl_next::DecoderExt::decode(buffer) {
14490 Ok(decoded) => {
14491 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
14492 Ok(())
14493 }
14494 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14495 ordinal: 9207534335756671346,
14496 error,
14497 }),
14498 },
14499
14500 6679970090861613324 => match ::fidl_next::DecoderExt::decode(buffer) {
14501 Ok(decoded) => {
14502 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
14503 Ok(())
14504 }
14505 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14506 ordinal: 6679970090861613324,
14507 error,
14508 }),
14509 },
14510
14511 ordinal => {
14512 handler.on_unknown_interaction(ordinal).await;
14513 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
14514 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
14515 } else {
14516 Ok(())
14517 }
14518 }
14519 }
14520 }
14521}
14522
14523pub trait SymlinkServerHandler<
14527 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14528 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
14529>
14530{
14531 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
14532 fn link_into(
14533 &mut self,
14534
14535 request: ::fidl_next::Request<symlink::LinkInto, ___T>,
14536
14537 responder: ::fidl_next::Responder<symlink::LinkInto, ___T>,
14538 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14539
14540 fn clone(
14541 &mut self,
14542
14543 request: ::fidl_next::Request<symlink::Clone, ___T>,
14544 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14545
14546 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
14547 fn close(
14548 &mut self,
14549
14550 responder: ::fidl_next::Responder<symlink::Close, ___T>,
14551 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14552
14553 fn query(
14554 &mut self,
14555
14556 responder: ::fidl_next::Responder<symlink::Query, ___T>,
14557 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14558
14559 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
14560 fn deprecated_clone(
14561 &mut self,
14562
14563 request: ::fidl_next::Request<symlink::DeprecatedClone, ___T>,
14564 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14565
14566 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
14567 fn deprecated_get_attr(
14568 &mut self,
14569
14570 responder: ::fidl_next::Responder<symlink::DeprecatedGetAttr, ___T>,
14571 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14572
14573 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
14574 fn deprecated_set_attr(
14575 &mut self,
14576
14577 request: ::fidl_next::Request<symlink::DeprecatedSetAttr, ___T>,
14578
14579 responder: ::fidl_next::Responder<symlink::DeprecatedSetAttr, ___T>,
14580 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14581
14582 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
14583 fn deprecated_get_flags(
14584 &mut self,
14585
14586 responder: ::fidl_next::Responder<symlink::DeprecatedGetFlags, ___T>,
14587 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14588
14589 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
14590 fn deprecated_set_flags(
14591 &mut self,
14592
14593 request: ::fidl_next::Request<symlink::DeprecatedSetFlags, ___T>,
14594
14595 responder: ::fidl_next::Responder<symlink::DeprecatedSetFlags, ___T>,
14596 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14597
14598 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
14599 fn get_flags(
14600 &mut self,
14601
14602 responder: ::fidl_next::Responder<symlink::GetFlags, ___T>,
14603 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14604
14605 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
14606 fn set_flags(
14607 &mut self,
14608
14609 request: ::fidl_next::Request<symlink::SetFlags, ___T>,
14610
14611 responder: ::fidl_next::Responder<symlink::SetFlags, ___T>,
14612 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14613
14614 #[doc = " Query the filesystem for filesystem-specific information.\n"]
14615 fn query_filesystem(
14616 &mut self,
14617
14618 responder: ::fidl_next::Responder<symlink::QueryFilesystem, ___T>,
14619 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14620
14621 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
14622 fn get_attributes(
14623 &mut self,
14624
14625 request: ::fidl_next::Request<symlink::GetAttributes, ___T>,
14626
14627 responder: ::fidl_next::Responder<symlink::GetAttributes, ___T>,
14628 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14629
14630 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
14631 fn update_attributes(
14632 &mut self,
14633
14634 request: ::fidl_next::Request<symlink::UpdateAttributes, ___T>,
14635
14636 responder: ::fidl_next::Responder<symlink::UpdateAttributes, ___T>,
14637 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14638
14639 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
14640 fn sync(
14641 &mut self,
14642
14643 responder: ::fidl_next::Responder<symlink::Sync, ___T>,
14644 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14645
14646 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
14647 fn list_extended_attributes(
14648 &mut self,
14649
14650 request: ::fidl_next::Request<symlink::ListExtendedAttributes, ___T>,
14651 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14652
14653 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
14654 fn get_extended_attribute(
14655 &mut self,
14656
14657 request: ::fidl_next::Request<symlink::GetExtendedAttribute, ___T>,
14658
14659 responder: ::fidl_next::Responder<symlink::GetExtendedAttribute, ___T>,
14660 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14661
14662 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
14663 fn set_extended_attribute(
14664 &mut self,
14665
14666 request: ::fidl_next::Request<symlink::SetExtendedAttribute, ___T>,
14667
14668 responder: ::fidl_next::Responder<symlink::SetExtendedAttribute, ___T>,
14669 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14670
14671 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
14672 fn remove_extended_attribute(
14673 &mut self,
14674
14675 request: ::fidl_next::Request<symlink::RemoveExtendedAttribute, ___T>,
14676
14677 responder: ::fidl_next::Responder<symlink::RemoveExtendedAttribute, ___T>,
14678 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14679
14680 fn describe(
14681 &mut self,
14682
14683 responder: ::fidl_next::Responder<symlink::Describe, ___T>,
14684 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14685
14686 fn on_unknown_interaction(
14687 &mut self,
14688 ordinal: u64,
14689 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
14690 ::core::future::ready(())
14691 }
14692}
14693
14694impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Symlink
14695where
14696 ___H: SymlinkServerHandler<___T> + ::core::marker::Send,
14697 ___T: ::fidl_next::Transport,
14698 <symlink::LinkInto as ::fidl_next::Method>::Request:
14699 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14700 <symlink::Clone as ::fidl_next::Method>::Request:
14701 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14702 <symlink::DeprecatedClone as ::fidl_next::Method>::Request:
14703 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14704 <symlink::DeprecatedSetAttr as ::fidl_next::Method>::Request:
14705 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14706 <symlink::DeprecatedSetFlags as ::fidl_next::Method>::Request:
14707 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14708 <symlink::SetFlags as ::fidl_next::Method>::Request:
14709 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14710 <symlink::GetAttributes as ::fidl_next::Method>::Request:
14711 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14712 <symlink::UpdateAttributes as ::fidl_next::Method>::Request:
14713 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14714 <symlink::ListExtendedAttributes as ::fidl_next::Method>::Request:
14715 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14716 <symlink::GetExtendedAttribute as ::fidl_next::Method>::Request:
14717 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14718 <symlink::SetExtendedAttribute as ::fidl_next::Method>::Request:
14719 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14720 <symlink::RemoveExtendedAttribute as ::fidl_next::Method>::Request:
14721 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14722{
14723 async fn on_one_way(
14724 handler: &mut ___H,
14725 ordinal: u64,
14726 flexibility: ::fidl_next::protocol::Flexibility,
14727 buffer: ___T::RecvBuffer,
14728 ) -> ::core::result::Result<
14729 (),
14730 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14731 > {
14732 match ordinal {
14733 2366825959783828089 => match ::fidl_next::DecoderExt::decode(buffer) {
14734 Ok(decoded) => {
14735 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
14736 Ok(())
14737 }
14738 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14739 ordinal: 2366825959783828089,
14740 error,
14741 }),
14742 },
14743
14744 6512600400724287855 => match ::fidl_next::DecoderExt::decode(buffer) {
14745 Ok(decoded) => {
14746 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
14747 Ok(())
14748 }
14749 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14750 ordinal: 6512600400724287855,
14751 error,
14752 }),
14753 },
14754
14755 5431626189872037072 => match ::fidl_next::DecoderExt::decode(buffer) {
14756 Ok(decoded) => {
14757 handler
14758 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
14759 .await;
14760 Ok(())
14761 }
14762 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14763 ordinal: 5431626189872037072,
14764 error,
14765 }),
14766 },
14767
14768 ordinal => {
14769 handler.on_unknown_interaction(ordinal).await;
14770 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
14771 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
14772 } else {
14773 Ok(())
14774 }
14775 }
14776 }
14777 }
14778
14779 async fn on_two_way(
14780 handler: &mut ___H,
14781 ordinal: u64,
14782 flexibility: ::fidl_next::protocol::Flexibility,
14783 buffer: ___T::RecvBuffer,
14784 responder: ::fidl_next::protocol::Responder<___T>,
14785 ) -> ::core::result::Result<
14786 (),
14787 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14788 > {
14789 match ordinal {
14790 6121399674497678964 => {
14791 let responder = ::fidl_next::Responder::from_untyped(responder);
14792
14793 match ::fidl_next::DecoderExt::decode(buffer) {
14794 Ok(decoded) => {
14795 handler
14796 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
14797 .await;
14798 Ok(())
14799 }
14800 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14801 ordinal: 6121399674497678964,
14802 error,
14803 }),
14804 }
14805 }
14806
14807 6540867515453498750 => {
14808 let responder = ::fidl_next::Responder::from_untyped(responder);
14809
14810 handler.close(responder).await;
14811 Ok(())
14812 }
14813
14814 2763219980499352582 => {
14815 let responder = ::fidl_next::Responder::from_untyped(responder);
14816
14817 handler.query(responder).await;
14818 Ok(())
14819 }
14820
14821 8689798978500614909 => {
14822 let responder = ::fidl_next::Responder::from_untyped(responder);
14823
14824 handler.deprecated_get_attr(responder).await;
14825 Ok(())
14826 }
14827
14828 4721673413776871238 => {
14829 let responder = ::fidl_next::Responder::from_untyped(responder);
14830
14831 match ::fidl_next::DecoderExt::decode(buffer) {
14832 Ok(decoded) => {
14833 handler
14834 .deprecated_set_attr(
14835 ::fidl_next::Request::from_decoded(decoded),
14836 responder,
14837 )
14838 .await;
14839 Ok(())
14840 }
14841 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14842 ordinal: 4721673413776871238,
14843 error,
14844 }),
14845 }
14846 }
14847
14848 6595803110182632097 => {
14849 let responder = ::fidl_next::Responder::from_untyped(responder);
14850
14851 handler.deprecated_get_flags(responder).await;
14852 Ok(())
14853 }
14854
14855 5950864159036794675 => {
14856 let responder = ::fidl_next::Responder::from_untyped(responder);
14857
14858 match ::fidl_next::DecoderExt::decode(buffer) {
14859 Ok(decoded) => {
14860 handler
14861 .deprecated_set_flags(
14862 ::fidl_next::Request::from_decoded(decoded),
14863 responder,
14864 )
14865 .await;
14866 Ok(())
14867 }
14868 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14869 ordinal: 5950864159036794675,
14870 error,
14871 }),
14872 }
14873 }
14874
14875 105530239381466147 => {
14876 let responder = ::fidl_next::Responder::from_untyped(responder);
14877
14878 handler.get_flags(responder).await;
14879 Ok(())
14880 }
14881
14882 6172186066099445416 => {
14883 let responder = ::fidl_next::Responder::from_untyped(responder);
14884
14885 match ::fidl_next::DecoderExt::decode(buffer) {
14886 Ok(decoded) => {
14887 handler
14888 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
14889 .await;
14890 Ok(())
14891 }
14892 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14893 ordinal: 6172186066099445416,
14894 error,
14895 }),
14896 }
14897 }
14898
14899 8013111122914313744 => {
14900 let responder = ::fidl_next::Responder::from_untyped(responder);
14901
14902 handler.query_filesystem(responder).await;
14903 Ok(())
14904 }
14905
14906 4414537700416816443 => {
14907 let responder = ::fidl_next::Responder::from_untyped(responder);
14908
14909 match ::fidl_next::DecoderExt::decode(buffer) {
14910 Ok(decoded) => {
14911 handler
14912 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
14913 .await;
14914 Ok(())
14915 }
14916 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14917 ordinal: 4414537700416816443,
14918 error,
14919 }),
14920 }
14921 }
14922
14923 3677402239314018056 => {
14924 let responder = ::fidl_next::Responder::from_untyped(responder);
14925
14926 match ::fidl_next::DecoderExt::decode(buffer) {
14927 Ok(decoded) => {
14928 handler
14929 .update_attributes(
14930 ::fidl_next::Request::from_decoded(decoded),
14931 responder,
14932 )
14933 .await;
14934 Ok(())
14935 }
14936 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14937 ordinal: 3677402239314018056,
14938 error,
14939 }),
14940 }
14941 }
14942
14943 3196473584242777161 => {
14944 let responder = ::fidl_next::Responder::from_untyped(responder);
14945
14946 handler.sync(responder).await;
14947 Ok(())
14948 }
14949
14950 5043930208506967771 => {
14951 let responder = ::fidl_next::Responder::from_untyped(responder);
14952
14953 match ::fidl_next::DecoderExt::decode(buffer) {
14954 Ok(decoded) => {
14955 handler
14956 .get_extended_attribute(
14957 ::fidl_next::Request::from_decoded(decoded),
14958 responder,
14959 )
14960 .await;
14961 Ok(())
14962 }
14963 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14964 ordinal: 5043930208506967771,
14965 error,
14966 }),
14967 }
14968 }
14969
14970 5374223046099989052 => {
14971 let responder = ::fidl_next::Responder::from_untyped(responder);
14972
14973 match ::fidl_next::DecoderExt::decode(buffer) {
14974 Ok(decoded) => {
14975 handler
14976 .set_extended_attribute(
14977 ::fidl_next::Request::from_decoded(decoded),
14978 responder,
14979 )
14980 .await;
14981 Ok(())
14982 }
14983 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14984 ordinal: 5374223046099989052,
14985 error,
14986 }),
14987 }
14988 }
14989
14990 8794297771444732717 => {
14991 let responder = ::fidl_next::Responder::from_untyped(responder);
14992
14993 match ::fidl_next::DecoderExt::decode(buffer) {
14994 Ok(decoded) => {
14995 handler
14996 .remove_extended_attribute(
14997 ::fidl_next::Request::from_decoded(decoded),
14998 responder,
14999 )
15000 .await;
15001 Ok(())
15002 }
15003 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15004 ordinal: 8794297771444732717,
15005 error,
15006 }),
15007 }
15008 }
15009
15010 8371117097481679347 => {
15011 let responder = ::fidl_next::Responder::from_untyped(responder);
15012
15013 handler.describe(responder).await;
15014 Ok(())
15015 }
15016
15017 ordinal => {
15018 handler.on_unknown_interaction(ordinal).await;
15019 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
15020 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15021 } else {
15022 responder
15023 .respond(
15024 ordinal,
15025 flexibility,
15026 ::fidl_next::Flexible::<()>::FrameworkErr(
15027 ::fidl_next::FrameworkError::UnknownMethod,
15028 ),
15029 )
15030 .expect("encoding a framework error should never fail")
15031 .await?;
15032 Ok(())
15033 }
15034 }
15035 }
15036 }
15037}
15038
15039pub use fidl_next_common_fuchsia_io::*;
15040
15041pub mod compat {
15043
15044 pub use fidl_next_common_fuchsia_io::compat::*;
15045
15046 impl ::fidl_next::CompatFrom<crate::ConnectionInfo> for ::fidl_fuchsia_io::ConnectionInfo {
15047 fn compat_from(value: crate::ConnectionInfo) -> Self {
15048 Self {
15049 rights: ::fidl_next::CompatFrom::compat_from(value.rights),
15050
15051 __source_breaking: ::fidl::marker::SourceBreaking,
15052 }
15053 }
15054 }
15055
15056 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::ConnectionInfo> for crate::ConnectionInfo {
15057 fn compat_from(value: ::fidl_fuchsia_io::ConnectionInfo) -> Self {
15058 Self { rights: ::fidl_next::CompatFrom::compat_from(value.rights) }
15059 }
15060 }
15061
15062 impl ::fidl_next::CompatFrom<crate::DirectoryGetTokenResponse>
15063 for ::fidl_fuchsia_io::DirectoryGetTokenResponse
15064 {
15065 #[inline]
15066 fn compat_from(value: crate::DirectoryGetTokenResponse) -> Self {
15067 Self {
15068 s: ::fidl_next::CompatFrom::compat_from(value.s),
15069
15070 token: ::fidl_next::CompatFrom::compat_from(value.token),
15071 }
15072 }
15073 }
15074
15075 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::DirectoryGetTokenResponse>
15076 for crate::DirectoryGetTokenResponse
15077 {
15078 #[inline]
15079 fn compat_from(value: ::fidl_fuchsia_io::DirectoryGetTokenResponse) -> Self {
15080 Self {
15081 s: ::fidl_next::CompatFrom::compat_from(value.s),
15082
15083 token: ::fidl_next::CompatFrom::compat_from(value.token),
15084 }
15085 }
15086 }
15087
15088 impl ::fidl_next::CompatFrom<crate::DirectoryLinkRequest>
15089 for ::fidl_fuchsia_io::DirectoryLinkRequest
15090 {
15091 #[inline]
15092 fn compat_from(value: crate::DirectoryLinkRequest) -> Self {
15093 Self {
15094 src: ::fidl_next::CompatFrom::compat_from(value.src),
15095
15096 dst_parent_token: ::fidl_next::CompatFrom::compat_from(value.dst_parent_token),
15097
15098 dst: ::fidl_next::CompatFrom::compat_from(value.dst),
15099 }
15100 }
15101 }
15102
15103 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::DirectoryLinkRequest>
15104 for crate::DirectoryLinkRequest
15105 {
15106 #[inline]
15107 fn compat_from(value: ::fidl_fuchsia_io::DirectoryLinkRequest) -> Self {
15108 Self {
15109 src: ::fidl_next::CompatFrom::compat_from(value.src),
15110
15111 dst_parent_token: ::fidl_next::CompatFrom::compat_from(value.dst_parent_token),
15112
15113 dst: ::fidl_next::CompatFrom::compat_from(value.dst),
15114 }
15115 }
15116 }
15117
15118 impl ::fidl_next::CompatFrom<crate::DirectoryRenameRequest>
15119 for ::fidl_fuchsia_io::DirectoryRenameRequest
15120 {
15121 #[inline]
15122 fn compat_from(value: crate::DirectoryRenameRequest) -> Self {
15123 Self {
15124 src: ::fidl_next::CompatFrom::compat_from(value.src),
15125
15126 dst_parent_token: ::fidl_next::CompatFrom::compat_from(value.dst_parent_token),
15127
15128 dst: ::fidl_next::CompatFrom::compat_from(value.dst),
15129 }
15130 }
15131 }
15132
15133 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::DirectoryRenameRequest>
15134 for crate::DirectoryRenameRequest
15135 {
15136 #[inline]
15137 fn compat_from(value: ::fidl_fuchsia_io::DirectoryRenameRequest) -> Self {
15138 Self {
15139 src: ::fidl_next::CompatFrom::compat_from(value.src),
15140
15141 dst_parent_token: ::fidl_next::CompatFrom::compat_from(value.dst_parent_token),
15142
15143 dst: ::fidl_next::CompatFrom::compat_from(value.dst),
15144 }
15145 }
15146 }
15147
15148 impl ::fidl_next::CompatFrom<crate::DirectoryWatchRequest>
15149 for ::fidl_fuchsia_io::DirectoryWatchRequest
15150 {
15151 #[inline]
15152 fn compat_from(value: crate::DirectoryWatchRequest) -> Self {
15153 Self {
15154 mask: ::fidl_next::CompatFrom::compat_from(value.mask),
15155
15156 options: ::fidl_next::CompatFrom::compat_from(value.options),
15157
15158 watcher: ::fidl_next::CompatFrom::compat_from(value.watcher),
15159 }
15160 }
15161 }
15162
15163 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::DirectoryWatchRequest>
15164 for crate::DirectoryWatchRequest
15165 {
15166 #[inline]
15167 fn compat_from(value: ::fidl_fuchsia_io::DirectoryWatchRequest) -> Self {
15168 Self {
15169 mask: ::fidl_next::CompatFrom::compat_from(value.mask),
15170
15171 options: ::fidl_next::CompatFrom::compat_from(value.options),
15172
15173 watcher: ::fidl_next::CompatFrom::compat_from(value.watcher),
15174 }
15175 }
15176 }
15177
15178 impl ::fidl_next::CompatFrom<crate::NodeOnOpenRequest> for ::fidl_fuchsia_io::NodeOnOpenRequest {
15179 #[inline]
15180 fn compat_from(value: crate::NodeOnOpenRequest) -> Self {
15181 Self {
15182 s: ::fidl_next::CompatFrom::compat_from(value.s),
15183
15184 info: ::fidl_next::CompatFrom::compat_from(value.info),
15185 }
15186 }
15187 }
15188
15189 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeOnOpenRequest> for crate::NodeOnOpenRequest {
15190 #[inline]
15191 fn compat_from(value: ::fidl_fuchsia_io::NodeOnOpenRequest) -> Self {
15192 Self {
15193 s: ::fidl_next::CompatFrom::compat_from(value.s),
15194
15195 info: ::fidl_next::CompatFrom::compat_from(value.info),
15196 }
15197 }
15198 }
15199
15200 impl ::fidl_next::CompatFrom<crate::NodeListExtendedAttributesRequest>
15201 for ::fidl_fuchsia_io::NodeListExtendedAttributesRequest
15202 {
15203 #[inline]
15204 fn compat_from(value: crate::NodeListExtendedAttributesRequest) -> Self {
15205 Self { iterator: ::fidl_next::CompatFrom::compat_from(value.iterator) }
15206 }
15207 }
15208
15209 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeListExtendedAttributesRequest>
15210 for crate::NodeListExtendedAttributesRequest
15211 {
15212 #[inline]
15213 fn compat_from(value: ::fidl_fuchsia_io::NodeListExtendedAttributesRequest) -> Self {
15214 Self { iterator: ::fidl_next::CompatFrom::compat_from(value.iterator) }
15215 }
15216 }
15217
15218 impl ::fidl_next::CompatFrom<crate::ExtendedAttributeValue>
15219 for ::fidl_fuchsia_io::ExtendedAttributeValue
15220 {
15221 fn compat_from(value: crate::ExtendedAttributeValue) -> Self {
15222 match value {
15223 crate::ExtendedAttributeValue::Bytes(value) => {
15224 Self::Bytes(::fidl_next::CompatFrom::compat_from(value))
15225 }
15226
15227 crate::ExtendedAttributeValue::Buffer(value) => {
15228 Self::Buffer(::fidl_next::CompatFrom::compat_from(value))
15229 }
15230
15231 crate::ExtendedAttributeValue::UnknownOrdinal_(unknown_ordinal) => {
15232 Self::__SourceBreaking { unknown_ordinal }
15233 }
15234 }
15235 }
15236 }
15237
15238 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::ExtendedAttributeValue>
15239 for crate::ExtendedAttributeValue
15240 {
15241 fn compat_from(value: ::fidl_fuchsia_io::ExtendedAttributeValue) -> Self {
15242 match value {
15243 ::fidl_fuchsia_io::ExtendedAttributeValue::Bytes(value) => {
15244 Self::Bytes(::fidl_next::CompatFrom::compat_from(value))
15245 }
15246
15247 ::fidl_fuchsia_io::ExtendedAttributeValue::Buffer(value) => {
15248 Self::Buffer(::fidl_next::CompatFrom::compat_from(value))
15249 }
15250
15251 ::fidl_fuchsia_io::ExtendedAttributeValue::__SourceBreaking { unknown_ordinal } => {
15252 Self::UnknownOrdinal_(unknown_ordinal)
15253 }
15254 }
15255 }
15256 }
15257
15258 impl ::fidl_next::CompatFrom<crate::NodeSetExtendedAttributeRequest>
15259 for ::fidl_fuchsia_io::NodeSetExtendedAttributeRequest
15260 {
15261 #[inline]
15262 fn compat_from(value: crate::NodeSetExtendedAttributeRequest) -> Self {
15263 Self {
15264 name: ::fidl_next::CompatFrom::compat_from(value.name),
15265
15266 value: ::fidl_next::CompatFrom::compat_from(value.value),
15267
15268 mode: ::fidl_next::CompatFrom::compat_from(value.mode),
15269 }
15270 }
15271 }
15272
15273 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeSetExtendedAttributeRequest>
15274 for crate::NodeSetExtendedAttributeRequest
15275 {
15276 #[inline]
15277 fn compat_from(value: ::fidl_fuchsia_io::NodeSetExtendedAttributeRequest) -> Self {
15278 Self {
15279 name: ::fidl_next::CompatFrom::compat_from(value.name),
15280
15281 value: ::fidl_next::CompatFrom::compat_from(value.value),
15282
15283 mode: ::fidl_next::CompatFrom::compat_from(value.mode),
15284 }
15285 }
15286 }
15287
15288 impl ::fidl_next::CompatFrom<crate::FileInfo> for ::fidl_fuchsia_io::FileInfo {
15289 fn compat_from(value: crate::FileInfo) -> Self {
15290 Self {
15291 is_append: ::fidl_next::CompatFrom::compat_from(value.is_append),
15292
15293 observer: ::fidl_next::CompatFrom::compat_from(value.observer),
15294
15295 stream: ::fidl_next::CompatFrom::compat_from(value.stream),
15296
15297 attributes: ::fidl_next::CompatFrom::compat_from(value.attributes),
15298
15299 __source_breaking: ::fidl::marker::SourceBreaking,
15300 }
15301 }
15302 }
15303
15304 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::FileInfo> for crate::FileInfo {
15305 fn compat_from(value: ::fidl_fuchsia_io::FileInfo) -> Self {
15306 Self {
15307 is_append: ::fidl_next::CompatFrom::compat_from(value.is_append),
15308
15309 observer: ::fidl_next::CompatFrom::compat_from(value.observer),
15310
15311 stream: ::fidl_next::CompatFrom::compat_from(value.stream),
15312
15313 attributes: ::fidl_next::CompatFrom::compat_from(value.attributes),
15314 }
15315 }
15316 }
15317
15318 impl ::fidl_next::CompatFrom<crate::Representation> for ::fidl_fuchsia_io::Representation {
15319 fn compat_from(value: crate::Representation) -> Self {
15320 match value {
15321 crate::Representation::Node(value) => {
15322 Self::Node(::fidl_next::CompatFrom::compat_from(value))
15323 }
15324
15325 crate::Representation::Directory(value) => {
15326 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
15327 }
15328
15329 crate::Representation::File(value) => {
15330 Self::File(::fidl_next::CompatFrom::compat_from(value))
15331 }
15332
15333 crate::Representation::Symlink(value) => {
15334 Self::Symlink(::fidl_next::CompatFrom::compat_from(value))
15335 }
15336
15337 crate::Representation::UnknownOrdinal_(unknown_ordinal) => {
15338 Self::__SourceBreaking { unknown_ordinal }
15339 }
15340 }
15341 }
15342 }
15343
15344 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::Representation> for crate::Representation {
15345 fn compat_from(value: ::fidl_fuchsia_io::Representation) -> Self {
15346 match value {
15347 ::fidl_fuchsia_io::Representation::Node(value) => {
15348 Self::Node(::fidl_next::CompatFrom::compat_from(value))
15349 }
15350
15351 ::fidl_fuchsia_io::Representation::Directory(value) => {
15352 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
15353 }
15354
15355 ::fidl_fuchsia_io::Representation::File(value) => {
15356 Self::File(::fidl_next::CompatFrom::compat_from(value))
15357 }
15358
15359 ::fidl_fuchsia_io::Representation::Symlink(value) => {
15360 Self::Symlink(::fidl_next::CompatFrom::compat_from(value))
15361 }
15362
15363 ::fidl_fuchsia_io::Representation::__SourceBreaking { unknown_ordinal } => {
15364 Self::UnknownOrdinal_(unknown_ordinal)
15365 }
15366 }
15367 }
15368 }
15369
15370 impl ::fidl_next::CompatFrom<crate::DirectoryOpenRequest>
15371 for ::fidl_fuchsia_io::DirectoryOpenRequest
15372 {
15373 #[inline]
15374 fn compat_from(value: crate::DirectoryOpenRequest) -> Self {
15375 Self {
15376 path: ::fidl_next::CompatFrom::compat_from(value.path),
15377
15378 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
15379
15380 options: ::fidl_next::CompatFrom::compat_from(value.options),
15381
15382 object: ::fidl_next::CompatFrom::compat_from(value.object),
15383 }
15384 }
15385 }
15386
15387 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::DirectoryOpenRequest>
15388 for crate::DirectoryOpenRequest
15389 {
15390 #[inline]
15391 fn compat_from(value: ::fidl_fuchsia_io::DirectoryOpenRequest) -> Self {
15392 Self {
15393 path: ::fidl_next::CompatFrom::compat_from(value.path),
15394
15395 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
15396
15397 options: ::fidl_next::CompatFrom::compat_from(value.options),
15398
15399 object: ::fidl_next::CompatFrom::compat_from(value.object),
15400 }
15401 }
15402 }
15403
15404 impl ::fidl_next::CompatFrom<crate::NodeDeprecatedCloneRequest>
15405 for ::fidl_fuchsia_io::NodeDeprecatedCloneRequest
15406 {
15407 #[inline]
15408 fn compat_from(value: crate::NodeDeprecatedCloneRequest) -> Self {
15409 Self {
15410 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
15411
15412 object: ::fidl_next::CompatFrom::compat_from(value.object),
15413 }
15414 }
15415 }
15416
15417 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeDeprecatedCloneRequest>
15418 for crate::NodeDeprecatedCloneRequest
15419 {
15420 #[inline]
15421 fn compat_from(value: ::fidl_fuchsia_io::NodeDeprecatedCloneRequest) -> Self {
15422 Self {
15423 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
15424
15425 object: ::fidl_next::CompatFrom::compat_from(value.object),
15426 }
15427 }
15428 }
15429
15430 #[cfg(target_os = "fuchsia")]
15431 pub type NodeProxy = ::fidl_next::Client<crate::Node>;
15434
15435 impl ::fidl_next::CompatFrom<crate::Node> for ::fidl_fuchsia_io::NodeMarker {
15436 fn compat_from(_: crate::Node) -> Self {
15437 Self
15438 }
15439 }
15440
15441 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeMarker> for crate::Node {
15442 fn compat_from(_: ::fidl_fuchsia_io::NodeMarker) -> Self {
15443 Self
15444 }
15445 }
15446
15447 #[cfg(target_os = "fuchsia")]
15448
15449 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_io::NodeProxy> for crate::Node {
15450 fn client_compat_from(
15451 proxy: ::fidl_fuchsia_io::NodeProxy,
15452 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
15453 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
15454 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
15455 ::fidl_next::ClientDispatcher::new(client_end)
15456 }
15457 }
15458
15459 impl ::fidl_next::CompatFrom<crate::DirectoryDeprecatedOpenRequest>
15460 for ::fidl_fuchsia_io::DirectoryDeprecatedOpenRequest
15461 {
15462 #[inline]
15463 fn compat_from(value: crate::DirectoryDeprecatedOpenRequest) -> Self {
15464 Self {
15465 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
15466
15467 mode: ::fidl_next::CompatFrom::compat_from(value.mode),
15468
15469 path: ::fidl_next::CompatFrom::compat_from(value.path),
15470
15471 object: ::fidl_next::CompatFrom::compat_from(value.object),
15472 }
15473 }
15474 }
15475
15476 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::DirectoryDeprecatedOpenRequest>
15477 for crate::DirectoryDeprecatedOpenRequest
15478 {
15479 #[inline]
15480 fn compat_from(value: ::fidl_fuchsia_io::DirectoryDeprecatedOpenRequest) -> Self {
15481 Self {
15482 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
15483
15484 mode: ::fidl_next::CompatFrom::compat_from(value.mode),
15485
15486 path: ::fidl_next::CompatFrom::compat_from(value.path),
15487
15488 object: ::fidl_next::CompatFrom::compat_from(value.object),
15489 }
15490 }
15491 }
15492
15493 impl ::fidl_next::CompatFrom<crate::DirectoryCreateSymlinkRequest>
15494 for ::fidl_fuchsia_io::DirectoryCreateSymlinkRequest
15495 {
15496 #[inline]
15497 fn compat_from(value: crate::DirectoryCreateSymlinkRequest) -> Self {
15498 Self {
15499 name: ::fidl_next::CompatFrom::compat_from(value.name),
15500
15501 target: ::fidl_next::CompatFrom::compat_from(value.target),
15502
15503 connection: ::fidl_next::CompatFrom::compat_from(value.connection),
15504 }
15505 }
15506 }
15507
15508 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::DirectoryCreateSymlinkRequest>
15509 for crate::DirectoryCreateSymlinkRequest
15510 {
15511 #[inline]
15512 fn compat_from(value: ::fidl_fuchsia_io::DirectoryCreateSymlinkRequest) -> Self {
15513 Self {
15514 name: ::fidl_next::CompatFrom::compat_from(value.name),
15515
15516 target: ::fidl_next::CompatFrom::compat_from(value.target),
15517
15518 connection: ::fidl_next::CompatFrom::compat_from(value.connection),
15519 }
15520 }
15521 }
15522
15523 #[cfg(target_os = "fuchsia")]
15524 pub type DirectoryProxy = ::fidl_next::Client<crate::Directory>;
15527
15528 impl ::fidl_next::CompatFrom<crate::Directory> for ::fidl_fuchsia_io::DirectoryMarker {
15529 fn compat_from(_: crate::Directory) -> Self {
15530 Self
15531 }
15532 }
15533
15534 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::DirectoryMarker> for crate::Directory {
15535 fn compat_from(_: ::fidl_fuchsia_io::DirectoryMarker) -> Self {
15536 Self
15537 }
15538 }
15539
15540 #[cfg(target_os = "fuchsia")]
15541
15542 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_io::DirectoryProxy> for crate::Directory {
15543 fn client_compat_from(
15544 proxy: ::fidl_fuchsia_io::DirectoryProxy,
15545 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
15546 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
15547 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
15548 ::fidl_next::ClientDispatcher::new(client_end)
15549 }
15550 }
15551
15552 impl ::fidl_next::CompatFrom<crate::FileGetBackingMemoryResponse>
15553 for ::fidl_fuchsia_io::FileGetBackingMemoryResponse
15554 {
15555 #[inline]
15556 fn compat_from(value: crate::FileGetBackingMemoryResponse) -> Self {
15557 Self { vmo: ::fidl_next::CompatFrom::compat_from(value.vmo) }
15558 }
15559 }
15560
15561 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::FileGetBackingMemoryResponse>
15562 for crate::FileGetBackingMemoryResponse
15563 {
15564 #[inline]
15565 fn compat_from(value: ::fidl_fuchsia_io::FileGetBackingMemoryResponse) -> Self {
15566 Self { vmo: ::fidl_next::CompatFrom::compat_from(value.vmo) }
15567 }
15568 }
15569
15570 impl ::fidl_next::CompatFrom<crate::LinkableLinkIntoRequest>
15571 for ::fidl_fuchsia_io::LinkableLinkIntoRequest
15572 {
15573 #[inline]
15574 fn compat_from(value: crate::LinkableLinkIntoRequest) -> Self {
15575 Self {
15576 dst_parent_token: ::fidl_next::CompatFrom::compat_from(value.dst_parent_token),
15577
15578 dst: ::fidl_next::CompatFrom::compat_from(value.dst),
15579 }
15580 }
15581 }
15582
15583 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::LinkableLinkIntoRequest>
15584 for crate::LinkableLinkIntoRequest
15585 {
15586 #[inline]
15587 fn compat_from(value: ::fidl_fuchsia_io::LinkableLinkIntoRequest) -> Self {
15588 Self {
15589 dst_parent_token: ::fidl_next::CompatFrom::compat_from(value.dst_parent_token),
15590
15591 dst: ::fidl_next::CompatFrom::compat_from(value.dst),
15592 }
15593 }
15594 }
15595
15596 #[cfg(target_os = "fuchsia")]
15597 pub type LinkableProxy = ::fidl_next::Client<crate::Linkable>;
15600
15601 impl ::fidl_next::CompatFrom<crate::Linkable> for ::fidl_fuchsia_io::LinkableMarker {
15602 fn compat_from(_: crate::Linkable) -> Self {
15603 Self
15604 }
15605 }
15606
15607 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::LinkableMarker> for crate::Linkable {
15608 fn compat_from(_: ::fidl_fuchsia_io::LinkableMarker) -> Self {
15609 Self
15610 }
15611 }
15612
15613 #[cfg(target_os = "fuchsia")]
15614
15615 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_io::LinkableProxy> for crate::Linkable {
15616 fn client_compat_from(
15617 proxy: ::fidl_fuchsia_io::LinkableProxy,
15618 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
15619 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
15620 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
15621 ::fidl_next::ClientDispatcher::new(client_end)
15622 }
15623 }
15624
15625 impl ::fidl_next::CompatFrom<crate::FileAllocateRequest>
15626 for ::fidl_fuchsia_io::FileAllocateRequest
15627 {
15628 #[inline]
15629 fn compat_from(value: crate::FileAllocateRequest) -> Self {
15630 Self {
15631 offset: ::fidl_next::CompatFrom::compat_from(value.offset),
15632
15633 length: ::fidl_next::CompatFrom::compat_from(value.length),
15634
15635 mode: ::fidl_next::CompatFrom::compat_from(value.mode),
15636 }
15637 }
15638 }
15639
15640 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::FileAllocateRequest>
15641 for crate::FileAllocateRequest
15642 {
15643 #[inline]
15644 fn compat_from(value: ::fidl_fuchsia_io::FileAllocateRequest) -> Self {
15645 Self {
15646 offset: ::fidl_next::CompatFrom::compat_from(value.offset),
15647
15648 length: ::fidl_next::CompatFrom::compat_from(value.length),
15649
15650 mode: ::fidl_next::CompatFrom::compat_from(value.mode),
15651 }
15652 }
15653 }
15654
15655 impl ::fidl_next::CompatFrom<crate::FileEnableVerityRequest>
15656 for ::fidl_fuchsia_io::FileEnableVerityRequest
15657 {
15658 #[inline]
15659 fn compat_from(value: crate::FileEnableVerityRequest) -> Self {
15660 Self { options: ::fidl_next::CompatFrom::compat_from(value.options) }
15661 }
15662 }
15663
15664 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::FileEnableVerityRequest>
15665 for crate::FileEnableVerityRequest
15666 {
15667 #[inline]
15668 fn compat_from(value: ::fidl_fuchsia_io::FileEnableVerityRequest) -> Self {
15669 Self { options: ::fidl_next::CompatFrom::compat_from(value.options) }
15670 }
15671 }
15672
15673 #[cfg(target_os = "fuchsia")]
15674 pub type FileProxy = ::fidl_next::Client<crate::File>;
15677
15678 impl ::fidl_next::CompatFrom<crate::File> for ::fidl_fuchsia_io::FileMarker {
15679 fn compat_from(_: crate::File) -> Self {
15680 Self
15681 }
15682 }
15683
15684 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::FileMarker> for crate::File {
15685 fn compat_from(_: ::fidl_fuchsia_io::FileMarker) -> Self {
15686 Self
15687 }
15688 }
15689
15690 #[cfg(target_os = "fuchsia")]
15691
15692 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_io::FileProxy> for crate::File {
15693 fn client_compat_from(
15694 proxy: ::fidl_fuchsia_io::FileProxy,
15695 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
15696 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
15697 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
15698 ::fidl_next::ClientDispatcher::new(client_end)
15699 }
15700 }
15701
15702 impl ::fidl_next::CompatFrom<crate::FileObject> for ::fidl_fuchsia_io::FileObject {
15703 #[inline]
15704 fn compat_from(value: crate::FileObject) -> Self {
15705 Self {
15706 event: ::fidl_next::CompatFrom::compat_from(value.event),
15707
15708 stream: ::fidl_next::CompatFrom::compat_from(value.stream),
15709 }
15710 }
15711 }
15712
15713 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::FileObject> for crate::FileObject {
15714 #[inline]
15715 fn compat_from(value: ::fidl_fuchsia_io::FileObject) -> Self {
15716 Self {
15717 event: ::fidl_next::CompatFrom::compat_from(value.event),
15718
15719 stream: ::fidl_next::CompatFrom::compat_from(value.stream),
15720 }
15721 }
15722 }
15723
15724 impl ::fidl_next::CompatFrom<crate::NodeInfoDeprecated> for ::fidl_fuchsia_io::NodeInfoDeprecated {
15725 fn compat_from(value: crate::NodeInfoDeprecated) -> Self {
15726 match value {
15727 crate::NodeInfoDeprecated::Service(value) => {
15728 Self::Service(::fidl_next::CompatFrom::compat_from(value))
15729 }
15730
15731 crate::NodeInfoDeprecated::File(value) => {
15732 Self::File(::fidl_next::CompatFrom::compat_from(value))
15733 }
15734
15735 crate::NodeInfoDeprecated::Directory(value) => {
15736 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
15737 }
15738
15739 crate::NodeInfoDeprecated::Symlink(value) => {
15740 Self::Symlink(::fidl_next::CompatFrom::compat_from(value))
15741 }
15742 }
15743 }
15744 }
15745
15746 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::NodeInfoDeprecated> for crate::NodeInfoDeprecated {
15747 fn compat_from(value: ::fidl_fuchsia_io::NodeInfoDeprecated) -> Self {
15748 match value {
15749 ::fidl_fuchsia_io::NodeInfoDeprecated::Service(value) => {
15750 Self::Service(::fidl_next::CompatFrom::compat_from(value))
15751 }
15752
15753 ::fidl_fuchsia_io::NodeInfoDeprecated::File(value) => {
15754 Self::File(::fidl_next::CompatFrom::compat_from(value))
15755 }
15756
15757 ::fidl_fuchsia_io::NodeInfoDeprecated::Directory(value) => {
15758 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
15759 }
15760
15761 ::fidl_fuchsia_io::NodeInfoDeprecated::Symlink(value) => {
15762 Self::Symlink(::fidl_next::CompatFrom::compat_from(value))
15763 }
15764 }
15765 }
15766 }
15767
15768 #[cfg(target_os = "fuchsia")]
15769 pub type SymlinkProxy = ::fidl_next::Client<crate::Symlink>;
15772
15773 impl ::fidl_next::CompatFrom<crate::Symlink> for ::fidl_fuchsia_io::SymlinkMarker {
15774 fn compat_from(_: crate::Symlink) -> Self {
15775 Self
15776 }
15777 }
15778
15779 impl ::fidl_next::CompatFrom<::fidl_fuchsia_io::SymlinkMarker> for crate::Symlink {
15780 fn compat_from(_: ::fidl_fuchsia_io::SymlinkMarker) -> Self {
15781 Self
15782 }
15783 }
15784
15785 #[cfg(target_os = "fuchsia")]
15786
15787 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_io::SymlinkProxy> for crate::Symlink {
15788 fn client_compat_from(
15789 proxy: ::fidl_fuchsia_io::SymlinkProxy,
15790 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
15791 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
15792 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
15793 ::fidl_next::ClientDispatcher::new(client_end)
15794 }
15795 }
15796}