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(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
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: ::fdomain_client::fidl_next::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::wire::Envelope>::uninit();
41 ::fidl_next::Wire::zero_padding(&mut out);
42
43 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
44 ::fidl_next::wire::Envelope,
45 >(encoder, max_ord);
46
47 for i in 1..=max_ord {
48 match i {
49 1 => {
50 if let Some(value) = self.rights.take() {
51 ::fidl_next::wire::Envelope::encode_value::<
52 crate::wire::Operations,
53 ___E,
54 >(
55 value, preallocated.encoder, &mut out, ()
56 )?;
57 } else {
58 ::fidl_next::wire::Envelope::encode_zero(&mut out)
59 }
60 }
61
62 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
63 }
64 unsafe {
65 preallocated.write_next(out.assume_init_ref());
66 }
67 }
68
69 ::fidl_next::wire::Table::encode_len(table, max_ord);
70
71 Ok(())
72 }
73 }
74
75 impl<'de> ::fidl_next::FromWire<crate::wire::ConnectionInfo<'de>> for ConnectionInfo {
76 #[inline]
77 fn from_wire(wire_: crate::wire::ConnectionInfo<'de>) -> Self {
78 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
79
80 let rights = wire_.table.get(1);
81
82 Self {
83 rights: rights.map(|envelope| {
84 ::fidl_next::FromWire::from_wire(unsafe {
85 envelope.read_unchecked::<crate::wire::Operations>()
86 })
87 }),
88 }
89 }
90 }
91
92 #[derive(Debug, PartialEq)]
93 #[repr(C)]
94 pub struct DirectoryGetTokenResponse {
95 pub s: i32,
96
97 pub token: ::core::option::Option<::fdomain_client::NullableHandle>,
98 }
99
100 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryGetTokenResponse, ___E>
101 for DirectoryGetTokenResponse
102 where
103 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
104 ___E: ::fdomain_client::fidl_next::HandleEncoder,
105 {
106 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
107 Self,
108 crate::wire::DirectoryGetTokenResponse,
109 > = unsafe {
110 ::fidl_next::CopyOptimization::enable_if(
111 true
112
113 && <
114 i32 as ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>
115 >::COPY_OPTIMIZATION.is_enabled()
116
117 && <
118 ::core::option::Option<::fdomain_client::NullableHandle> as ::fidl_next::Encode<::fdomain_client::fidl_next::wire::OptionalHandle, ___E>
119 >::COPY_OPTIMIZATION.is_enabled()
120
121 )
122 };
123
124 #[inline]
125 fn encode(
126 self,
127 encoder_: &mut ___E,
128 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryGetTokenResponse>,
129 _: (),
130 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
131 ::fidl_next::munge! {
132 let crate::wire::DirectoryGetTokenResponse {
133 s,
134 token,
135
136 } = out_;
137 }
138
139 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
140
141 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
142
143 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
144
145 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
146
147 Ok(())
148 }
149 }
150
151 unsafe impl<___E>
152 ::fidl_next::EncodeOption<
153 ::fidl_next::wire::Box<'static, crate::wire::DirectoryGetTokenResponse>,
154 ___E,
155 > for DirectoryGetTokenResponse
156 where
157 ___E: ::fidl_next::Encoder + ?Sized,
158 DirectoryGetTokenResponse:
159 ::fidl_next::Encode<crate::wire::DirectoryGetTokenResponse, ___E>,
160 {
161 #[inline]
162 fn encode_option(
163 this: ::core::option::Option<Self>,
164 encoder: &mut ___E,
165 out: &mut ::core::mem::MaybeUninit<
166 ::fidl_next::wire::Box<'static, crate::wire::DirectoryGetTokenResponse>,
167 >,
168 _: (),
169 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
170 if let Some(inner) = this {
171 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
172 ::fidl_next::wire::Box::encode_present(out);
173 } else {
174 ::fidl_next::wire::Box::encode_absent(out);
175 }
176
177 Ok(())
178 }
179 }
180
181 impl ::fidl_next::FromWire<crate::wire::DirectoryGetTokenResponse> for DirectoryGetTokenResponse {
182 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
183 crate::wire::DirectoryGetTokenResponse,
184 Self,
185 > = unsafe {
186 ::fidl_next::CopyOptimization::enable_if(
187 true
188
189 && <
190 i32 as ::fidl_next::FromWire<::fidl_next::wire::Int32>
191 >::COPY_OPTIMIZATION.is_enabled()
192
193 && <
194 ::core::option::Option<::fdomain_client::NullableHandle> as ::fidl_next::FromWire<::fdomain_client::fidl_next::wire::OptionalHandle>
195 >::COPY_OPTIMIZATION.is_enabled()
196
197 )
198 };
199
200 #[inline]
201 fn from_wire(wire: crate::wire::DirectoryGetTokenResponse) -> Self {
202 Self {
203 s: ::fidl_next::FromWire::from_wire(wire.s),
204
205 token: ::fidl_next::FromWire::from_wire(wire.token),
206 }
207 }
208 }
209
210 #[derive(Debug, PartialEq)]
211 pub struct DirectoryLinkRequest {
212 pub src: ::std::string::String,
213
214 pub dst_parent_token: ::fdomain_client::NullableHandle,
215
216 pub dst: ::std::string::String,
217 }
218
219 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryLinkRequest<'static>, ___E>
220 for DirectoryLinkRequest
221 where
222 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
223 ___E: ::fidl_next::Encoder,
224 ___E: ::fdomain_client::fidl_next::HandleEncoder,
225 {
226 #[inline]
227 fn encode(
228 self,
229 encoder_: &mut ___E,
230 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkRequest<'static>>,
231 _: (),
232 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
233 ::fidl_next::munge! {
234 let crate::wire::DirectoryLinkRequest {
235 src,
236 dst_parent_token,
237 dst,
238
239 } = out_;
240 }
241
242 ::fidl_next::Encode::encode(self.src, encoder_, src, 255)?;
243
244 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(src.as_mut_ptr()) };
245 ::fidl_next::Constrained::validate(_field, 255)?;
246
247 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
248
249 let mut _field =
250 unsafe { ::fidl_next::Slot::new_unchecked(dst_parent_token.as_mut_ptr()) };
251
252 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
253
254 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dst.as_mut_ptr()) };
255 ::fidl_next::Constrained::validate(_field, 255)?;
256
257 Ok(())
258 }
259 }
260
261 unsafe impl<___E>
262 ::fidl_next::EncodeOption<
263 ::fidl_next::wire::Box<'static, crate::wire::DirectoryLinkRequest<'static>>,
264 ___E,
265 > for DirectoryLinkRequest
266 where
267 ___E: ::fidl_next::Encoder + ?Sized,
268 DirectoryLinkRequest: ::fidl_next::Encode<crate::wire::DirectoryLinkRequest<'static>, ___E>,
269 {
270 #[inline]
271 fn encode_option(
272 this: ::core::option::Option<Self>,
273 encoder: &mut ___E,
274 out: &mut ::core::mem::MaybeUninit<
275 ::fidl_next::wire::Box<'static, crate::wire::DirectoryLinkRequest<'static>>,
276 >,
277 _: (),
278 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
279 if let Some(inner) = this {
280 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
281 ::fidl_next::wire::Box::encode_present(out);
282 } else {
283 ::fidl_next::wire::Box::encode_absent(out);
284 }
285
286 Ok(())
287 }
288 }
289
290 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryLinkRequest<'de>> for DirectoryLinkRequest {
291 #[inline]
292 fn from_wire(wire: crate::wire::DirectoryLinkRequest<'de>) -> Self {
293 Self {
294 src: ::fidl_next::FromWire::from_wire(wire.src),
295
296 dst_parent_token: ::fidl_next::FromWire::from_wire(wire.dst_parent_token),
297
298 dst: ::fidl_next::FromWire::from_wire(wire.dst),
299 }
300 }
301 }
302
303 #[doc = " The type to identify a connection to a node.\n It represents a capability: a reference to a node with associated rights.\n"]
304 pub type Token = ::fdomain_client::Event;
305
306 #[derive(Debug, PartialEq)]
307 pub struct DirectoryRenameRequest {
308 pub src: ::std::string::String,
309
310 pub dst_parent_token: ::fdomain_client::Event,
311
312 pub dst: ::std::string::String,
313 }
314
315 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryRenameRequest<'static>, ___E>
316 for DirectoryRenameRequest
317 where
318 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
319 ___E: ::fidl_next::Encoder,
320 ___E: ::fdomain_client::fidl_next::HandleEncoder,
321 {
322 #[inline]
323 fn encode(
324 self,
325 encoder_: &mut ___E,
326 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRenameRequest<'static>>,
327 _: (),
328 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
329 ::fidl_next::munge! {
330 let crate::wire::DirectoryRenameRequest {
331 src,
332 dst_parent_token,
333 dst,
334
335 } = out_;
336 }
337
338 ::fidl_next::Encode::encode(self.src, encoder_, src, 255)?;
339
340 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(src.as_mut_ptr()) };
341 ::fidl_next::Constrained::validate(_field, 255)?;
342
343 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
344
345 let mut _field =
346 unsafe { ::fidl_next::Slot::new_unchecked(dst_parent_token.as_mut_ptr()) };
347
348 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
349
350 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dst.as_mut_ptr()) };
351 ::fidl_next::Constrained::validate(_field, 255)?;
352
353 Ok(())
354 }
355 }
356
357 unsafe impl<___E>
358 ::fidl_next::EncodeOption<
359 ::fidl_next::wire::Box<'static, crate::wire::DirectoryRenameRequest<'static>>,
360 ___E,
361 > for DirectoryRenameRequest
362 where
363 ___E: ::fidl_next::Encoder + ?Sized,
364 DirectoryRenameRequest:
365 ::fidl_next::Encode<crate::wire::DirectoryRenameRequest<'static>, ___E>,
366 {
367 #[inline]
368 fn encode_option(
369 this: ::core::option::Option<Self>,
370 encoder: &mut ___E,
371 out: &mut ::core::mem::MaybeUninit<
372 ::fidl_next::wire::Box<'static, crate::wire::DirectoryRenameRequest<'static>>,
373 >,
374 _: (),
375 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
376 if let Some(inner) = this {
377 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
378 ::fidl_next::wire::Box::encode_present(out);
379 } else {
380 ::fidl_next::wire::Box::encode_absent(out);
381 }
382
383 Ok(())
384 }
385 }
386
387 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryRenameRequest<'de>>
388 for DirectoryRenameRequest
389 {
390 #[inline]
391 fn from_wire(wire: crate::wire::DirectoryRenameRequest<'de>) -> Self {
392 Self {
393 src: ::fidl_next::FromWire::from_wire(wire.src),
394
395 dst_parent_token: ::fidl_next::FromWire::from_wire(wire.dst_parent_token),
396
397 dst: ::fidl_next::FromWire::from_wire(wire.dst),
398 }
399 }
400 }
401
402 #[derive(Debug, PartialEq)]
403 #[repr(C)]
404 pub struct DirectoryWatchRequest {
405 pub mask: crate::natural::WatchMask,
406
407 pub options: u32,
408
409 pub watcher: ::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fdomain_client::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: ::fdomain_client::fidl_next::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
424
425 && <
426 crate::natural::WatchMask as ::fidl_next::Encode<crate::wire::WatchMask, ___E>
427 >::COPY_OPTIMIZATION.is_enabled()
428
429 && <
430 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
431 >::COPY_OPTIMIZATION.is_enabled()
432
433 && <
434 ::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fdomain_client::Channel> as ::fidl_next::Encode<::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fdomain_client::fidl_next::wire::Handle>, ___E>
435 >::COPY_OPTIMIZATION.is_enabled()
436
437 )
438 };
439
440 #[inline]
441 fn encode(
442 self,
443 encoder_: &mut ___E,
444 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchRequest>,
445 _: (),
446 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
447 ::fidl_next::munge! {
448 let crate::wire::DirectoryWatchRequest {
449 mask,
450 options,
451 watcher,
452
453 } = out_;
454 }
455
456 ::fidl_next::Encode::encode(self.mask, encoder_, mask, ())?;
457
458 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mask.as_mut_ptr()) };
459
460 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
461
462 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
463
464 ::fidl_next::Encode::encode(self.watcher, encoder_, watcher, ())?;
465
466 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(watcher.as_mut_ptr()) };
467
468 Ok(())
469 }
470 }
471
472 unsafe impl<___E>
473 ::fidl_next::EncodeOption<
474 ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchRequest>,
475 ___E,
476 > for DirectoryWatchRequest
477 where
478 ___E: ::fidl_next::Encoder + ?Sized,
479 DirectoryWatchRequest: ::fidl_next::Encode<crate::wire::DirectoryWatchRequest, ___E>,
480 {
481 #[inline]
482 fn encode_option(
483 this: ::core::option::Option<Self>,
484 encoder: &mut ___E,
485 out: &mut ::core::mem::MaybeUninit<
486 ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchRequest>,
487 >,
488 _: (),
489 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
490 if let Some(inner) = this {
491 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
492 ::fidl_next::wire::Box::encode_present(out);
493 } else {
494 ::fidl_next::wire::Box::encode_absent(out);
495 }
496
497 Ok(())
498 }
499 }
500
501 impl ::fidl_next::FromWire<crate::wire::DirectoryWatchRequest> for DirectoryWatchRequest {
502 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
503 crate::wire::DirectoryWatchRequest,
504 Self,
505 > = unsafe {
506 ::fidl_next::CopyOptimization::enable_if(
507 true
508
509 && <
510 crate::natural::WatchMask as ::fidl_next::FromWire<crate::wire::WatchMask>
511 >::COPY_OPTIMIZATION.is_enabled()
512
513 && <
514 u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>
515 >::COPY_OPTIMIZATION.is_enabled()
516
517 && <
518 ::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fdomain_client::Channel> as ::fidl_next::FromWire<::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fdomain_client::fidl_next::wire::Handle>>
519 >::COPY_OPTIMIZATION.is_enabled()
520
521 )
522 };
523
524 #[inline]
525 fn from_wire(wire: crate::wire::DirectoryWatchRequest) -> Self {
526 Self {
527 mask: ::fidl_next::FromWire::from_wire(wire.mask),
528
529 options: ::fidl_next::FromWire::from_wire(wire.options),
530
531 watcher: ::fidl_next::FromWire::from_wire(wire.watcher),
532 }
533 }
534 }
535
536 #[derive(Debug, PartialEq)]
537 pub struct NodeOnOpenRequest {
538 pub s: i32,
539
540 pub info: ::core::option::Option<::std::boxed::Box<crate::natural::NodeInfoDeprecated>>,
541 }
542
543 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeOnOpenRequest<'static>, ___E>
544 for NodeOnOpenRequest
545 where
546 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
547 ___E: ::fidl_next::Encoder,
548 ___E: ::fdomain_client::fidl_next::HandleEncoder,
549 {
550 #[inline]
551 fn encode(
552 self,
553 encoder_: &mut ___E,
554 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeOnOpenRequest<'static>>,
555 _: (),
556 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
557 ::fidl_next::munge! {
558 let crate::wire::NodeOnOpenRequest {
559 s,
560 info,
561
562 } = out_;
563 }
564
565 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
566
567 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
568
569 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
570
571 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
572
573 Ok(())
574 }
575 }
576
577 unsafe impl<___E>
578 ::fidl_next::EncodeOption<
579 ::fidl_next::wire::Box<'static, crate::wire::NodeOnOpenRequest<'static>>,
580 ___E,
581 > for NodeOnOpenRequest
582 where
583 ___E: ::fidl_next::Encoder + ?Sized,
584 NodeOnOpenRequest: ::fidl_next::Encode<crate::wire::NodeOnOpenRequest<'static>, ___E>,
585 {
586 #[inline]
587 fn encode_option(
588 this: ::core::option::Option<Self>,
589 encoder: &mut ___E,
590 out: &mut ::core::mem::MaybeUninit<
591 ::fidl_next::wire::Box<'static, crate::wire::NodeOnOpenRequest<'static>>,
592 >,
593 _: (),
594 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
595 if let Some(inner) = this {
596 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
597 ::fidl_next::wire::Box::encode_present(out);
598 } else {
599 ::fidl_next::wire::Box::encode_absent(out);
600 }
601
602 Ok(())
603 }
604 }
605
606 impl<'de> ::fidl_next::FromWire<crate::wire::NodeOnOpenRequest<'de>> for NodeOnOpenRequest {
607 #[inline]
608 fn from_wire(wire: crate::wire::NodeOnOpenRequest<'de>) -> Self {
609 Self {
610 s: ::fidl_next::FromWire::from_wire(wire.s),
611
612 info: ::fidl_next::FromWire::from_wire(wire.info),
613 }
614 }
615 }
616
617 #[derive(Debug, PartialEq)]
618 #[repr(C)]
619 pub struct NodeListExtendedAttributesRequest {
620 pub iterator:
621 ::fidl_next::ServerEnd<crate::ExtendedAttributeIterator, ::fdomain_client::Channel>,
622 }
623
624 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeListExtendedAttributesRequest, ___E>
625 for NodeListExtendedAttributesRequest
626 where
627 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
628 ___E: ::fdomain_client::fidl_next::HandleEncoder,
629 {
630 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
631 Self,
632 crate::wire::NodeListExtendedAttributesRequest,
633 > = unsafe {
634 ::fidl_next::CopyOptimization::enable_if(
635 true && <::fidl_next::ServerEnd<
636 crate::ExtendedAttributeIterator,
637 ::fdomain_client::Channel,
638 > as ::fidl_next::Encode<
639 ::fidl_next::ServerEnd<
640 crate::ExtendedAttributeIterator,
641 ::fdomain_client::fidl_next::wire::Handle,
642 >,
643 ___E,
644 >>::COPY_OPTIMIZATION
645 .is_enabled(),
646 )
647 };
648
649 #[inline]
650 fn encode(
651 self,
652 encoder_: &mut ___E,
653 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeListExtendedAttributesRequest>,
654 _: (),
655 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
656 ::fidl_next::munge! {
657 let crate::wire::NodeListExtendedAttributesRequest {
658 iterator,
659
660 } = out_;
661 }
662
663 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
664
665 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
666
667 Ok(())
668 }
669 }
670
671 unsafe impl<___E>
672 ::fidl_next::EncodeOption<
673 ::fidl_next::wire::Box<'static, crate::wire::NodeListExtendedAttributesRequest>,
674 ___E,
675 > for NodeListExtendedAttributesRequest
676 where
677 ___E: ::fidl_next::Encoder + ?Sized,
678 NodeListExtendedAttributesRequest:
679 ::fidl_next::Encode<crate::wire::NodeListExtendedAttributesRequest, ___E>,
680 {
681 #[inline]
682 fn encode_option(
683 this: ::core::option::Option<Self>,
684 encoder: &mut ___E,
685 out: &mut ::core::mem::MaybeUninit<
686 ::fidl_next::wire::Box<'static, crate::wire::NodeListExtendedAttributesRequest>,
687 >,
688 _: (),
689 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
690 if let Some(inner) = this {
691 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
692 ::fidl_next::wire::Box::encode_present(out);
693 } else {
694 ::fidl_next::wire::Box::encode_absent(out);
695 }
696
697 Ok(())
698 }
699 }
700
701 impl ::fidl_next::FromWire<crate::wire::NodeListExtendedAttributesRequest>
702 for NodeListExtendedAttributesRequest
703 {
704 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
705 crate::wire::NodeListExtendedAttributesRequest,
706 Self,
707 > = unsafe {
708 ::fidl_next::CopyOptimization::enable_if(
709 true && <::fidl_next::ServerEnd<
710 crate::ExtendedAttributeIterator,
711 ::fdomain_client::Channel,
712 > as ::fidl_next::FromWire<
713 ::fidl_next::ServerEnd<
714 crate::ExtendedAttributeIterator,
715 ::fdomain_client::fidl_next::wire::Handle,
716 >,
717 >>::COPY_OPTIMIZATION
718 .is_enabled(),
719 )
720 };
721
722 #[inline]
723 fn from_wire(wire: crate::wire::NodeListExtendedAttributesRequest) -> Self {
724 Self { iterator: ::fidl_next::FromWire::from_wire(wire.iterator) }
725 }
726 }
727
728 #[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"]
729 #[derive(Debug, PartialEq)]
730 pub enum ExtendedAttributeValue {
731 Bytes(::std::vec::Vec<u8>),
732
733 Buffer(::fdomain_client::Vmo),
734
735 UnknownOrdinal_(u64),
736 }
737
738 impl ExtendedAttributeValue {
739 pub fn is_unknown(&self) -> bool {
740 #[allow(unreachable_patterns)]
741 match self {
742 Self::UnknownOrdinal_(_) => true,
743 _ => false,
744 }
745 }
746 }
747
748 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExtendedAttributeValue<'static>, ___E>
749 for ExtendedAttributeValue
750 where
751 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
752 ___E: ::fidl_next::Encoder,
753 ___E: ::fdomain_client::fidl_next::HandleEncoder,
754 {
755 #[inline]
756 fn encode(
757 self,
758 encoder: &mut ___E,
759 out: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedAttributeValue<'static>>,
760 _: (),
761 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
762 ::fidl_next::munge!(let crate::wire::ExtendedAttributeValue { raw, _phantom: _ } = out);
763
764 match self {
765 Self::Bytes(value) => ::fidl_next::wire::Union::encode_as::<
766 ___E,
767 ::fidl_next::wire::Vector<'static, u8>,
768 >(value, 1, encoder, raw, (32768, ()))?,
769
770 Self::Buffer(value) => ::fidl_next::wire::Union::encode_as::<
771 ___E,
772 ::fdomain_client::fidl_next::wire::Handle,
773 >(value, 2, encoder, raw, ())?,
774
775 Self::UnknownOrdinal_(ordinal) => {
776 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
777 }
778 }
779
780 Ok(())
781 }
782 }
783
784 unsafe impl<___E>
785 ::fidl_next::EncodeOption<crate::wire_optional::ExtendedAttributeValue<'static>, ___E>
786 for ExtendedAttributeValue
787 where
788 ___E: ?Sized,
789 ExtendedAttributeValue:
790 ::fidl_next::Encode<crate::wire::ExtendedAttributeValue<'static>, ___E>,
791 {
792 #[inline]
793 fn encode_option(
794 this: ::core::option::Option<Self>,
795 encoder: &mut ___E,
796 out: &mut ::core::mem::MaybeUninit<
797 crate::wire_optional::ExtendedAttributeValue<'static>,
798 >,
799 _: (),
800 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
801 ::fidl_next::munge!(let crate::wire_optional::ExtendedAttributeValue { raw, _phantom: _ } = &mut *out);
802
803 if let Some(inner) = this {
804 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
805 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
806 } else {
807 ::fidl_next::wire::Union::encode_absent(raw);
808 }
809
810 Ok(())
811 }
812 }
813
814 impl<'de> ::fidl_next::FromWire<crate::wire::ExtendedAttributeValue<'de>>
815 for ExtendedAttributeValue
816 {
817 #[inline]
818 fn from_wire(wire: crate::wire::ExtendedAttributeValue<'de>) -> Self {
819 let wire = ::core::mem::ManuallyDrop::new(wire);
820 match wire.raw.ordinal() {
821 1 => Self::Bytes(::fidl_next::FromWire::from_wire(unsafe {
822 wire.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
823 })),
824
825 2 => Self::Buffer(::fidl_next::FromWire::from_wire(unsafe {
826 wire.raw.get().read_unchecked::<::fdomain_client::fidl_next::wire::Handle>()
827 })),
828
829 ord => return Self::UnknownOrdinal_(ord as u64),
830 }
831 }
832 }
833
834 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ExtendedAttributeValue<'de>>
835 for ExtendedAttributeValue
836 {
837 #[inline]
838 fn from_wire_option(
839 wire: crate::wire_optional::ExtendedAttributeValue<'de>,
840 ) -> ::core::option::Option<Self> {
841 if let Some(inner) = wire.into_option() {
842 Some(::fidl_next::FromWire::from_wire(inner))
843 } else {
844 None
845 }
846 }
847 }
848
849 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ExtendedAttributeValue<'de>>
850 for Box<ExtendedAttributeValue>
851 {
852 #[inline]
853 fn from_wire_option(
854 wire: crate::wire_optional::ExtendedAttributeValue<'de>,
855 ) -> ::core::option::Option<Self> {
856 <ExtendedAttributeValue as ::fidl_next::FromWireOption<
857 crate::wire_optional::ExtendedAttributeValue<'de>,
858 >>::from_wire_option(wire)
859 .map(Box::new)
860 }
861 }
862
863 #[derive(Debug, PartialEq)]
864 pub struct NodeSetExtendedAttributeRequest {
865 pub name: ::std::vec::Vec<u8>,
866
867 pub value: crate::natural::ExtendedAttributeValue,
868
869 pub mode: crate::natural::SetExtendedAttributeMode,
870 }
871
872 unsafe impl<___E>
873 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeRequest<'static>, ___E>
874 for NodeSetExtendedAttributeRequest
875 where
876 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
877 ___E: ::fidl_next::Encoder,
878 ___E: ::fdomain_client::fidl_next::HandleEncoder,
879 {
880 #[inline]
881 fn encode(
882 self,
883 encoder_: &mut ___E,
884 out_: &mut ::core::mem::MaybeUninit<
885 crate::wire::NodeSetExtendedAttributeRequest<'static>,
886 >,
887 _: (),
888 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
889 ::fidl_next::munge! {
890 let crate::wire::NodeSetExtendedAttributeRequest {
891 name,
892 value,
893 mode,
894
895 } = out_;
896 }
897
898 ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
899
900 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
901 ::fidl_next::Constrained::validate(_field, (255, ()))?;
902
903 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
904
905 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
906
907 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
908
909 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
910
911 Ok(())
912 }
913 }
914
915 unsafe impl<___E>
916 ::fidl_next::EncodeOption<
917 ::fidl_next::wire::Box<'static, crate::wire::NodeSetExtendedAttributeRequest<'static>>,
918 ___E,
919 > for NodeSetExtendedAttributeRequest
920 where
921 ___E: ::fidl_next::Encoder + ?Sized,
922 NodeSetExtendedAttributeRequest:
923 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeRequest<'static>, ___E>,
924 {
925 #[inline]
926 fn encode_option(
927 this: ::core::option::Option<Self>,
928 encoder: &mut ___E,
929 out: &mut ::core::mem::MaybeUninit<
930 ::fidl_next::wire::Box<
931 'static,
932 crate::wire::NodeSetExtendedAttributeRequest<'static>,
933 >,
934 >,
935 _: (),
936 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
937 if let Some(inner) = this {
938 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
939 ::fidl_next::wire::Box::encode_present(out);
940 } else {
941 ::fidl_next::wire::Box::encode_absent(out);
942 }
943
944 Ok(())
945 }
946 }
947
948 impl<'de> ::fidl_next::FromWire<crate::wire::NodeSetExtendedAttributeRequest<'de>>
949 for NodeSetExtendedAttributeRequest
950 {
951 #[inline]
952 fn from_wire(wire: crate::wire::NodeSetExtendedAttributeRequest<'de>) -> Self {
953 Self {
954 name: ::fidl_next::FromWire::from_wire(wire.name),
955
956 value: ::fidl_next::FromWire::from_wire(wire.value),
957
958 mode: ::fidl_next::FromWire::from_wire(wire.mode),
959 }
960 }
961 }
962
963 #[doc = " Auxiliary data for the file representation of a node.\n"]
964 #[derive(Debug, Default, PartialEq)]
965 pub struct FileInfo {
966 pub is_append: ::core::option::Option<bool>,
967
968 pub observer: ::core::option::Option<::fdomain_client::Event>,
969
970 pub stream: ::core::option::Option<::fdomain_client::Stream>,
971
972 pub attributes: ::core::option::Option<crate::natural::NodeAttributes2>,
973 }
974
975 impl FileInfo {
976 fn __max_ordinal(&self) -> usize {
977 if self.attributes.is_some() {
978 return 4;
979 }
980
981 if self.stream.is_some() {
982 return 3;
983 }
984
985 if self.observer.is_some() {
986 return 2;
987 }
988
989 if self.is_append.is_some() {
990 return 1;
991 }
992
993 0
994 }
995 }
996
997 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileInfo<'static>, ___E> for FileInfo
998 where
999 ___E: ::fidl_next::Encoder + ?Sized,
1000 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1001 {
1002 #[inline]
1003 fn encode(
1004 mut self,
1005 encoder: &mut ___E,
1006 out: &mut ::core::mem::MaybeUninit<crate::wire::FileInfo<'static>>,
1007 _: (),
1008 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1009 ::fidl_next::munge!(let crate::wire::FileInfo { table } = out);
1010
1011 let max_ord = self.__max_ordinal();
1012
1013 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1014 ::fidl_next::Wire::zero_padding(&mut out);
1015
1016 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1017 ::fidl_next::wire::Envelope,
1018 >(encoder, max_ord);
1019
1020 for i in 1..=max_ord {
1021 match i {
1022 4 => {
1023 if let Some(value) = self.attributes.take() {
1024 ::fidl_next::wire::Envelope::encode_value::<
1025 crate::wire::NodeAttributes2<'static>,
1026 ___E,
1027 >(
1028 value, preallocated.encoder, &mut out, ()
1029 )?;
1030 } else {
1031 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1032 }
1033 }
1034
1035 3 => {
1036 if let Some(value) = self.stream.take() {
1037 ::fidl_next::wire::Envelope::encode_value::<
1038 ::fdomain_client::fidl_next::wire::Handle,
1039 ___E,
1040 >(
1041 value, preallocated.encoder, &mut out, ()
1042 )?;
1043 } else {
1044 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1045 }
1046 }
1047
1048 2 => {
1049 if let Some(value) = self.observer.take() {
1050 ::fidl_next::wire::Envelope::encode_value::<
1051 ::fdomain_client::fidl_next::wire::Handle,
1052 ___E,
1053 >(
1054 value, preallocated.encoder, &mut out, ()
1055 )?;
1056 } else {
1057 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1058 }
1059 }
1060
1061 1 => {
1062 if let Some(value) = self.is_append.take() {
1063 ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
1064 value,
1065 preallocated.encoder,
1066 &mut out,
1067 (),
1068 )?;
1069 } else {
1070 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1071 }
1072 }
1073
1074 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1075 }
1076 unsafe {
1077 preallocated.write_next(out.assume_init_ref());
1078 }
1079 }
1080
1081 ::fidl_next::wire::Table::encode_len(table, max_ord);
1082
1083 Ok(())
1084 }
1085 }
1086
1087 impl<'de> ::fidl_next::FromWire<crate::wire::FileInfo<'de>> for FileInfo {
1088 #[inline]
1089 fn from_wire(wire_: crate::wire::FileInfo<'de>) -> Self {
1090 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1091
1092 let is_append = wire_.table.get(1);
1093
1094 let observer = wire_.table.get(2);
1095
1096 let stream = wire_.table.get(3);
1097
1098 let attributes = wire_.table.get(4);
1099
1100 Self {
1101 is_append: is_append.map(|envelope| {
1102 ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
1103 }),
1104
1105 observer: observer.map(|envelope| {
1106 ::fidl_next::FromWire::from_wire(unsafe {
1107 envelope.read_unchecked::<::fdomain_client::fidl_next::wire::Handle>()
1108 })
1109 }),
1110
1111 stream: stream.map(|envelope| {
1112 ::fidl_next::FromWire::from_wire(unsafe {
1113 envelope.read_unchecked::<::fdomain_client::fidl_next::wire::Handle>()
1114 })
1115 }),
1116
1117 attributes: attributes.map(|envelope| {
1118 ::fidl_next::FromWire::from_wire(unsafe {
1119 envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
1120 })
1121 }),
1122 }
1123 }
1124 }
1125
1126 #[derive(Debug, PartialEq)]
1127 pub enum Representation {
1128 Node(crate::natural::NodeInfo),
1129
1130 Directory(crate::natural::DirectoryInfo),
1131
1132 File(crate::natural::FileInfo),
1133
1134 Symlink(crate::natural::SymlinkInfo),
1135
1136 UnknownOrdinal_(u64),
1137 }
1138
1139 impl Representation {
1140 pub fn is_unknown(&self) -> bool {
1141 #[allow(unreachable_patterns)]
1142 match self {
1143 Self::UnknownOrdinal_(_) => true,
1144 _ => false,
1145 }
1146 }
1147 }
1148
1149 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Representation<'static>, ___E> for Representation
1150 where
1151 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1152 ___E: ::fidl_next::Encoder,
1153 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1154 {
1155 #[inline]
1156 fn encode(
1157 self,
1158 encoder: &mut ___E,
1159 out: &mut ::core::mem::MaybeUninit<crate::wire::Representation<'static>>,
1160 _: (),
1161 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1162 ::fidl_next::munge!(let crate::wire::Representation { raw, _phantom: _ } = out);
1163
1164 match self {
1165 Self::Node(value) => ::fidl_next::wire::Union::encode_as::<
1166 ___E,
1167 crate::wire::NodeInfo<'static>,
1168 >(value, 1, encoder, raw, ())?,
1169
1170 Self::Directory(value) => ::fidl_next::wire::Union::encode_as::<
1171 ___E,
1172 crate::wire::DirectoryInfo<'static>,
1173 >(value, 2, encoder, raw, ())?,
1174
1175 Self::File(value) => ::fidl_next::wire::Union::encode_as::<
1176 ___E,
1177 crate::wire::FileInfo<'static>,
1178 >(value, 3, encoder, raw, ())?,
1179
1180 Self::Symlink(value) => ::fidl_next::wire::Union::encode_as::<
1181 ___E,
1182 crate::wire::SymlinkInfo<'static>,
1183 >(value, 4, encoder, raw, ())?,
1184
1185 Self::UnknownOrdinal_(ordinal) => {
1186 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
1187 }
1188 }
1189
1190 Ok(())
1191 }
1192 }
1193
1194 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::Representation<'static>, ___E>
1195 for Representation
1196 where
1197 ___E: ?Sized,
1198 Representation: ::fidl_next::Encode<crate::wire::Representation<'static>, ___E>,
1199 {
1200 #[inline]
1201 fn encode_option(
1202 this: ::core::option::Option<Self>,
1203 encoder: &mut ___E,
1204 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::Representation<'static>>,
1205 _: (),
1206 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1207 ::fidl_next::munge!(let crate::wire_optional::Representation { raw, _phantom: _ } = &mut *out);
1208
1209 if let Some(inner) = this {
1210 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
1211 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
1212 } else {
1213 ::fidl_next::wire::Union::encode_absent(raw);
1214 }
1215
1216 Ok(())
1217 }
1218 }
1219
1220 impl<'de> ::fidl_next::FromWire<crate::wire::Representation<'de>> for Representation {
1221 #[inline]
1222 fn from_wire(wire: crate::wire::Representation<'de>) -> Self {
1223 let wire = ::core::mem::ManuallyDrop::new(wire);
1224 match wire.raw.ordinal() {
1225 1 => Self::Node(::fidl_next::FromWire::from_wire(unsafe {
1226 wire.raw.get().read_unchecked::<crate::wire::NodeInfo<'de>>()
1227 })),
1228
1229 2 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
1230 wire.raw.get().read_unchecked::<crate::wire::DirectoryInfo<'de>>()
1231 })),
1232
1233 3 => Self::File(::fidl_next::FromWire::from_wire(unsafe {
1234 wire.raw.get().read_unchecked::<crate::wire::FileInfo<'de>>()
1235 })),
1236
1237 4 => Self::Symlink(::fidl_next::FromWire::from_wire(unsafe {
1238 wire.raw.get().read_unchecked::<crate::wire::SymlinkInfo<'de>>()
1239 })),
1240
1241 ord => return Self::UnknownOrdinal_(ord as u64),
1242 }
1243 }
1244 }
1245
1246 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Representation<'de>>
1247 for Representation
1248 {
1249 #[inline]
1250 fn from_wire_option(
1251 wire: crate::wire_optional::Representation<'de>,
1252 ) -> ::core::option::Option<Self> {
1253 if let Some(inner) = wire.into_option() {
1254 Some(::fidl_next::FromWire::from_wire(inner))
1255 } else {
1256 None
1257 }
1258 }
1259 }
1260
1261 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Representation<'de>>
1262 for Box<Representation>
1263 {
1264 #[inline]
1265 fn from_wire_option(
1266 wire: crate::wire_optional::Representation<'de>,
1267 ) -> ::core::option::Option<Self> {
1268 <Representation as ::fidl_next::FromWireOption<
1269 crate::wire_optional::Representation<'de>,
1270 >>::from_wire_option(wire)
1271 .map(Box::new)
1272 }
1273 }
1274
1275 #[derive(Debug, PartialEq)]
1276 pub struct OpenableOpenRequest {
1277 pub path: ::std::string::String,
1278
1279 pub flags: crate::natural::Flags,
1280
1281 pub options: crate::natural::Options,
1282
1283 pub object: ::fdomain_client::Channel,
1284 }
1285
1286 unsafe impl<___E> ::fidl_next::Encode<crate::wire::OpenableOpenRequest<'static>, ___E>
1287 for OpenableOpenRequest
1288 where
1289 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1290 ___E: ::fidl_next::Encoder,
1291 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1292 {
1293 #[inline]
1294 fn encode(
1295 self,
1296 encoder_: &mut ___E,
1297 out_: &mut ::core::mem::MaybeUninit<crate::wire::OpenableOpenRequest<'static>>,
1298 _: (),
1299 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1300 ::fidl_next::munge! {
1301 let crate::wire::OpenableOpenRequest {
1302 path,
1303 flags,
1304 options,
1305 object,
1306
1307 } = out_;
1308 }
1309
1310 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
1311
1312 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
1313 ::fidl_next::Constrained::validate(_field, 4095)?;
1314
1315 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
1316
1317 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
1318
1319 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
1320
1321 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
1322
1323 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
1324
1325 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
1326
1327 Ok(())
1328 }
1329 }
1330
1331 unsafe impl<___E>
1332 ::fidl_next::EncodeOption<
1333 ::fidl_next::wire::Box<'static, crate::wire::OpenableOpenRequest<'static>>,
1334 ___E,
1335 > for OpenableOpenRequest
1336 where
1337 ___E: ::fidl_next::Encoder + ?Sized,
1338 OpenableOpenRequest: ::fidl_next::Encode<crate::wire::OpenableOpenRequest<'static>, ___E>,
1339 {
1340 #[inline]
1341 fn encode_option(
1342 this: ::core::option::Option<Self>,
1343 encoder: &mut ___E,
1344 out: &mut ::core::mem::MaybeUninit<
1345 ::fidl_next::wire::Box<'static, crate::wire::OpenableOpenRequest<'static>>,
1346 >,
1347 _: (),
1348 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1349 if let Some(inner) = this {
1350 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1351 ::fidl_next::wire::Box::encode_present(out);
1352 } else {
1353 ::fidl_next::wire::Box::encode_absent(out);
1354 }
1355
1356 Ok(())
1357 }
1358 }
1359
1360 impl<'de> ::fidl_next::FromWire<crate::wire::OpenableOpenRequest<'de>> for OpenableOpenRequest {
1361 #[inline]
1362 fn from_wire(wire: crate::wire::OpenableOpenRequest<'de>) -> Self {
1363 Self {
1364 path: ::fidl_next::FromWire::from_wire(wire.path),
1365
1366 flags: ::fidl_next::FromWire::from_wire(wire.flags),
1367
1368 options: ::fidl_next::FromWire::from_wire(wire.options),
1369
1370 object: ::fidl_next::FromWire::from_wire(wire.object),
1371 }
1372 }
1373 }
1374
1375 #[derive(Debug, PartialEq)]
1376 #[repr(C)]
1377 pub struct NodeDeprecatedCloneRequest {
1378 pub flags: crate::natural::OpenFlags,
1379
1380 pub object: ::fidl_next::ServerEnd<crate::Node, ::fdomain_client::Channel>,
1381 }
1382
1383 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedCloneRequest, ___E>
1384 for NodeDeprecatedCloneRequest
1385 where
1386 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1387 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1388 {
1389 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1390 Self,
1391 crate::wire::NodeDeprecatedCloneRequest,
1392 > = unsafe {
1393 ::fidl_next::CopyOptimization::enable_if(
1394 true
1395
1396 && <
1397 crate::natural::OpenFlags as ::fidl_next::Encode<crate::wire::OpenFlags, ___E>
1398 >::COPY_OPTIMIZATION.is_enabled()
1399
1400 && <
1401 ::fidl_next::ServerEnd<crate::Node, ::fdomain_client::Channel> as ::fidl_next::Encode<::fidl_next::ServerEnd<crate::Node, ::fdomain_client::fidl_next::wire::Handle>, ___E>
1402 >::COPY_OPTIMIZATION.is_enabled()
1403
1404 )
1405 };
1406
1407 #[inline]
1408 fn encode(
1409 self,
1410 encoder_: &mut ___E,
1411 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedCloneRequest>,
1412 _: (),
1413 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1414 ::fidl_next::munge! {
1415 let crate::wire::NodeDeprecatedCloneRequest {
1416 flags,
1417 object,
1418
1419 } = out_;
1420 }
1421
1422 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
1423
1424 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
1425
1426 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
1427
1428 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
1429
1430 Ok(())
1431 }
1432 }
1433
1434 unsafe impl<___E>
1435 ::fidl_next::EncodeOption<
1436 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedCloneRequest>,
1437 ___E,
1438 > for NodeDeprecatedCloneRequest
1439 where
1440 ___E: ::fidl_next::Encoder + ?Sized,
1441 NodeDeprecatedCloneRequest:
1442 ::fidl_next::Encode<crate::wire::NodeDeprecatedCloneRequest, ___E>,
1443 {
1444 #[inline]
1445 fn encode_option(
1446 this: ::core::option::Option<Self>,
1447 encoder: &mut ___E,
1448 out: &mut ::core::mem::MaybeUninit<
1449 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedCloneRequest>,
1450 >,
1451 _: (),
1452 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1453 if let Some(inner) = this {
1454 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1455 ::fidl_next::wire::Box::encode_present(out);
1456 } else {
1457 ::fidl_next::wire::Box::encode_absent(out);
1458 }
1459
1460 Ok(())
1461 }
1462 }
1463
1464 impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedCloneRequest> for NodeDeprecatedCloneRequest {
1465 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1466 crate::wire::NodeDeprecatedCloneRequest,
1467 Self,
1468 > = unsafe {
1469 ::fidl_next::CopyOptimization::enable_if(
1470 true
1471
1472 && <
1473 crate::natural::OpenFlags as ::fidl_next::FromWire<crate::wire::OpenFlags>
1474 >::COPY_OPTIMIZATION.is_enabled()
1475
1476 && <
1477 ::fidl_next::ServerEnd<crate::Node, ::fdomain_client::Channel> as ::fidl_next::FromWire<::fidl_next::ServerEnd<crate::Node, ::fdomain_client::fidl_next::wire::Handle>>
1478 >::COPY_OPTIMIZATION.is_enabled()
1479
1480 )
1481 };
1482
1483 #[inline]
1484 fn from_wire(wire: crate::wire::NodeDeprecatedCloneRequest) -> Self {
1485 Self {
1486 flags: ::fidl_next::FromWire::from_wire(wire.flags),
1487
1488 object: ::fidl_next::FromWire::from_wire(wire.object),
1489 }
1490 }
1491 }
1492
1493 #[derive(Debug, PartialEq)]
1494 pub struct DirectoryDeprecatedOpenRequest {
1495 pub flags: crate::natural::OpenFlags,
1496
1497 pub mode: crate::natural::ModeType,
1498
1499 pub path: ::std::string::String,
1500
1501 pub object: ::fidl_next::ServerEnd<crate::Node, ::fdomain_client::Channel>,
1502 }
1503
1504 unsafe impl<___E>
1505 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedOpenRequest<'static>, ___E>
1506 for DirectoryDeprecatedOpenRequest
1507 where
1508 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1509 ___E: ::fidl_next::Encoder,
1510 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1511 {
1512 #[inline]
1513 fn encode(
1514 self,
1515 encoder_: &mut ___E,
1516 out_: &mut ::core::mem::MaybeUninit<
1517 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
1518 >,
1519 _: (),
1520 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1521 ::fidl_next::munge! {
1522 let crate::wire::DirectoryDeprecatedOpenRequest {
1523 flags,
1524 mode,
1525 path,
1526 object,
1527
1528 } = out_;
1529 }
1530
1531 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
1532
1533 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
1534
1535 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
1536
1537 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
1538
1539 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
1540
1541 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
1542 ::fidl_next::Constrained::validate(_field, 4095)?;
1543
1544 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
1545
1546 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
1547
1548 Ok(())
1549 }
1550 }
1551
1552 unsafe impl<___E>
1553 ::fidl_next::EncodeOption<
1554 ::fidl_next::wire::Box<'static, crate::wire::DirectoryDeprecatedOpenRequest<'static>>,
1555 ___E,
1556 > for DirectoryDeprecatedOpenRequest
1557 where
1558 ___E: ::fidl_next::Encoder + ?Sized,
1559 DirectoryDeprecatedOpenRequest:
1560 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedOpenRequest<'static>, ___E>,
1561 {
1562 #[inline]
1563 fn encode_option(
1564 this: ::core::option::Option<Self>,
1565 encoder: &mut ___E,
1566 out: &mut ::core::mem::MaybeUninit<
1567 ::fidl_next::wire::Box<
1568 'static,
1569 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
1570 >,
1571 >,
1572 _: (),
1573 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1574 if let Some(inner) = this {
1575 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1576 ::fidl_next::wire::Box::encode_present(out);
1577 } else {
1578 ::fidl_next::wire::Box::encode_absent(out);
1579 }
1580
1581 Ok(())
1582 }
1583 }
1584
1585 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryDeprecatedOpenRequest<'de>>
1586 for DirectoryDeprecatedOpenRequest
1587 {
1588 #[inline]
1589 fn from_wire(wire: crate::wire::DirectoryDeprecatedOpenRequest<'de>) -> Self {
1590 Self {
1591 flags: ::fidl_next::FromWire::from_wire(wire.flags),
1592
1593 mode: ::fidl_next::FromWire::from_wire(wire.mode),
1594
1595 path: ::fidl_next::FromWire::from_wire(wire.path),
1596
1597 object: ::fidl_next::FromWire::from_wire(wire.object),
1598 }
1599 }
1600 }
1601
1602 #[derive(Debug, PartialEq)]
1603 pub struct DirectoryCreateSymlinkRequest {
1604 pub name: ::std::string::String,
1605
1606 pub target: ::std::vec::Vec<u8>,
1607
1608 pub connection: ::core::option::Option<
1609 ::fidl_next::ServerEnd<crate::Symlink, ::fdomain_client::Channel>,
1610 >,
1611 }
1612
1613 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkRequest<'static>, ___E>
1614 for DirectoryCreateSymlinkRequest
1615 where
1616 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1617 ___E: ::fidl_next::Encoder,
1618 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1619 {
1620 #[inline]
1621 fn encode(
1622 self,
1623 encoder_: &mut ___E,
1624 out_: &mut ::core::mem::MaybeUninit<
1625 crate::wire::DirectoryCreateSymlinkRequest<'static>,
1626 >,
1627 _: (),
1628 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1629 ::fidl_next::munge! {
1630 let crate::wire::DirectoryCreateSymlinkRequest {
1631 name,
1632 target,
1633 connection,
1634
1635 } = out_;
1636 }
1637
1638 ::fidl_next::Encode::encode(self.name, encoder_, name, 255)?;
1639
1640 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
1641 ::fidl_next::Constrained::validate(_field, 255)?;
1642
1643 ::fidl_next::Encode::encode(self.target, encoder_, target, (4095, ()))?;
1644
1645 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(target.as_mut_ptr()) };
1646 ::fidl_next::Constrained::validate(_field, (4095, ()))?;
1647
1648 ::fidl_next::Encode::encode(self.connection, encoder_, connection, ())?;
1649
1650 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(connection.as_mut_ptr()) };
1651
1652 Ok(())
1653 }
1654 }
1655
1656 unsafe impl<___E>
1657 ::fidl_next::EncodeOption<
1658 ::fidl_next::wire::Box<'static, crate::wire::DirectoryCreateSymlinkRequest<'static>>,
1659 ___E,
1660 > for DirectoryCreateSymlinkRequest
1661 where
1662 ___E: ::fidl_next::Encoder + ?Sized,
1663 DirectoryCreateSymlinkRequest:
1664 ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkRequest<'static>, ___E>,
1665 {
1666 #[inline]
1667 fn encode_option(
1668 this: ::core::option::Option<Self>,
1669 encoder: &mut ___E,
1670 out: &mut ::core::mem::MaybeUninit<
1671 ::fidl_next::wire::Box<
1672 'static,
1673 crate::wire::DirectoryCreateSymlinkRequest<'static>,
1674 >,
1675 >,
1676 _: (),
1677 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1678 if let Some(inner) = this {
1679 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1680 ::fidl_next::wire::Box::encode_present(out);
1681 } else {
1682 ::fidl_next::wire::Box::encode_absent(out);
1683 }
1684
1685 Ok(())
1686 }
1687 }
1688
1689 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryCreateSymlinkRequest<'de>>
1690 for DirectoryCreateSymlinkRequest
1691 {
1692 #[inline]
1693 fn from_wire(wire: crate::wire::DirectoryCreateSymlinkRequest<'de>) -> Self {
1694 Self {
1695 name: ::fidl_next::FromWire::from_wire(wire.name),
1696
1697 target: ::fidl_next::FromWire::from_wire(wire.target),
1698
1699 connection: ::fidl_next::FromWire::from_wire(wire.connection),
1700 }
1701 }
1702 }
1703
1704 #[derive(Debug, PartialEq)]
1705 #[repr(C)]
1706 pub struct FileGetBackingMemoryResponse {
1707 pub vmo: ::fdomain_client::Vmo,
1708 }
1709
1710 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryResponse, ___E>
1711 for FileGetBackingMemoryResponse
1712 where
1713 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1714 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1715 {
1716 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1717 Self,
1718 crate::wire::FileGetBackingMemoryResponse,
1719 > = unsafe {
1720 ::fidl_next::CopyOptimization::enable_if(
1721 true && <::fdomain_client::Vmo as ::fidl_next::Encode<
1722 ::fdomain_client::fidl_next::wire::Handle,
1723 ___E,
1724 >>::COPY_OPTIMIZATION
1725 .is_enabled(),
1726 )
1727 };
1728
1729 #[inline]
1730 fn encode(
1731 self,
1732 encoder_: &mut ___E,
1733 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryResponse>,
1734 _: (),
1735 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1736 ::fidl_next::munge! {
1737 let crate::wire::FileGetBackingMemoryResponse {
1738 vmo,
1739
1740 } = out_;
1741 }
1742
1743 ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
1744
1745 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vmo.as_mut_ptr()) };
1746
1747 Ok(())
1748 }
1749 }
1750
1751 unsafe impl<___E>
1752 ::fidl_next::EncodeOption<
1753 ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryResponse>,
1754 ___E,
1755 > for FileGetBackingMemoryResponse
1756 where
1757 ___E: ::fidl_next::Encoder + ?Sized,
1758 FileGetBackingMemoryResponse:
1759 ::fidl_next::Encode<crate::wire::FileGetBackingMemoryResponse, ___E>,
1760 {
1761 #[inline]
1762 fn encode_option(
1763 this: ::core::option::Option<Self>,
1764 encoder: &mut ___E,
1765 out: &mut ::core::mem::MaybeUninit<
1766 ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryResponse>,
1767 >,
1768 _: (),
1769 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1770 if let Some(inner) = this {
1771 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1772 ::fidl_next::wire::Box::encode_present(out);
1773 } else {
1774 ::fidl_next::wire::Box::encode_absent(out);
1775 }
1776
1777 Ok(())
1778 }
1779 }
1780
1781 impl ::fidl_next::FromWire<crate::wire::FileGetBackingMemoryResponse>
1782 for FileGetBackingMemoryResponse
1783 {
1784 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1785 crate::wire::FileGetBackingMemoryResponse,
1786 Self,
1787 > = unsafe {
1788 ::fidl_next::CopyOptimization::enable_if(
1789 true && <::fdomain_client::Vmo as ::fidl_next::FromWire<
1790 ::fdomain_client::fidl_next::wire::Handle,
1791 >>::COPY_OPTIMIZATION
1792 .is_enabled(),
1793 )
1794 };
1795
1796 #[inline]
1797 fn from_wire(wire: crate::wire::FileGetBackingMemoryResponse) -> Self {
1798 Self { vmo: ::fidl_next::FromWire::from_wire(wire.vmo) }
1799 }
1800 }
1801
1802 #[derive(Debug, PartialEq)]
1803 pub struct LinkableLinkIntoRequest {
1804 pub dst_parent_token: ::fdomain_client::Event,
1805
1806 pub dst: ::std::string::String,
1807 }
1808
1809 unsafe impl<___E> ::fidl_next::Encode<crate::wire::LinkableLinkIntoRequest<'static>, ___E>
1810 for LinkableLinkIntoRequest
1811 where
1812 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1813 ___E: ::fidl_next::Encoder,
1814 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1815 {
1816 #[inline]
1817 fn encode(
1818 self,
1819 encoder_: &mut ___E,
1820 out_: &mut ::core::mem::MaybeUninit<crate::wire::LinkableLinkIntoRequest<'static>>,
1821 _: (),
1822 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1823 ::fidl_next::munge! {
1824 let crate::wire::LinkableLinkIntoRequest {
1825 dst_parent_token,
1826 dst,
1827
1828 } = out_;
1829 }
1830
1831 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
1832
1833 let mut _field =
1834 unsafe { ::fidl_next::Slot::new_unchecked(dst_parent_token.as_mut_ptr()) };
1835
1836 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
1837
1838 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dst.as_mut_ptr()) };
1839 ::fidl_next::Constrained::validate(_field, 255)?;
1840
1841 Ok(())
1842 }
1843 }
1844
1845 unsafe impl<___E>
1846 ::fidl_next::EncodeOption<
1847 ::fidl_next::wire::Box<'static, crate::wire::LinkableLinkIntoRequest<'static>>,
1848 ___E,
1849 > for LinkableLinkIntoRequest
1850 where
1851 ___E: ::fidl_next::Encoder + ?Sized,
1852 LinkableLinkIntoRequest:
1853 ::fidl_next::Encode<crate::wire::LinkableLinkIntoRequest<'static>, ___E>,
1854 {
1855 #[inline]
1856 fn encode_option(
1857 this: ::core::option::Option<Self>,
1858 encoder: &mut ___E,
1859 out: &mut ::core::mem::MaybeUninit<
1860 ::fidl_next::wire::Box<'static, crate::wire::LinkableLinkIntoRequest<'static>>,
1861 >,
1862 _: (),
1863 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1864 if let Some(inner) = this {
1865 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1866 ::fidl_next::wire::Box::encode_present(out);
1867 } else {
1868 ::fidl_next::wire::Box::encode_absent(out);
1869 }
1870
1871 Ok(())
1872 }
1873 }
1874
1875 impl<'de> ::fidl_next::FromWire<crate::wire::LinkableLinkIntoRequest<'de>>
1876 for LinkableLinkIntoRequest
1877 {
1878 #[inline]
1879 fn from_wire(wire: crate::wire::LinkableLinkIntoRequest<'de>) -> Self {
1880 Self {
1881 dst_parent_token: ::fidl_next::FromWire::from_wire(wire.dst_parent_token),
1882
1883 dst: ::fidl_next::FromWire::from_wire(wire.dst),
1884 }
1885 }
1886 }
1887
1888 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1889 pub struct FileAllocateRequest {
1890 pub offset: u64,
1891
1892 pub length: u64,
1893
1894 pub mode: crate::natural::AllocateMode,
1895 }
1896
1897 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileAllocateRequest, ___E>
1898 for FileAllocateRequest
1899 where
1900 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1901 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1902 {
1903 #[inline]
1904 fn encode(
1905 self,
1906 encoder_: &mut ___E,
1907 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileAllocateRequest>,
1908 _: (),
1909 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1910 ::fidl_next::munge! {
1911 let crate::wire::FileAllocateRequest {
1912 offset,
1913 length,
1914 mode,
1915
1916 } = out_;
1917 }
1918
1919 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
1920
1921 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
1922
1923 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
1924
1925 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
1926
1927 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
1928
1929 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
1930
1931 Ok(())
1932 }
1933 }
1934
1935 unsafe impl<___E>
1936 ::fidl_next::EncodeOption<
1937 ::fidl_next::wire::Box<'static, crate::wire::FileAllocateRequest>,
1938 ___E,
1939 > for FileAllocateRequest
1940 where
1941 ___E: ::fidl_next::Encoder + ?Sized,
1942 FileAllocateRequest: ::fidl_next::Encode<crate::wire::FileAllocateRequest, ___E>,
1943 {
1944 #[inline]
1945 fn encode_option(
1946 this: ::core::option::Option<Self>,
1947 encoder: &mut ___E,
1948 out: &mut ::core::mem::MaybeUninit<
1949 ::fidl_next::wire::Box<'static, crate::wire::FileAllocateRequest>,
1950 >,
1951 _: (),
1952 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1953 if let Some(inner) = this {
1954 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1955 ::fidl_next::wire::Box::encode_present(out);
1956 } else {
1957 ::fidl_next::wire::Box::encode_absent(out);
1958 }
1959
1960 Ok(())
1961 }
1962 }
1963
1964 impl ::fidl_next::FromWire<crate::wire::FileAllocateRequest> for FileAllocateRequest {
1965 #[inline]
1966 fn from_wire(wire: crate::wire::FileAllocateRequest) -> Self {
1967 Self {
1968 offset: ::fidl_next::FromWire::from_wire(wire.offset),
1969
1970 length: ::fidl_next::FromWire::from_wire(wire.length),
1971
1972 mode: ::fidl_next::FromWire::from_wire(wire.mode),
1973 }
1974 }
1975 }
1976
1977 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1978 pub struct FileEnableVerityRequest {
1979 pub options: crate::natural::VerificationOptions,
1980 }
1981
1982 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileEnableVerityRequest<'static>, ___E>
1983 for FileEnableVerityRequest
1984 where
1985 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1986 ___E: ::fidl_next::Encoder,
1987 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1988 {
1989 #[inline]
1990 fn encode(
1991 self,
1992 encoder_: &mut ___E,
1993 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileEnableVerityRequest<'static>>,
1994 _: (),
1995 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1996 ::fidl_next::munge! {
1997 let crate::wire::FileEnableVerityRequest {
1998 options,
1999
2000 } = out_;
2001 }
2002
2003 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
2004
2005 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
2006
2007 Ok(())
2008 }
2009 }
2010
2011 unsafe impl<___E>
2012 ::fidl_next::EncodeOption<
2013 ::fidl_next::wire::Box<'static, crate::wire::FileEnableVerityRequest<'static>>,
2014 ___E,
2015 > for FileEnableVerityRequest
2016 where
2017 ___E: ::fidl_next::Encoder + ?Sized,
2018 FileEnableVerityRequest:
2019 ::fidl_next::Encode<crate::wire::FileEnableVerityRequest<'static>, ___E>,
2020 {
2021 #[inline]
2022 fn encode_option(
2023 this: ::core::option::Option<Self>,
2024 encoder: &mut ___E,
2025 out: &mut ::core::mem::MaybeUninit<
2026 ::fidl_next::wire::Box<'static, crate::wire::FileEnableVerityRequest<'static>>,
2027 >,
2028 _: (),
2029 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2030 if let Some(inner) = this {
2031 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2032 ::fidl_next::wire::Box::encode_present(out);
2033 } else {
2034 ::fidl_next::wire::Box::encode_absent(out);
2035 }
2036
2037 Ok(())
2038 }
2039 }
2040
2041 impl<'de> ::fidl_next::FromWire<crate::wire::FileEnableVerityRequest<'de>>
2042 for FileEnableVerityRequest
2043 {
2044 #[inline]
2045 fn from_wire(wire: crate::wire::FileEnableVerityRequest<'de>) -> Self {
2046 Self { options: ::fidl_next::FromWire::from_wire(wire.options) }
2047 }
2048 }
2049
2050 #[derive(Debug, PartialEq)]
2051 #[repr(C)]
2052 pub struct FileObject {
2053 pub event: ::core::option::Option<::fdomain_client::Event>,
2054
2055 pub stream: ::core::option::Option<::fdomain_client::Stream>,
2056 }
2057
2058 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileObject, ___E> for FileObject
2059 where
2060 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2061 ___E: ::fdomain_client::fidl_next::HandleEncoder,
2062 {
2063 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::FileObject> = unsafe {
2064 ::fidl_next::CopyOptimization::enable_if(
2065 true && <::core::option::Option<::fdomain_client::Event> as ::fidl_next::Encode<
2066 ::fdomain_client::fidl_next::wire::OptionalHandle,
2067 ___E,
2068 >>::COPY_OPTIMIZATION
2069 .is_enabled()
2070 && <::core::option::Option<::fdomain_client::Stream> as ::fidl_next::Encode<
2071 ::fdomain_client::fidl_next::wire::OptionalHandle,
2072 ___E,
2073 >>::COPY_OPTIMIZATION
2074 .is_enabled(),
2075 )
2076 };
2077
2078 #[inline]
2079 fn encode(
2080 self,
2081 encoder_: &mut ___E,
2082 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileObject>,
2083 _: (),
2084 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2085 ::fidl_next::munge! {
2086 let crate::wire::FileObject {
2087 event,
2088 stream,
2089
2090 } = out_;
2091 }
2092
2093 ::fidl_next::Encode::encode(self.event, encoder_, event, ())?;
2094
2095 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(event.as_mut_ptr()) };
2096
2097 ::fidl_next::Encode::encode(self.stream, encoder_, stream, ())?;
2098
2099 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(stream.as_mut_ptr()) };
2100
2101 Ok(())
2102 }
2103 }
2104
2105 unsafe impl<___E>
2106 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::FileObject>, ___E>
2107 for FileObject
2108 where
2109 ___E: ::fidl_next::Encoder + ?Sized,
2110 FileObject: ::fidl_next::Encode<crate::wire::FileObject, ___E>,
2111 {
2112 #[inline]
2113 fn encode_option(
2114 this: ::core::option::Option<Self>,
2115 encoder: &mut ___E,
2116 out: &mut ::core::mem::MaybeUninit<
2117 ::fidl_next::wire::Box<'static, crate::wire::FileObject>,
2118 >,
2119 _: (),
2120 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2121 if let Some(inner) = this {
2122 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2123 ::fidl_next::wire::Box::encode_present(out);
2124 } else {
2125 ::fidl_next::wire::Box::encode_absent(out);
2126 }
2127
2128 Ok(())
2129 }
2130 }
2131
2132 impl ::fidl_next::FromWire<crate::wire::FileObject> for FileObject {
2133 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::FileObject, Self> = unsafe {
2134 ::fidl_next::CopyOptimization::enable_if(
2135 true
2136
2137 && <
2138 ::core::option::Option<::fdomain_client::Event> as ::fidl_next::FromWire<::fdomain_client::fidl_next::wire::OptionalHandle>
2139 >::COPY_OPTIMIZATION.is_enabled()
2140
2141 && <
2142 ::core::option::Option<::fdomain_client::Stream> as ::fidl_next::FromWire<::fdomain_client::fidl_next::wire::OptionalHandle>
2143 >::COPY_OPTIMIZATION.is_enabled()
2144
2145 )
2146 };
2147
2148 #[inline]
2149 fn from_wire(wire: crate::wire::FileObject) -> Self {
2150 Self {
2151 event: ::fidl_next::FromWire::from_wire(wire.event),
2152
2153 stream: ::fidl_next::FromWire::from_wire(wire.stream),
2154 }
2155 }
2156 }
2157
2158 #[derive(Debug, PartialEq)]
2159 pub enum NodeInfoDeprecated {
2160 Service(crate::natural::Service),
2161
2162 File(crate::natural::FileObject),
2163
2164 Directory(crate::natural::DirectoryObject),
2165
2166 Symlink(crate::natural::SymlinkObject),
2167 }
2168
2169 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeInfoDeprecated<'static>, ___E>
2170 for NodeInfoDeprecated
2171 where
2172 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2173 ___E: ::fidl_next::Encoder,
2174 ___E: ::fdomain_client::fidl_next::HandleEncoder,
2175 {
2176 #[inline]
2177 fn encode(
2178 self,
2179 encoder: &mut ___E,
2180 out: &mut ::core::mem::MaybeUninit<crate::wire::NodeInfoDeprecated<'static>>,
2181 _: (),
2182 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2183 ::fidl_next::munge!(let crate::wire::NodeInfoDeprecated { raw, _phantom: _ } = out);
2184
2185 match self {
2186 Self::Service(value) => ::fidl_next::wire::Union::encode_as::<
2187 ___E,
2188 crate::wire::Service,
2189 >(value, 1, encoder, raw, ())?,
2190
2191 Self::File(value) => ::fidl_next::wire::Union::encode_as::<
2192 ___E,
2193 crate::wire::FileObject,
2194 >(value, 2, encoder, raw, ())?,
2195
2196 Self::Directory(value) => ::fidl_next::wire::Union::encode_as::<
2197 ___E,
2198 crate::wire::DirectoryObject,
2199 >(value, 3, encoder, raw, ())?,
2200
2201 Self::Symlink(value) => ::fidl_next::wire::Union::encode_as::<
2202 ___E,
2203 crate::wire::SymlinkObject<'static>,
2204 >(value, 4, encoder, raw, ())?,
2205 }
2206
2207 Ok(())
2208 }
2209 }
2210
2211 unsafe impl<___E>
2212 ::fidl_next::EncodeOption<crate::wire_optional::NodeInfoDeprecated<'static>, ___E>
2213 for NodeInfoDeprecated
2214 where
2215 ___E: ?Sized,
2216 NodeInfoDeprecated: ::fidl_next::Encode<crate::wire::NodeInfoDeprecated<'static>, ___E>,
2217 {
2218 #[inline]
2219 fn encode_option(
2220 this: ::core::option::Option<Self>,
2221 encoder: &mut ___E,
2222 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::NodeInfoDeprecated<'static>>,
2223 _: (),
2224 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2225 ::fidl_next::munge!(let crate::wire_optional::NodeInfoDeprecated { raw, _phantom: _ } = &mut *out);
2226
2227 if let Some(inner) = this {
2228 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2229 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2230 } else {
2231 ::fidl_next::wire::Union::encode_absent(raw);
2232 }
2233
2234 Ok(())
2235 }
2236 }
2237
2238 impl<'de> ::fidl_next::FromWire<crate::wire::NodeInfoDeprecated<'de>> for NodeInfoDeprecated {
2239 #[inline]
2240 fn from_wire(wire: crate::wire::NodeInfoDeprecated<'de>) -> Self {
2241 let wire = ::core::mem::ManuallyDrop::new(wire);
2242 match wire.raw.ordinal() {
2243 1 => Self::Service(::fidl_next::FromWire::from_wire(unsafe {
2244 wire.raw.get().read_unchecked::<crate::wire::Service>()
2245 })),
2246
2247 2 => Self::File(::fidl_next::FromWire::from_wire(unsafe {
2248 wire.raw.get().read_unchecked::<crate::wire::FileObject>()
2249 })),
2250
2251 3 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
2252 wire.raw.get().read_unchecked::<crate::wire::DirectoryObject>()
2253 })),
2254
2255 4 => Self::Symlink(::fidl_next::FromWire::from_wire(unsafe {
2256 wire.raw.get().read_unchecked::<crate::wire::SymlinkObject<'de>>()
2257 })),
2258
2259 _ => unsafe { ::core::hint::unreachable_unchecked() },
2260 }
2261 }
2262 }
2263
2264 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::NodeInfoDeprecated<'de>>
2265 for NodeInfoDeprecated
2266 {
2267 #[inline]
2268 fn from_wire_option(
2269 wire: crate::wire_optional::NodeInfoDeprecated<'de>,
2270 ) -> ::core::option::Option<Self> {
2271 if let Some(inner) = wire.into_option() {
2272 Some(::fidl_next::FromWire::from_wire(inner))
2273 } else {
2274 None
2275 }
2276 }
2277 }
2278
2279 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::NodeInfoDeprecated<'de>>
2280 for Box<NodeInfoDeprecated>
2281 {
2282 #[inline]
2283 fn from_wire_option(
2284 wire: crate::wire_optional::NodeInfoDeprecated<'de>,
2285 ) -> ::core::option::Option<Self> {
2286 <NodeInfoDeprecated as ::fidl_next::FromWireOption<
2287 crate::wire_optional::NodeInfoDeprecated<'de>,
2288 >>::from_wire_option(wire)
2289 .map(Box::new)
2290 }
2291 }
2292}
2293
2294pub mod wire {
2295
2296 pub use fidl_next_common_fuchsia_io::wire::*;
2297
2298 #[repr(C)]
2300 pub struct ConnectionInfo<'de> {
2301 pub(crate) table: ::fidl_next::wire::Table<'de>,
2302 }
2303
2304 impl<'de> Drop for ConnectionInfo<'de> {
2305 fn drop(&mut self) {
2306 let _ = self
2307 .table
2308 .get(1)
2309 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Operations>() });
2310 }
2311 }
2312
2313 impl ::fidl_next::Constrained for ConnectionInfo<'_> {
2314 type Constraint = ();
2315
2316 fn validate(
2317 _: ::fidl_next::Slot<'_, Self>,
2318 _: Self::Constraint,
2319 ) -> Result<(), ::fidl_next::ValidationError> {
2320 Ok(())
2321 }
2322 }
2323
2324 unsafe impl ::fidl_next::Wire for ConnectionInfo<'static> {
2325 type Narrowed<'de> = ConnectionInfo<'de>;
2326
2327 #[inline]
2328 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
2329 ::fidl_next::munge!(let Self { table } = out);
2330 ::fidl_next::wire::Table::zero_padding(table);
2331 }
2332 }
2333
2334 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConnectionInfo<'de>
2335 where
2336 ___D: ::fidl_next::Decoder<'de> + ?Sized,
2337 ___D: ::fdomain_client::fidl_next::HandleDecoder,
2338 {
2339 fn decode(
2340 slot: ::fidl_next::Slot<'_, Self>,
2341 decoder: &mut ___D,
2342 _: (),
2343 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2344 ::fidl_next::munge!(let Self { table } = slot);
2345
2346 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
2347 match ordinal {
2348 0 => unsafe { ::core::hint::unreachable_unchecked() },
2349
2350 1 => {
2351 ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Operations>(
2352 slot.as_mut(),
2353 decoder,
2354 (),
2355 )?;
2356
2357 Ok(())
2358 }
2359
2360 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
2361 }
2362 })
2363 }
2364 }
2365
2366 impl<'de> ConnectionInfo<'de> {
2367 pub fn rights(&self) -> ::core::option::Option<&crate::wire::Operations> {
2368 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
2369 }
2370 }
2371
2372 impl<'de> ::core::fmt::Debug for ConnectionInfo<'de> {
2373 fn fmt(
2374 &self,
2375 f: &mut ::core::fmt::Formatter<'_>,
2376 ) -> ::core::result::Result<(), ::core::fmt::Error> {
2377 f.debug_struct("ConnectionInfo").field("rights", &self.rights()).finish()
2378 }
2379 }
2380
2381 impl<'de> ::fidl_next::IntoNatural for ConnectionInfo<'de> {
2382 type Natural = crate::natural::ConnectionInfo;
2383 }
2384
2385 #[derive(Debug)]
2387 #[repr(C)]
2388 pub struct DirectoryGetTokenResponse {
2389 pub s: ::fidl_next::wire::Int32,
2390
2391 pub token: ::fdomain_client::fidl_next::wire::OptionalHandle,
2392 }
2393
2394 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryGetTokenResponse>(), 8);
2395 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryGetTokenResponse>(), 4);
2396
2397 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryGetTokenResponse, s), 0);
2398
2399 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryGetTokenResponse, token), 4);
2400
2401 impl ::fidl_next::Constrained for DirectoryGetTokenResponse {
2402 type Constraint = ();
2403
2404 fn validate(
2405 _: ::fidl_next::Slot<'_, Self>,
2406 _: Self::Constraint,
2407 ) -> Result<(), ::fidl_next::ValidationError> {
2408 Ok(())
2409 }
2410 }
2411
2412 unsafe impl ::fidl_next::Wire for DirectoryGetTokenResponse {
2413 type Narrowed<'de> = DirectoryGetTokenResponse;
2414
2415 #[inline]
2416 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2417 ::fidl_next::munge! {
2418 let Self {
2419 s,
2420 token,
2421
2422 } = &mut *out_;
2423 }
2424
2425 ::fidl_next::Wire::zero_padding(s);
2426
2427 ::fidl_next::Wire::zero_padding(token);
2428 }
2429 }
2430
2431 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryGetTokenResponse
2432 where
2433 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2434 ___D: ::fdomain_client::fidl_next::HandleDecoder,
2435 {
2436 fn decode(
2437 slot_: ::fidl_next::Slot<'_, Self>,
2438 decoder_: &mut ___D,
2439 _: (),
2440 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2441 ::fidl_next::munge! {
2442 let Self {
2443 mut s,
2444 mut token,
2445
2446 } = slot_;
2447 }
2448
2449 let _field = s.as_mut();
2450
2451 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
2452
2453 let _field = token.as_mut();
2454
2455 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
2456
2457 Ok(())
2458 }
2459 }
2460
2461 impl ::fidl_next::IntoNatural for DirectoryGetTokenResponse {
2462 type Natural = crate::natural::DirectoryGetTokenResponse;
2463 }
2464
2465 #[derive(Debug)]
2467 #[repr(C)]
2468 pub struct DirectoryLinkRequest<'de> {
2469 pub src: ::fidl_next::wire::String<'de>,
2470
2471 pub dst_parent_token: ::fdomain_client::fidl_next::wire::Handle,
2472
2473 pub dst: ::fidl_next::wire::String<'de>,
2474 }
2475
2476 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryLinkRequest<'_>>(), 40);
2477 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryLinkRequest<'_>>(), 8);
2478
2479 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryLinkRequest<'_>, src), 0);
2480
2481 static_assertions::const_assert_eq!(
2482 std::mem::offset_of!(DirectoryLinkRequest<'_>, dst_parent_token),
2483 16
2484 );
2485
2486 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryLinkRequest<'_>, dst), 24);
2487
2488 impl ::fidl_next::Constrained for DirectoryLinkRequest<'_> {
2489 type Constraint = ();
2490
2491 fn validate(
2492 _: ::fidl_next::Slot<'_, Self>,
2493 _: Self::Constraint,
2494 ) -> Result<(), ::fidl_next::ValidationError> {
2495 Ok(())
2496 }
2497 }
2498
2499 unsafe impl ::fidl_next::Wire for DirectoryLinkRequest<'static> {
2500 type Narrowed<'de> = DirectoryLinkRequest<'de>;
2501
2502 #[inline]
2503 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2504 ::fidl_next::munge! {
2505 let Self {
2506 src,
2507 dst_parent_token,
2508 dst,
2509
2510 } = &mut *out_;
2511 }
2512
2513 ::fidl_next::Wire::zero_padding(src);
2514
2515 ::fidl_next::Wire::zero_padding(dst_parent_token);
2516
2517 ::fidl_next::Wire::zero_padding(dst);
2518
2519 unsafe {
2520 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
2521 }
2522 }
2523 }
2524
2525 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryLinkRequest<'de>
2526 where
2527 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2528 ___D: ::fidl_next::Decoder<'de>,
2529 ___D: ::fdomain_client::fidl_next::HandleDecoder,
2530 {
2531 fn decode(
2532 slot_: ::fidl_next::Slot<'_, Self>,
2533 decoder_: &mut ___D,
2534 _: (),
2535 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2536 if slot_.as_bytes()[20..24] != [0u8; 4] {
2537 return Err(::fidl_next::DecodeError::InvalidPadding);
2538 }
2539
2540 ::fidl_next::munge! {
2541 let Self {
2542 mut src,
2543 mut dst_parent_token,
2544 mut dst,
2545
2546 } = slot_;
2547 }
2548
2549 let _field = src.as_mut();
2550 ::fidl_next::Constrained::validate(_field, 255)?;
2551 ::fidl_next::Decode::decode(src.as_mut(), decoder_, 255)?;
2552
2553 let src = unsafe { src.deref_unchecked() };
2554
2555 if src.len() > 255 {
2556 return Err(::fidl_next::DecodeError::VectorTooLong {
2557 size: src.len() as u64,
2558 limit: 255,
2559 });
2560 }
2561
2562 let _field = dst_parent_token.as_mut();
2563
2564 ::fidl_next::Decode::decode(dst_parent_token.as_mut(), decoder_, ())?;
2565
2566 let _field = dst.as_mut();
2567 ::fidl_next::Constrained::validate(_field, 255)?;
2568 ::fidl_next::Decode::decode(dst.as_mut(), decoder_, 255)?;
2569
2570 let dst = unsafe { dst.deref_unchecked() };
2571
2572 if dst.len() > 255 {
2573 return Err(::fidl_next::DecodeError::VectorTooLong {
2574 size: dst.len() as u64,
2575 limit: 255,
2576 });
2577 }
2578
2579 Ok(())
2580 }
2581 }
2582
2583 impl<'de> ::fidl_next::IntoNatural for DirectoryLinkRequest<'de> {
2584 type Natural = crate::natural::DirectoryLinkRequest;
2585 }
2586
2587 pub type Token = ::fdomain_client::fidl_next::wire::Handle;
2589
2590 #[derive(Debug)]
2592 #[repr(C)]
2593 pub struct DirectoryRenameRequest<'de> {
2594 pub src: ::fidl_next::wire::String<'de>,
2595
2596 pub dst_parent_token: ::fdomain_client::fidl_next::wire::Handle,
2597
2598 pub dst: ::fidl_next::wire::String<'de>,
2599 }
2600
2601 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryRenameRequest<'_>>(), 40);
2602 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryRenameRequest<'_>>(), 8);
2603
2604 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryRenameRequest<'_>, src), 0);
2605
2606 static_assertions::const_assert_eq!(
2607 std::mem::offset_of!(DirectoryRenameRequest<'_>, dst_parent_token),
2608 16
2609 );
2610
2611 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryRenameRequest<'_>, dst), 24);
2612
2613 impl ::fidl_next::Constrained for DirectoryRenameRequest<'_> {
2614 type Constraint = ();
2615
2616 fn validate(
2617 _: ::fidl_next::Slot<'_, Self>,
2618 _: Self::Constraint,
2619 ) -> Result<(), ::fidl_next::ValidationError> {
2620 Ok(())
2621 }
2622 }
2623
2624 unsafe impl ::fidl_next::Wire for DirectoryRenameRequest<'static> {
2625 type Narrowed<'de> = DirectoryRenameRequest<'de>;
2626
2627 #[inline]
2628 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2629 ::fidl_next::munge! {
2630 let Self {
2631 src,
2632 dst_parent_token,
2633 dst,
2634
2635 } = &mut *out_;
2636 }
2637
2638 ::fidl_next::Wire::zero_padding(src);
2639
2640 ::fidl_next::Wire::zero_padding(dst_parent_token);
2641
2642 ::fidl_next::Wire::zero_padding(dst);
2643
2644 unsafe {
2645 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
2646 }
2647 }
2648 }
2649
2650 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryRenameRequest<'de>
2651 where
2652 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2653 ___D: ::fidl_next::Decoder<'de>,
2654 ___D: ::fdomain_client::fidl_next::HandleDecoder,
2655 {
2656 fn decode(
2657 slot_: ::fidl_next::Slot<'_, Self>,
2658 decoder_: &mut ___D,
2659 _: (),
2660 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2661 if slot_.as_bytes()[20..24] != [0u8; 4] {
2662 return Err(::fidl_next::DecodeError::InvalidPadding);
2663 }
2664
2665 ::fidl_next::munge! {
2666 let Self {
2667 mut src,
2668 mut dst_parent_token,
2669 mut dst,
2670
2671 } = slot_;
2672 }
2673
2674 let _field = src.as_mut();
2675 ::fidl_next::Constrained::validate(_field, 255)?;
2676 ::fidl_next::Decode::decode(src.as_mut(), decoder_, 255)?;
2677
2678 let src = unsafe { src.deref_unchecked() };
2679
2680 if src.len() > 255 {
2681 return Err(::fidl_next::DecodeError::VectorTooLong {
2682 size: src.len() as u64,
2683 limit: 255,
2684 });
2685 }
2686
2687 let _field = dst_parent_token.as_mut();
2688
2689 ::fidl_next::Decode::decode(dst_parent_token.as_mut(), decoder_, ())?;
2690
2691 let _field = dst.as_mut();
2692 ::fidl_next::Constrained::validate(_field, 255)?;
2693 ::fidl_next::Decode::decode(dst.as_mut(), decoder_, 255)?;
2694
2695 let dst = unsafe { dst.deref_unchecked() };
2696
2697 if dst.len() > 255 {
2698 return Err(::fidl_next::DecodeError::VectorTooLong {
2699 size: dst.len() as u64,
2700 limit: 255,
2701 });
2702 }
2703
2704 Ok(())
2705 }
2706 }
2707
2708 impl<'de> ::fidl_next::IntoNatural for DirectoryRenameRequest<'de> {
2709 type Natural = crate::natural::DirectoryRenameRequest;
2710 }
2711
2712 #[derive(Debug)]
2714 #[repr(C)]
2715 pub struct DirectoryWatchRequest {
2716 pub mask: crate::wire::WatchMask,
2717
2718 pub options: ::fidl_next::wire::Uint32,
2719
2720 pub watcher: ::fidl_next::ServerEnd<
2721 crate::DirectoryWatcher,
2722 ::fdomain_client::fidl_next::wire::Handle,
2723 >,
2724 }
2725
2726 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryWatchRequest>(), 12);
2727 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryWatchRequest>(), 4);
2728
2729 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryWatchRequest, mask), 0);
2730
2731 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryWatchRequest, options), 4);
2732
2733 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryWatchRequest, watcher), 8);
2734
2735 impl ::fidl_next::Constrained for DirectoryWatchRequest {
2736 type Constraint = ();
2737
2738 fn validate(
2739 _: ::fidl_next::Slot<'_, Self>,
2740 _: Self::Constraint,
2741 ) -> Result<(), ::fidl_next::ValidationError> {
2742 Ok(())
2743 }
2744 }
2745
2746 unsafe impl ::fidl_next::Wire for DirectoryWatchRequest {
2747 type Narrowed<'de> = DirectoryWatchRequest;
2748
2749 #[inline]
2750 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2751 ::fidl_next::munge! {
2752 let Self {
2753 mask,
2754 options,
2755 watcher,
2756
2757 } = &mut *out_;
2758 }
2759
2760 ::fidl_next::Wire::zero_padding(mask);
2761
2762 ::fidl_next::Wire::zero_padding(options);
2763
2764 ::fidl_next::Wire::zero_padding(watcher);
2765 }
2766 }
2767
2768 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryWatchRequest
2769 where
2770 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2771 ___D: ::fdomain_client::fidl_next::HandleDecoder,
2772 {
2773 fn decode(
2774 slot_: ::fidl_next::Slot<'_, Self>,
2775 decoder_: &mut ___D,
2776 _: (),
2777 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2778 ::fidl_next::munge! {
2779 let Self {
2780 mut mask,
2781 mut options,
2782 mut watcher,
2783
2784 } = slot_;
2785 }
2786
2787 let _field = mask.as_mut();
2788
2789 ::fidl_next::Decode::decode(mask.as_mut(), decoder_, ())?;
2790
2791 let _field = options.as_mut();
2792
2793 ::fidl_next::Decode::decode(options.as_mut(), decoder_, ())?;
2794
2795 let _field = watcher.as_mut();
2796
2797 ::fidl_next::Decode::decode(watcher.as_mut(), decoder_, ())?;
2798
2799 Ok(())
2800 }
2801 }
2802
2803 impl ::fidl_next::IntoNatural for DirectoryWatchRequest {
2804 type Natural = crate::natural::DirectoryWatchRequest;
2805 }
2806
2807 #[derive(Debug)]
2809 #[repr(C)]
2810 pub struct NodeOnOpenRequest<'de> {
2811 pub s: ::fidl_next::wire::Int32,
2812
2813 pub info: crate::wire_optional::NodeInfoDeprecated<'de>,
2814 }
2815
2816 static_assertions::const_assert_eq!(std::mem::size_of::<NodeOnOpenRequest<'_>>(), 24);
2817 static_assertions::const_assert_eq!(std::mem::align_of::<NodeOnOpenRequest<'_>>(), 8);
2818
2819 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeOnOpenRequest<'_>, s), 0);
2820
2821 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeOnOpenRequest<'_>, info), 8);
2822
2823 impl ::fidl_next::Constrained for NodeOnOpenRequest<'_> {
2824 type Constraint = ();
2825
2826 fn validate(
2827 _: ::fidl_next::Slot<'_, Self>,
2828 _: Self::Constraint,
2829 ) -> Result<(), ::fidl_next::ValidationError> {
2830 Ok(())
2831 }
2832 }
2833
2834 unsafe impl ::fidl_next::Wire for NodeOnOpenRequest<'static> {
2835 type Narrowed<'de> = NodeOnOpenRequest<'de>;
2836
2837 #[inline]
2838 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2839 ::fidl_next::munge! {
2840 let Self {
2841 s,
2842 info,
2843
2844 } = &mut *out_;
2845 }
2846
2847 ::fidl_next::Wire::zero_padding(s);
2848
2849 ::fidl_next::Wire::zero_padding(info);
2850
2851 unsafe {
2852 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
2853 }
2854 }
2855 }
2856
2857 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeOnOpenRequest<'de>
2858 where
2859 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2860 ___D: ::fidl_next::Decoder<'de>,
2861 ___D: ::fdomain_client::fidl_next::HandleDecoder,
2862 {
2863 fn decode(
2864 slot_: ::fidl_next::Slot<'_, Self>,
2865 decoder_: &mut ___D,
2866 _: (),
2867 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2868 if slot_.as_bytes()[4..8] != [0u8; 4] {
2869 return Err(::fidl_next::DecodeError::InvalidPadding);
2870 }
2871
2872 ::fidl_next::munge! {
2873 let Self {
2874 mut s,
2875 mut info,
2876
2877 } = slot_;
2878 }
2879
2880 let _field = s.as_mut();
2881
2882 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
2883
2884 let _field = info.as_mut();
2885
2886 ::fidl_next::Decode::decode(info.as_mut(), decoder_, ())?;
2887
2888 Ok(())
2889 }
2890 }
2891
2892 impl<'de> ::fidl_next::IntoNatural for NodeOnOpenRequest<'de> {
2893 type Natural = crate::natural::NodeOnOpenRequest;
2894 }
2895
2896 #[derive(Debug)]
2898 #[repr(C)]
2899 pub struct NodeListExtendedAttributesRequest {
2900 pub iterator: ::fidl_next::ServerEnd<
2901 crate::ExtendedAttributeIterator,
2902 ::fdomain_client::fidl_next::wire::Handle,
2903 >,
2904 }
2905
2906 static_assertions::const_assert_eq!(
2907 std::mem::size_of::<NodeListExtendedAttributesRequest>(),
2908 4
2909 );
2910 static_assertions::const_assert_eq!(
2911 std::mem::align_of::<NodeListExtendedAttributesRequest>(),
2912 4
2913 );
2914
2915 static_assertions::const_assert_eq!(
2916 std::mem::offset_of!(NodeListExtendedAttributesRequest, iterator),
2917 0
2918 );
2919
2920 impl ::fidl_next::Constrained for NodeListExtendedAttributesRequest {
2921 type Constraint = ();
2922
2923 fn validate(
2924 _: ::fidl_next::Slot<'_, Self>,
2925 _: Self::Constraint,
2926 ) -> Result<(), ::fidl_next::ValidationError> {
2927 Ok(())
2928 }
2929 }
2930
2931 unsafe impl ::fidl_next::Wire for NodeListExtendedAttributesRequest {
2932 type Narrowed<'de> = NodeListExtendedAttributesRequest;
2933
2934 #[inline]
2935 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2936 ::fidl_next::munge! {
2937 let Self {
2938 iterator,
2939
2940 } = &mut *out_;
2941 }
2942
2943 ::fidl_next::Wire::zero_padding(iterator);
2944 }
2945 }
2946
2947 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeListExtendedAttributesRequest
2948 where
2949 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2950 ___D: ::fdomain_client::fidl_next::HandleDecoder,
2951 {
2952 fn decode(
2953 slot_: ::fidl_next::Slot<'_, Self>,
2954 decoder_: &mut ___D,
2955 _: (),
2956 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2957 ::fidl_next::munge! {
2958 let Self {
2959 mut iterator,
2960
2961 } = slot_;
2962 }
2963
2964 let _field = iterator.as_mut();
2965
2966 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
2967
2968 Ok(())
2969 }
2970 }
2971
2972 impl ::fidl_next::IntoNatural for NodeListExtendedAttributesRequest {
2973 type Natural = crate::natural::NodeListExtendedAttributesRequest;
2974 }
2975
2976 #[repr(transparent)]
2978 pub struct ExtendedAttributeValue<'de> {
2979 pub(crate) raw: ::fidl_next::wire::Union,
2980 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
2981 }
2982
2983 impl<'de> Drop for ExtendedAttributeValue<'de> {
2984 fn drop(&mut self) {
2985 match self.raw.ordinal() {
2986 1 => {
2987 let _ = unsafe {
2988 self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
2989 };
2990 }
2991
2992 2 => {
2993 let _ = unsafe {
2994 self.raw.get().read_unchecked::<::fdomain_client::fidl_next::wire::Handle>()
2995 };
2996 }
2997
2998 _ => (),
2999 }
3000 }
3001 }
3002
3003 impl ::fidl_next::Constrained for ExtendedAttributeValue<'_> {
3004 type Constraint = ();
3005
3006 fn validate(
3007 _: ::fidl_next::Slot<'_, Self>,
3008 _: Self::Constraint,
3009 ) -> Result<(), ::fidl_next::ValidationError> {
3010 Ok(())
3011 }
3012 }
3013
3014 unsafe impl ::fidl_next::Wire for ExtendedAttributeValue<'static> {
3015 type Narrowed<'de> = ExtendedAttributeValue<'de>;
3016
3017 #[inline]
3018 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3019 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
3020 ::fidl_next::wire::Union::zero_padding(raw);
3021 }
3022 }
3023
3024 pub mod extended_attribute_value {
3025 pub enum Ref<'de> {
3026 Bytes(&'de ::fidl_next::wire::Vector<'de, u8>),
3027
3028 Buffer(&'de ::fdomain_client::fidl_next::wire::Handle),
3029
3030 UnknownOrdinal_(u64),
3031 }
3032 }
3033
3034 impl<'de> ExtendedAttributeValue<'de> {
3035 pub fn as_ref(&self) -> crate::wire::extended_attribute_value::Ref<'_> {
3036 match self.raw.ordinal() {
3037 1 => crate::wire::extended_attribute_value::Ref::Bytes(unsafe {
3038 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
3039 }),
3040
3041 2 => crate::wire::extended_attribute_value::Ref::Buffer(unsafe {
3042 self.raw.get().deref_unchecked::<::fdomain_client::fidl_next::wire::Handle>()
3043 }),
3044
3045 unknown => crate::wire::extended_attribute_value::Ref::UnknownOrdinal_(unknown),
3046 }
3047 }
3048 }
3049
3050 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExtendedAttributeValue<'de>
3051 where
3052 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3053 ___D: ::fidl_next::Decoder<'de>,
3054 ___D: ::fdomain_client::fidl_next::HandleDecoder,
3055 {
3056 fn decode(
3057 mut slot: ::fidl_next::Slot<'_, Self>,
3058 decoder: &mut ___D,
3059 _: (),
3060 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3061 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
3062 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
3063 1 => {
3064 ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
3065 raw,
3066 decoder,
3067 (32768, ()),
3068 )?
3069 }
3070
3071 2 => ::fidl_next::wire::Union::decode_as::<
3072 ___D,
3073 ::fdomain_client::fidl_next::wire::Handle,
3074 >(raw, decoder, ())?,
3075
3076 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
3077 }
3078
3079 Ok(())
3080 }
3081 }
3082
3083 impl<'de> ::core::fmt::Debug for ExtendedAttributeValue<'de> {
3084 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3085 match self.raw.ordinal() {
3086 1 => unsafe {
3087 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>().fmt(f)
3088 },
3089 2 => unsafe {
3090 self.raw
3091 .get()
3092 .deref_unchecked::<::fdomain_client::fidl_next::wire::Handle>()
3093 .fmt(f)
3094 },
3095 _ => unsafe { ::core::hint::unreachable_unchecked() },
3096 }
3097 }
3098 }
3099
3100 impl<'de> ::fidl_next::IntoNatural for ExtendedAttributeValue<'de> {
3101 type Natural = crate::natural::ExtendedAttributeValue;
3102 }
3103
3104 #[derive(Debug)]
3106 #[repr(C)]
3107 pub struct NodeSetExtendedAttributeRequest<'de> {
3108 pub name: ::fidl_next::wire::Vector<'de, u8>,
3109
3110 pub value: crate::wire::ExtendedAttributeValue<'de>,
3111
3112 pub mode: crate::wire::SetExtendedAttributeMode,
3113 }
3114
3115 static_assertions::const_assert_eq!(
3116 std::mem::size_of::<NodeSetExtendedAttributeRequest<'_>>(),
3117 40
3118 );
3119 static_assertions::const_assert_eq!(
3120 std::mem::align_of::<NodeSetExtendedAttributeRequest<'_>>(),
3121 8
3122 );
3123
3124 static_assertions::const_assert_eq!(
3125 std::mem::offset_of!(NodeSetExtendedAttributeRequest<'_>, name),
3126 0
3127 );
3128
3129 static_assertions::const_assert_eq!(
3130 std::mem::offset_of!(NodeSetExtendedAttributeRequest<'_>, value),
3131 16
3132 );
3133
3134 static_assertions::const_assert_eq!(
3135 std::mem::offset_of!(NodeSetExtendedAttributeRequest<'_>, mode),
3136 32
3137 );
3138
3139 impl ::fidl_next::Constrained for NodeSetExtendedAttributeRequest<'_> {
3140 type Constraint = ();
3141
3142 fn validate(
3143 _: ::fidl_next::Slot<'_, Self>,
3144 _: Self::Constraint,
3145 ) -> Result<(), ::fidl_next::ValidationError> {
3146 Ok(())
3147 }
3148 }
3149
3150 unsafe impl ::fidl_next::Wire for NodeSetExtendedAttributeRequest<'static> {
3151 type Narrowed<'de> = NodeSetExtendedAttributeRequest<'de>;
3152
3153 #[inline]
3154 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3155 ::fidl_next::munge! {
3156 let Self {
3157 name,
3158 value,
3159 mode,
3160
3161 } = &mut *out_;
3162 }
3163
3164 ::fidl_next::Wire::zero_padding(name);
3165
3166 ::fidl_next::Wire::zero_padding(value);
3167
3168 ::fidl_next::Wire::zero_padding(mode);
3169
3170 unsafe {
3171 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
3172 }
3173 }
3174 }
3175
3176 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeSetExtendedAttributeRequest<'de>
3177 where
3178 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3179 ___D: ::fidl_next::Decoder<'de>,
3180 ___D: ::fdomain_client::fidl_next::HandleDecoder,
3181 {
3182 fn decode(
3183 slot_: ::fidl_next::Slot<'_, Self>,
3184 decoder_: &mut ___D,
3185 _: (),
3186 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3187 if slot_.as_bytes()[36..40] != [0u8; 4] {
3188 return Err(::fidl_next::DecodeError::InvalidPadding);
3189 }
3190
3191 ::fidl_next::munge! {
3192 let Self {
3193 mut name,
3194 mut value,
3195 mut mode,
3196
3197 } = slot_;
3198 }
3199
3200 let _field = name.as_mut();
3201 ::fidl_next::Constrained::validate(_field, (255, ()))?;
3202 ::fidl_next::Decode::decode(name.as_mut(), decoder_, (255, ()))?;
3203
3204 let name = unsafe { name.deref_unchecked() };
3205
3206 if name.len() > 255 {
3207 return Err(::fidl_next::DecodeError::VectorTooLong {
3208 size: name.len() as u64,
3209 limit: 255,
3210 });
3211 }
3212
3213 let _field = value.as_mut();
3214
3215 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
3216
3217 let _field = mode.as_mut();
3218
3219 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
3220
3221 Ok(())
3222 }
3223 }
3224
3225 impl<'de> ::fidl_next::IntoNatural for NodeSetExtendedAttributeRequest<'de> {
3226 type Natural = crate::natural::NodeSetExtendedAttributeRequest;
3227 }
3228
3229 #[repr(C)]
3231 pub struct FileInfo<'de> {
3232 pub(crate) table: ::fidl_next::wire::Table<'de>,
3233 }
3234
3235 impl<'de> Drop for FileInfo<'de> {
3236 fn drop(&mut self) {
3237 let _ = self.table.get(1).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });
3238
3239 let _ = self.table.get(2).map(|envelope| unsafe {
3240 envelope.read_unchecked::<::fdomain_client::fidl_next::wire::Handle>()
3241 });
3242
3243 let _ = self.table.get(3).map(|envelope| unsafe {
3244 envelope.read_unchecked::<::fdomain_client::fidl_next::wire::Handle>()
3245 });
3246
3247 let _ = self.table.get(4).map(|envelope| unsafe {
3248 envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
3249 });
3250 }
3251 }
3252
3253 impl ::fidl_next::Constrained for FileInfo<'_> {
3254 type Constraint = ();
3255
3256 fn validate(
3257 _: ::fidl_next::Slot<'_, Self>,
3258 _: Self::Constraint,
3259 ) -> Result<(), ::fidl_next::ValidationError> {
3260 Ok(())
3261 }
3262 }
3263
3264 unsafe impl ::fidl_next::Wire for FileInfo<'static> {
3265 type Narrowed<'de> = FileInfo<'de>;
3266
3267 #[inline]
3268 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3269 ::fidl_next::munge!(let Self { table } = out);
3270 ::fidl_next::wire::Table::zero_padding(table);
3271 }
3272 }
3273
3274 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for FileInfo<'de>
3275 where
3276 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3277 ___D: ::fdomain_client::fidl_next::HandleDecoder,
3278 {
3279 fn decode(
3280 slot: ::fidl_next::Slot<'_, Self>,
3281 decoder: &mut ___D,
3282 _: (),
3283 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3284 ::fidl_next::munge!(let Self { table } = slot);
3285
3286 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3287 match ordinal {
3288 0 => unsafe { ::core::hint::unreachable_unchecked() },
3289
3290 1 => {
3291 ::fidl_next::wire::Envelope::decode_as::<___D, bool>(
3292 slot.as_mut(),
3293 decoder,
3294 (),
3295 )?;
3296
3297 Ok(())
3298 }
3299
3300 2 => {
3301 ::fidl_next::wire::Envelope::decode_as::<
3302 ___D,
3303 ::fdomain_client::fidl_next::wire::Handle,
3304 >(slot.as_mut(), decoder, ())?;
3305
3306 Ok(())
3307 }
3308
3309 3 => {
3310 ::fidl_next::wire::Envelope::decode_as::<
3311 ___D,
3312 ::fdomain_client::fidl_next::wire::Handle,
3313 >(slot.as_mut(), decoder, ())?;
3314
3315 Ok(())
3316 }
3317
3318 4 => {
3319 ::fidl_next::wire::Envelope::decode_as::<
3320 ___D,
3321 crate::wire::NodeAttributes2<'de>,
3322 >(slot.as_mut(), decoder, ())?;
3323
3324 Ok(())
3325 }
3326
3327 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3328 }
3329 })
3330 }
3331 }
3332
3333 impl<'de> FileInfo<'de> {
3334 pub fn is_append(&self) -> ::core::option::Option<&bool> {
3335 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3336 }
3337
3338 pub fn observer(
3339 &self,
3340 ) -> ::core::option::Option<&::fdomain_client::fidl_next::wire::Handle> {
3341 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3342 }
3343
3344 pub fn stream(&self) -> ::core::option::Option<&::fdomain_client::fidl_next::wire::Handle> {
3345 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
3346 }
3347
3348 pub fn attributes(&self) -> ::core::option::Option<&crate::wire::NodeAttributes2<'de>> {
3349 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
3350 }
3351 }
3352
3353 impl<'de> ::core::fmt::Debug for FileInfo<'de> {
3354 fn fmt(
3355 &self,
3356 f: &mut ::core::fmt::Formatter<'_>,
3357 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3358 f.debug_struct("FileInfo")
3359 .field("is_append", &self.is_append())
3360 .field("observer", &self.observer())
3361 .field("stream", &self.stream())
3362 .field("attributes", &self.attributes())
3363 .finish()
3364 }
3365 }
3366
3367 impl<'de> ::fidl_next::IntoNatural for FileInfo<'de> {
3368 type Natural = crate::natural::FileInfo;
3369 }
3370
3371 #[repr(transparent)]
3373 pub struct Representation<'de> {
3374 pub(crate) raw: ::fidl_next::wire::Union,
3375 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
3376 }
3377
3378 impl<'de> Drop for Representation<'de> {
3379 fn drop(&mut self) {
3380 match self.raw.ordinal() {
3381 1 => {
3382 let _ =
3383 unsafe { self.raw.get().read_unchecked::<crate::wire::NodeInfo<'de>>() };
3384 }
3385
3386 2 => {
3387 let _ = unsafe {
3388 self.raw.get().read_unchecked::<crate::wire::DirectoryInfo<'de>>()
3389 };
3390 }
3391
3392 3 => {
3393 let _ =
3394 unsafe { self.raw.get().read_unchecked::<crate::wire::FileInfo<'de>>() };
3395 }
3396
3397 4 => {
3398 let _ =
3399 unsafe { self.raw.get().read_unchecked::<crate::wire::SymlinkInfo<'de>>() };
3400 }
3401
3402 _ => (),
3403 }
3404 }
3405 }
3406
3407 impl ::fidl_next::Constrained for Representation<'_> {
3408 type Constraint = ();
3409
3410 fn validate(
3411 _: ::fidl_next::Slot<'_, Self>,
3412 _: Self::Constraint,
3413 ) -> Result<(), ::fidl_next::ValidationError> {
3414 Ok(())
3415 }
3416 }
3417
3418 unsafe impl ::fidl_next::Wire for Representation<'static> {
3419 type Narrowed<'de> = Representation<'de>;
3420
3421 #[inline]
3422 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3423 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
3424 ::fidl_next::wire::Union::zero_padding(raw);
3425 }
3426 }
3427
3428 pub mod representation {
3429 pub enum Ref<'de> {
3430 Node(&'de crate::wire::NodeInfo<'de>),
3431
3432 Directory(&'de crate::wire::DirectoryInfo<'de>),
3433
3434 File(&'de crate::wire::FileInfo<'de>),
3435
3436 Symlink(&'de crate::wire::SymlinkInfo<'de>),
3437
3438 UnknownOrdinal_(u64),
3439 }
3440 }
3441
3442 impl<'de> Representation<'de> {
3443 pub fn as_ref(&self) -> crate::wire::representation::Ref<'_> {
3444 match self.raw.ordinal() {
3445 1 => crate::wire::representation::Ref::Node(unsafe {
3446 self.raw.get().deref_unchecked::<crate::wire::NodeInfo<'_>>()
3447 }),
3448
3449 2 => crate::wire::representation::Ref::Directory(unsafe {
3450 self.raw.get().deref_unchecked::<crate::wire::DirectoryInfo<'_>>()
3451 }),
3452
3453 3 => crate::wire::representation::Ref::File(unsafe {
3454 self.raw.get().deref_unchecked::<crate::wire::FileInfo<'_>>()
3455 }),
3456
3457 4 => crate::wire::representation::Ref::Symlink(unsafe {
3458 self.raw.get().deref_unchecked::<crate::wire::SymlinkInfo<'_>>()
3459 }),
3460
3461 unknown => crate::wire::representation::Ref::UnknownOrdinal_(unknown),
3462 }
3463 }
3464 }
3465
3466 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Representation<'de>
3467 where
3468 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3469 ___D: ::fidl_next::Decoder<'de>,
3470 ___D: ::fdomain_client::fidl_next::HandleDecoder,
3471 {
3472 fn decode(
3473 mut slot: ::fidl_next::Slot<'_, Self>,
3474 decoder: &mut ___D,
3475 _: (),
3476 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3477 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
3478 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
3479 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::NodeInfo<'de>>(
3480 raw,
3481 decoder,
3482 (),
3483 )?,
3484
3485 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirectoryInfo<'de>>(
3486 raw,
3487 decoder,
3488 (),
3489 )?,
3490
3491 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::FileInfo<'de>>(
3492 raw,
3493 decoder,
3494 (),
3495 )?,
3496
3497 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SymlinkInfo<'de>>(
3498 raw,
3499 decoder,
3500 (),
3501 )?,
3502
3503 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
3504 }
3505
3506 Ok(())
3507 }
3508 }
3509
3510 impl<'de> ::core::fmt::Debug for Representation<'de> {
3511 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3512 match self.raw.ordinal() {
3513 1 => unsafe {
3514 self.raw.get().deref_unchecked::<crate::wire::NodeInfo<'_>>().fmt(f)
3515 },
3516 2 => unsafe {
3517 self.raw.get().deref_unchecked::<crate::wire::DirectoryInfo<'_>>().fmt(f)
3518 },
3519 3 => unsafe {
3520 self.raw.get().deref_unchecked::<crate::wire::FileInfo<'_>>().fmt(f)
3521 },
3522 4 => unsafe {
3523 self.raw.get().deref_unchecked::<crate::wire::SymlinkInfo<'_>>().fmt(f)
3524 },
3525 _ => unsafe { ::core::hint::unreachable_unchecked() },
3526 }
3527 }
3528 }
3529
3530 impl<'de> ::fidl_next::IntoNatural for Representation<'de> {
3531 type Natural = crate::natural::Representation;
3532 }
3533
3534 #[derive(Debug)]
3536 #[repr(C)]
3537 pub struct OpenableOpenRequest<'de> {
3538 pub path: ::fidl_next::wire::String<'de>,
3539
3540 pub flags: crate::wire::Flags,
3541
3542 pub options: crate::wire::Options<'de>,
3543
3544 pub object: ::fdomain_client::fidl_next::wire::Handle,
3545 }
3546
3547 static_assertions::const_assert_eq!(std::mem::size_of::<OpenableOpenRequest<'_>>(), 48);
3548 static_assertions::const_assert_eq!(std::mem::align_of::<OpenableOpenRequest<'_>>(), 8);
3549
3550 static_assertions::const_assert_eq!(std::mem::offset_of!(OpenableOpenRequest<'_>, path), 0);
3551
3552 static_assertions::const_assert_eq!(std::mem::offset_of!(OpenableOpenRequest<'_>, flags), 16);
3553
3554 static_assertions::const_assert_eq!(std::mem::offset_of!(OpenableOpenRequest<'_>, options), 24);
3555
3556 static_assertions::const_assert_eq!(std::mem::offset_of!(OpenableOpenRequest<'_>, object), 40);
3557
3558 impl ::fidl_next::Constrained for OpenableOpenRequest<'_> {
3559 type Constraint = ();
3560
3561 fn validate(
3562 _: ::fidl_next::Slot<'_, Self>,
3563 _: Self::Constraint,
3564 ) -> Result<(), ::fidl_next::ValidationError> {
3565 Ok(())
3566 }
3567 }
3568
3569 unsafe impl ::fidl_next::Wire for OpenableOpenRequest<'static> {
3570 type Narrowed<'de> = OpenableOpenRequest<'de>;
3571
3572 #[inline]
3573 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3574 ::fidl_next::munge! {
3575 let Self {
3576 path,
3577 flags,
3578 options,
3579 object,
3580
3581 } = &mut *out_;
3582 }
3583
3584 ::fidl_next::Wire::zero_padding(path);
3585
3586 ::fidl_next::Wire::zero_padding(flags);
3587
3588 ::fidl_next::Wire::zero_padding(options);
3589
3590 ::fidl_next::Wire::zero_padding(object);
3591
3592 unsafe {
3593 out_.as_mut_ptr().cast::<u8>().add(44).write_bytes(0, 4);
3594 }
3595 }
3596 }
3597
3598 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for OpenableOpenRequest<'de>
3599 where
3600 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3601 ___D: ::fidl_next::Decoder<'de>,
3602 ___D: ::fdomain_client::fidl_next::HandleDecoder,
3603 {
3604 fn decode(
3605 slot_: ::fidl_next::Slot<'_, Self>,
3606 decoder_: &mut ___D,
3607 _: (),
3608 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3609 if slot_.as_bytes()[44..48] != [0u8; 4] {
3610 return Err(::fidl_next::DecodeError::InvalidPadding);
3611 }
3612
3613 ::fidl_next::munge! {
3614 let Self {
3615 mut path,
3616 mut flags,
3617 mut options,
3618 mut object,
3619
3620 } = slot_;
3621 }
3622
3623 let _field = path.as_mut();
3624 ::fidl_next::Constrained::validate(_field, 4095)?;
3625 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
3626
3627 let path = unsafe { path.deref_unchecked() };
3628
3629 if path.len() > 4095 {
3630 return Err(::fidl_next::DecodeError::VectorTooLong {
3631 size: path.len() as u64,
3632 limit: 4095,
3633 });
3634 }
3635
3636 let _field = flags.as_mut();
3637
3638 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
3639
3640 let _field = options.as_mut();
3641
3642 ::fidl_next::Decode::decode(options.as_mut(), decoder_, ())?;
3643
3644 let _field = object.as_mut();
3645
3646 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
3647
3648 Ok(())
3649 }
3650 }
3651
3652 impl<'de> ::fidl_next::IntoNatural for OpenableOpenRequest<'de> {
3653 type Natural = crate::natural::OpenableOpenRequest;
3654 }
3655
3656 #[derive(Debug)]
3658 #[repr(C)]
3659 pub struct NodeDeprecatedCloneRequest {
3660 pub flags: crate::wire::OpenFlags,
3661
3662 pub object: ::fidl_next::ServerEnd<crate::Node, ::fdomain_client::fidl_next::wire::Handle>,
3663 }
3664
3665 static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedCloneRequest>(), 8);
3666 static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedCloneRequest>(), 4);
3667
3668 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeDeprecatedCloneRequest, flags), 0);
3669
3670 static_assertions::const_assert_eq!(
3671 std::mem::offset_of!(NodeDeprecatedCloneRequest, object),
3672 4
3673 );
3674
3675 impl ::fidl_next::Constrained for NodeDeprecatedCloneRequest {
3676 type Constraint = ();
3677
3678 fn validate(
3679 _: ::fidl_next::Slot<'_, Self>,
3680 _: Self::Constraint,
3681 ) -> Result<(), ::fidl_next::ValidationError> {
3682 Ok(())
3683 }
3684 }
3685
3686 unsafe impl ::fidl_next::Wire for NodeDeprecatedCloneRequest {
3687 type Narrowed<'de> = NodeDeprecatedCloneRequest;
3688
3689 #[inline]
3690 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3691 ::fidl_next::munge! {
3692 let Self {
3693 flags,
3694 object,
3695
3696 } = &mut *out_;
3697 }
3698
3699 ::fidl_next::Wire::zero_padding(flags);
3700
3701 ::fidl_next::Wire::zero_padding(object);
3702 }
3703 }
3704
3705 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedCloneRequest
3706 where
3707 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3708 ___D: ::fdomain_client::fidl_next::HandleDecoder,
3709 {
3710 fn decode(
3711 slot_: ::fidl_next::Slot<'_, Self>,
3712 decoder_: &mut ___D,
3713 _: (),
3714 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3715 ::fidl_next::munge! {
3716 let Self {
3717 mut flags,
3718 mut object,
3719
3720 } = slot_;
3721 }
3722
3723 let _field = flags.as_mut();
3724
3725 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
3726
3727 let _field = object.as_mut();
3728
3729 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
3730
3731 Ok(())
3732 }
3733 }
3734
3735 impl ::fidl_next::IntoNatural for NodeDeprecatedCloneRequest {
3736 type Natural = crate::natural::NodeDeprecatedCloneRequest;
3737 }
3738
3739 #[derive(Debug)]
3741 #[repr(C)]
3742 pub struct DirectoryDeprecatedOpenRequest<'de> {
3743 pub flags: crate::wire::OpenFlags,
3744
3745 pub mode: crate::wire::ModeType,
3746
3747 pub path: ::fidl_next::wire::String<'de>,
3748
3749 pub object: ::fidl_next::ServerEnd<crate::Node, ::fdomain_client::fidl_next::wire::Handle>,
3750 }
3751
3752 static_assertions::const_assert_eq!(
3753 std::mem::size_of::<DirectoryDeprecatedOpenRequest<'_>>(),
3754 32
3755 );
3756 static_assertions::const_assert_eq!(
3757 std::mem::align_of::<DirectoryDeprecatedOpenRequest<'_>>(),
3758 8
3759 );
3760
3761 static_assertions::const_assert_eq!(
3762 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, flags),
3763 0
3764 );
3765
3766 static_assertions::const_assert_eq!(
3767 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, mode),
3768 4
3769 );
3770
3771 static_assertions::const_assert_eq!(
3772 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, path),
3773 8
3774 );
3775
3776 static_assertions::const_assert_eq!(
3777 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, object),
3778 24
3779 );
3780
3781 impl ::fidl_next::Constrained for DirectoryDeprecatedOpenRequest<'_> {
3782 type Constraint = ();
3783
3784 fn validate(
3785 _: ::fidl_next::Slot<'_, Self>,
3786 _: Self::Constraint,
3787 ) -> Result<(), ::fidl_next::ValidationError> {
3788 Ok(())
3789 }
3790 }
3791
3792 unsafe impl ::fidl_next::Wire for DirectoryDeprecatedOpenRequest<'static> {
3793 type Narrowed<'de> = DirectoryDeprecatedOpenRequest<'de>;
3794
3795 #[inline]
3796 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3797 ::fidl_next::munge! {
3798 let Self {
3799 flags,
3800 mode,
3801 path,
3802 object,
3803
3804 } = &mut *out_;
3805 }
3806
3807 ::fidl_next::Wire::zero_padding(flags);
3808
3809 ::fidl_next::Wire::zero_padding(mode);
3810
3811 ::fidl_next::Wire::zero_padding(path);
3812
3813 ::fidl_next::Wire::zero_padding(object);
3814
3815 unsafe {
3816 out_.as_mut_ptr().cast::<u8>().add(28).write_bytes(0, 4);
3817 }
3818 }
3819 }
3820
3821 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryDeprecatedOpenRequest<'de>
3822 where
3823 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3824 ___D: ::fidl_next::Decoder<'de>,
3825 ___D: ::fdomain_client::fidl_next::HandleDecoder,
3826 {
3827 fn decode(
3828 slot_: ::fidl_next::Slot<'_, Self>,
3829 decoder_: &mut ___D,
3830 _: (),
3831 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3832 if slot_.as_bytes()[28..32] != [0u8; 4] {
3833 return Err(::fidl_next::DecodeError::InvalidPadding);
3834 }
3835
3836 ::fidl_next::munge! {
3837 let Self {
3838 mut flags,
3839 mut mode,
3840 mut path,
3841 mut object,
3842
3843 } = slot_;
3844 }
3845
3846 let _field = flags.as_mut();
3847
3848 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
3849
3850 let _field = mode.as_mut();
3851
3852 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
3853
3854 let _field = path.as_mut();
3855 ::fidl_next::Constrained::validate(_field, 4095)?;
3856 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
3857
3858 let path = unsafe { path.deref_unchecked() };
3859
3860 if path.len() > 4095 {
3861 return Err(::fidl_next::DecodeError::VectorTooLong {
3862 size: path.len() as u64,
3863 limit: 4095,
3864 });
3865 }
3866
3867 let _field = object.as_mut();
3868
3869 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
3870
3871 Ok(())
3872 }
3873 }
3874
3875 impl<'de> ::fidl_next::IntoNatural for DirectoryDeprecatedOpenRequest<'de> {
3876 type Natural = crate::natural::DirectoryDeprecatedOpenRequest;
3877 }
3878
3879 #[derive(Debug)]
3881 #[repr(C)]
3882 pub struct DirectoryCreateSymlinkRequest<'de> {
3883 pub name: ::fidl_next::wire::String<'de>,
3884
3885 pub target: ::fidl_next::wire::Vector<'de, u8>,
3886
3887 pub connection: ::fidl_next::ServerEnd<
3888 crate::Symlink,
3889 ::fdomain_client::fidl_next::wire::OptionalHandle,
3890 >,
3891 }
3892
3893 static_assertions::const_assert_eq!(
3894 std::mem::size_of::<DirectoryCreateSymlinkRequest<'_>>(),
3895 40
3896 );
3897 static_assertions::const_assert_eq!(
3898 std::mem::align_of::<DirectoryCreateSymlinkRequest<'_>>(),
3899 8
3900 );
3901
3902 static_assertions::const_assert_eq!(
3903 std::mem::offset_of!(DirectoryCreateSymlinkRequest<'_>, name),
3904 0
3905 );
3906
3907 static_assertions::const_assert_eq!(
3908 std::mem::offset_of!(DirectoryCreateSymlinkRequest<'_>, target),
3909 16
3910 );
3911
3912 static_assertions::const_assert_eq!(
3913 std::mem::offset_of!(DirectoryCreateSymlinkRequest<'_>, connection),
3914 32
3915 );
3916
3917 impl ::fidl_next::Constrained for DirectoryCreateSymlinkRequest<'_> {
3918 type Constraint = ();
3919
3920 fn validate(
3921 _: ::fidl_next::Slot<'_, Self>,
3922 _: Self::Constraint,
3923 ) -> Result<(), ::fidl_next::ValidationError> {
3924 Ok(())
3925 }
3926 }
3927
3928 unsafe impl ::fidl_next::Wire for DirectoryCreateSymlinkRequest<'static> {
3929 type Narrowed<'de> = DirectoryCreateSymlinkRequest<'de>;
3930
3931 #[inline]
3932 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3933 ::fidl_next::munge! {
3934 let Self {
3935 name,
3936 target,
3937 connection,
3938
3939 } = &mut *out_;
3940 }
3941
3942 ::fidl_next::Wire::zero_padding(name);
3943
3944 ::fidl_next::Wire::zero_padding(target);
3945
3946 ::fidl_next::Wire::zero_padding(connection);
3947
3948 unsafe {
3949 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
3950 }
3951 }
3952 }
3953
3954 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryCreateSymlinkRequest<'de>
3955 where
3956 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3957 ___D: ::fidl_next::Decoder<'de>,
3958 ___D: ::fdomain_client::fidl_next::HandleDecoder,
3959 {
3960 fn decode(
3961 slot_: ::fidl_next::Slot<'_, Self>,
3962 decoder_: &mut ___D,
3963 _: (),
3964 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3965 if slot_.as_bytes()[36..40] != [0u8; 4] {
3966 return Err(::fidl_next::DecodeError::InvalidPadding);
3967 }
3968
3969 ::fidl_next::munge! {
3970 let Self {
3971 mut name,
3972 mut target,
3973 mut connection,
3974
3975 } = slot_;
3976 }
3977
3978 let _field = name.as_mut();
3979 ::fidl_next::Constrained::validate(_field, 255)?;
3980 ::fidl_next::Decode::decode(name.as_mut(), decoder_, 255)?;
3981
3982 let name = unsafe { name.deref_unchecked() };
3983
3984 if name.len() > 255 {
3985 return Err(::fidl_next::DecodeError::VectorTooLong {
3986 size: name.len() as u64,
3987 limit: 255,
3988 });
3989 }
3990
3991 let _field = target.as_mut();
3992 ::fidl_next::Constrained::validate(_field, (4095, ()))?;
3993 ::fidl_next::Decode::decode(target.as_mut(), decoder_, (4095, ()))?;
3994
3995 let target = unsafe { target.deref_unchecked() };
3996
3997 if target.len() > 4095 {
3998 return Err(::fidl_next::DecodeError::VectorTooLong {
3999 size: target.len() as u64,
4000 limit: 4095,
4001 });
4002 }
4003
4004 let _field = connection.as_mut();
4005
4006 ::fidl_next::Decode::decode(connection.as_mut(), decoder_, ())?;
4007
4008 Ok(())
4009 }
4010 }
4011
4012 impl<'de> ::fidl_next::IntoNatural for DirectoryCreateSymlinkRequest<'de> {
4013 type Natural = crate::natural::DirectoryCreateSymlinkRequest;
4014 }
4015
4016 #[derive(Debug)]
4018 #[repr(C)]
4019 pub struct FileGetBackingMemoryResponse {
4020 pub vmo: ::fdomain_client::fidl_next::wire::Handle,
4021 }
4022
4023 static_assertions::const_assert_eq!(std::mem::size_of::<FileGetBackingMemoryResponse>(), 4);
4024 static_assertions::const_assert_eq!(std::mem::align_of::<FileGetBackingMemoryResponse>(), 4);
4025
4026 static_assertions::const_assert_eq!(std::mem::offset_of!(FileGetBackingMemoryResponse, vmo), 0);
4027
4028 impl ::fidl_next::Constrained for FileGetBackingMemoryResponse {
4029 type Constraint = ();
4030
4031 fn validate(
4032 _: ::fidl_next::Slot<'_, Self>,
4033 _: Self::Constraint,
4034 ) -> Result<(), ::fidl_next::ValidationError> {
4035 Ok(())
4036 }
4037 }
4038
4039 unsafe impl ::fidl_next::Wire for FileGetBackingMemoryResponse {
4040 type Narrowed<'de> = FileGetBackingMemoryResponse;
4041
4042 #[inline]
4043 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4044 ::fidl_next::munge! {
4045 let Self {
4046 vmo,
4047
4048 } = &mut *out_;
4049 }
4050
4051 ::fidl_next::Wire::zero_padding(vmo);
4052 }
4053 }
4054
4055 unsafe impl<___D> ::fidl_next::Decode<___D> for FileGetBackingMemoryResponse
4056 where
4057 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4058 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4059 {
4060 fn decode(
4061 slot_: ::fidl_next::Slot<'_, Self>,
4062 decoder_: &mut ___D,
4063 _: (),
4064 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4065 ::fidl_next::munge! {
4066 let Self {
4067 mut vmo,
4068
4069 } = slot_;
4070 }
4071
4072 let _field = vmo.as_mut();
4073
4074 ::fidl_next::Decode::decode(vmo.as_mut(), decoder_, ())?;
4075
4076 Ok(())
4077 }
4078 }
4079
4080 impl ::fidl_next::IntoNatural for FileGetBackingMemoryResponse {
4081 type Natural = crate::natural::FileGetBackingMemoryResponse;
4082 }
4083
4084 #[derive(Debug)]
4086 #[repr(C)]
4087 pub struct LinkableLinkIntoRequest<'de> {
4088 pub dst_parent_token: ::fdomain_client::fidl_next::wire::Handle,
4089
4090 pub dst: ::fidl_next::wire::String<'de>,
4091 }
4092
4093 static_assertions::const_assert_eq!(std::mem::size_of::<LinkableLinkIntoRequest<'_>>(), 24);
4094 static_assertions::const_assert_eq!(std::mem::align_of::<LinkableLinkIntoRequest<'_>>(), 8);
4095
4096 static_assertions::const_assert_eq!(
4097 std::mem::offset_of!(LinkableLinkIntoRequest<'_>, dst_parent_token),
4098 0
4099 );
4100
4101 static_assertions::const_assert_eq!(std::mem::offset_of!(LinkableLinkIntoRequest<'_>, dst), 8);
4102
4103 impl ::fidl_next::Constrained for LinkableLinkIntoRequest<'_> {
4104 type Constraint = ();
4105
4106 fn validate(
4107 _: ::fidl_next::Slot<'_, Self>,
4108 _: Self::Constraint,
4109 ) -> Result<(), ::fidl_next::ValidationError> {
4110 Ok(())
4111 }
4112 }
4113
4114 unsafe impl ::fidl_next::Wire for LinkableLinkIntoRequest<'static> {
4115 type Narrowed<'de> = LinkableLinkIntoRequest<'de>;
4116
4117 #[inline]
4118 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4119 ::fidl_next::munge! {
4120 let Self {
4121 dst_parent_token,
4122 dst,
4123
4124 } = &mut *out_;
4125 }
4126
4127 ::fidl_next::Wire::zero_padding(dst_parent_token);
4128
4129 ::fidl_next::Wire::zero_padding(dst);
4130
4131 unsafe {
4132 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
4133 }
4134 }
4135 }
4136
4137 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for LinkableLinkIntoRequest<'de>
4138 where
4139 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4140 ___D: ::fidl_next::Decoder<'de>,
4141 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4142 {
4143 fn decode(
4144 slot_: ::fidl_next::Slot<'_, Self>,
4145 decoder_: &mut ___D,
4146 _: (),
4147 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4148 if slot_.as_bytes()[4..8] != [0u8; 4] {
4149 return Err(::fidl_next::DecodeError::InvalidPadding);
4150 }
4151
4152 ::fidl_next::munge! {
4153 let Self {
4154 mut dst_parent_token,
4155 mut dst,
4156
4157 } = slot_;
4158 }
4159
4160 let _field = dst_parent_token.as_mut();
4161
4162 ::fidl_next::Decode::decode(dst_parent_token.as_mut(), decoder_, ())?;
4163
4164 let _field = dst.as_mut();
4165 ::fidl_next::Constrained::validate(_field, 255)?;
4166 ::fidl_next::Decode::decode(dst.as_mut(), decoder_, 255)?;
4167
4168 let dst = unsafe { dst.deref_unchecked() };
4169
4170 if dst.len() > 255 {
4171 return Err(::fidl_next::DecodeError::VectorTooLong {
4172 size: dst.len() as u64,
4173 limit: 255,
4174 });
4175 }
4176
4177 Ok(())
4178 }
4179 }
4180
4181 impl<'de> ::fidl_next::IntoNatural for LinkableLinkIntoRequest<'de> {
4182 type Natural = crate::natural::LinkableLinkIntoRequest;
4183 }
4184
4185 #[derive(Debug)]
4187 #[repr(C)]
4188 pub struct FileAllocateRequest {
4189 pub offset: ::fidl_next::wire::Uint64,
4190
4191 pub length: ::fidl_next::wire::Uint64,
4192
4193 pub mode: crate::wire::AllocateMode,
4194 }
4195
4196 static_assertions::const_assert_eq!(std::mem::size_of::<FileAllocateRequest>(), 24);
4197 static_assertions::const_assert_eq!(std::mem::align_of::<FileAllocateRequest>(), 8);
4198
4199 static_assertions::const_assert_eq!(std::mem::offset_of!(FileAllocateRequest, offset), 0);
4200
4201 static_assertions::const_assert_eq!(std::mem::offset_of!(FileAllocateRequest, length), 8);
4202
4203 static_assertions::const_assert_eq!(std::mem::offset_of!(FileAllocateRequest, mode), 16);
4204
4205 impl ::fidl_next::Constrained for FileAllocateRequest {
4206 type Constraint = ();
4207
4208 fn validate(
4209 _: ::fidl_next::Slot<'_, Self>,
4210 _: Self::Constraint,
4211 ) -> Result<(), ::fidl_next::ValidationError> {
4212 Ok(())
4213 }
4214 }
4215
4216 unsafe impl ::fidl_next::Wire for FileAllocateRequest {
4217 type Narrowed<'de> = FileAllocateRequest;
4218
4219 #[inline]
4220 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4221 ::fidl_next::munge! {
4222 let Self {
4223 offset,
4224 length,
4225 mode,
4226
4227 } = &mut *out_;
4228 }
4229
4230 ::fidl_next::Wire::zero_padding(offset);
4231
4232 ::fidl_next::Wire::zero_padding(length);
4233
4234 ::fidl_next::Wire::zero_padding(mode);
4235
4236 unsafe {
4237 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
4238 }
4239 }
4240 }
4241
4242 unsafe impl<___D> ::fidl_next::Decode<___D> for FileAllocateRequest
4243 where
4244 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4245 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4246 {
4247 fn decode(
4248 slot_: ::fidl_next::Slot<'_, Self>,
4249 decoder_: &mut ___D,
4250 _: (),
4251 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4252 if slot_.as_bytes()[20..24] != [0u8; 4] {
4253 return Err(::fidl_next::DecodeError::InvalidPadding);
4254 }
4255
4256 ::fidl_next::munge! {
4257 let Self {
4258 mut offset,
4259 mut length,
4260 mut mode,
4261
4262 } = slot_;
4263 }
4264
4265 let _field = offset.as_mut();
4266
4267 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
4268
4269 let _field = length.as_mut();
4270
4271 ::fidl_next::Decode::decode(length.as_mut(), decoder_, ())?;
4272
4273 let _field = mode.as_mut();
4274
4275 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
4276
4277 Ok(())
4278 }
4279 }
4280
4281 impl ::fidl_next::IntoNatural for FileAllocateRequest {
4282 type Natural = crate::natural::FileAllocateRequest;
4283 }
4284
4285 #[derive(Debug)]
4287 #[repr(C)]
4288 pub struct FileEnableVerityRequest<'de> {
4289 pub options: crate::wire::VerificationOptions<'de>,
4290 }
4291
4292 static_assertions::const_assert_eq!(std::mem::size_of::<FileEnableVerityRequest<'_>>(), 16);
4293 static_assertions::const_assert_eq!(std::mem::align_of::<FileEnableVerityRequest<'_>>(), 8);
4294
4295 static_assertions::const_assert_eq!(
4296 std::mem::offset_of!(FileEnableVerityRequest<'_>, options),
4297 0
4298 );
4299
4300 impl ::fidl_next::Constrained for FileEnableVerityRequest<'_> {
4301 type Constraint = ();
4302
4303 fn validate(
4304 _: ::fidl_next::Slot<'_, Self>,
4305 _: Self::Constraint,
4306 ) -> Result<(), ::fidl_next::ValidationError> {
4307 Ok(())
4308 }
4309 }
4310
4311 unsafe impl ::fidl_next::Wire for FileEnableVerityRequest<'static> {
4312 type Narrowed<'de> = FileEnableVerityRequest<'de>;
4313
4314 #[inline]
4315 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4316 ::fidl_next::munge! {
4317 let Self {
4318 options,
4319
4320 } = &mut *out_;
4321 }
4322
4323 ::fidl_next::Wire::zero_padding(options);
4324 }
4325 }
4326
4327 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for FileEnableVerityRequest<'de>
4328 where
4329 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4330 ___D: ::fidl_next::Decoder<'de>,
4331 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4332 {
4333 fn decode(
4334 slot_: ::fidl_next::Slot<'_, Self>,
4335 decoder_: &mut ___D,
4336 _: (),
4337 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4338 ::fidl_next::munge! {
4339 let Self {
4340 mut options,
4341
4342 } = slot_;
4343 }
4344
4345 let _field = options.as_mut();
4346
4347 ::fidl_next::Decode::decode(options.as_mut(), decoder_, ())?;
4348
4349 Ok(())
4350 }
4351 }
4352
4353 impl<'de> ::fidl_next::IntoNatural for FileEnableVerityRequest<'de> {
4354 type Natural = crate::natural::FileEnableVerityRequest;
4355 }
4356
4357 #[derive(Debug)]
4359 #[repr(C)]
4360 pub struct FileObject {
4361 pub event: ::fdomain_client::fidl_next::wire::OptionalHandle,
4362
4363 pub stream: ::fdomain_client::fidl_next::wire::OptionalHandle,
4364 }
4365
4366 static_assertions::const_assert_eq!(std::mem::size_of::<FileObject>(), 8);
4367 static_assertions::const_assert_eq!(std::mem::align_of::<FileObject>(), 4);
4368
4369 static_assertions::const_assert_eq!(std::mem::offset_of!(FileObject, event), 0);
4370
4371 static_assertions::const_assert_eq!(std::mem::offset_of!(FileObject, stream), 4);
4372
4373 impl ::fidl_next::Constrained for FileObject {
4374 type Constraint = ();
4375
4376 fn validate(
4377 _: ::fidl_next::Slot<'_, Self>,
4378 _: Self::Constraint,
4379 ) -> Result<(), ::fidl_next::ValidationError> {
4380 Ok(())
4381 }
4382 }
4383
4384 unsafe impl ::fidl_next::Wire for FileObject {
4385 type Narrowed<'de> = FileObject;
4386
4387 #[inline]
4388 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4389 ::fidl_next::munge! {
4390 let Self {
4391 event,
4392 stream,
4393
4394 } = &mut *out_;
4395 }
4396
4397 ::fidl_next::Wire::zero_padding(event);
4398
4399 ::fidl_next::Wire::zero_padding(stream);
4400 }
4401 }
4402
4403 unsafe impl<___D> ::fidl_next::Decode<___D> for FileObject
4404 where
4405 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4406 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4407 {
4408 fn decode(
4409 slot_: ::fidl_next::Slot<'_, Self>,
4410 decoder_: &mut ___D,
4411 _: (),
4412 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4413 ::fidl_next::munge! {
4414 let Self {
4415 mut event,
4416 mut stream,
4417
4418 } = slot_;
4419 }
4420
4421 let _field = event.as_mut();
4422
4423 ::fidl_next::Decode::decode(event.as_mut(), decoder_, ())?;
4424
4425 let _field = stream.as_mut();
4426
4427 ::fidl_next::Decode::decode(stream.as_mut(), decoder_, ())?;
4428
4429 Ok(())
4430 }
4431 }
4432
4433 impl ::fidl_next::IntoNatural for FileObject {
4434 type Natural = crate::natural::FileObject;
4435 }
4436
4437 #[repr(transparent)]
4439 pub struct NodeInfoDeprecated<'de> {
4440 pub(crate) raw: ::fidl_next::wire::Union,
4441 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4442 }
4443
4444 impl<'de> Drop for NodeInfoDeprecated<'de> {
4445 fn drop(&mut self) {
4446 match self.raw.ordinal() {
4447 1 => {
4448 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Service>() };
4449 }
4450
4451 2 => {
4452 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::FileObject>() };
4453 }
4454
4455 3 => {
4456 let _ =
4457 unsafe { self.raw.get().read_unchecked::<crate::wire::DirectoryObject>() };
4458 }
4459
4460 4 => {
4461 let _ = unsafe {
4462 self.raw.get().read_unchecked::<crate::wire::SymlinkObject<'de>>()
4463 };
4464 }
4465
4466 _ => unsafe { ::core::hint::unreachable_unchecked() },
4467 }
4468 }
4469 }
4470
4471 impl ::fidl_next::Constrained for NodeInfoDeprecated<'_> {
4472 type Constraint = ();
4473
4474 fn validate(
4475 _: ::fidl_next::Slot<'_, Self>,
4476 _: Self::Constraint,
4477 ) -> Result<(), ::fidl_next::ValidationError> {
4478 Ok(())
4479 }
4480 }
4481
4482 unsafe impl ::fidl_next::Wire for NodeInfoDeprecated<'static> {
4483 type Narrowed<'de> = NodeInfoDeprecated<'de>;
4484
4485 #[inline]
4486 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4487 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4488 ::fidl_next::wire::Union::zero_padding(raw);
4489 }
4490 }
4491
4492 pub mod node_info_deprecated {
4493 pub enum Ref<'de> {
4494 Service(&'de crate::wire::Service),
4495
4496 File(&'de crate::wire::FileObject),
4497
4498 Directory(&'de crate::wire::DirectoryObject),
4499
4500 Symlink(&'de crate::wire::SymlinkObject<'de>),
4501 }
4502 }
4503
4504 impl<'de> NodeInfoDeprecated<'de> {
4505 pub fn as_ref(&self) -> crate::wire::node_info_deprecated::Ref<'_> {
4506 match self.raw.ordinal() {
4507 1 => crate::wire::node_info_deprecated::Ref::Service(unsafe {
4508 self.raw.get().deref_unchecked::<crate::wire::Service>()
4509 }),
4510
4511 2 => crate::wire::node_info_deprecated::Ref::File(unsafe {
4512 self.raw.get().deref_unchecked::<crate::wire::FileObject>()
4513 }),
4514
4515 3 => crate::wire::node_info_deprecated::Ref::Directory(unsafe {
4516 self.raw.get().deref_unchecked::<crate::wire::DirectoryObject>()
4517 }),
4518
4519 4 => crate::wire::node_info_deprecated::Ref::Symlink(unsafe {
4520 self.raw.get().deref_unchecked::<crate::wire::SymlinkObject<'_>>()
4521 }),
4522
4523 _ => unsafe { ::core::hint::unreachable_unchecked() },
4524 }
4525 }
4526 }
4527
4528 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeInfoDeprecated<'de>
4529 where
4530 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4531 ___D: ::fidl_next::Decoder<'de>,
4532 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4533 {
4534 fn decode(
4535 mut slot: ::fidl_next::Slot<'_, Self>,
4536 decoder: &mut ___D,
4537 _: (),
4538 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4539 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4540 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4541 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Service>(
4542 raw,
4543 decoder,
4544 (),
4545 )?,
4546
4547 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::FileObject>(
4548 raw,
4549 decoder,
4550 (),
4551 )?,
4552
4553 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirectoryObject>(
4554 raw,
4555 decoder,
4556 (),
4557 )?,
4558
4559 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SymlinkObject<'de>>(
4560 raw,
4561 decoder,
4562 (),
4563 )?,
4564
4565 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
4566 }
4567
4568 Ok(())
4569 }
4570 }
4571
4572 impl<'de> ::core::fmt::Debug for NodeInfoDeprecated<'de> {
4573 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4574 match self.raw.ordinal() {
4575 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Service>().fmt(f) },
4576 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::FileObject>().fmt(f) },
4577 3 => unsafe {
4578 self.raw.get().deref_unchecked::<crate::wire::DirectoryObject>().fmt(f)
4579 },
4580 4 => unsafe {
4581 self.raw.get().deref_unchecked::<crate::wire::SymlinkObject<'_>>().fmt(f)
4582 },
4583 _ => unsafe { ::core::hint::unreachable_unchecked() },
4584 }
4585 }
4586 }
4587
4588 impl<'de> ::fidl_next::IntoNatural for NodeInfoDeprecated<'de> {
4589 type Natural = crate::natural::NodeInfoDeprecated;
4590 }
4591}
4592
4593pub mod wire_optional {
4594
4595 pub use fidl_next_common_fuchsia_io::wire_optional::*;
4596
4597 #[repr(transparent)]
4598 pub struct ExtendedAttributeValue<'de> {
4599 pub(crate) raw: ::fidl_next::wire::Union,
4600 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4601 }
4602
4603 impl ::fidl_next::Constrained for ExtendedAttributeValue<'_> {
4604 type Constraint = ();
4605
4606 fn validate(
4607 _: ::fidl_next::Slot<'_, Self>,
4608 _: Self::Constraint,
4609 ) -> Result<(), ::fidl_next::ValidationError> {
4610 Ok(())
4611 }
4612 }
4613
4614 unsafe impl ::fidl_next::Wire for ExtendedAttributeValue<'static> {
4615 type Narrowed<'de> = ExtendedAttributeValue<'de>;
4616
4617 #[inline]
4618 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4619 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4620 ::fidl_next::wire::Union::zero_padding(raw);
4621 }
4622 }
4623
4624 impl<'de> ExtendedAttributeValue<'de> {
4625 pub fn is_some(&self) -> bool {
4626 self.raw.is_some()
4627 }
4628
4629 pub fn is_none(&self) -> bool {
4630 self.raw.is_none()
4631 }
4632
4633 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::ExtendedAttributeValue<'de>> {
4634 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
4635 }
4636
4637 pub fn into_option(
4638 self,
4639 ) -> ::core::option::Option<crate::wire::ExtendedAttributeValue<'de>> {
4640 if self.is_some() {
4641 Some(crate::wire::ExtendedAttributeValue {
4642 raw: self.raw,
4643 _phantom: ::core::marker::PhantomData,
4644 })
4645 } else {
4646 None
4647 }
4648 }
4649 }
4650
4651 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExtendedAttributeValue<'de>
4652 where
4653 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4654 ___D: ::fidl_next::Decoder<'de>,
4655 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4656 {
4657 fn decode(
4658 mut slot: ::fidl_next::Slot<'_, Self>,
4659 decoder: &mut ___D,
4660 _: (),
4661 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4662 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4663 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4664 1 => {
4665 ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
4666 raw,
4667 decoder,
4668 (32768, ()),
4669 )?
4670 }
4671
4672 2 => ::fidl_next::wire::Union::decode_as::<
4673 ___D,
4674 ::fdomain_client::fidl_next::wire::Handle,
4675 >(raw, decoder, ())?,
4676
4677 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
4678 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4679 }
4680
4681 Ok(())
4682 }
4683 }
4684
4685 impl<'de> ::core::fmt::Debug for ExtendedAttributeValue<'de> {
4686 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4687 self.as_ref().fmt(f)
4688 }
4689 }
4690
4691 impl<'de> ::fidl_next::IntoNatural for ExtendedAttributeValue<'de> {
4692 type Natural = ::core::option::Option<crate::natural::ExtendedAttributeValue>;
4693 }
4694
4695 #[repr(transparent)]
4696 pub struct Representation<'de> {
4697 pub(crate) raw: ::fidl_next::wire::Union,
4698 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4699 }
4700
4701 impl ::fidl_next::Constrained for Representation<'_> {
4702 type Constraint = ();
4703
4704 fn validate(
4705 _: ::fidl_next::Slot<'_, Self>,
4706 _: Self::Constraint,
4707 ) -> Result<(), ::fidl_next::ValidationError> {
4708 Ok(())
4709 }
4710 }
4711
4712 unsafe impl ::fidl_next::Wire for Representation<'static> {
4713 type Narrowed<'de> = Representation<'de>;
4714
4715 #[inline]
4716 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4717 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4718 ::fidl_next::wire::Union::zero_padding(raw);
4719 }
4720 }
4721
4722 impl<'de> Representation<'de> {
4723 pub fn is_some(&self) -> bool {
4724 self.raw.is_some()
4725 }
4726
4727 pub fn is_none(&self) -> bool {
4728 self.raw.is_none()
4729 }
4730
4731 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Representation<'de>> {
4732 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
4733 }
4734
4735 pub fn into_option(self) -> ::core::option::Option<crate::wire::Representation<'de>> {
4736 if self.is_some() {
4737 Some(crate::wire::Representation {
4738 raw: self.raw,
4739 _phantom: ::core::marker::PhantomData,
4740 })
4741 } else {
4742 None
4743 }
4744 }
4745 }
4746
4747 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Representation<'de>
4748 where
4749 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4750 ___D: ::fidl_next::Decoder<'de>,
4751 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4752 {
4753 fn decode(
4754 mut slot: ::fidl_next::Slot<'_, Self>,
4755 decoder: &mut ___D,
4756 _: (),
4757 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4758 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4759 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4760 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::NodeInfo<'de>>(
4761 raw,
4762 decoder,
4763 (),
4764 )?,
4765
4766 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirectoryInfo<'de>>(
4767 raw,
4768 decoder,
4769 (),
4770 )?,
4771
4772 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::FileInfo<'de>>(
4773 raw,
4774 decoder,
4775 (),
4776 )?,
4777
4778 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SymlinkInfo<'de>>(
4779 raw,
4780 decoder,
4781 (),
4782 )?,
4783
4784 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
4785 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4786 }
4787
4788 Ok(())
4789 }
4790 }
4791
4792 impl<'de> ::core::fmt::Debug for Representation<'de> {
4793 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4794 self.as_ref().fmt(f)
4795 }
4796 }
4797
4798 impl<'de> ::fidl_next::IntoNatural for Representation<'de> {
4799 type Natural = ::core::option::Option<crate::natural::Representation>;
4800 }
4801
4802 #[repr(transparent)]
4803 pub struct NodeInfoDeprecated<'de> {
4804 pub(crate) raw: ::fidl_next::wire::Union,
4805 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4806 }
4807
4808 impl ::fidl_next::Constrained for NodeInfoDeprecated<'_> {
4809 type Constraint = ();
4810
4811 fn validate(
4812 _: ::fidl_next::Slot<'_, Self>,
4813 _: Self::Constraint,
4814 ) -> Result<(), ::fidl_next::ValidationError> {
4815 Ok(())
4816 }
4817 }
4818
4819 unsafe impl ::fidl_next::Wire for NodeInfoDeprecated<'static> {
4820 type Narrowed<'de> = NodeInfoDeprecated<'de>;
4821
4822 #[inline]
4823 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4824 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4825 ::fidl_next::wire::Union::zero_padding(raw);
4826 }
4827 }
4828
4829 impl<'de> NodeInfoDeprecated<'de> {
4830 pub fn is_some(&self) -> bool {
4831 self.raw.is_some()
4832 }
4833
4834 pub fn is_none(&self) -> bool {
4835 self.raw.is_none()
4836 }
4837
4838 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::NodeInfoDeprecated<'de>> {
4839 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
4840 }
4841
4842 pub fn into_option(self) -> ::core::option::Option<crate::wire::NodeInfoDeprecated<'de>> {
4843 if self.is_some() {
4844 Some(crate::wire::NodeInfoDeprecated {
4845 raw: self.raw,
4846 _phantom: ::core::marker::PhantomData,
4847 })
4848 } else {
4849 None
4850 }
4851 }
4852 }
4853
4854 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeInfoDeprecated<'de>
4855 where
4856 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4857 ___D: ::fidl_next::Decoder<'de>,
4858 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4859 {
4860 fn decode(
4861 mut slot: ::fidl_next::Slot<'_, Self>,
4862 decoder: &mut ___D,
4863 _: (),
4864 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4865 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4866 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4867 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Service>(
4868 raw,
4869 decoder,
4870 (),
4871 )?,
4872
4873 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::FileObject>(
4874 raw,
4875 decoder,
4876 (),
4877 )?,
4878
4879 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirectoryObject>(
4880 raw,
4881 decoder,
4882 (),
4883 )?,
4884
4885 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SymlinkObject<'de>>(
4886 raw,
4887 decoder,
4888 (),
4889 )?,
4890
4891 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
4892 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4893 }
4894
4895 Ok(())
4896 }
4897 }
4898
4899 impl<'de> ::core::fmt::Debug for NodeInfoDeprecated<'de> {
4900 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4901 self.as_ref().fmt(f)
4902 }
4903 }
4904
4905 impl<'de> ::fidl_next::IntoNatural for NodeInfoDeprecated<'de> {
4906 type Natural = ::core::option::Option<crate::natural::NodeInfoDeprecated>;
4907 }
4908}
4909
4910pub mod generic {
4911
4912 pub use fidl_next_common_fuchsia_io::generic::*;
4913
4914 pub struct DirectoryGetTokenResponse<T0, T1> {
4916 pub s: T0,
4917
4918 pub token: T1,
4919 }
4920
4921 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DirectoryGetTokenResponse, ___E>
4922 for DirectoryGetTokenResponse<T0, T1>
4923 where
4924 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4925 ___E: ::fdomain_client::fidl_next::HandleEncoder,
4926 T0: ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>,
4927 T1: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::OptionalHandle, ___E>,
4928 {
4929 #[inline]
4930 fn encode(
4931 self,
4932 encoder_: &mut ___E,
4933 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryGetTokenResponse>,
4934 _: (),
4935 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4936 ::fidl_next::munge! {
4937 let crate::wire::DirectoryGetTokenResponse {
4938 s,
4939 token,
4940
4941 } = out_;
4942 }
4943
4944 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
4945
4946 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
4947
4948 Ok(())
4949 }
4950 }
4951
4952 pub struct DirectoryLinkRequest<T0, T1, T2> {
4954 pub src: T0,
4955
4956 pub dst_parent_token: T1,
4957
4958 pub dst: T2,
4959 }
4960
4961 unsafe impl<___E, T0, T1, T2>
4962 ::fidl_next::Encode<crate::wire::DirectoryLinkRequest<'static>, ___E>
4963 for DirectoryLinkRequest<T0, T1, T2>
4964 where
4965 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4966 ___E: ::fidl_next::Encoder,
4967 ___E: ::fdomain_client::fidl_next::HandleEncoder,
4968 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
4969 T1: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::Handle, ___E>,
4970 T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
4971 {
4972 #[inline]
4973 fn encode(
4974 self,
4975 encoder_: &mut ___E,
4976 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkRequest<'static>>,
4977 _: (),
4978 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4979 ::fidl_next::munge! {
4980 let crate::wire::DirectoryLinkRequest {
4981 src,
4982 dst_parent_token,
4983 dst,
4984
4985 } = out_;
4986 }
4987
4988 ::fidl_next::Encode::encode(self.src, encoder_, src, 255)?;
4989
4990 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
4991
4992 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
4993
4994 Ok(())
4995 }
4996 }
4997
4998 pub struct DirectoryRenameRequest<T0, T1, T2> {
5000 pub src: T0,
5001
5002 pub dst_parent_token: T1,
5003
5004 pub dst: T2,
5005 }
5006
5007 unsafe impl<___E, T0, T1, T2>
5008 ::fidl_next::Encode<crate::wire::DirectoryRenameRequest<'static>, ___E>
5009 for DirectoryRenameRequest<T0, T1, T2>
5010 where
5011 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5012 ___E: ::fidl_next::Encoder,
5013 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5014 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5015 T1: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::Handle, ___E>,
5016 T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5017 {
5018 #[inline]
5019 fn encode(
5020 self,
5021 encoder_: &mut ___E,
5022 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRenameRequest<'static>>,
5023 _: (),
5024 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5025 ::fidl_next::munge! {
5026 let crate::wire::DirectoryRenameRequest {
5027 src,
5028 dst_parent_token,
5029 dst,
5030
5031 } = out_;
5032 }
5033
5034 ::fidl_next::Encode::encode(self.src, encoder_, src, 255)?;
5035
5036 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
5037
5038 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
5039
5040 Ok(())
5041 }
5042 }
5043
5044 pub struct DirectoryWatchRequest<T0, T1, T2> {
5046 pub mask: T0,
5047
5048 pub options: T1,
5049
5050 pub watcher: T2,
5051 }
5052
5053 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::DirectoryWatchRequest, ___E>
5054 for DirectoryWatchRequest<T0, T1, T2>
5055 where
5056 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5057 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5058 T0: ::fidl_next::Encode<crate::wire::WatchMask, ___E>,
5059 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
5060 T2: ::fidl_next::Encode<
5061 ::fidl_next::ServerEnd<
5062 crate::DirectoryWatcher,
5063 ::fdomain_client::fidl_next::wire::Handle,
5064 >,
5065 ___E,
5066 >,
5067 {
5068 #[inline]
5069 fn encode(
5070 self,
5071 encoder_: &mut ___E,
5072 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchRequest>,
5073 _: (),
5074 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5075 ::fidl_next::munge! {
5076 let crate::wire::DirectoryWatchRequest {
5077 mask,
5078 options,
5079 watcher,
5080
5081 } = out_;
5082 }
5083
5084 ::fidl_next::Encode::encode(self.mask, encoder_, mask, ())?;
5085
5086 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
5087
5088 ::fidl_next::Encode::encode(self.watcher, encoder_, watcher, ())?;
5089
5090 Ok(())
5091 }
5092 }
5093
5094 pub struct NodeOnOpenRequest<T0, T1> {
5096 pub s: T0,
5097
5098 pub info: T1,
5099 }
5100
5101 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeOnOpenRequest<'static>, ___E>
5102 for NodeOnOpenRequest<T0, T1>
5103 where
5104 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5105 ___E: ::fidl_next::Encoder,
5106 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5107 T0: ::fidl_next::Encode<::fidl_next::wire::Int32, ___E>,
5108 T1: ::fidl_next::Encode<crate::wire_optional::NodeInfoDeprecated<'static>, ___E>,
5109 {
5110 #[inline]
5111 fn encode(
5112 self,
5113 encoder_: &mut ___E,
5114 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeOnOpenRequest<'static>>,
5115 _: (),
5116 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5117 ::fidl_next::munge! {
5118 let crate::wire::NodeOnOpenRequest {
5119 s,
5120 info,
5121
5122 } = out_;
5123 }
5124
5125 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
5126
5127 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
5128
5129 Ok(())
5130 }
5131 }
5132
5133 pub struct NodeListExtendedAttributesRequest<T0> {
5135 pub iterator: T0,
5136 }
5137
5138 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeListExtendedAttributesRequest, ___E>
5139 for NodeListExtendedAttributesRequest<T0>
5140 where
5141 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5142 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5143 T0: ::fidl_next::Encode<
5144 ::fidl_next::ServerEnd<
5145 crate::ExtendedAttributeIterator,
5146 ::fdomain_client::fidl_next::wire::Handle,
5147 >,
5148 ___E,
5149 >,
5150 {
5151 #[inline]
5152 fn encode(
5153 self,
5154 encoder_: &mut ___E,
5155 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeListExtendedAttributesRequest>,
5156 _: (),
5157 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5158 ::fidl_next::munge! {
5159 let crate::wire::NodeListExtendedAttributesRequest {
5160 iterator,
5161
5162 } = out_;
5163 }
5164
5165 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
5166
5167 Ok(())
5168 }
5169 }
5170
5171 pub struct NodeSetExtendedAttributeRequest<T0, T1, T2> {
5173 pub name: T0,
5174
5175 pub value: T1,
5176
5177 pub mode: T2,
5178 }
5179
5180 unsafe impl<___E, T0, T1, T2>
5181 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeRequest<'static>, ___E>
5182 for NodeSetExtendedAttributeRequest<T0, T1, T2>
5183 where
5184 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5185 ___E: ::fidl_next::Encoder,
5186 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5187 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
5188 T1: ::fidl_next::Encode<crate::wire::ExtendedAttributeValue<'static>, ___E>,
5189 T2: ::fidl_next::Encode<crate::wire::SetExtendedAttributeMode, ___E>,
5190 {
5191 #[inline]
5192 fn encode(
5193 self,
5194 encoder_: &mut ___E,
5195 out_: &mut ::core::mem::MaybeUninit<
5196 crate::wire::NodeSetExtendedAttributeRequest<'static>,
5197 >,
5198 _: (),
5199 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5200 ::fidl_next::munge! {
5201 let crate::wire::NodeSetExtendedAttributeRequest {
5202 name,
5203 value,
5204 mode,
5205
5206 } = out_;
5207 }
5208
5209 ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
5210
5211 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
5212
5213 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
5214
5215 Ok(())
5216 }
5217 }
5218
5219 pub struct OpenableOpenRequest<T0, T1, T2, T3> {
5221 pub path: T0,
5222
5223 pub flags: T1,
5224
5225 pub options: T2,
5226
5227 pub object: T3,
5228 }
5229
5230 unsafe impl<___E, T0, T1, T2, T3>
5231 ::fidl_next::Encode<crate::wire::OpenableOpenRequest<'static>, ___E>
5232 for OpenableOpenRequest<T0, T1, T2, T3>
5233 where
5234 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5235 ___E: ::fidl_next::Encoder,
5236 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5237 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5238 T1: ::fidl_next::Encode<crate::wire::Flags, ___E>,
5239 T2: ::fidl_next::Encode<crate::wire::Options<'static>, ___E>,
5240 T3: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::Handle, ___E>,
5241 {
5242 #[inline]
5243 fn encode(
5244 self,
5245 encoder_: &mut ___E,
5246 out_: &mut ::core::mem::MaybeUninit<crate::wire::OpenableOpenRequest<'static>>,
5247 _: (),
5248 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5249 ::fidl_next::munge! {
5250 let crate::wire::OpenableOpenRequest {
5251 path,
5252 flags,
5253 options,
5254 object,
5255
5256 } = out_;
5257 }
5258
5259 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
5260
5261 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
5262
5263 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
5264
5265 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
5266
5267 Ok(())
5268 }
5269 }
5270
5271 pub struct NodeDeprecatedCloneRequest<T0, T1> {
5273 pub flags: T0,
5274
5275 pub object: T1,
5276 }
5277
5278 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeDeprecatedCloneRequest, ___E>
5279 for NodeDeprecatedCloneRequest<T0, T1>
5280 where
5281 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5282 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5283 T0: ::fidl_next::Encode<crate::wire::OpenFlags, ___E>,
5284 T1: ::fidl_next::Encode<
5285 ::fidl_next::ServerEnd<crate::Node, ::fdomain_client::fidl_next::wire::Handle>,
5286 ___E,
5287 >,
5288 {
5289 #[inline]
5290 fn encode(
5291 self,
5292 encoder_: &mut ___E,
5293 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedCloneRequest>,
5294 _: (),
5295 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5296 ::fidl_next::munge! {
5297 let crate::wire::NodeDeprecatedCloneRequest {
5298 flags,
5299 object,
5300
5301 } = out_;
5302 }
5303
5304 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
5305
5306 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
5307
5308 Ok(())
5309 }
5310 }
5311
5312 pub struct DirectoryDeprecatedOpenRequest<T0, T1, T2, T3> {
5314 pub flags: T0,
5315
5316 pub mode: T1,
5317
5318 pub path: T2,
5319
5320 pub object: T3,
5321 }
5322
5323 unsafe impl<___E, T0, T1, T2, T3>
5324 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedOpenRequest<'static>, ___E>
5325 for DirectoryDeprecatedOpenRequest<T0, T1, T2, T3>
5326 where
5327 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5328 ___E: ::fidl_next::Encoder,
5329 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5330 T0: ::fidl_next::Encode<crate::wire::OpenFlags, ___E>,
5331 T1: ::fidl_next::Encode<crate::wire::ModeType, ___E>,
5332 T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5333 T3: ::fidl_next::Encode<
5334 ::fidl_next::ServerEnd<crate::Node, ::fdomain_client::fidl_next::wire::Handle>,
5335 ___E,
5336 >,
5337 {
5338 #[inline]
5339 fn encode(
5340 self,
5341 encoder_: &mut ___E,
5342 out_: &mut ::core::mem::MaybeUninit<
5343 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
5344 >,
5345 _: (),
5346 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5347 ::fidl_next::munge! {
5348 let crate::wire::DirectoryDeprecatedOpenRequest {
5349 flags,
5350 mode,
5351 path,
5352 object,
5353
5354 } = out_;
5355 }
5356
5357 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
5358
5359 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
5360
5361 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
5362
5363 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
5364
5365 Ok(())
5366 }
5367 }
5368
5369 pub struct DirectoryCreateSymlinkRequest<T0, T1, T2> {
5371 pub name: T0,
5372
5373 pub target: T1,
5374
5375 pub connection: T2,
5376 }
5377
5378 unsafe impl<___E, T0, T1, T2>
5379 ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkRequest<'static>, ___E>
5380 for DirectoryCreateSymlinkRequest<T0, T1, T2>
5381 where
5382 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5383 ___E: ::fidl_next::Encoder,
5384 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5385 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5386 T1: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
5387 T2: ::fidl_next::Encode<
5388 ::fidl_next::ServerEnd<
5389 crate::Symlink,
5390 ::fdomain_client::fidl_next::wire::OptionalHandle,
5391 >,
5392 ___E,
5393 >,
5394 {
5395 #[inline]
5396 fn encode(
5397 self,
5398 encoder_: &mut ___E,
5399 out_: &mut ::core::mem::MaybeUninit<
5400 crate::wire::DirectoryCreateSymlinkRequest<'static>,
5401 >,
5402 _: (),
5403 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5404 ::fidl_next::munge! {
5405 let crate::wire::DirectoryCreateSymlinkRequest {
5406 name,
5407 target,
5408 connection,
5409
5410 } = out_;
5411 }
5412
5413 ::fidl_next::Encode::encode(self.name, encoder_, name, 255)?;
5414
5415 ::fidl_next::Encode::encode(self.target, encoder_, target, (4095, ()))?;
5416
5417 ::fidl_next::Encode::encode(self.connection, encoder_, connection, ())?;
5418
5419 Ok(())
5420 }
5421 }
5422
5423 pub struct FileGetBackingMemoryResponse<T0> {
5425 pub vmo: T0,
5426 }
5427
5428 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryResponse, ___E>
5429 for FileGetBackingMemoryResponse<T0>
5430 where
5431 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5432 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5433 T0: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::Handle, ___E>,
5434 {
5435 #[inline]
5436 fn encode(
5437 self,
5438 encoder_: &mut ___E,
5439 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryResponse>,
5440 _: (),
5441 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5442 ::fidl_next::munge! {
5443 let crate::wire::FileGetBackingMemoryResponse {
5444 vmo,
5445
5446 } = out_;
5447 }
5448
5449 ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
5450
5451 Ok(())
5452 }
5453 }
5454
5455 pub struct LinkableLinkIntoRequest<T0, T1> {
5457 pub dst_parent_token: T0,
5458
5459 pub dst: T1,
5460 }
5461
5462 unsafe impl<___E, T0, T1>
5463 ::fidl_next::Encode<crate::wire::LinkableLinkIntoRequest<'static>, ___E>
5464 for LinkableLinkIntoRequest<T0, T1>
5465 where
5466 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5467 ___E: ::fidl_next::Encoder,
5468 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5469 T0: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::Handle, ___E>,
5470 T1: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5471 {
5472 #[inline]
5473 fn encode(
5474 self,
5475 encoder_: &mut ___E,
5476 out_: &mut ::core::mem::MaybeUninit<crate::wire::LinkableLinkIntoRequest<'static>>,
5477 _: (),
5478 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5479 ::fidl_next::munge! {
5480 let crate::wire::LinkableLinkIntoRequest {
5481 dst_parent_token,
5482 dst,
5483
5484 } = out_;
5485 }
5486
5487 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
5488
5489 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
5490
5491 Ok(())
5492 }
5493 }
5494
5495 pub struct FileAllocateRequest<T0, T1, T2> {
5497 pub offset: T0,
5498
5499 pub length: T1,
5500
5501 pub mode: T2,
5502 }
5503
5504 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::FileAllocateRequest, ___E>
5505 for FileAllocateRequest<T0, T1, T2>
5506 where
5507 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5508 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5509 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
5510 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
5511 T2: ::fidl_next::Encode<crate::wire::AllocateMode, ___E>,
5512 {
5513 #[inline]
5514 fn encode(
5515 self,
5516 encoder_: &mut ___E,
5517 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileAllocateRequest>,
5518 _: (),
5519 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5520 ::fidl_next::munge! {
5521 let crate::wire::FileAllocateRequest {
5522 offset,
5523 length,
5524 mode,
5525
5526 } = out_;
5527 }
5528
5529 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
5530
5531 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
5532
5533 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
5534
5535 Ok(())
5536 }
5537 }
5538
5539 pub struct FileEnableVerityRequest<T0> {
5541 pub options: T0,
5542 }
5543
5544 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileEnableVerityRequest<'static>, ___E>
5545 for FileEnableVerityRequest<T0>
5546 where
5547 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5548 ___E: ::fidl_next::Encoder,
5549 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5550 T0: ::fidl_next::Encode<crate::wire::VerificationOptions<'static>, ___E>,
5551 {
5552 #[inline]
5553 fn encode(
5554 self,
5555 encoder_: &mut ___E,
5556 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileEnableVerityRequest<'static>>,
5557 _: (),
5558 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5559 ::fidl_next::munge! {
5560 let crate::wire::FileEnableVerityRequest {
5561 options,
5562
5563 } = out_;
5564 }
5565
5566 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
5567
5568 Ok(())
5569 }
5570 }
5571
5572 pub struct FileObject<T0, T1> {
5574 pub event: T0,
5575
5576 pub stream: T1,
5577 }
5578
5579 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::FileObject, ___E> for FileObject<T0, T1>
5580 where
5581 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5582 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5583 T0: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::OptionalHandle, ___E>,
5584 T1: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::OptionalHandle, ___E>,
5585 {
5586 #[inline]
5587 fn encode(
5588 self,
5589 encoder_: &mut ___E,
5590 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileObject>,
5591 _: (),
5592 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5593 ::fidl_next::munge! {
5594 let crate::wire::FileObject {
5595 event,
5596 stream,
5597
5598 } = out_;
5599 }
5600
5601 ::fidl_next::Encode::encode(self.event, encoder_, event, ())?;
5602
5603 ::fidl_next::Encode::encode(self.stream, encoder_, stream, ())?;
5604
5605 Ok(())
5606 }
5607 }
5608}
5609
5610pub use self::natural::*;
5611
5612#[doc = " Openable defines a node which is capable of opening other objects.\n"]
5614#[derive(PartialEq, Debug)]
5615pub struct Openable;
5616
5617#[cfg(target_os = "fuchsia")]
5618impl ::fidl_next::HasTransport for Openable {
5619 type Transport = ::fdomain_client::Channel;
5620}
5621
5622pub mod openable {
5623 pub mod prelude {
5624 pub use crate::{
5625 Openable, OpenableClientHandler, OpenableLocalClientHandler,
5626 OpenableLocalServerHandler, OpenableServerHandler, openable,
5627 };
5628
5629 pub use crate::natural::OpenableOpenRequest;
5630 }
5631
5632 pub struct Open;
5633
5634 impl ::fidl_next::Method for Open {
5635 const ORDINAL: u64 = 6236883748953765593;
5636 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5637 ::fidl_next::protocol::Flexibility::Flexible;
5638
5639 type Protocol = crate::Openable;
5640
5641 type Request = crate::wire::OpenableOpenRequest<'static>;
5642 }
5643
5644 mod ___detail {
5645 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Openable
5646 where
5647 ___T: ::fidl_next::Transport,
5648 {
5649 type Client = OpenableClient<___T>;
5650 type Server = OpenableServer<___T>;
5651 }
5652
5653 #[repr(transparent)]
5655 pub struct OpenableClient<___T: ::fidl_next::Transport> {
5656 #[allow(dead_code)]
5657 client: ::fidl_next::protocol::Client<___T>,
5658 }
5659
5660 impl<___T> OpenableClient<___T>
5661 where
5662 ___T: ::fidl_next::Transport,
5663 {
5664 #[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"]
5665 pub fn open(
5666 &self,
5667
5668 path: impl ::fidl_next::Encode<
5669 ::fidl_next::wire::String<'static>,
5670 <___T as ::fidl_next::Transport>::SendBuffer,
5671 >,
5672
5673 flags: impl ::fidl_next::Encode<
5674 crate::wire::Flags,
5675 <___T as ::fidl_next::Transport>::SendBuffer,
5676 >,
5677
5678 options: impl ::fidl_next::Encode<
5679 crate::wire::Options<'static>,
5680 <___T as ::fidl_next::Transport>::SendBuffer,
5681 >,
5682
5683 object: impl ::fidl_next::Encode<
5684 ::fdomain_client::fidl_next::wire::Handle,
5685 <___T as ::fidl_next::Transport>::SendBuffer,
5686 >,
5687 ) -> ::fidl_next::SendFuture<'_, ___T>
5688 where
5689 <___T as ::fidl_next::Transport>::SendBuffer:
5690 ::fidl_next::encoder::InternalHandleEncoder,
5691 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
5692 <___T as ::fidl_next::Transport>::SendBuffer:
5693 ::fdomain_client::fidl_next::HandleEncoder,
5694 {
5695 self.open_with(crate::generic::OpenableOpenRequest { path, flags, options, object })
5696 }
5697
5698 #[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"]
5699 pub fn open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
5700 where
5701 ___R: ::fidl_next::Encode<
5702 crate::wire::OpenableOpenRequest<'static>,
5703 <___T as ::fidl_next::Transport>::SendBuffer,
5704 >,
5705 {
5706 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
5707 6236883748953765593,
5708 <super::Open as ::fidl_next::Method>::FLEXIBILITY,
5709 request,
5710 ))
5711 }
5712 }
5713
5714 #[repr(transparent)]
5716 pub struct OpenableServer<___T: ::fidl_next::Transport> {
5717 server: ::fidl_next::protocol::Server<___T>,
5718 }
5719
5720 impl<___T> OpenableServer<___T> where ___T: ::fidl_next::Transport {}
5721 }
5722}
5723
5724#[diagnostic::on_unimplemented(
5725 note = "If {Self} implements the non-local OpenableClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
5726)]
5727
5728pub trait OpenableLocalClientHandler<
5732 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
5733 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5734>
5735{
5736 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
5737 ::core::future::ready(())
5738 }
5739}
5740
5741impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Openable
5742where
5743 ___H: OpenableLocalClientHandler<___T>,
5744 ___T: ::fidl_next::Transport,
5745{
5746 async fn on_event(
5747 handler: &mut ___H,
5748 ordinal: u64,
5749 flexibility: ::fidl_next::protocol::Flexibility,
5750 body: ::fidl_next::Body<___T>,
5751 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5752 match ordinal {
5753 ordinal => {
5754 handler.on_unknown_interaction(ordinal).await;
5755 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
5756 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5757 } else {
5758 Ok(())
5759 }
5760 }
5761 }
5762 }
5763}
5764
5765#[diagnostic::on_unimplemented(
5766 note = "If {Self} implements the non-local OpenableServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
5767)]
5768
5769pub trait OpenableLocalServerHandler<
5773 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
5774 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5775>
5776{
5777 #[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"]
5778 fn open(
5779 &mut self,
5780
5781 request: ::fidl_next::Request<openable::Open, ___T>,
5782 ) -> impl ::core::future::Future<Output = ()>;
5783
5784 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
5785 ::core::future::ready(())
5786 }
5787}
5788
5789impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Openable
5790where
5791 ___H: OpenableLocalServerHandler<___T>,
5792 ___T: ::fidl_next::Transport,
5793 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
5794 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5795 Constraint = (),
5796 >,
5797{
5798 async fn on_one_way(
5799 handler: &mut ___H,
5800 ordinal: u64,
5801 flexibility: ::fidl_next::protocol::Flexibility,
5802 body: ::fidl_next::Body<___T>,
5803 ) -> ::core::result::Result<
5804 (),
5805 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5806 > {
5807 match ordinal {
5808 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
5809 Ok(decoded) => {
5810 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
5811 Ok(())
5812 }
5813 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5814 ordinal: 6236883748953765593,
5815 error,
5816 }),
5817 },
5818
5819 ordinal => {
5820 handler.on_unknown_interaction(ordinal).await;
5821 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
5822 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5823 } else {
5824 Ok(())
5825 }
5826 }
5827 }
5828 }
5829
5830 async fn on_two_way(
5831 handler: &mut ___H,
5832 ordinal: u64,
5833 flexibility: ::fidl_next::protocol::Flexibility,
5834 body: ::fidl_next::Body<___T>,
5835 responder: ::fidl_next::protocol::Responder<___T>,
5836 ) -> ::core::result::Result<
5837 (),
5838 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5839 > {
5840 match ordinal {
5841 ordinal => {
5842 handler.on_unknown_interaction(ordinal).await;
5843 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
5844 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5845 } else {
5846 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
5847 ordinal,
5848 flexibility,
5849 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
5850 )
5851 .expect("encoding a framework error should never fail")
5852 .await?;
5853 Ok(())
5854 }
5855 }
5856 }
5857 }
5858}
5859
5860pub trait OpenableClientHandler<
5864 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
5865 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5866>
5867{
5868 fn on_unknown_interaction(
5869 &mut self,
5870 ordinal: u64,
5871 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
5872 ::core::future::ready(())
5873 }
5874}
5875
5876impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Openable
5877where
5878 ___H: OpenableClientHandler<___T> + ::core::marker::Send,
5879 ___T: ::fidl_next::Transport,
5880{
5881 async fn on_event(
5882 handler: &mut ___H,
5883 ordinal: u64,
5884 flexibility: ::fidl_next::protocol::Flexibility,
5885 body: ::fidl_next::Body<___T>,
5886 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5887 match ordinal {
5888 ordinal => {
5889 handler.on_unknown_interaction(ordinal).await;
5890 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
5891 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5892 } else {
5893 Ok(())
5894 }
5895 }
5896 }
5897 }
5898}
5899
5900pub trait OpenableServerHandler<
5904 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
5905 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5906>
5907{
5908 #[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"]
5909 fn open(
5910 &mut self,
5911
5912 request: ::fidl_next::Request<openable::Open, ___T>,
5913 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5914
5915 fn on_unknown_interaction(
5916 &mut self,
5917 ordinal: u64,
5918 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
5919 ::core::future::ready(())
5920 }
5921}
5922
5923impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Openable
5924where
5925 ___H: OpenableServerHandler<___T> + ::core::marker::Send,
5926 ___T: ::fidl_next::Transport,
5927 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
5928 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5929 Constraint = (),
5930 >,
5931{
5932 async fn on_one_way(
5933 handler: &mut ___H,
5934 ordinal: u64,
5935 flexibility: ::fidl_next::protocol::Flexibility,
5936 body: ::fidl_next::Body<___T>,
5937 ) -> ::core::result::Result<
5938 (),
5939 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5940 > {
5941 match ordinal {
5942 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
5943 Ok(decoded) => {
5944 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
5945 Ok(())
5946 }
5947 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5948 ordinal: 6236883748953765593,
5949 error,
5950 }),
5951 },
5952
5953 ordinal => {
5954 handler.on_unknown_interaction(ordinal).await;
5955 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
5956 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5957 } else {
5958 Ok(())
5959 }
5960 }
5961 }
5962 }
5963
5964 async fn on_two_way(
5965 handler: &mut ___H,
5966 ordinal: u64,
5967 flexibility: ::fidl_next::protocol::Flexibility,
5968 body: ::fidl_next::Body<___T>,
5969 responder: ::fidl_next::protocol::Responder<___T>,
5970 ) -> ::core::result::Result<
5971 (),
5972 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5973 > {
5974 match ordinal {
5975 ordinal => {
5976 handler.on_unknown_interaction(ordinal).await;
5977 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
5978 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5979 } else {
5980 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
5981 ordinal,
5982 flexibility,
5983 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
5984 )
5985 .expect("encoding a framework error should never fail")
5986 .await?;
5987 Ok(())
5988 }
5989 }
5990 }
5991 }
5992}
5993
5994impl<___T> OpenableClientHandler<___T> for ::fidl_next::IgnoreEvents
5995where
5996 ___T: ::fidl_next::Transport,
5997{
5998 async fn on_unknown_interaction(&mut self, _: u64) {}
5999}
6000
6001impl<___H, ___T> OpenableLocalClientHandler<___T> for ::fidl_next::Local<___H>
6002where
6003 ___H: OpenableClientHandler<___T>,
6004 ___T: ::fidl_next::Transport,
6005{
6006 async fn on_unknown_interaction(&mut self, ordinal: u64) {
6007 ___H::on_unknown_interaction(&mut self.0, ordinal).await
6008 }
6009}
6010
6011impl<___H, ___T> OpenableLocalServerHandler<___T> for ::fidl_next::Local<___H>
6012where
6013 ___H: OpenableServerHandler<___T>,
6014 ___T: ::fidl_next::Transport,
6015{
6016 async fn open(&mut self, request: ::fidl_next::Request<openable::Open, ___T>) {
6017 ___H::open(&mut self.0, request).await
6018 }
6019
6020 async fn on_unknown_interaction(&mut self, ordinal: u64) {
6021 ___H::on_unknown_interaction(&mut self.0, ordinal).await
6022 }
6023}
6024
6025#[doc = " Node defines the minimal interface for entities which can be accessed in a filesystem.\n"]
6027#[derive(PartialEq, Debug)]
6028pub struct Node;
6029
6030impl ::fidl_next::Discoverable for Node {
6031 const PROTOCOL_NAME: &'static str = "fuchsia.io.Node";
6032}
6033
6034#[cfg(target_os = "fuchsia")]
6035impl ::fidl_next::HasTransport for Node {
6036 type Transport = ::fdomain_client::Channel;
6037}
6038
6039pub mod node {
6040 pub mod prelude {
6041 pub use crate::{
6042 Node, NodeClientHandler, NodeLocalClientHandler, NodeLocalServerHandler,
6043 NodeServerHandler, node,
6044 };
6045
6046 pub use crate::natural::ExtendedAttributeValue;
6047
6048 pub use crate::natural::MutableNodeAttributes;
6049
6050 pub use crate::natural::NodeAttributes2;
6051
6052 pub use crate::natural::NodeDeprecatedCloneRequest;
6053
6054 pub use crate::natural::NodeDeprecatedGetAttrResponse;
6055
6056 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
6057
6058 pub use crate::natural::NodeDeprecatedSetAttrRequest;
6059
6060 pub use crate::natural::NodeDeprecatedSetAttrResponse;
6061
6062 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
6063
6064 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
6065
6066 pub use crate::natural::NodeGetAttributesRequest;
6067
6068 pub use crate::natural::NodeGetExtendedAttributeRequest;
6069
6070 pub use crate::natural::NodeListExtendedAttributesRequest;
6071
6072 pub use crate::natural::NodeOnOpenRequest;
6073
6074 pub use crate::natural::NodeQueryFilesystemResponse;
6075
6076 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
6077
6078 pub use crate::natural::NodeSetExtendedAttributeRequest;
6079
6080 pub use crate::natural::NodeSetFlagsRequest;
6081
6082 pub use crate::natural::NodeGetFlagsResponse;
6083
6084 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
6085
6086 pub use crate::natural::NodeSetExtendedAttributeResponse;
6087
6088 pub use crate::natural::NodeSetFlagsResponse;
6089
6090 pub use crate::natural::NodeSyncResponse;
6091
6092 pub use crate::natural::NodeUpdateAttributesResponse;
6093
6094 pub use crate::natural::Representation;
6095
6096 pub use ::fdomain_next_fuchsia_unknown::natural::CloneableCloneRequest;
6097
6098 pub use ::fdomain_next_fuchsia_unknown::natural::CloseableCloseResponse;
6099
6100 pub use ::fdomain_next_fuchsia_unknown::natural::QueryableQueryResponse;
6101 }
6102
6103 pub struct Clone;
6104
6105 impl ::fidl_next::Method for Clone {
6106 const ORDINAL: u64 = 2366825959783828089;
6107 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6108 ::fidl_next::protocol::Flexibility::Strict;
6109
6110 type Protocol = crate::Node;
6111
6112 type Request = ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest;
6113 }
6114
6115 pub struct Close;
6116
6117 impl ::fidl_next::Method for Close {
6118 const ORDINAL: u64 = 6540867515453498750;
6119 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6120 ::fidl_next::protocol::Flexibility::Strict;
6121
6122 type Protocol = crate::Node;
6123
6124 type Request = ::fidl_next::wire::EmptyMessageBody;
6125 }
6126
6127 impl ::fidl_next::TwoWayMethod for Close {
6128 type Response = ::fidl_next::wire::Result<
6129 'static,
6130 ::fdomain_next_fuchsia_unknown::wire::CloseableCloseResponse,
6131 ::fidl_next::wire::Int32,
6132 >;
6133 }
6134
6135 impl<___R> ::fidl_next::Respond<___R> for Close {
6136 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
6137
6138 fn respond(response: ___R) -> Self::Output {
6139 ::core::result::Result::Ok(response)
6140 }
6141 }
6142
6143 impl<___R> ::fidl_next::RespondErr<___R> for Close {
6144 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
6145
6146 fn respond_err(response: ___R) -> Self::Output {
6147 ::core::result::Result::Err(response)
6148 }
6149 }
6150
6151 pub struct Query;
6152
6153 impl ::fidl_next::Method for Query {
6154 const ORDINAL: u64 = 2763219980499352582;
6155 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6156 ::fidl_next::protocol::Flexibility::Strict;
6157
6158 type Protocol = crate::Node;
6159
6160 type Request = ::fidl_next::wire::EmptyMessageBody;
6161 }
6162
6163 impl ::fidl_next::TwoWayMethod for Query {
6164 type Response = ::fdomain_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>;
6165 }
6166
6167 impl<___R> ::fidl_next::Respond<___R> for Query {
6168 type Output = ::fdomain_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>;
6169
6170 fn respond(response: ___R) -> Self::Output {
6171 ::fdomain_next_fuchsia_unknown::generic::QueryableQueryResponse { protocol: response }
6172 }
6173 }
6174
6175 pub struct DeprecatedClone;
6176
6177 impl ::fidl_next::Method for DeprecatedClone {
6178 const ORDINAL: u64 = 6512600400724287855;
6179 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6180 ::fidl_next::protocol::Flexibility::Flexible;
6181
6182 type Protocol = crate::Node;
6183
6184 type Request = crate::wire::NodeDeprecatedCloneRequest;
6185 }
6186
6187 pub struct OnOpen;
6188
6189 impl ::fidl_next::Method for OnOpen {
6190 const ORDINAL: u64 = 9207534335756671346;
6191 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6192 ::fidl_next::protocol::Flexibility::Flexible;
6193
6194 type Protocol = crate::Node;
6195
6196 type Request = crate::wire::NodeOnOpenRequest<'static>;
6197 }
6198
6199 pub struct DeprecatedGetAttr;
6200
6201 impl ::fidl_next::Method for DeprecatedGetAttr {
6202 const ORDINAL: u64 = 8689798978500614909;
6203 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6204 ::fidl_next::protocol::Flexibility::Strict;
6205
6206 type Protocol = crate::Node;
6207
6208 type Request = ::fidl_next::wire::EmptyMessageBody;
6209 }
6210
6211 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
6212 type Response = crate::wire::NodeDeprecatedGetAttrResponse;
6213 }
6214
6215 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
6216 type Output = ___R;
6217
6218 fn respond(response: ___R) -> Self::Output {
6219 response
6220 }
6221 }
6222
6223 pub struct DeprecatedSetAttr;
6224
6225 impl ::fidl_next::Method for DeprecatedSetAttr {
6226 const ORDINAL: u64 = 4721673413776871238;
6227 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6228 ::fidl_next::protocol::Flexibility::Strict;
6229
6230 type Protocol = crate::Node;
6231
6232 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
6233 }
6234
6235 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
6236 type Response = crate::wire::NodeDeprecatedSetAttrResponse;
6237 }
6238
6239 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
6240 type Output = crate::generic::NodeDeprecatedSetAttrResponse<___R>;
6241
6242 fn respond(response: ___R) -> Self::Output {
6243 crate::generic::NodeDeprecatedSetAttrResponse { s: response }
6244 }
6245 }
6246
6247 pub struct DeprecatedGetFlags;
6248
6249 impl ::fidl_next::Method for DeprecatedGetFlags {
6250 const ORDINAL: u64 = 6595803110182632097;
6251 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6252 ::fidl_next::protocol::Flexibility::Strict;
6253
6254 type Protocol = crate::Node;
6255
6256 type Request = ::fidl_next::wire::EmptyMessageBody;
6257 }
6258
6259 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
6260 type Response = crate::wire::NodeDeprecatedGetFlagsResponse;
6261 }
6262
6263 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
6264 type Output = ___R;
6265
6266 fn respond(response: ___R) -> Self::Output {
6267 response
6268 }
6269 }
6270
6271 pub struct DeprecatedSetFlags;
6272
6273 impl ::fidl_next::Method for DeprecatedSetFlags {
6274 const ORDINAL: u64 = 5950864159036794675;
6275 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6276 ::fidl_next::protocol::Flexibility::Strict;
6277
6278 type Protocol = crate::Node;
6279
6280 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
6281 }
6282
6283 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
6284 type Response = crate::wire::NodeDeprecatedSetFlagsResponse;
6285 }
6286
6287 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
6288 type Output = crate::generic::NodeDeprecatedSetFlagsResponse<___R>;
6289
6290 fn respond(response: ___R) -> Self::Output {
6291 crate::generic::NodeDeprecatedSetFlagsResponse { s: response }
6292 }
6293 }
6294
6295 pub struct GetFlags;
6296
6297 impl ::fidl_next::Method for GetFlags {
6298 const ORDINAL: u64 = 105530239381466147;
6299 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6300 ::fidl_next::protocol::Flexibility::Flexible;
6301
6302 type Protocol = crate::Node;
6303
6304 type Request = ::fidl_next::wire::EmptyMessageBody;
6305 }
6306
6307 impl ::fidl_next::TwoWayMethod for GetFlags {
6308 type Response = ::fidl_next::wire::FlexibleResult<
6309 'static,
6310 crate::wire::NodeGetFlagsResponse,
6311 ::fidl_next::wire::Int32,
6312 >;
6313 }
6314
6315 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
6316 type Output = ::fidl_next::FlexibleResult<
6317 crate::generic::NodeGetFlagsResponse<___R>,
6318 ::fidl_next::util::Never,
6319 >;
6320
6321 fn respond(response: ___R) -> Self::Output {
6322 ::fidl_next::FlexibleResult::Ok(crate::generic::NodeGetFlagsResponse {
6323 flags: response,
6324 })
6325 }
6326 }
6327
6328 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
6329 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
6330
6331 fn respond_err(response: ___R) -> Self::Output {
6332 ::fidl_next::FlexibleResult::Err(response)
6333 }
6334 }
6335
6336 pub struct SetFlags;
6337
6338 impl ::fidl_next::Method for SetFlags {
6339 const ORDINAL: u64 = 6172186066099445416;
6340 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6341 ::fidl_next::protocol::Flexibility::Flexible;
6342
6343 type Protocol = crate::Node;
6344
6345 type Request = crate::wire::NodeSetFlagsRequest;
6346 }
6347
6348 impl ::fidl_next::TwoWayMethod for SetFlags {
6349 type Response = ::fidl_next::wire::FlexibleResult<
6350 'static,
6351 crate::wire::NodeSetFlagsResponse,
6352 ::fidl_next::wire::Int32,
6353 >;
6354 }
6355
6356 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
6357 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
6358
6359 fn respond(response: ___R) -> Self::Output {
6360 ::fidl_next::FlexibleResult::Ok(response)
6361 }
6362 }
6363
6364 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
6365 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
6366
6367 fn respond_err(response: ___R) -> Self::Output {
6368 ::fidl_next::FlexibleResult::Err(response)
6369 }
6370 }
6371
6372 pub struct QueryFilesystem;
6373
6374 impl ::fidl_next::Method for QueryFilesystem {
6375 const ORDINAL: u64 = 8013111122914313744;
6376 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6377 ::fidl_next::protocol::Flexibility::Strict;
6378
6379 type Protocol = crate::Node;
6380
6381 type Request = ::fidl_next::wire::EmptyMessageBody;
6382 }
6383
6384 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
6385 type Response = crate::wire::NodeQueryFilesystemResponse<'static>;
6386 }
6387
6388 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
6389 type Output = ___R;
6390
6391 fn respond(response: ___R) -> Self::Output {
6392 response
6393 }
6394 }
6395
6396 pub struct OnRepresentation;
6397
6398 impl ::fidl_next::Method for OnRepresentation {
6399 const ORDINAL: u64 = 6679970090861613324;
6400 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6401 ::fidl_next::protocol::Flexibility::Strict;
6402
6403 type Protocol = crate::Node;
6404
6405 type Request = crate::wire::Representation<'static>;
6406 }
6407
6408 pub struct GetAttributes;
6409
6410 impl ::fidl_next::Method for GetAttributes {
6411 const ORDINAL: u64 = 4414537700416816443;
6412 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6413 ::fidl_next::protocol::Flexibility::Strict;
6414
6415 type Protocol = crate::Node;
6416
6417 type Request = crate::wire::NodeGetAttributesRequest;
6418 }
6419
6420 impl ::fidl_next::TwoWayMethod for GetAttributes {
6421 type Response = ::fidl_next::wire::Result<
6422 'static,
6423 crate::wire::NodeAttributes2<'static>,
6424 ::fidl_next::wire::Int32,
6425 >;
6426 }
6427
6428 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
6429 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
6430
6431 fn respond(response: ___R) -> Self::Output {
6432 ::core::result::Result::Ok(response)
6433 }
6434 }
6435
6436 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
6437 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
6438
6439 fn respond_err(response: ___R) -> Self::Output {
6440 ::core::result::Result::Err(response)
6441 }
6442 }
6443
6444 pub struct UpdateAttributes;
6445
6446 impl ::fidl_next::Method for UpdateAttributes {
6447 const ORDINAL: u64 = 3677402239314018056;
6448 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6449 ::fidl_next::protocol::Flexibility::Strict;
6450
6451 type Protocol = crate::Node;
6452
6453 type Request = crate::wire::MutableNodeAttributes<'static>;
6454 }
6455
6456 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
6457 type Response = ::fidl_next::wire::Result<
6458 'static,
6459 crate::wire::NodeUpdateAttributesResponse,
6460 ::fidl_next::wire::Int32,
6461 >;
6462 }
6463
6464 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
6465 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
6466
6467 fn respond(response: ___R) -> Self::Output {
6468 ::core::result::Result::Ok(response)
6469 }
6470 }
6471
6472 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
6473 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
6474
6475 fn respond_err(response: ___R) -> Self::Output {
6476 ::core::result::Result::Err(response)
6477 }
6478 }
6479
6480 pub struct Sync;
6481
6482 impl ::fidl_next::Method for Sync {
6483 const ORDINAL: u64 = 3196473584242777161;
6484 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6485 ::fidl_next::protocol::Flexibility::Strict;
6486
6487 type Protocol = crate::Node;
6488
6489 type Request = ::fidl_next::wire::EmptyMessageBody;
6490 }
6491
6492 impl ::fidl_next::TwoWayMethod for Sync {
6493 type Response = ::fidl_next::wire::Result<
6494 'static,
6495 crate::wire::NodeSyncResponse,
6496 ::fidl_next::wire::Int32,
6497 >;
6498 }
6499
6500 impl<___R> ::fidl_next::Respond<___R> for Sync {
6501 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
6502
6503 fn respond(response: ___R) -> Self::Output {
6504 ::core::result::Result::Ok(response)
6505 }
6506 }
6507
6508 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
6509 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
6510
6511 fn respond_err(response: ___R) -> Self::Output {
6512 ::core::result::Result::Err(response)
6513 }
6514 }
6515
6516 pub struct ListExtendedAttributes;
6517
6518 impl ::fidl_next::Method for ListExtendedAttributes {
6519 const ORDINAL: u64 = 5431626189872037072;
6520 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6521 ::fidl_next::protocol::Flexibility::Strict;
6522
6523 type Protocol = crate::Node;
6524
6525 type Request = crate::wire::NodeListExtendedAttributesRequest;
6526 }
6527
6528 pub struct GetExtendedAttribute;
6529
6530 impl ::fidl_next::Method for GetExtendedAttribute {
6531 const ORDINAL: u64 = 5043930208506967771;
6532 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6533 ::fidl_next::protocol::Flexibility::Strict;
6534
6535 type Protocol = crate::Node;
6536
6537 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
6538 }
6539
6540 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
6541 type Response = ::fidl_next::wire::Result<
6542 'static,
6543 crate::wire::ExtendedAttributeValue<'static>,
6544 ::fidl_next::wire::Int32,
6545 >;
6546 }
6547
6548 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
6549 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
6550
6551 fn respond(response: ___R) -> Self::Output {
6552 ::core::result::Result::Ok(response)
6553 }
6554 }
6555
6556 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
6557 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
6558
6559 fn respond_err(response: ___R) -> Self::Output {
6560 ::core::result::Result::Err(response)
6561 }
6562 }
6563
6564 pub struct SetExtendedAttribute;
6565
6566 impl ::fidl_next::Method for SetExtendedAttribute {
6567 const ORDINAL: u64 = 5374223046099989052;
6568 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6569 ::fidl_next::protocol::Flexibility::Strict;
6570
6571 type Protocol = crate::Node;
6572
6573 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
6574 }
6575
6576 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
6577 type Response = ::fidl_next::wire::Result<
6578 'static,
6579 crate::wire::NodeSetExtendedAttributeResponse,
6580 ::fidl_next::wire::Int32,
6581 >;
6582 }
6583
6584 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
6585 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
6586
6587 fn respond(response: ___R) -> Self::Output {
6588 ::core::result::Result::Ok(response)
6589 }
6590 }
6591
6592 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
6593 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
6594
6595 fn respond_err(response: ___R) -> Self::Output {
6596 ::core::result::Result::Err(response)
6597 }
6598 }
6599
6600 pub struct RemoveExtendedAttribute;
6601
6602 impl ::fidl_next::Method for RemoveExtendedAttribute {
6603 const ORDINAL: u64 = 8794297771444732717;
6604 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6605 ::fidl_next::protocol::Flexibility::Strict;
6606
6607 type Protocol = crate::Node;
6608
6609 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
6610 }
6611
6612 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
6613 type Response = ::fidl_next::wire::Result<
6614 'static,
6615 crate::wire::NodeRemoveExtendedAttributeResponse,
6616 ::fidl_next::wire::Int32,
6617 >;
6618 }
6619
6620 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
6621 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
6622
6623 fn respond(response: ___R) -> Self::Output {
6624 ::core::result::Result::Ok(response)
6625 }
6626 }
6627
6628 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
6629 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
6630
6631 fn respond_err(response: ___R) -> Self::Output {
6632 ::core::result::Result::Err(response)
6633 }
6634 }
6635
6636 mod ___detail {
6637 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Node
6638 where
6639 ___T: ::fidl_next::Transport,
6640 {
6641 type Client = NodeClient<___T>;
6642 type Server = NodeServer<___T>;
6643 }
6644
6645 #[repr(transparent)]
6647 pub struct NodeClient<___T: ::fidl_next::Transport> {
6648 #[allow(dead_code)]
6649 client: ::fidl_next::protocol::Client<___T>,
6650 }
6651
6652 impl<___T> NodeClient<___T>
6653 where
6654 ___T: ::fidl_next::Transport,
6655 {
6656 pub fn clone(
6657 &self,
6658
6659 request: impl ::fidl_next::Encode<
6660 ::fidl_next::ServerEnd<
6661 ::fdomain_next_fuchsia_unknown::Cloneable,
6662 ::fdomain_client::fidl_next::wire::Handle,
6663 >,
6664 <___T as ::fidl_next::Transport>::SendBuffer,
6665 >,
6666 ) -> ::fidl_next::SendFuture<'_, ___T>
6667 where
6668 <___T as ::fidl_next::Transport>::SendBuffer:
6669 ::fidl_next::encoder::InternalHandleEncoder,
6670 <___T as ::fidl_next::Transport>::SendBuffer:
6671 ::fdomain_client::fidl_next::HandleEncoder,
6672 {
6673 self.clone_with(::fdomain_next_fuchsia_unknown::generic::CloneableCloneRequest {
6674 request,
6675 })
6676 }
6677
6678 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
6679 where
6680 ___R: ::fidl_next::Encode<
6681 ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest,
6682 <___T as ::fidl_next::Transport>::SendBuffer,
6683 >,
6684 {
6685 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
6686 2366825959783828089,
6687 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
6688 request,
6689 ))
6690 }
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 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
6694 ::fidl_next::TwoWayFuture::from_untyped(
6695 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
6696 6540867515453498750,
6697 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
6698 (),
6699 ),
6700 )
6701 }
6702
6703 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
6704 ::fidl_next::TwoWayFuture::from_untyped(
6705 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
6706 2763219980499352582,
6707 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
6708 (),
6709 ),
6710 )
6711 }
6712
6713 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
6714 pub fn deprecated_clone(
6715 &self,
6716
6717 flags: impl ::fidl_next::Encode<
6718 crate::wire::OpenFlags,
6719 <___T as ::fidl_next::Transport>::SendBuffer,
6720 >,
6721
6722 object: impl ::fidl_next::Encode<
6723 ::fidl_next::ServerEnd<crate::Node, ::fdomain_client::fidl_next::wire::Handle>,
6724 <___T as ::fidl_next::Transport>::SendBuffer,
6725 >,
6726 ) -> ::fidl_next::SendFuture<'_, ___T>
6727 where
6728 <___T as ::fidl_next::Transport>::SendBuffer:
6729 ::fidl_next::encoder::InternalHandleEncoder,
6730 <___T as ::fidl_next::Transport>::SendBuffer:
6731 ::fdomain_client::fidl_next::HandleEncoder,
6732 {
6733 self.deprecated_clone_with(crate::generic::NodeDeprecatedCloneRequest {
6734 flags,
6735
6736 object,
6737 })
6738 }
6739
6740 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
6741 pub fn deprecated_clone_with<___R>(
6742 &self,
6743 request: ___R,
6744 ) -> ::fidl_next::SendFuture<'_, ___T>
6745 where
6746 ___R: ::fidl_next::Encode<
6747 crate::wire::NodeDeprecatedCloneRequest,
6748 <___T as ::fidl_next::Transport>::SendBuffer,
6749 >,
6750 {
6751 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
6752 6512600400724287855,
6753 <super::DeprecatedClone as ::fidl_next::Method>::FLEXIBILITY,
6754 request,
6755 ))
6756 }
6757
6758 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
6759 pub fn deprecated_get_attr(
6760 &self,
6761 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
6762 ::fidl_next::TwoWayFuture::from_untyped(
6763 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
6764 8689798978500614909,
6765 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
6766 (),
6767 ),
6768 )
6769 }
6770
6771 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
6772 pub fn deprecated_set_attr(
6773 &self,
6774
6775 flags: impl ::fidl_next::Encode<
6776 crate::wire::NodeAttributeFlags,
6777 <___T as ::fidl_next::Transport>::SendBuffer,
6778 >,
6779
6780 attributes: impl ::fidl_next::Encode<
6781 crate::wire::NodeAttributes,
6782 <___T as ::fidl_next::Transport>::SendBuffer,
6783 >,
6784 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
6785 where
6786 <___T as ::fidl_next::Transport>::SendBuffer:
6787 ::fidl_next::encoder::InternalHandleEncoder,
6788 {
6789 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
6790 flags,
6791
6792 attributes,
6793 })
6794 }
6795
6796 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
6797 pub fn deprecated_set_attr_with<___R>(
6798 &self,
6799 request: ___R,
6800 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
6801 where
6802 ___R: ::fidl_next::Encode<
6803 crate::wire::NodeDeprecatedSetAttrRequest,
6804 <___T as ::fidl_next::Transport>::SendBuffer,
6805 >,
6806 {
6807 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6808 4721673413776871238,
6809 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
6810 request,
6811 ))
6812 }
6813
6814 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
6815 pub fn deprecated_get_flags(
6816 &self,
6817 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
6818 ::fidl_next::TwoWayFuture::from_untyped(
6819 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
6820 6595803110182632097,
6821 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
6822 (),
6823 ),
6824 )
6825 }
6826
6827 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
6828 pub fn deprecated_set_flags(
6829 &self,
6830
6831 flags: impl ::fidl_next::Encode<
6832 crate::wire::OpenFlags,
6833 <___T as ::fidl_next::Transport>::SendBuffer,
6834 >,
6835 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
6836 where
6837 <___T as ::fidl_next::Transport>::SendBuffer:
6838 ::fidl_next::encoder::InternalHandleEncoder,
6839 {
6840 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
6841 flags,
6842 })
6843 }
6844
6845 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
6846 pub fn deprecated_set_flags_with<___R>(
6847 &self,
6848 request: ___R,
6849 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
6850 where
6851 ___R: ::fidl_next::Encode<
6852 crate::wire::NodeDeprecatedSetFlagsRequest,
6853 <___T as ::fidl_next::Transport>::SendBuffer,
6854 >,
6855 {
6856 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6857 5950864159036794675,
6858 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
6859 request,
6860 ))
6861 }
6862
6863 #[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"]
6864 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
6865 ::fidl_next::TwoWayFuture::from_untyped(
6866 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
6867 105530239381466147,
6868 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
6869 (),
6870 ),
6871 )
6872 }
6873
6874 #[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"]
6875 pub fn set_flags(
6876 &self,
6877
6878 flags: impl ::fidl_next::Encode<
6879 crate::wire::Flags,
6880 <___T as ::fidl_next::Transport>::SendBuffer,
6881 >,
6882 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
6883 where
6884 <___T as ::fidl_next::Transport>::SendBuffer:
6885 ::fidl_next::encoder::InternalHandleEncoder,
6886 {
6887 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
6888 }
6889
6890 #[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"]
6891 pub fn set_flags_with<___R>(
6892 &self,
6893 request: ___R,
6894 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
6895 where
6896 ___R: ::fidl_next::Encode<
6897 crate::wire::NodeSetFlagsRequest,
6898 <___T as ::fidl_next::Transport>::SendBuffer,
6899 >,
6900 {
6901 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6902 6172186066099445416,
6903 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
6904 request,
6905 ))
6906 }
6907
6908 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
6909 pub fn query_filesystem(
6910 &self,
6911 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
6912 ::fidl_next::TwoWayFuture::from_untyped(
6913 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
6914 8013111122914313744,
6915 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
6916 (),
6917 ),
6918 )
6919 }
6920
6921 #[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"]
6922 pub fn get_attributes(
6923 &self,
6924
6925 query: impl ::fidl_next::Encode<
6926 crate::wire::NodeAttributesQuery,
6927 <___T as ::fidl_next::Transport>::SendBuffer,
6928 >,
6929 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
6930 where
6931 <___T as ::fidl_next::Transport>::SendBuffer:
6932 ::fidl_next::encoder::InternalHandleEncoder,
6933 {
6934 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
6935 }
6936
6937 #[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"]
6938 pub fn get_attributes_with<___R>(
6939 &self,
6940 request: ___R,
6941 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
6942 where
6943 ___R: ::fidl_next::Encode<
6944 crate::wire::NodeGetAttributesRequest,
6945 <___T as ::fidl_next::Transport>::SendBuffer,
6946 >,
6947 {
6948 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6949 4414537700416816443,
6950 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
6951 request,
6952 ))
6953 }
6954
6955 #[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"]
6956 pub fn update_attributes_with<___R>(
6957 &self,
6958 request: ___R,
6959 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
6960 where
6961 ___R: ::fidl_next::Encode<
6962 crate::wire::MutableNodeAttributes<'static>,
6963 <___T as ::fidl_next::Transport>::SendBuffer,
6964 >,
6965 {
6966 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6967 3677402239314018056,
6968 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
6969 request,
6970 ))
6971 }
6972
6973 #[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"]
6974 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
6975 ::fidl_next::TwoWayFuture::from_untyped(
6976 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
6977 3196473584242777161,
6978 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
6979 (),
6980 ),
6981 )
6982 }
6983
6984 #[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"]
6985 pub fn list_extended_attributes(
6986 &self,
6987
6988 iterator: impl ::fidl_next::Encode<
6989 ::fidl_next::ServerEnd<
6990 crate::ExtendedAttributeIterator,
6991 ::fdomain_client::fidl_next::wire::Handle,
6992 >,
6993 <___T as ::fidl_next::Transport>::SendBuffer,
6994 >,
6995 ) -> ::fidl_next::SendFuture<'_, ___T>
6996 where
6997 <___T as ::fidl_next::Transport>::SendBuffer:
6998 ::fidl_next::encoder::InternalHandleEncoder,
6999 <___T as ::fidl_next::Transport>::SendBuffer:
7000 ::fdomain_client::fidl_next::HandleEncoder,
7001 {
7002 self.list_extended_attributes_with(
7003 crate::generic::NodeListExtendedAttributesRequest { iterator },
7004 )
7005 }
7006
7007 #[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"]
7008 pub fn list_extended_attributes_with<___R>(
7009 &self,
7010 request: ___R,
7011 ) -> ::fidl_next::SendFuture<'_, ___T>
7012 where
7013 ___R: ::fidl_next::Encode<
7014 crate::wire::NodeListExtendedAttributesRequest,
7015 <___T as ::fidl_next::Transport>::SendBuffer,
7016 >,
7017 {
7018 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
7019 5431626189872037072,
7020 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
7021 request,
7022 ))
7023 }
7024
7025 #[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"]
7026 pub fn get_extended_attribute(
7027 &self,
7028
7029 name: impl ::fidl_next::Encode<
7030 ::fidl_next::wire::Vector<'static, u8>,
7031 <___T as ::fidl_next::Transport>::SendBuffer,
7032 >,
7033 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
7034 where
7035 <___T as ::fidl_next::Transport>::SendBuffer:
7036 ::fidl_next::encoder::InternalHandleEncoder,
7037 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
7038 {
7039 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
7040 name,
7041 })
7042 }
7043
7044 #[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"]
7045 pub fn get_extended_attribute_with<___R>(
7046 &self,
7047 request: ___R,
7048 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
7049 where
7050 ___R: ::fidl_next::Encode<
7051 crate::wire::NodeGetExtendedAttributeRequest<'static>,
7052 <___T as ::fidl_next::Transport>::SendBuffer,
7053 >,
7054 {
7055 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7056 5043930208506967771,
7057 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
7058 request,
7059 ))
7060 }
7061
7062 #[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"]
7063 pub fn set_extended_attribute(
7064 &self,
7065
7066 name: impl ::fidl_next::Encode<
7067 ::fidl_next::wire::Vector<'static, u8>,
7068 <___T as ::fidl_next::Transport>::SendBuffer,
7069 >,
7070
7071 value: impl ::fidl_next::Encode<
7072 crate::wire::ExtendedAttributeValue<'static>,
7073 <___T as ::fidl_next::Transport>::SendBuffer,
7074 >,
7075
7076 mode: impl ::fidl_next::Encode<
7077 crate::wire::SetExtendedAttributeMode,
7078 <___T as ::fidl_next::Transport>::SendBuffer,
7079 >,
7080 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
7081 where
7082 <___T as ::fidl_next::Transport>::SendBuffer:
7083 ::fidl_next::encoder::InternalHandleEncoder,
7084 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
7085 <___T as ::fidl_next::Transport>::SendBuffer:
7086 ::fdomain_client::fidl_next::HandleEncoder,
7087 {
7088 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
7089 name,
7090
7091 value,
7092
7093 mode,
7094 })
7095 }
7096
7097 #[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"]
7098 pub fn set_extended_attribute_with<___R>(
7099 &self,
7100 request: ___R,
7101 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
7102 where
7103 ___R: ::fidl_next::Encode<
7104 crate::wire::NodeSetExtendedAttributeRequest<'static>,
7105 <___T as ::fidl_next::Transport>::SendBuffer,
7106 >,
7107 {
7108 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7109 5374223046099989052,
7110 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
7111 request,
7112 ))
7113 }
7114
7115 #[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"]
7116 pub fn remove_extended_attribute(
7117 &self,
7118
7119 name: impl ::fidl_next::Encode<
7120 ::fidl_next::wire::Vector<'static, u8>,
7121 <___T as ::fidl_next::Transport>::SendBuffer,
7122 >,
7123 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
7124 where
7125 <___T as ::fidl_next::Transport>::SendBuffer:
7126 ::fidl_next::encoder::InternalHandleEncoder,
7127 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
7128 {
7129 self.remove_extended_attribute_with(
7130 crate::generic::NodeRemoveExtendedAttributeRequest { name },
7131 )
7132 }
7133
7134 #[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"]
7135 pub fn remove_extended_attribute_with<___R>(
7136 &self,
7137 request: ___R,
7138 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
7139 where
7140 ___R: ::fidl_next::Encode<
7141 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
7142 <___T as ::fidl_next::Transport>::SendBuffer,
7143 >,
7144 {
7145 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7146 8794297771444732717,
7147 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
7148 request,
7149 ))
7150 }
7151 }
7152
7153 #[repr(transparent)]
7155 pub struct NodeServer<___T: ::fidl_next::Transport> {
7156 server: ::fidl_next::protocol::Server<___T>,
7157 }
7158
7159 impl<___T> NodeServer<___T>
7160 where
7161 ___T: ::fidl_next::Transport,
7162 {
7163 #[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"]
7164 pub fn on_open(
7165 &self,
7166
7167 s: impl ::fidl_next::Encode<
7168 ::fidl_next::wire::Int32,
7169 <___T as ::fidl_next::Transport>::SendBuffer,
7170 >,
7171
7172 info: impl ::fidl_next::Encode<
7173 crate::wire_optional::NodeInfoDeprecated<'static>,
7174 <___T as ::fidl_next::Transport>::SendBuffer,
7175 >,
7176 ) -> ::fidl_next::SendFuture<'_, ___T>
7177 where
7178 <___T as ::fidl_next::Transport>::SendBuffer:
7179 ::fidl_next::encoder::InternalHandleEncoder,
7180 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
7181 <___T as ::fidl_next::Transport>::SendBuffer:
7182 ::fdomain_client::fidl_next::HandleEncoder,
7183 {
7184 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
7185 }
7186
7187 #[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"]
7188
7189 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
7190 where
7191 ___R: ::fidl_next::Encode<
7192 <super::OnOpen as ::fidl_next::Method>::Request,
7193 <___T as ::fidl_next::Transport>::SendBuffer,
7194 >,
7195 {
7196 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
7197 9207534335756671346,
7198 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
7199 request,
7200 ))
7201 }
7202
7203 #[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"]
7204
7205 pub fn on_representation_with<___R>(
7206 &self,
7207 request: ___R,
7208 ) -> ::fidl_next::SendFuture<'_, ___T>
7209 where
7210 ___R: ::fidl_next::Encode<
7211 <super::OnRepresentation as ::fidl_next::Method>::Request,
7212 <___T as ::fidl_next::Transport>::SendBuffer,
7213 >,
7214 {
7215 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
7216 6679970090861613324,
7217 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
7218 request,
7219 ))
7220 }
7221 }
7222 }
7223}
7224
7225#[diagnostic::on_unimplemented(
7226 note = "If {Self} implements the non-local NodeClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
7227)]
7228
7229pub trait NodeLocalClientHandler<
7233 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
7234 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
7235>
7236{
7237 #[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"]
7238 fn on_open(
7239 &mut self,
7240
7241 request: ::fidl_next::Request<node::OnOpen, ___T>,
7242 ) -> impl ::core::future::Future<Output = ()>;
7243
7244 #[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"]
7245 fn on_representation(
7246 &mut self,
7247
7248 request: ::fidl_next::Request<node::OnRepresentation, ___T>,
7249 ) -> impl ::core::future::Future<Output = ()>;
7250
7251 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
7252 ::core::future::ready(())
7253 }
7254}
7255
7256impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Node
7257where
7258 ___H: NodeLocalClientHandler<___T>,
7259 ___T: ::fidl_next::Transport,
7260 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
7261 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7262 Constraint = (),
7263 >,
7264 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
7265 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7266 Constraint = (),
7267 >,
7268{
7269 async fn on_event(
7270 handler: &mut ___H,
7271 ordinal: u64,
7272 flexibility: ::fidl_next::protocol::Flexibility,
7273 body: ::fidl_next::Body<___T>,
7274 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
7275 match ordinal {
7276 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
7277 Ok(decoded) => {
7278 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
7279 Ok(())
7280 }
7281 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7282 ordinal: 9207534335756671346,
7283 error,
7284 }),
7285 },
7286
7287 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
7288 Ok(decoded) => {
7289 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
7290 Ok(())
7291 }
7292 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7293 ordinal: 6679970090861613324,
7294 error,
7295 }),
7296 },
7297
7298 ordinal => {
7299 handler.on_unknown_interaction(ordinal).await;
7300 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
7301 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
7302 } else {
7303 Ok(())
7304 }
7305 }
7306 }
7307 }
7308}
7309
7310#[diagnostic::on_unimplemented(
7311 note = "If {Self} implements the non-local NodeServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
7312)]
7313
7314pub trait NodeLocalServerHandler<
7318 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
7319 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
7320>
7321{
7322 fn clone(
7323 &mut self,
7324
7325 request: ::fidl_next::Request<node::Clone, ___T>,
7326 ) -> impl ::core::future::Future<Output = ()>;
7327
7328 #[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"]
7329 fn close(
7330 &mut self,
7331
7332 responder: ::fidl_next::Responder<node::Close, ___T>,
7333 ) -> impl ::core::future::Future<Output = ()>;
7334
7335 fn query(
7336 &mut self,
7337
7338 responder: ::fidl_next::Responder<node::Query, ___T>,
7339 ) -> impl ::core::future::Future<Output = ()>;
7340
7341 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
7342 fn deprecated_clone(
7343 &mut self,
7344
7345 request: ::fidl_next::Request<node::DeprecatedClone, ___T>,
7346 ) -> impl ::core::future::Future<Output = ()>;
7347
7348 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
7349 fn deprecated_get_attr(
7350 &mut self,
7351
7352 responder: ::fidl_next::Responder<node::DeprecatedGetAttr, ___T>,
7353 ) -> impl ::core::future::Future<Output = ()>;
7354
7355 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
7356 fn deprecated_set_attr(
7357 &mut self,
7358
7359 request: ::fidl_next::Request<node::DeprecatedSetAttr, ___T>,
7360
7361 responder: ::fidl_next::Responder<node::DeprecatedSetAttr, ___T>,
7362 ) -> impl ::core::future::Future<Output = ()>;
7363
7364 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
7365 fn deprecated_get_flags(
7366 &mut self,
7367
7368 responder: ::fidl_next::Responder<node::DeprecatedGetFlags, ___T>,
7369 ) -> impl ::core::future::Future<Output = ()>;
7370
7371 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
7372 fn deprecated_set_flags(
7373 &mut self,
7374
7375 request: ::fidl_next::Request<node::DeprecatedSetFlags, ___T>,
7376
7377 responder: ::fidl_next::Responder<node::DeprecatedSetFlags, ___T>,
7378 ) -> impl ::core::future::Future<Output = ()>;
7379
7380 #[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"]
7381 fn get_flags(
7382 &mut self,
7383
7384 responder: ::fidl_next::Responder<node::GetFlags, ___T>,
7385 ) -> impl ::core::future::Future<Output = ()>;
7386
7387 #[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"]
7388 fn set_flags(
7389 &mut self,
7390
7391 request: ::fidl_next::Request<node::SetFlags, ___T>,
7392
7393 responder: ::fidl_next::Responder<node::SetFlags, ___T>,
7394 ) -> impl ::core::future::Future<Output = ()>;
7395
7396 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
7397 fn query_filesystem(
7398 &mut self,
7399
7400 responder: ::fidl_next::Responder<node::QueryFilesystem, ___T>,
7401 ) -> impl ::core::future::Future<Output = ()>;
7402
7403 #[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"]
7404 fn get_attributes(
7405 &mut self,
7406
7407 request: ::fidl_next::Request<node::GetAttributes, ___T>,
7408
7409 responder: ::fidl_next::Responder<node::GetAttributes, ___T>,
7410 ) -> impl ::core::future::Future<Output = ()>;
7411
7412 #[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"]
7413 fn update_attributes(
7414 &mut self,
7415
7416 request: ::fidl_next::Request<node::UpdateAttributes, ___T>,
7417
7418 responder: ::fidl_next::Responder<node::UpdateAttributes, ___T>,
7419 ) -> impl ::core::future::Future<Output = ()>;
7420
7421 #[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"]
7422 fn sync(
7423 &mut self,
7424
7425 responder: ::fidl_next::Responder<node::Sync, ___T>,
7426 ) -> impl ::core::future::Future<Output = ()>;
7427
7428 #[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"]
7429 fn list_extended_attributes(
7430 &mut self,
7431
7432 request: ::fidl_next::Request<node::ListExtendedAttributes, ___T>,
7433 ) -> impl ::core::future::Future<Output = ()>;
7434
7435 #[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"]
7436 fn get_extended_attribute(
7437 &mut self,
7438
7439 request: ::fidl_next::Request<node::GetExtendedAttribute, ___T>,
7440
7441 responder: ::fidl_next::Responder<node::GetExtendedAttribute, ___T>,
7442 ) -> impl ::core::future::Future<Output = ()>;
7443
7444 #[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"]
7445 fn set_extended_attribute(
7446 &mut self,
7447
7448 request: ::fidl_next::Request<node::SetExtendedAttribute, ___T>,
7449
7450 responder: ::fidl_next::Responder<node::SetExtendedAttribute, ___T>,
7451 ) -> impl ::core::future::Future<Output = ()>;
7452
7453 #[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"]
7454 fn remove_extended_attribute(
7455 &mut self,
7456
7457 request: ::fidl_next::Request<node::RemoveExtendedAttribute, ___T>,
7458
7459 responder: ::fidl_next::Responder<node::RemoveExtendedAttribute, ___T>,
7460 ) -> impl ::core::future::Future<Output = ()>;
7461
7462 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
7463 ::core::future::ready(())
7464 }
7465}
7466
7467impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Node
7468where
7469 ___H: NodeLocalServerHandler<___T>,
7470 ___T: ::fidl_next::Transport,
7471 for<'de> ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
7472 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7473 Constraint = (),
7474 >,
7475 for<'de> crate::wire::NodeDeprecatedCloneRequest: ::fidl_next::Decode<
7476 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7477 Constraint = (),
7478 >,
7479 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
7480 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7481 Constraint = (),
7482 >,
7483 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
7484 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7485 Constraint = (),
7486 >,
7487 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
7488 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7489 Constraint = (),
7490 >,
7491 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
7492 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7493 Constraint = (),
7494 >,
7495 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
7496 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7497 Constraint = (),
7498 >,
7499 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
7500 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7501 Constraint = (),
7502 >,
7503 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
7504 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7505 Constraint = (),
7506 >,
7507 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
7508 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7509 Constraint = (),
7510 >,
7511 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
7512 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7513 Constraint = (),
7514 >,
7515{
7516 async fn on_one_way(
7517 handler: &mut ___H,
7518 ordinal: u64,
7519 flexibility: ::fidl_next::protocol::Flexibility,
7520 body: ::fidl_next::Body<___T>,
7521 ) -> ::core::result::Result<
7522 (),
7523 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
7524 > {
7525 match ordinal {
7526 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
7527 Ok(decoded) => {
7528 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
7529 Ok(())
7530 }
7531 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7532 ordinal: 2366825959783828089,
7533 error,
7534 }),
7535 },
7536
7537 6512600400724287855 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
7538 Ok(decoded) => {
7539 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
7540 Ok(())
7541 }
7542 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7543 ordinal: 6512600400724287855,
7544 error,
7545 }),
7546 },
7547
7548 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
7549 Ok(decoded) => {
7550 handler
7551 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
7552 .await;
7553 Ok(())
7554 }
7555 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7556 ordinal: 5431626189872037072,
7557 error,
7558 }),
7559 },
7560
7561 ordinal => {
7562 handler.on_unknown_interaction(ordinal).await;
7563 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
7564 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
7565 } else {
7566 Ok(())
7567 }
7568 }
7569 }
7570 }
7571
7572 async fn on_two_way(
7573 handler: &mut ___H,
7574 ordinal: u64,
7575 flexibility: ::fidl_next::protocol::Flexibility,
7576 body: ::fidl_next::Body<___T>,
7577 responder: ::fidl_next::protocol::Responder<___T>,
7578 ) -> ::core::result::Result<
7579 (),
7580 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
7581 > {
7582 match ordinal {
7583 6540867515453498750 => {
7584 let responder = ::fidl_next::Responder::from_untyped(responder);
7585
7586 handler.close(responder).await;
7587 Ok(())
7588 }
7589
7590 2763219980499352582 => {
7591 let responder = ::fidl_next::Responder::from_untyped(responder);
7592
7593 handler.query(responder).await;
7594 Ok(())
7595 }
7596
7597 8689798978500614909 => {
7598 let responder = ::fidl_next::Responder::from_untyped(responder);
7599
7600 handler.deprecated_get_attr(responder).await;
7601 Ok(())
7602 }
7603
7604 4721673413776871238 => {
7605 let responder = ::fidl_next::Responder::from_untyped(responder);
7606
7607 match ::fidl_next::AsDecoderExt::into_decoded(body) {
7608 Ok(decoded) => {
7609 handler
7610 .deprecated_set_attr(
7611 ::fidl_next::Request::from_decoded(decoded),
7612 responder,
7613 )
7614 .await;
7615 Ok(())
7616 }
7617 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7618 ordinal: 4721673413776871238,
7619 error,
7620 }),
7621 }
7622 }
7623
7624 6595803110182632097 => {
7625 let responder = ::fidl_next::Responder::from_untyped(responder);
7626
7627 handler.deprecated_get_flags(responder).await;
7628 Ok(())
7629 }
7630
7631 5950864159036794675 => {
7632 let responder = ::fidl_next::Responder::from_untyped(responder);
7633
7634 match ::fidl_next::AsDecoderExt::into_decoded(body) {
7635 Ok(decoded) => {
7636 handler
7637 .deprecated_set_flags(
7638 ::fidl_next::Request::from_decoded(decoded),
7639 responder,
7640 )
7641 .await;
7642 Ok(())
7643 }
7644 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7645 ordinal: 5950864159036794675,
7646 error,
7647 }),
7648 }
7649 }
7650
7651 105530239381466147 => {
7652 let responder = ::fidl_next::Responder::from_untyped(responder);
7653
7654 handler.get_flags(responder).await;
7655 Ok(())
7656 }
7657
7658 6172186066099445416 => {
7659 let responder = ::fidl_next::Responder::from_untyped(responder);
7660
7661 match ::fidl_next::AsDecoderExt::into_decoded(body) {
7662 Ok(decoded) => {
7663 handler
7664 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
7665 .await;
7666 Ok(())
7667 }
7668 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7669 ordinal: 6172186066099445416,
7670 error,
7671 }),
7672 }
7673 }
7674
7675 8013111122914313744 => {
7676 let responder = ::fidl_next::Responder::from_untyped(responder);
7677
7678 handler.query_filesystem(responder).await;
7679 Ok(())
7680 }
7681
7682 4414537700416816443 => {
7683 let responder = ::fidl_next::Responder::from_untyped(responder);
7684
7685 match ::fidl_next::AsDecoderExt::into_decoded(body) {
7686 Ok(decoded) => {
7687 handler
7688 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
7689 .await;
7690 Ok(())
7691 }
7692 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7693 ordinal: 4414537700416816443,
7694 error,
7695 }),
7696 }
7697 }
7698
7699 3677402239314018056 => {
7700 let responder = ::fidl_next::Responder::from_untyped(responder);
7701
7702 match ::fidl_next::AsDecoderExt::into_decoded(body) {
7703 Ok(decoded) => {
7704 handler
7705 .update_attributes(
7706 ::fidl_next::Request::from_decoded(decoded),
7707 responder,
7708 )
7709 .await;
7710 Ok(())
7711 }
7712 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7713 ordinal: 3677402239314018056,
7714 error,
7715 }),
7716 }
7717 }
7718
7719 3196473584242777161 => {
7720 let responder = ::fidl_next::Responder::from_untyped(responder);
7721
7722 handler.sync(responder).await;
7723 Ok(())
7724 }
7725
7726 5043930208506967771 => {
7727 let responder = ::fidl_next::Responder::from_untyped(responder);
7728
7729 match ::fidl_next::AsDecoderExt::into_decoded(body) {
7730 Ok(decoded) => {
7731 handler
7732 .get_extended_attribute(
7733 ::fidl_next::Request::from_decoded(decoded),
7734 responder,
7735 )
7736 .await;
7737 Ok(())
7738 }
7739 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7740 ordinal: 5043930208506967771,
7741 error,
7742 }),
7743 }
7744 }
7745
7746 5374223046099989052 => {
7747 let responder = ::fidl_next::Responder::from_untyped(responder);
7748
7749 match ::fidl_next::AsDecoderExt::into_decoded(body) {
7750 Ok(decoded) => {
7751 handler
7752 .set_extended_attribute(
7753 ::fidl_next::Request::from_decoded(decoded),
7754 responder,
7755 )
7756 .await;
7757 Ok(())
7758 }
7759 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7760 ordinal: 5374223046099989052,
7761 error,
7762 }),
7763 }
7764 }
7765
7766 8794297771444732717 => {
7767 let responder = ::fidl_next::Responder::from_untyped(responder);
7768
7769 match ::fidl_next::AsDecoderExt::into_decoded(body) {
7770 Ok(decoded) => {
7771 handler
7772 .remove_extended_attribute(
7773 ::fidl_next::Request::from_decoded(decoded),
7774 responder,
7775 )
7776 .await;
7777 Ok(())
7778 }
7779 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7780 ordinal: 8794297771444732717,
7781 error,
7782 }),
7783 }
7784 }
7785
7786 ordinal => {
7787 handler.on_unknown_interaction(ordinal).await;
7788 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
7789 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
7790 } else {
7791 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
7792 ordinal,
7793 flexibility,
7794 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
7795 )
7796 .expect("encoding a framework error should never fail")
7797 .await?;
7798 Ok(())
7799 }
7800 }
7801 }
7802 }
7803}
7804
7805pub trait NodeClientHandler<
7809 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
7810 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
7811>
7812{
7813 #[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"]
7814 fn on_open(
7815 &mut self,
7816
7817 request: ::fidl_next::Request<node::OnOpen, ___T>,
7818 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7819
7820 #[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"]
7821 fn on_representation(
7822 &mut self,
7823
7824 request: ::fidl_next::Request<node::OnRepresentation, ___T>,
7825 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7826
7827 fn on_unknown_interaction(
7828 &mut self,
7829 ordinal: u64,
7830 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
7831 ::core::future::ready(())
7832 }
7833}
7834
7835impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Node
7836where
7837 ___H: NodeClientHandler<___T> + ::core::marker::Send,
7838 ___T: ::fidl_next::Transport,
7839 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
7840 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7841 Constraint = (),
7842 >,
7843 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
7844 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7845 Constraint = (),
7846 >,
7847{
7848 async fn on_event(
7849 handler: &mut ___H,
7850 ordinal: u64,
7851 flexibility: ::fidl_next::protocol::Flexibility,
7852 body: ::fidl_next::Body<___T>,
7853 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
7854 match ordinal {
7855 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
7856 Ok(decoded) => {
7857 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
7858 Ok(())
7859 }
7860 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7861 ordinal: 9207534335756671346,
7862 error,
7863 }),
7864 },
7865
7866 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
7867 Ok(decoded) => {
7868 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
7869 Ok(())
7870 }
7871 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7872 ordinal: 6679970090861613324,
7873 error,
7874 }),
7875 },
7876
7877 ordinal => {
7878 handler.on_unknown_interaction(ordinal).await;
7879 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
7880 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
7881 } else {
7882 Ok(())
7883 }
7884 }
7885 }
7886 }
7887}
7888
7889pub trait NodeServerHandler<
7893 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
7894 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
7895>
7896{
7897 fn clone(
7898 &mut self,
7899
7900 request: ::fidl_next::Request<node::Clone, ___T>,
7901 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7902
7903 #[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"]
7904 fn close(
7905 &mut self,
7906
7907 responder: ::fidl_next::Responder<node::Close, ___T>,
7908 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7909
7910 fn query(
7911 &mut self,
7912
7913 responder: ::fidl_next::Responder<node::Query, ___T>,
7914 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7915
7916 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
7917 fn deprecated_clone(
7918 &mut self,
7919
7920 request: ::fidl_next::Request<node::DeprecatedClone, ___T>,
7921 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7922
7923 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
7924 fn deprecated_get_attr(
7925 &mut self,
7926
7927 responder: ::fidl_next::Responder<node::DeprecatedGetAttr, ___T>,
7928 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7929
7930 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
7931 fn deprecated_set_attr(
7932 &mut self,
7933
7934 request: ::fidl_next::Request<node::DeprecatedSetAttr, ___T>,
7935
7936 responder: ::fidl_next::Responder<node::DeprecatedSetAttr, ___T>,
7937 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7938
7939 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
7940 fn deprecated_get_flags(
7941 &mut self,
7942
7943 responder: ::fidl_next::Responder<node::DeprecatedGetFlags, ___T>,
7944 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7945
7946 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
7947 fn deprecated_set_flags(
7948 &mut self,
7949
7950 request: ::fidl_next::Request<node::DeprecatedSetFlags, ___T>,
7951
7952 responder: ::fidl_next::Responder<node::DeprecatedSetFlags, ___T>,
7953 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7954
7955 #[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"]
7956 fn get_flags(
7957 &mut self,
7958
7959 responder: ::fidl_next::Responder<node::GetFlags, ___T>,
7960 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7961
7962 #[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"]
7963 fn set_flags(
7964 &mut self,
7965
7966 request: ::fidl_next::Request<node::SetFlags, ___T>,
7967
7968 responder: ::fidl_next::Responder<node::SetFlags, ___T>,
7969 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7970
7971 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
7972 fn query_filesystem(
7973 &mut self,
7974
7975 responder: ::fidl_next::Responder<node::QueryFilesystem, ___T>,
7976 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7977
7978 #[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"]
7979 fn get_attributes(
7980 &mut self,
7981
7982 request: ::fidl_next::Request<node::GetAttributes, ___T>,
7983
7984 responder: ::fidl_next::Responder<node::GetAttributes, ___T>,
7985 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7986
7987 #[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"]
7988 fn update_attributes(
7989 &mut self,
7990
7991 request: ::fidl_next::Request<node::UpdateAttributes, ___T>,
7992
7993 responder: ::fidl_next::Responder<node::UpdateAttributes, ___T>,
7994 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7995
7996 #[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"]
7997 fn sync(
7998 &mut self,
7999
8000 responder: ::fidl_next::Responder<node::Sync, ___T>,
8001 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8002
8003 #[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"]
8004 fn list_extended_attributes(
8005 &mut self,
8006
8007 request: ::fidl_next::Request<node::ListExtendedAttributes, ___T>,
8008 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8009
8010 #[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"]
8011 fn get_extended_attribute(
8012 &mut self,
8013
8014 request: ::fidl_next::Request<node::GetExtendedAttribute, ___T>,
8015
8016 responder: ::fidl_next::Responder<node::GetExtendedAttribute, ___T>,
8017 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8018
8019 #[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"]
8020 fn set_extended_attribute(
8021 &mut self,
8022
8023 request: ::fidl_next::Request<node::SetExtendedAttribute, ___T>,
8024
8025 responder: ::fidl_next::Responder<node::SetExtendedAttribute, ___T>,
8026 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8027
8028 #[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"]
8029 fn remove_extended_attribute(
8030 &mut self,
8031
8032 request: ::fidl_next::Request<node::RemoveExtendedAttribute, ___T>,
8033
8034 responder: ::fidl_next::Responder<node::RemoveExtendedAttribute, ___T>,
8035 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8036
8037 fn on_unknown_interaction(
8038 &mut self,
8039 ordinal: u64,
8040 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
8041 ::core::future::ready(())
8042 }
8043}
8044
8045impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Node
8046where
8047 ___H: NodeServerHandler<___T> + ::core::marker::Send,
8048 ___T: ::fidl_next::Transport,
8049 for<'de> ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
8050 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8051 Constraint = (),
8052 >,
8053 for<'de> crate::wire::NodeDeprecatedCloneRequest: ::fidl_next::Decode<
8054 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8055 Constraint = (),
8056 >,
8057 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
8058 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8059 Constraint = (),
8060 >,
8061 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
8062 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8063 Constraint = (),
8064 >,
8065 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
8066 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8067 Constraint = (),
8068 >,
8069 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
8070 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8071 Constraint = (),
8072 >,
8073 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
8074 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8075 Constraint = (),
8076 >,
8077 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
8078 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8079 Constraint = (),
8080 >,
8081 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
8082 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8083 Constraint = (),
8084 >,
8085 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
8086 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8087 Constraint = (),
8088 >,
8089 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
8090 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8091 Constraint = (),
8092 >,
8093{
8094 async fn on_one_way(
8095 handler: &mut ___H,
8096 ordinal: u64,
8097 flexibility: ::fidl_next::protocol::Flexibility,
8098 body: ::fidl_next::Body<___T>,
8099 ) -> ::core::result::Result<
8100 (),
8101 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8102 > {
8103 match ordinal {
8104 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
8105 Ok(decoded) => {
8106 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
8107 Ok(())
8108 }
8109 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8110 ordinal: 2366825959783828089,
8111 error,
8112 }),
8113 },
8114
8115 6512600400724287855 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
8116 Ok(decoded) => {
8117 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
8118 Ok(())
8119 }
8120 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8121 ordinal: 6512600400724287855,
8122 error,
8123 }),
8124 },
8125
8126 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
8127 Ok(decoded) => {
8128 handler
8129 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
8130 .await;
8131 Ok(())
8132 }
8133 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8134 ordinal: 5431626189872037072,
8135 error,
8136 }),
8137 },
8138
8139 ordinal => {
8140 handler.on_unknown_interaction(ordinal).await;
8141 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
8142 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8143 } else {
8144 Ok(())
8145 }
8146 }
8147 }
8148 }
8149
8150 async fn on_two_way(
8151 handler: &mut ___H,
8152 ordinal: u64,
8153 flexibility: ::fidl_next::protocol::Flexibility,
8154 body: ::fidl_next::Body<___T>,
8155 responder: ::fidl_next::protocol::Responder<___T>,
8156 ) -> ::core::result::Result<
8157 (),
8158 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8159 > {
8160 match ordinal {
8161 6540867515453498750 => {
8162 let responder = ::fidl_next::Responder::from_untyped(responder);
8163
8164 handler.close(responder).await;
8165 Ok(())
8166 }
8167
8168 2763219980499352582 => {
8169 let responder = ::fidl_next::Responder::from_untyped(responder);
8170
8171 handler.query(responder).await;
8172 Ok(())
8173 }
8174
8175 8689798978500614909 => {
8176 let responder = ::fidl_next::Responder::from_untyped(responder);
8177
8178 handler.deprecated_get_attr(responder).await;
8179 Ok(())
8180 }
8181
8182 4721673413776871238 => {
8183 let responder = ::fidl_next::Responder::from_untyped(responder);
8184
8185 match ::fidl_next::AsDecoderExt::into_decoded(body) {
8186 Ok(decoded) => {
8187 handler
8188 .deprecated_set_attr(
8189 ::fidl_next::Request::from_decoded(decoded),
8190 responder,
8191 )
8192 .await;
8193 Ok(())
8194 }
8195 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8196 ordinal: 4721673413776871238,
8197 error,
8198 }),
8199 }
8200 }
8201
8202 6595803110182632097 => {
8203 let responder = ::fidl_next::Responder::from_untyped(responder);
8204
8205 handler.deprecated_get_flags(responder).await;
8206 Ok(())
8207 }
8208
8209 5950864159036794675 => {
8210 let responder = ::fidl_next::Responder::from_untyped(responder);
8211
8212 match ::fidl_next::AsDecoderExt::into_decoded(body) {
8213 Ok(decoded) => {
8214 handler
8215 .deprecated_set_flags(
8216 ::fidl_next::Request::from_decoded(decoded),
8217 responder,
8218 )
8219 .await;
8220 Ok(())
8221 }
8222 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8223 ordinal: 5950864159036794675,
8224 error,
8225 }),
8226 }
8227 }
8228
8229 105530239381466147 => {
8230 let responder = ::fidl_next::Responder::from_untyped(responder);
8231
8232 handler.get_flags(responder).await;
8233 Ok(())
8234 }
8235
8236 6172186066099445416 => {
8237 let responder = ::fidl_next::Responder::from_untyped(responder);
8238
8239 match ::fidl_next::AsDecoderExt::into_decoded(body) {
8240 Ok(decoded) => {
8241 handler
8242 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
8243 .await;
8244 Ok(())
8245 }
8246 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8247 ordinal: 6172186066099445416,
8248 error,
8249 }),
8250 }
8251 }
8252
8253 8013111122914313744 => {
8254 let responder = ::fidl_next::Responder::from_untyped(responder);
8255
8256 handler.query_filesystem(responder).await;
8257 Ok(())
8258 }
8259
8260 4414537700416816443 => {
8261 let responder = ::fidl_next::Responder::from_untyped(responder);
8262
8263 match ::fidl_next::AsDecoderExt::into_decoded(body) {
8264 Ok(decoded) => {
8265 handler
8266 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
8267 .await;
8268 Ok(())
8269 }
8270 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8271 ordinal: 4414537700416816443,
8272 error,
8273 }),
8274 }
8275 }
8276
8277 3677402239314018056 => {
8278 let responder = ::fidl_next::Responder::from_untyped(responder);
8279
8280 match ::fidl_next::AsDecoderExt::into_decoded(body) {
8281 Ok(decoded) => {
8282 handler
8283 .update_attributes(
8284 ::fidl_next::Request::from_decoded(decoded),
8285 responder,
8286 )
8287 .await;
8288 Ok(())
8289 }
8290 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8291 ordinal: 3677402239314018056,
8292 error,
8293 }),
8294 }
8295 }
8296
8297 3196473584242777161 => {
8298 let responder = ::fidl_next::Responder::from_untyped(responder);
8299
8300 handler.sync(responder).await;
8301 Ok(())
8302 }
8303
8304 5043930208506967771 => {
8305 let responder = ::fidl_next::Responder::from_untyped(responder);
8306
8307 match ::fidl_next::AsDecoderExt::into_decoded(body) {
8308 Ok(decoded) => {
8309 handler
8310 .get_extended_attribute(
8311 ::fidl_next::Request::from_decoded(decoded),
8312 responder,
8313 )
8314 .await;
8315 Ok(())
8316 }
8317 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8318 ordinal: 5043930208506967771,
8319 error,
8320 }),
8321 }
8322 }
8323
8324 5374223046099989052 => {
8325 let responder = ::fidl_next::Responder::from_untyped(responder);
8326
8327 match ::fidl_next::AsDecoderExt::into_decoded(body) {
8328 Ok(decoded) => {
8329 handler
8330 .set_extended_attribute(
8331 ::fidl_next::Request::from_decoded(decoded),
8332 responder,
8333 )
8334 .await;
8335 Ok(())
8336 }
8337 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8338 ordinal: 5374223046099989052,
8339 error,
8340 }),
8341 }
8342 }
8343
8344 8794297771444732717 => {
8345 let responder = ::fidl_next::Responder::from_untyped(responder);
8346
8347 match ::fidl_next::AsDecoderExt::into_decoded(body) {
8348 Ok(decoded) => {
8349 handler
8350 .remove_extended_attribute(
8351 ::fidl_next::Request::from_decoded(decoded),
8352 responder,
8353 )
8354 .await;
8355 Ok(())
8356 }
8357 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8358 ordinal: 8794297771444732717,
8359 error,
8360 }),
8361 }
8362 }
8363
8364 ordinal => {
8365 handler.on_unknown_interaction(ordinal).await;
8366 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
8367 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8368 } else {
8369 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
8370 ordinal,
8371 flexibility,
8372 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
8373 )
8374 .expect("encoding a framework error should never fail")
8375 .await?;
8376 Ok(())
8377 }
8378 }
8379 }
8380 }
8381}
8382
8383impl<___T> NodeClientHandler<___T> for ::fidl_next::IgnoreEvents
8384where
8385 ___T: ::fidl_next::Transport,
8386{
8387 async fn on_open(&mut self, _: ::fidl_next::Request<node::OnOpen, ___T>) {}
8388
8389 async fn on_representation(&mut self, _: ::fidl_next::Request<node::OnRepresentation, ___T>) {}
8390
8391 async fn on_unknown_interaction(&mut self, _: u64) {}
8392}
8393
8394impl<___H, ___T> NodeLocalClientHandler<___T> for ::fidl_next::Local<___H>
8395where
8396 ___H: NodeClientHandler<___T>,
8397 ___T: ::fidl_next::Transport,
8398{
8399 async fn on_open(&mut self, request: ::fidl_next::Request<node::OnOpen, ___T>) {
8400 ___H::on_open(&mut self.0, request).await
8401 }
8402
8403 async fn on_representation(
8404 &mut self,
8405
8406 request: ::fidl_next::Request<node::OnRepresentation, ___T>,
8407 ) {
8408 ___H::on_representation(&mut self.0, request).await
8409 }
8410
8411 async fn on_unknown_interaction(&mut self, ordinal: u64) {
8412 ___H::on_unknown_interaction(&mut self.0, ordinal).await
8413 }
8414}
8415
8416impl<___H, ___T> NodeLocalServerHandler<___T> for ::fidl_next::Local<___H>
8417where
8418 ___H: NodeServerHandler<___T>,
8419 ___T: ::fidl_next::Transport,
8420{
8421 async fn clone(&mut self, request: ::fidl_next::Request<node::Clone, ___T>) {
8422 ___H::clone(&mut self.0, request).await
8423 }
8424
8425 async fn close(&mut self, responder: ::fidl_next::Responder<node::Close, ___T>) {
8426 ___H::close(&mut self.0, responder).await
8427 }
8428
8429 async fn query(&mut self, responder: ::fidl_next::Responder<node::Query, ___T>) {
8430 ___H::query(&mut self.0, responder).await
8431 }
8432
8433 async fn deprecated_clone(
8434 &mut self,
8435
8436 request: ::fidl_next::Request<node::DeprecatedClone, ___T>,
8437 ) {
8438 ___H::deprecated_clone(&mut self.0, request).await
8439 }
8440
8441 async fn deprecated_get_attr(
8442 &mut self,
8443
8444 responder: ::fidl_next::Responder<node::DeprecatedGetAttr, ___T>,
8445 ) {
8446 ___H::deprecated_get_attr(&mut self.0, responder).await
8447 }
8448
8449 async fn deprecated_set_attr(
8450 &mut self,
8451
8452 request: ::fidl_next::Request<node::DeprecatedSetAttr, ___T>,
8453
8454 responder: ::fidl_next::Responder<node::DeprecatedSetAttr, ___T>,
8455 ) {
8456 ___H::deprecated_set_attr(&mut self.0, request, responder).await
8457 }
8458
8459 async fn deprecated_get_flags(
8460 &mut self,
8461
8462 responder: ::fidl_next::Responder<node::DeprecatedGetFlags, ___T>,
8463 ) {
8464 ___H::deprecated_get_flags(&mut self.0, responder).await
8465 }
8466
8467 async fn deprecated_set_flags(
8468 &mut self,
8469
8470 request: ::fidl_next::Request<node::DeprecatedSetFlags, ___T>,
8471
8472 responder: ::fidl_next::Responder<node::DeprecatedSetFlags, ___T>,
8473 ) {
8474 ___H::deprecated_set_flags(&mut self.0, request, responder).await
8475 }
8476
8477 async fn get_flags(&mut self, responder: ::fidl_next::Responder<node::GetFlags, ___T>) {
8478 ___H::get_flags(&mut self.0, responder).await
8479 }
8480
8481 async fn set_flags(
8482 &mut self,
8483
8484 request: ::fidl_next::Request<node::SetFlags, ___T>,
8485
8486 responder: ::fidl_next::Responder<node::SetFlags, ___T>,
8487 ) {
8488 ___H::set_flags(&mut self.0, request, responder).await
8489 }
8490
8491 async fn query_filesystem(
8492 &mut self,
8493
8494 responder: ::fidl_next::Responder<node::QueryFilesystem, ___T>,
8495 ) {
8496 ___H::query_filesystem(&mut self.0, responder).await
8497 }
8498
8499 async fn get_attributes(
8500 &mut self,
8501
8502 request: ::fidl_next::Request<node::GetAttributes, ___T>,
8503
8504 responder: ::fidl_next::Responder<node::GetAttributes, ___T>,
8505 ) {
8506 ___H::get_attributes(&mut self.0, request, responder).await
8507 }
8508
8509 async fn update_attributes(
8510 &mut self,
8511
8512 request: ::fidl_next::Request<node::UpdateAttributes, ___T>,
8513
8514 responder: ::fidl_next::Responder<node::UpdateAttributes, ___T>,
8515 ) {
8516 ___H::update_attributes(&mut self.0, request, responder).await
8517 }
8518
8519 async fn sync(&mut self, responder: ::fidl_next::Responder<node::Sync, ___T>) {
8520 ___H::sync(&mut self.0, responder).await
8521 }
8522
8523 async fn list_extended_attributes(
8524 &mut self,
8525
8526 request: ::fidl_next::Request<node::ListExtendedAttributes, ___T>,
8527 ) {
8528 ___H::list_extended_attributes(&mut self.0, request).await
8529 }
8530
8531 async fn get_extended_attribute(
8532 &mut self,
8533
8534 request: ::fidl_next::Request<node::GetExtendedAttribute, ___T>,
8535
8536 responder: ::fidl_next::Responder<node::GetExtendedAttribute, ___T>,
8537 ) {
8538 ___H::get_extended_attribute(&mut self.0, request, responder).await
8539 }
8540
8541 async fn set_extended_attribute(
8542 &mut self,
8543
8544 request: ::fidl_next::Request<node::SetExtendedAttribute, ___T>,
8545
8546 responder: ::fidl_next::Responder<node::SetExtendedAttribute, ___T>,
8547 ) {
8548 ___H::set_extended_attribute(&mut self.0, request, responder).await
8549 }
8550
8551 async fn remove_extended_attribute(
8552 &mut self,
8553
8554 request: ::fidl_next::Request<node::RemoveExtendedAttribute, ___T>,
8555
8556 responder: ::fidl_next::Responder<node::RemoveExtendedAttribute, ___T>,
8557 ) {
8558 ___H::remove_extended_attribute(&mut self.0, request, responder).await
8559 }
8560
8561 async fn on_unknown_interaction(&mut self, ordinal: u64) {
8562 ___H::on_unknown_interaction(&mut self.0, ordinal).await
8563 }
8564}
8565
8566#[doc = " Directory defines a node which is capable of containing other Objects.\n"]
8568#[derive(PartialEq, Debug)]
8569pub struct Directory;
8570
8571impl ::fidl_next::Discoverable for Directory {
8572 const PROTOCOL_NAME: &'static str = "fuchsia.io.Directory";
8573}
8574
8575#[cfg(target_os = "fuchsia")]
8576impl ::fidl_next::HasTransport for Directory {
8577 type Transport = ::fdomain_client::Channel;
8578}
8579
8580pub mod directory {
8581 pub mod prelude {
8582 pub use crate::{
8583 Directory, DirectoryClientHandler, DirectoryLocalClientHandler,
8584 DirectoryLocalServerHandler, DirectoryServerHandler, directory,
8585 };
8586
8587 pub use crate::natural::AdvisoryLockingAdvisoryLockRequest;
8588
8589 pub use crate::natural::AdvisoryLockingAdvisoryLockResponse;
8590
8591 pub use crate::natural::DirectoryCreateSymlinkRequest;
8592
8593 pub use crate::natural::DirectoryDeprecatedOpenRequest;
8594
8595 pub use crate::natural::DirectoryGetTokenResponse;
8596
8597 pub use crate::natural::DirectoryLinkRequest;
8598
8599 pub use crate::natural::DirectoryLinkResponse;
8600
8601 pub use crate::natural::DirectoryReadDirentsRequest;
8602
8603 pub use crate::natural::DirectoryReadDirentsResponse;
8604
8605 pub use crate::natural::DirectoryRenameRequest;
8606
8607 pub use crate::natural::DirectoryRewindResponse;
8608
8609 pub use crate::natural::DirectoryUnlinkRequest;
8610
8611 pub use crate::natural::DirectoryWatchRequest;
8612
8613 pub use crate::natural::DirectoryWatchResponse;
8614
8615 pub use crate::natural::DirectoryCreateSymlinkResponse;
8616
8617 pub use crate::natural::DirectoryRenameResponse;
8618
8619 pub use crate::natural::DirectoryUnlinkResponse;
8620
8621 pub use crate::natural::ExtendedAttributeValue;
8622
8623 pub use crate::natural::MutableNodeAttributes;
8624
8625 pub use crate::natural::NodeAttributes2;
8626
8627 pub use crate::natural::NodeDeprecatedCloneRequest;
8628
8629 pub use crate::natural::NodeDeprecatedGetAttrResponse;
8630
8631 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
8632
8633 pub use crate::natural::NodeDeprecatedSetAttrRequest;
8634
8635 pub use crate::natural::NodeDeprecatedSetAttrResponse;
8636
8637 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
8638
8639 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
8640
8641 pub use crate::natural::NodeGetAttributesRequest;
8642
8643 pub use crate::natural::NodeGetExtendedAttributeRequest;
8644
8645 pub use crate::natural::NodeListExtendedAttributesRequest;
8646
8647 pub use crate::natural::NodeOnOpenRequest;
8648
8649 pub use crate::natural::NodeQueryFilesystemResponse;
8650
8651 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
8652
8653 pub use crate::natural::NodeSetExtendedAttributeRequest;
8654
8655 pub use crate::natural::NodeSetFlagsRequest;
8656
8657 pub use crate::natural::NodeGetFlagsResponse;
8658
8659 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
8660
8661 pub use crate::natural::NodeSetExtendedAttributeResponse;
8662
8663 pub use crate::natural::NodeSetFlagsResponse;
8664
8665 pub use crate::natural::NodeSyncResponse;
8666
8667 pub use crate::natural::NodeUpdateAttributesResponse;
8668
8669 pub use crate::natural::OpenableOpenRequest;
8670
8671 pub use crate::natural::Representation;
8672
8673 pub use ::fdomain_next_fuchsia_unknown::natural::CloneableCloneRequest;
8674
8675 pub use ::fdomain_next_fuchsia_unknown::natural::CloseableCloseResponse;
8676
8677 pub use ::fdomain_next_fuchsia_unknown::natural::QueryableQueryResponse;
8678 }
8679
8680 pub struct AdvisoryLock;
8681
8682 impl ::fidl_next::Method for AdvisoryLock {
8683 const ORDINAL: u64 = 7992130864415541162;
8684 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8685 ::fidl_next::protocol::Flexibility::Strict;
8686
8687 type Protocol = crate::Directory;
8688
8689 type Request = crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>;
8690 }
8691
8692 impl ::fidl_next::TwoWayMethod for AdvisoryLock {
8693 type Response = ::fidl_next::wire::Result<
8694 'static,
8695 crate::wire::AdvisoryLockingAdvisoryLockResponse,
8696 ::fidl_next::wire::Int32,
8697 >;
8698 }
8699
8700 impl<___R> ::fidl_next::Respond<___R> for AdvisoryLock {
8701 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
8702
8703 fn respond(response: ___R) -> Self::Output {
8704 ::core::result::Result::Ok(response)
8705 }
8706 }
8707
8708 impl<___R> ::fidl_next::RespondErr<___R> for AdvisoryLock {
8709 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
8710
8711 fn respond_err(response: ___R) -> Self::Output {
8712 ::core::result::Result::Err(response)
8713 }
8714 }
8715
8716 pub struct Clone;
8717
8718 impl ::fidl_next::Method for Clone {
8719 const ORDINAL: u64 = 2366825959783828089;
8720 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8721 ::fidl_next::protocol::Flexibility::Strict;
8722
8723 type Protocol = crate::Directory;
8724
8725 type Request = ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest;
8726 }
8727
8728 pub struct Close;
8729
8730 impl ::fidl_next::Method for Close {
8731 const ORDINAL: u64 = 6540867515453498750;
8732 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8733 ::fidl_next::protocol::Flexibility::Strict;
8734
8735 type Protocol = crate::Directory;
8736
8737 type Request = ::fidl_next::wire::EmptyMessageBody;
8738 }
8739
8740 impl ::fidl_next::TwoWayMethod for Close {
8741 type Response = ::fidl_next::wire::Result<
8742 'static,
8743 ::fdomain_next_fuchsia_unknown::wire::CloseableCloseResponse,
8744 ::fidl_next::wire::Int32,
8745 >;
8746 }
8747
8748 impl<___R> ::fidl_next::Respond<___R> for Close {
8749 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
8750
8751 fn respond(response: ___R) -> Self::Output {
8752 ::core::result::Result::Ok(response)
8753 }
8754 }
8755
8756 impl<___R> ::fidl_next::RespondErr<___R> for Close {
8757 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
8758
8759 fn respond_err(response: ___R) -> Self::Output {
8760 ::core::result::Result::Err(response)
8761 }
8762 }
8763
8764 pub struct Query;
8765
8766 impl ::fidl_next::Method for Query {
8767 const ORDINAL: u64 = 2763219980499352582;
8768 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8769 ::fidl_next::protocol::Flexibility::Strict;
8770
8771 type Protocol = crate::Directory;
8772
8773 type Request = ::fidl_next::wire::EmptyMessageBody;
8774 }
8775
8776 impl ::fidl_next::TwoWayMethod for Query {
8777 type Response = ::fdomain_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>;
8778 }
8779
8780 impl<___R> ::fidl_next::Respond<___R> for Query {
8781 type Output = ::fdomain_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>;
8782
8783 fn respond(response: ___R) -> Self::Output {
8784 ::fdomain_next_fuchsia_unknown::generic::QueryableQueryResponse { protocol: response }
8785 }
8786 }
8787
8788 pub struct DeprecatedClone;
8789
8790 impl ::fidl_next::Method for DeprecatedClone {
8791 const ORDINAL: u64 = 6512600400724287855;
8792 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8793 ::fidl_next::protocol::Flexibility::Flexible;
8794
8795 type Protocol = crate::Directory;
8796
8797 type Request = crate::wire::NodeDeprecatedCloneRequest;
8798 }
8799
8800 pub struct OnOpen;
8801
8802 impl ::fidl_next::Method for OnOpen {
8803 const ORDINAL: u64 = 9207534335756671346;
8804 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8805 ::fidl_next::protocol::Flexibility::Flexible;
8806
8807 type Protocol = crate::Directory;
8808
8809 type Request = crate::wire::NodeOnOpenRequest<'static>;
8810 }
8811
8812 pub struct DeprecatedGetAttr;
8813
8814 impl ::fidl_next::Method for DeprecatedGetAttr {
8815 const ORDINAL: u64 = 8689798978500614909;
8816 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8817 ::fidl_next::protocol::Flexibility::Strict;
8818
8819 type Protocol = crate::Directory;
8820
8821 type Request = ::fidl_next::wire::EmptyMessageBody;
8822 }
8823
8824 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
8825 type Response = crate::wire::NodeDeprecatedGetAttrResponse;
8826 }
8827
8828 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
8829 type Output = ___R;
8830
8831 fn respond(response: ___R) -> Self::Output {
8832 response
8833 }
8834 }
8835
8836 pub struct DeprecatedSetAttr;
8837
8838 impl ::fidl_next::Method for DeprecatedSetAttr {
8839 const ORDINAL: u64 = 4721673413776871238;
8840 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8841 ::fidl_next::protocol::Flexibility::Strict;
8842
8843 type Protocol = crate::Directory;
8844
8845 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
8846 }
8847
8848 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
8849 type Response = crate::wire::NodeDeprecatedSetAttrResponse;
8850 }
8851
8852 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
8853 type Output = crate::generic::NodeDeprecatedSetAttrResponse<___R>;
8854
8855 fn respond(response: ___R) -> Self::Output {
8856 crate::generic::NodeDeprecatedSetAttrResponse { s: response }
8857 }
8858 }
8859
8860 pub struct DeprecatedGetFlags;
8861
8862 impl ::fidl_next::Method for DeprecatedGetFlags {
8863 const ORDINAL: u64 = 6595803110182632097;
8864 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8865 ::fidl_next::protocol::Flexibility::Strict;
8866
8867 type Protocol = crate::Directory;
8868
8869 type Request = ::fidl_next::wire::EmptyMessageBody;
8870 }
8871
8872 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
8873 type Response = crate::wire::NodeDeprecatedGetFlagsResponse;
8874 }
8875
8876 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
8877 type Output = ___R;
8878
8879 fn respond(response: ___R) -> Self::Output {
8880 response
8881 }
8882 }
8883
8884 pub struct DeprecatedSetFlags;
8885
8886 impl ::fidl_next::Method for DeprecatedSetFlags {
8887 const ORDINAL: u64 = 5950864159036794675;
8888 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8889 ::fidl_next::protocol::Flexibility::Strict;
8890
8891 type Protocol = crate::Directory;
8892
8893 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
8894 }
8895
8896 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
8897 type Response = crate::wire::NodeDeprecatedSetFlagsResponse;
8898 }
8899
8900 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
8901 type Output = crate::generic::NodeDeprecatedSetFlagsResponse<___R>;
8902
8903 fn respond(response: ___R) -> Self::Output {
8904 crate::generic::NodeDeprecatedSetFlagsResponse { s: response }
8905 }
8906 }
8907
8908 pub struct GetFlags;
8909
8910 impl ::fidl_next::Method for GetFlags {
8911 const ORDINAL: u64 = 105530239381466147;
8912 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8913 ::fidl_next::protocol::Flexibility::Flexible;
8914
8915 type Protocol = crate::Directory;
8916
8917 type Request = ::fidl_next::wire::EmptyMessageBody;
8918 }
8919
8920 impl ::fidl_next::TwoWayMethod for GetFlags {
8921 type Response = ::fidl_next::wire::FlexibleResult<
8922 'static,
8923 crate::wire::NodeGetFlagsResponse,
8924 ::fidl_next::wire::Int32,
8925 >;
8926 }
8927
8928 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
8929 type Output = ::fidl_next::FlexibleResult<
8930 crate::generic::NodeGetFlagsResponse<___R>,
8931 ::fidl_next::util::Never,
8932 >;
8933
8934 fn respond(response: ___R) -> Self::Output {
8935 ::fidl_next::FlexibleResult::Ok(crate::generic::NodeGetFlagsResponse {
8936 flags: response,
8937 })
8938 }
8939 }
8940
8941 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
8942 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8943
8944 fn respond_err(response: ___R) -> Self::Output {
8945 ::fidl_next::FlexibleResult::Err(response)
8946 }
8947 }
8948
8949 pub struct SetFlags;
8950
8951 impl ::fidl_next::Method for SetFlags {
8952 const ORDINAL: u64 = 6172186066099445416;
8953 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8954 ::fidl_next::protocol::Flexibility::Flexible;
8955
8956 type Protocol = crate::Directory;
8957
8958 type Request = crate::wire::NodeSetFlagsRequest;
8959 }
8960
8961 impl ::fidl_next::TwoWayMethod for SetFlags {
8962 type Response = ::fidl_next::wire::FlexibleResult<
8963 'static,
8964 crate::wire::NodeSetFlagsResponse,
8965 ::fidl_next::wire::Int32,
8966 >;
8967 }
8968
8969 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
8970 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8971
8972 fn respond(response: ___R) -> Self::Output {
8973 ::fidl_next::FlexibleResult::Ok(response)
8974 }
8975 }
8976
8977 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
8978 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8979
8980 fn respond_err(response: ___R) -> Self::Output {
8981 ::fidl_next::FlexibleResult::Err(response)
8982 }
8983 }
8984
8985 pub struct QueryFilesystem;
8986
8987 impl ::fidl_next::Method for QueryFilesystem {
8988 const ORDINAL: u64 = 8013111122914313744;
8989 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8990 ::fidl_next::protocol::Flexibility::Strict;
8991
8992 type Protocol = crate::Directory;
8993
8994 type Request = ::fidl_next::wire::EmptyMessageBody;
8995 }
8996
8997 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
8998 type Response = crate::wire::NodeQueryFilesystemResponse<'static>;
8999 }
9000
9001 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
9002 type Output = ___R;
9003
9004 fn respond(response: ___R) -> Self::Output {
9005 response
9006 }
9007 }
9008
9009 pub struct OnRepresentation;
9010
9011 impl ::fidl_next::Method for OnRepresentation {
9012 const ORDINAL: u64 = 6679970090861613324;
9013 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9014 ::fidl_next::protocol::Flexibility::Strict;
9015
9016 type Protocol = crate::Directory;
9017
9018 type Request = crate::wire::Representation<'static>;
9019 }
9020
9021 pub struct GetAttributes;
9022
9023 impl ::fidl_next::Method for GetAttributes {
9024 const ORDINAL: u64 = 4414537700416816443;
9025 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9026 ::fidl_next::protocol::Flexibility::Strict;
9027
9028 type Protocol = crate::Directory;
9029
9030 type Request = crate::wire::NodeGetAttributesRequest;
9031 }
9032
9033 impl ::fidl_next::TwoWayMethod for GetAttributes {
9034 type Response = ::fidl_next::wire::Result<
9035 'static,
9036 crate::wire::NodeAttributes2<'static>,
9037 ::fidl_next::wire::Int32,
9038 >;
9039 }
9040
9041 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
9042 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9043
9044 fn respond(response: ___R) -> Self::Output {
9045 ::core::result::Result::Ok(response)
9046 }
9047 }
9048
9049 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
9050 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9051
9052 fn respond_err(response: ___R) -> Self::Output {
9053 ::core::result::Result::Err(response)
9054 }
9055 }
9056
9057 pub struct UpdateAttributes;
9058
9059 impl ::fidl_next::Method for UpdateAttributes {
9060 const ORDINAL: u64 = 3677402239314018056;
9061 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9062 ::fidl_next::protocol::Flexibility::Strict;
9063
9064 type Protocol = crate::Directory;
9065
9066 type Request = crate::wire::MutableNodeAttributes<'static>;
9067 }
9068
9069 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
9070 type Response = ::fidl_next::wire::Result<
9071 'static,
9072 crate::wire::NodeUpdateAttributesResponse,
9073 ::fidl_next::wire::Int32,
9074 >;
9075 }
9076
9077 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
9078 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9079
9080 fn respond(response: ___R) -> Self::Output {
9081 ::core::result::Result::Ok(response)
9082 }
9083 }
9084
9085 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
9086 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9087
9088 fn respond_err(response: ___R) -> Self::Output {
9089 ::core::result::Result::Err(response)
9090 }
9091 }
9092
9093 pub struct Sync;
9094
9095 impl ::fidl_next::Method for Sync {
9096 const ORDINAL: u64 = 3196473584242777161;
9097 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9098 ::fidl_next::protocol::Flexibility::Strict;
9099
9100 type Protocol = crate::Directory;
9101
9102 type Request = ::fidl_next::wire::EmptyMessageBody;
9103 }
9104
9105 impl ::fidl_next::TwoWayMethod for Sync {
9106 type Response = ::fidl_next::wire::Result<
9107 'static,
9108 crate::wire::NodeSyncResponse,
9109 ::fidl_next::wire::Int32,
9110 >;
9111 }
9112
9113 impl<___R> ::fidl_next::Respond<___R> for Sync {
9114 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9115
9116 fn respond(response: ___R) -> Self::Output {
9117 ::core::result::Result::Ok(response)
9118 }
9119 }
9120
9121 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
9122 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9123
9124 fn respond_err(response: ___R) -> Self::Output {
9125 ::core::result::Result::Err(response)
9126 }
9127 }
9128
9129 pub struct ListExtendedAttributes;
9130
9131 impl ::fidl_next::Method for ListExtendedAttributes {
9132 const ORDINAL: u64 = 5431626189872037072;
9133 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9134 ::fidl_next::protocol::Flexibility::Strict;
9135
9136 type Protocol = crate::Directory;
9137
9138 type Request = crate::wire::NodeListExtendedAttributesRequest;
9139 }
9140
9141 pub struct GetExtendedAttribute;
9142
9143 impl ::fidl_next::Method for GetExtendedAttribute {
9144 const ORDINAL: u64 = 5043930208506967771;
9145 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9146 ::fidl_next::protocol::Flexibility::Strict;
9147
9148 type Protocol = crate::Directory;
9149
9150 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
9151 }
9152
9153 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
9154 type Response = ::fidl_next::wire::Result<
9155 'static,
9156 crate::wire::ExtendedAttributeValue<'static>,
9157 ::fidl_next::wire::Int32,
9158 >;
9159 }
9160
9161 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
9162 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9163
9164 fn respond(response: ___R) -> Self::Output {
9165 ::core::result::Result::Ok(response)
9166 }
9167 }
9168
9169 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
9170 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9171
9172 fn respond_err(response: ___R) -> Self::Output {
9173 ::core::result::Result::Err(response)
9174 }
9175 }
9176
9177 pub struct SetExtendedAttribute;
9178
9179 impl ::fidl_next::Method for SetExtendedAttribute {
9180 const ORDINAL: u64 = 5374223046099989052;
9181 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9182 ::fidl_next::protocol::Flexibility::Strict;
9183
9184 type Protocol = crate::Directory;
9185
9186 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
9187 }
9188
9189 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
9190 type Response = ::fidl_next::wire::Result<
9191 'static,
9192 crate::wire::NodeSetExtendedAttributeResponse,
9193 ::fidl_next::wire::Int32,
9194 >;
9195 }
9196
9197 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
9198 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9199
9200 fn respond(response: ___R) -> Self::Output {
9201 ::core::result::Result::Ok(response)
9202 }
9203 }
9204
9205 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
9206 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9207
9208 fn respond_err(response: ___R) -> Self::Output {
9209 ::core::result::Result::Err(response)
9210 }
9211 }
9212
9213 pub struct RemoveExtendedAttribute;
9214
9215 impl ::fidl_next::Method for RemoveExtendedAttribute {
9216 const ORDINAL: u64 = 8794297771444732717;
9217 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9218 ::fidl_next::protocol::Flexibility::Strict;
9219
9220 type Protocol = crate::Directory;
9221
9222 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
9223 }
9224
9225 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
9226 type Response = ::fidl_next::wire::Result<
9227 'static,
9228 crate::wire::NodeRemoveExtendedAttributeResponse,
9229 ::fidl_next::wire::Int32,
9230 >;
9231 }
9232
9233 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
9234 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9235
9236 fn respond(response: ___R) -> Self::Output {
9237 ::core::result::Result::Ok(response)
9238 }
9239 }
9240
9241 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
9242 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9243
9244 fn respond_err(response: ___R) -> Self::Output {
9245 ::core::result::Result::Err(response)
9246 }
9247 }
9248
9249 pub struct Open;
9250
9251 impl ::fidl_next::Method for Open {
9252 const ORDINAL: u64 = 6236883748953765593;
9253 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9254 ::fidl_next::protocol::Flexibility::Flexible;
9255
9256 type Protocol = crate::Directory;
9257
9258 type Request = crate::wire::OpenableOpenRequest<'static>;
9259 }
9260
9261 pub struct DeprecatedOpen;
9262
9263 impl ::fidl_next::Method for DeprecatedOpen {
9264 const ORDINAL: u64 = 3193127272456937152;
9265 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9266 ::fidl_next::protocol::Flexibility::Flexible;
9267
9268 type Protocol = crate::Directory;
9269
9270 type Request = crate::wire::DirectoryDeprecatedOpenRequest<'static>;
9271 }
9272
9273 pub struct ReadDirents;
9274
9275 impl ::fidl_next::Method for ReadDirents {
9276 const ORDINAL: u64 = 3855785432100874762;
9277 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9278 ::fidl_next::protocol::Flexibility::Strict;
9279
9280 type Protocol = crate::Directory;
9281
9282 type Request = crate::wire::DirectoryReadDirentsRequest;
9283 }
9284
9285 impl ::fidl_next::TwoWayMethod for ReadDirents {
9286 type Response = crate::wire::DirectoryReadDirentsResponse<'static>;
9287 }
9288
9289 impl<___R> ::fidl_next::Respond<___R> for ReadDirents {
9290 type Output = ___R;
9291
9292 fn respond(response: ___R) -> Self::Output {
9293 response
9294 }
9295 }
9296
9297 pub struct Rewind;
9298
9299 impl ::fidl_next::Method for Rewind {
9300 const ORDINAL: u64 = 1635123508515392625;
9301 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9302 ::fidl_next::protocol::Flexibility::Strict;
9303
9304 type Protocol = crate::Directory;
9305
9306 type Request = ::fidl_next::wire::EmptyMessageBody;
9307 }
9308
9309 impl ::fidl_next::TwoWayMethod for Rewind {
9310 type Response = crate::wire::DirectoryRewindResponse;
9311 }
9312
9313 impl<___R> ::fidl_next::Respond<___R> for Rewind {
9314 type Output = crate::generic::DirectoryRewindResponse<___R>;
9315
9316 fn respond(response: ___R) -> Self::Output {
9317 crate::generic::DirectoryRewindResponse { s: response }
9318 }
9319 }
9320
9321 pub struct GetToken;
9322
9323 impl ::fidl_next::Method for GetToken {
9324 const ORDINAL: u64 = 2787337947777369685;
9325 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9326 ::fidl_next::protocol::Flexibility::Strict;
9327
9328 type Protocol = crate::Directory;
9329
9330 type Request = ::fidl_next::wire::EmptyMessageBody;
9331 }
9332
9333 impl ::fidl_next::TwoWayMethod for GetToken {
9334 type Response = crate::wire::DirectoryGetTokenResponse;
9335 }
9336
9337 impl<___R> ::fidl_next::Respond<___R> for GetToken {
9338 type Output = ___R;
9339
9340 fn respond(response: ___R) -> Self::Output {
9341 response
9342 }
9343 }
9344
9345 pub struct Link;
9346
9347 impl ::fidl_next::Method for Link {
9348 const ORDINAL: u64 = 8360374984291987687;
9349 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9350 ::fidl_next::protocol::Flexibility::Strict;
9351
9352 type Protocol = crate::Directory;
9353
9354 type Request = crate::wire::DirectoryLinkRequest<'static>;
9355 }
9356
9357 impl ::fidl_next::TwoWayMethod for Link {
9358 type Response = crate::wire::DirectoryLinkResponse;
9359 }
9360
9361 impl<___R> ::fidl_next::Respond<___R> for Link {
9362 type Output = crate::generic::DirectoryLinkResponse<___R>;
9363
9364 fn respond(response: ___R) -> Self::Output {
9365 crate::generic::DirectoryLinkResponse { s: response }
9366 }
9367 }
9368
9369 pub struct Unlink;
9370
9371 impl ::fidl_next::Method for Unlink {
9372 const ORDINAL: u64 = 8433556716759383021;
9373 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9374 ::fidl_next::protocol::Flexibility::Strict;
9375
9376 type Protocol = crate::Directory;
9377
9378 type Request = crate::wire::DirectoryUnlinkRequest<'static>;
9379 }
9380
9381 impl ::fidl_next::TwoWayMethod for Unlink {
9382 type Response = ::fidl_next::wire::Result<
9383 'static,
9384 crate::wire::DirectoryUnlinkResponse,
9385 ::fidl_next::wire::Int32,
9386 >;
9387 }
9388
9389 impl<___R> ::fidl_next::Respond<___R> for Unlink {
9390 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9391
9392 fn respond(response: ___R) -> Self::Output {
9393 ::core::result::Result::Ok(response)
9394 }
9395 }
9396
9397 impl<___R> ::fidl_next::RespondErr<___R> for Unlink {
9398 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9399
9400 fn respond_err(response: ___R) -> Self::Output {
9401 ::core::result::Result::Err(response)
9402 }
9403 }
9404
9405 pub struct Rename;
9406
9407 impl ::fidl_next::Method for Rename {
9408 const ORDINAL: u64 = 8097726607824333022;
9409 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9410 ::fidl_next::protocol::Flexibility::Strict;
9411
9412 type Protocol = crate::Directory;
9413
9414 type Request = crate::wire::DirectoryRenameRequest<'static>;
9415 }
9416
9417 impl ::fidl_next::TwoWayMethod for Rename {
9418 type Response = ::fidl_next::wire::Result<
9419 'static,
9420 crate::wire::DirectoryRenameResponse,
9421 ::fidl_next::wire::Int32,
9422 >;
9423 }
9424
9425 impl<___R> ::fidl_next::Respond<___R> for Rename {
9426 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9427
9428 fn respond(response: ___R) -> Self::Output {
9429 ::core::result::Result::Ok(response)
9430 }
9431 }
9432
9433 impl<___R> ::fidl_next::RespondErr<___R> for Rename {
9434 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9435
9436 fn respond_err(response: ___R) -> Self::Output {
9437 ::core::result::Result::Err(response)
9438 }
9439 }
9440
9441 pub struct CreateSymlink;
9442
9443 impl ::fidl_next::Method for CreateSymlink {
9444 const ORDINAL: u64 = 2435901052462315657;
9445 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9446 ::fidl_next::protocol::Flexibility::Strict;
9447
9448 type Protocol = crate::Directory;
9449
9450 type Request = crate::wire::DirectoryCreateSymlinkRequest<'static>;
9451 }
9452
9453 impl ::fidl_next::TwoWayMethod for CreateSymlink {
9454 type Response = ::fidl_next::wire::Result<
9455 'static,
9456 crate::wire::DirectoryCreateSymlinkResponse,
9457 ::fidl_next::wire::Int32,
9458 >;
9459 }
9460
9461 impl<___R> ::fidl_next::Respond<___R> for CreateSymlink {
9462 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9463
9464 fn respond(response: ___R) -> Self::Output {
9465 ::core::result::Result::Ok(response)
9466 }
9467 }
9468
9469 impl<___R> ::fidl_next::RespondErr<___R> for CreateSymlink {
9470 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9471
9472 fn respond_err(response: ___R) -> Self::Output {
9473 ::core::result::Result::Err(response)
9474 }
9475 }
9476
9477 pub struct Watch;
9478
9479 impl ::fidl_next::Method for Watch {
9480 const ORDINAL: u64 = 6275512344170098065;
9481 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9482 ::fidl_next::protocol::Flexibility::Strict;
9483
9484 type Protocol = crate::Directory;
9485
9486 type Request = crate::wire::DirectoryWatchRequest;
9487 }
9488
9489 impl ::fidl_next::TwoWayMethod for Watch {
9490 type Response = crate::wire::DirectoryWatchResponse;
9491 }
9492
9493 impl<___R> ::fidl_next::Respond<___R> for Watch {
9494 type Output = crate::generic::DirectoryWatchResponse<___R>;
9495
9496 fn respond(response: ___R) -> Self::Output {
9497 crate::generic::DirectoryWatchResponse { s: response }
9498 }
9499 }
9500
9501 mod ___detail {
9502 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Directory
9503 where
9504 ___T: ::fidl_next::Transport,
9505 {
9506 type Client = DirectoryClient<___T>;
9507 type Server = DirectoryServer<___T>;
9508 }
9509
9510 #[repr(transparent)]
9512 pub struct DirectoryClient<___T: ::fidl_next::Transport> {
9513 #[allow(dead_code)]
9514 client: ::fidl_next::protocol::Client<___T>,
9515 }
9516
9517 impl<___T> DirectoryClient<___T>
9518 where
9519 ___T: ::fidl_next::Transport,
9520 {
9521 #[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"]
9522 pub fn advisory_lock(
9523 &self,
9524
9525 request: impl ::fidl_next::Encode<
9526 crate::wire::AdvisoryLockRequest<'static>,
9527 <___T as ::fidl_next::Transport>::SendBuffer,
9528 >,
9529 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
9530 where
9531 <___T as ::fidl_next::Transport>::SendBuffer:
9532 ::fidl_next::encoder::InternalHandleEncoder,
9533 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9534 {
9535 self.advisory_lock_with(crate::generic::AdvisoryLockingAdvisoryLockRequest {
9536 request,
9537 })
9538 }
9539
9540 #[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"]
9541 pub fn advisory_lock_with<___R>(
9542 &self,
9543 request: ___R,
9544 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
9545 where
9546 ___R: ::fidl_next::Encode<
9547 crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
9548 <___T as ::fidl_next::Transport>::SendBuffer,
9549 >,
9550 {
9551 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9552 7992130864415541162,
9553 <super::AdvisoryLock as ::fidl_next::Method>::FLEXIBILITY,
9554 request,
9555 ))
9556 }
9557
9558 pub fn clone(
9559 &self,
9560
9561 request: impl ::fidl_next::Encode<
9562 ::fidl_next::ServerEnd<
9563 ::fdomain_next_fuchsia_unknown::Cloneable,
9564 ::fdomain_client::fidl_next::wire::Handle,
9565 >,
9566 <___T as ::fidl_next::Transport>::SendBuffer,
9567 >,
9568 ) -> ::fidl_next::SendFuture<'_, ___T>
9569 where
9570 <___T as ::fidl_next::Transport>::SendBuffer:
9571 ::fidl_next::encoder::InternalHandleEncoder,
9572 <___T as ::fidl_next::Transport>::SendBuffer:
9573 ::fdomain_client::fidl_next::HandleEncoder,
9574 {
9575 self.clone_with(::fdomain_next_fuchsia_unknown::generic::CloneableCloneRequest {
9576 request,
9577 })
9578 }
9579
9580 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
9581 where
9582 ___R: ::fidl_next::Encode<
9583 ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest,
9584 <___T as ::fidl_next::Transport>::SendBuffer,
9585 >,
9586 {
9587 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
9588 2366825959783828089,
9589 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
9590 request,
9591 ))
9592 }
9593
9594 #[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"]
9595 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
9596 ::fidl_next::TwoWayFuture::from_untyped(
9597 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9598 6540867515453498750,
9599 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
9600 (),
9601 ),
9602 )
9603 }
9604
9605 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
9606 ::fidl_next::TwoWayFuture::from_untyped(
9607 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9608 2763219980499352582,
9609 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
9610 (),
9611 ),
9612 )
9613 }
9614
9615 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
9616 pub fn deprecated_clone(
9617 &self,
9618
9619 flags: impl ::fidl_next::Encode<
9620 crate::wire::OpenFlags,
9621 <___T as ::fidl_next::Transport>::SendBuffer,
9622 >,
9623
9624 object: impl ::fidl_next::Encode<
9625 ::fidl_next::ServerEnd<crate::Node, ::fdomain_client::fidl_next::wire::Handle>,
9626 <___T as ::fidl_next::Transport>::SendBuffer,
9627 >,
9628 ) -> ::fidl_next::SendFuture<'_, ___T>
9629 where
9630 <___T as ::fidl_next::Transport>::SendBuffer:
9631 ::fidl_next::encoder::InternalHandleEncoder,
9632 <___T as ::fidl_next::Transport>::SendBuffer:
9633 ::fdomain_client::fidl_next::HandleEncoder,
9634 {
9635 self.deprecated_clone_with(crate::generic::NodeDeprecatedCloneRequest {
9636 flags,
9637
9638 object,
9639 })
9640 }
9641
9642 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
9643 pub fn deprecated_clone_with<___R>(
9644 &self,
9645 request: ___R,
9646 ) -> ::fidl_next::SendFuture<'_, ___T>
9647 where
9648 ___R: ::fidl_next::Encode<
9649 crate::wire::NodeDeprecatedCloneRequest,
9650 <___T as ::fidl_next::Transport>::SendBuffer,
9651 >,
9652 {
9653 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
9654 6512600400724287855,
9655 <super::DeprecatedClone as ::fidl_next::Method>::FLEXIBILITY,
9656 request,
9657 ))
9658 }
9659
9660 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
9661 pub fn deprecated_get_attr(
9662 &self,
9663 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
9664 ::fidl_next::TwoWayFuture::from_untyped(
9665 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9666 8689798978500614909,
9667 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
9668 (),
9669 ),
9670 )
9671 }
9672
9673 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
9674 pub fn deprecated_set_attr(
9675 &self,
9676
9677 flags: impl ::fidl_next::Encode<
9678 crate::wire::NodeAttributeFlags,
9679 <___T as ::fidl_next::Transport>::SendBuffer,
9680 >,
9681
9682 attributes: impl ::fidl_next::Encode<
9683 crate::wire::NodeAttributes,
9684 <___T as ::fidl_next::Transport>::SendBuffer,
9685 >,
9686 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
9687 where
9688 <___T as ::fidl_next::Transport>::SendBuffer:
9689 ::fidl_next::encoder::InternalHandleEncoder,
9690 {
9691 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
9692 flags,
9693
9694 attributes,
9695 })
9696 }
9697
9698 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
9699 pub fn deprecated_set_attr_with<___R>(
9700 &self,
9701 request: ___R,
9702 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
9703 where
9704 ___R: ::fidl_next::Encode<
9705 crate::wire::NodeDeprecatedSetAttrRequest,
9706 <___T as ::fidl_next::Transport>::SendBuffer,
9707 >,
9708 {
9709 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9710 4721673413776871238,
9711 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
9712 request,
9713 ))
9714 }
9715
9716 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
9717 pub fn deprecated_get_flags(
9718 &self,
9719 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
9720 ::fidl_next::TwoWayFuture::from_untyped(
9721 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9722 6595803110182632097,
9723 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
9724 (),
9725 ),
9726 )
9727 }
9728
9729 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
9730 pub fn deprecated_set_flags(
9731 &self,
9732
9733 flags: impl ::fidl_next::Encode<
9734 crate::wire::OpenFlags,
9735 <___T as ::fidl_next::Transport>::SendBuffer,
9736 >,
9737 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
9738 where
9739 <___T as ::fidl_next::Transport>::SendBuffer:
9740 ::fidl_next::encoder::InternalHandleEncoder,
9741 {
9742 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
9743 flags,
9744 })
9745 }
9746
9747 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
9748 pub fn deprecated_set_flags_with<___R>(
9749 &self,
9750 request: ___R,
9751 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
9752 where
9753 ___R: ::fidl_next::Encode<
9754 crate::wire::NodeDeprecatedSetFlagsRequest,
9755 <___T as ::fidl_next::Transport>::SendBuffer,
9756 >,
9757 {
9758 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9759 5950864159036794675,
9760 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
9761 request,
9762 ))
9763 }
9764
9765 #[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"]
9766 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
9767 ::fidl_next::TwoWayFuture::from_untyped(
9768 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9769 105530239381466147,
9770 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
9771 (),
9772 ),
9773 )
9774 }
9775
9776 #[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"]
9777 pub fn set_flags(
9778 &self,
9779
9780 flags: impl ::fidl_next::Encode<
9781 crate::wire::Flags,
9782 <___T as ::fidl_next::Transport>::SendBuffer,
9783 >,
9784 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
9785 where
9786 <___T as ::fidl_next::Transport>::SendBuffer:
9787 ::fidl_next::encoder::InternalHandleEncoder,
9788 {
9789 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
9790 }
9791
9792 #[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"]
9793 pub fn set_flags_with<___R>(
9794 &self,
9795 request: ___R,
9796 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
9797 where
9798 ___R: ::fidl_next::Encode<
9799 crate::wire::NodeSetFlagsRequest,
9800 <___T as ::fidl_next::Transport>::SendBuffer,
9801 >,
9802 {
9803 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9804 6172186066099445416,
9805 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
9806 request,
9807 ))
9808 }
9809
9810 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
9811 pub fn query_filesystem(
9812 &self,
9813 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
9814 ::fidl_next::TwoWayFuture::from_untyped(
9815 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9816 8013111122914313744,
9817 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
9818 (),
9819 ),
9820 )
9821 }
9822
9823 #[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"]
9824 pub fn get_attributes(
9825 &self,
9826
9827 query: impl ::fidl_next::Encode<
9828 crate::wire::NodeAttributesQuery,
9829 <___T as ::fidl_next::Transport>::SendBuffer,
9830 >,
9831 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
9832 where
9833 <___T as ::fidl_next::Transport>::SendBuffer:
9834 ::fidl_next::encoder::InternalHandleEncoder,
9835 {
9836 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
9837 }
9838
9839 #[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"]
9840 pub fn get_attributes_with<___R>(
9841 &self,
9842 request: ___R,
9843 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
9844 where
9845 ___R: ::fidl_next::Encode<
9846 crate::wire::NodeGetAttributesRequest,
9847 <___T as ::fidl_next::Transport>::SendBuffer,
9848 >,
9849 {
9850 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9851 4414537700416816443,
9852 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
9853 request,
9854 ))
9855 }
9856
9857 #[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"]
9858 pub fn update_attributes_with<___R>(
9859 &self,
9860 request: ___R,
9861 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
9862 where
9863 ___R: ::fidl_next::Encode<
9864 crate::wire::MutableNodeAttributes<'static>,
9865 <___T as ::fidl_next::Transport>::SendBuffer,
9866 >,
9867 {
9868 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9869 3677402239314018056,
9870 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
9871 request,
9872 ))
9873 }
9874
9875 #[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"]
9876 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
9877 ::fidl_next::TwoWayFuture::from_untyped(
9878 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9879 3196473584242777161,
9880 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
9881 (),
9882 ),
9883 )
9884 }
9885
9886 #[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"]
9887 pub fn list_extended_attributes(
9888 &self,
9889
9890 iterator: impl ::fidl_next::Encode<
9891 ::fidl_next::ServerEnd<
9892 crate::ExtendedAttributeIterator,
9893 ::fdomain_client::fidl_next::wire::Handle,
9894 >,
9895 <___T as ::fidl_next::Transport>::SendBuffer,
9896 >,
9897 ) -> ::fidl_next::SendFuture<'_, ___T>
9898 where
9899 <___T as ::fidl_next::Transport>::SendBuffer:
9900 ::fidl_next::encoder::InternalHandleEncoder,
9901 <___T as ::fidl_next::Transport>::SendBuffer:
9902 ::fdomain_client::fidl_next::HandleEncoder,
9903 {
9904 self.list_extended_attributes_with(
9905 crate::generic::NodeListExtendedAttributesRequest { iterator },
9906 )
9907 }
9908
9909 #[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"]
9910 pub fn list_extended_attributes_with<___R>(
9911 &self,
9912 request: ___R,
9913 ) -> ::fidl_next::SendFuture<'_, ___T>
9914 where
9915 ___R: ::fidl_next::Encode<
9916 crate::wire::NodeListExtendedAttributesRequest,
9917 <___T as ::fidl_next::Transport>::SendBuffer,
9918 >,
9919 {
9920 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
9921 5431626189872037072,
9922 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
9923 request,
9924 ))
9925 }
9926
9927 #[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"]
9928 pub fn get_extended_attribute(
9929 &self,
9930
9931 name: impl ::fidl_next::Encode<
9932 ::fidl_next::wire::Vector<'static, u8>,
9933 <___T as ::fidl_next::Transport>::SendBuffer,
9934 >,
9935 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
9936 where
9937 <___T as ::fidl_next::Transport>::SendBuffer:
9938 ::fidl_next::encoder::InternalHandleEncoder,
9939 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9940 {
9941 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
9942 name,
9943 })
9944 }
9945
9946 #[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"]
9947 pub fn get_extended_attribute_with<___R>(
9948 &self,
9949 request: ___R,
9950 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
9951 where
9952 ___R: ::fidl_next::Encode<
9953 crate::wire::NodeGetExtendedAttributeRequest<'static>,
9954 <___T as ::fidl_next::Transport>::SendBuffer,
9955 >,
9956 {
9957 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9958 5043930208506967771,
9959 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
9960 request,
9961 ))
9962 }
9963
9964 #[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"]
9965 pub fn set_extended_attribute(
9966 &self,
9967
9968 name: impl ::fidl_next::Encode<
9969 ::fidl_next::wire::Vector<'static, u8>,
9970 <___T as ::fidl_next::Transport>::SendBuffer,
9971 >,
9972
9973 value: impl ::fidl_next::Encode<
9974 crate::wire::ExtendedAttributeValue<'static>,
9975 <___T as ::fidl_next::Transport>::SendBuffer,
9976 >,
9977
9978 mode: impl ::fidl_next::Encode<
9979 crate::wire::SetExtendedAttributeMode,
9980 <___T as ::fidl_next::Transport>::SendBuffer,
9981 >,
9982 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
9983 where
9984 <___T as ::fidl_next::Transport>::SendBuffer:
9985 ::fidl_next::encoder::InternalHandleEncoder,
9986 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9987 <___T as ::fidl_next::Transport>::SendBuffer:
9988 ::fdomain_client::fidl_next::HandleEncoder,
9989 {
9990 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
9991 name,
9992
9993 value,
9994
9995 mode,
9996 })
9997 }
9998
9999 #[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"]
10000 pub fn set_extended_attribute_with<___R>(
10001 &self,
10002 request: ___R,
10003 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
10004 where
10005 ___R: ::fidl_next::Encode<
10006 crate::wire::NodeSetExtendedAttributeRequest<'static>,
10007 <___T as ::fidl_next::Transport>::SendBuffer,
10008 >,
10009 {
10010 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10011 5374223046099989052,
10012 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
10013 request,
10014 ))
10015 }
10016
10017 #[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"]
10018 pub fn remove_extended_attribute(
10019 &self,
10020
10021 name: impl ::fidl_next::Encode<
10022 ::fidl_next::wire::Vector<'static, u8>,
10023 <___T as ::fidl_next::Transport>::SendBuffer,
10024 >,
10025 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
10026 where
10027 <___T as ::fidl_next::Transport>::SendBuffer:
10028 ::fidl_next::encoder::InternalHandleEncoder,
10029 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10030 {
10031 self.remove_extended_attribute_with(
10032 crate::generic::NodeRemoveExtendedAttributeRequest { name },
10033 )
10034 }
10035
10036 #[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"]
10037 pub fn remove_extended_attribute_with<___R>(
10038 &self,
10039 request: ___R,
10040 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
10041 where
10042 ___R: ::fidl_next::Encode<
10043 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
10044 <___T as ::fidl_next::Transport>::SendBuffer,
10045 >,
10046 {
10047 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10048 8794297771444732717,
10049 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
10050 request,
10051 ))
10052 }
10053
10054 #[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"]
10055 pub fn open(
10056 &self,
10057
10058 path: impl ::fidl_next::Encode<
10059 ::fidl_next::wire::String<'static>,
10060 <___T as ::fidl_next::Transport>::SendBuffer,
10061 >,
10062
10063 flags: impl ::fidl_next::Encode<
10064 crate::wire::Flags,
10065 <___T as ::fidl_next::Transport>::SendBuffer,
10066 >,
10067
10068 options: impl ::fidl_next::Encode<
10069 crate::wire::Options<'static>,
10070 <___T as ::fidl_next::Transport>::SendBuffer,
10071 >,
10072
10073 object: impl ::fidl_next::Encode<
10074 ::fdomain_client::fidl_next::wire::Handle,
10075 <___T as ::fidl_next::Transport>::SendBuffer,
10076 >,
10077 ) -> ::fidl_next::SendFuture<'_, ___T>
10078 where
10079 <___T as ::fidl_next::Transport>::SendBuffer:
10080 ::fidl_next::encoder::InternalHandleEncoder,
10081 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10082 <___T as ::fidl_next::Transport>::SendBuffer:
10083 ::fdomain_client::fidl_next::HandleEncoder,
10084 {
10085 self.open_with(crate::generic::OpenableOpenRequest { path, flags, options, object })
10086 }
10087
10088 #[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"]
10089 pub fn open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
10090 where
10091 ___R: ::fidl_next::Encode<
10092 crate::wire::OpenableOpenRequest<'static>,
10093 <___T as ::fidl_next::Transport>::SendBuffer,
10094 >,
10095 {
10096 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
10097 6236883748953765593,
10098 <super::Open as ::fidl_next::Method>::FLEXIBILITY,
10099 request,
10100 ))
10101 }
10102
10103 #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
10104 pub fn deprecated_open(
10105 &self,
10106
10107 flags: impl ::fidl_next::Encode<
10108 crate::wire::OpenFlags,
10109 <___T as ::fidl_next::Transport>::SendBuffer,
10110 >,
10111
10112 mode: impl ::fidl_next::Encode<
10113 crate::wire::ModeType,
10114 <___T as ::fidl_next::Transport>::SendBuffer,
10115 >,
10116
10117 path: impl ::fidl_next::Encode<
10118 ::fidl_next::wire::String<'static>,
10119 <___T as ::fidl_next::Transport>::SendBuffer,
10120 >,
10121
10122 object: impl ::fidl_next::Encode<
10123 ::fidl_next::ServerEnd<crate::Node, ::fdomain_client::fidl_next::wire::Handle>,
10124 <___T as ::fidl_next::Transport>::SendBuffer,
10125 >,
10126 ) -> ::fidl_next::SendFuture<'_, ___T>
10127 where
10128 <___T as ::fidl_next::Transport>::SendBuffer:
10129 ::fidl_next::encoder::InternalHandleEncoder,
10130 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10131 <___T as ::fidl_next::Transport>::SendBuffer:
10132 ::fdomain_client::fidl_next::HandleEncoder,
10133 {
10134 self.deprecated_open_with(crate::generic::DirectoryDeprecatedOpenRequest {
10135 flags,
10136
10137 mode,
10138
10139 path,
10140
10141 object,
10142 })
10143 }
10144
10145 #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
10146 pub fn deprecated_open_with<___R>(
10147 &self,
10148 request: ___R,
10149 ) -> ::fidl_next::SendFuture<'_, ___T>
10150 where
10151 ___R: ::fidl_next::Encode<
10152 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
10153 <___T as ::fidl_next::Transport>::SendBuffer,
10154 >,
10155 {
10156 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
10157 3193127272456937152,
10158 <super::DeprecatedOpen as ::fidl_next::Method>::FLEXIBILITY,
10159 request,
10160 ))
10161 }
10162
10163 #[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"]
10164 pub fn read_dirents(
10165 &self,
10166
10167 max_bytes: impl ::fidl_next::Encode<
10168 ::fidl_next::wire::Uint64,
10169 <___T as ::fidl_next::Transport>::SendBuffer,
10170 >,
10171 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadDirents, ___T>
10172 where
10173 <___T as ::fidl_next::Transport>::SendBuffer:
10174 ::fidl_next::encoder::InternalHandleEncoder,
10175 {
10176 self.read_dirents_with(crate::generic::DirectoryReadDirentsRequest { max_bytes })
10177 }
10178
10179 #[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"]
10180 pub fn read_dirents_with<___R>(
10181 &self,
10182 request: ___R,
10183 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadDirents, ___T>
10184 where
10185 ___R: ::fidl_next::Encode<
10186 crate::wire::DirectoryReadDirentsRequest,
10187 <___T as ::fidl_next::Transport>::SendBuffer,
10188 >,
10189 {
10190 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10191 3855785432100874762,
10192 <super::ReadDirents as ::fidl_next::Method>::FLEXIBILITY,
10193 request,
10194 ))
10195 }
10196
10197 #[doc = " Resets the directory seek offset.\n\n This method does not require any rights, similar to ReadDirents.\n"]
10198 pub fn rewind(&self) -> ::fidl_next::TwoWayFuture<'_, super::Rewind, ___T> {
10199 ::fidl_next::TwoWayFuture::from_untyped(
10200 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10201 1635123508515392625,
10202 <super::Rewind as ::fidl_next::Method>::FLEXIBILITY,
10203 (),
10204 ),
10205 )
10206 }
10207
10208 #[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"]
10209 pub fn get_token(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetToken, ___T> {
10210 ::fidl_next::TwoWayFuture::from_untyped(
10211 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10212 2787337947777369685,
10213 <super::GetToken as ::fidl_next::Method>::FLEXIBILITY,
10214 (),
10215 ),
10216 )
10217 }
10218
10219 #[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"]
10220 pub fn link(
10221 &self,
10222
10223 src: impl ::fidl_next::Encode<
10224 ::fidl_next::wire::String<'static>,
10225 <___T as ::fidl_next::Transport>::SendBuffer,
10226 >,
10227
10228 dst_parent_token: impl ::fidl_next::Encode<
10229 ::fdomain_client::fidl_next::wire::Handle,
10230 <___T as ::fidl_next::Transport>::SendBuffer,
10231 >,
10232
10233 dst: impl ::fidl_next::Encode<
10234 ::fidl_next::wire::String<'static>,
10235 <___T as ::fidl_next::Transport>::SendBuffer,
10236 >,
10237 ) -> ::fidl_next::TwoWayFuture<'_, super::Link, ___T>
10238 where
10239 <___T as ::fidl_next::Transport>::SendBuffer:
10240 ::fidl_next::encoder::InternalHandleEncoder,
10241 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10242 <___T as ::fidl_next::Transport>::SendBuffer:
10243 ::fdomain_client::fidl_next::HandleEncoder,
10244 {
10245 self.link_with(crate::generic::DirectoryLinkRequest { src, dst_parent_token, dst })
10246 }
10247
10248 #[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"]
10249 pub fn link_with<___R>(
10250 &self,
10251 request: ___R,
10252 ) -> ::fidl_next::TwoWayFuture<'_, super::Link, ___T>
10253 where
10254 ___R: ::fidl_next::Encode<
10255 crate::wire::DirectoryLinkRequest<'static>,
10256 <___T as ::fidl_next::Transport>::SendBuffer,
10257 >,
10258 {
10259 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10260 8360374984291987687,
10261 <super::Link as ::fidl_next::Method>::FLEXIBILITY,
10262 request,
10263 ))
10264 }
10265
10266 #[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"]
10267 pub fn unlink(
10268 &self,
10269
10270 name: impl ::fidl_next::Encode<
10271 ::fidl_next::wire::String<'static>,
10272 <___T as ::fidl_next::Transport>::SendBuffer,
10273 >,
10274
10275 options: impl ::fidl_next::Encode<
10276 crate::wire::UnlinkOptions<'static>,
10277 <___T as ::fidl_next::Transport>::SendBuffer,
10278 >,
10279 ) -> ::fidl_next::TwoWayFuture<'_, super::Unlink, ___T>
10280 where
10281 <___T as ::fidl_next::Transport>::SendBuffer:
10282 ::fidl_next::encoder::InternalHandleEncoder,
10283 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10284 {
10285 self.unlink_with(crate::generic::DirectoryUnlinkRequest { name, options })
10286 }
10287
10288 #[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"]
10289 pub fn unlink_with<___R>(
10290 &self,
10291 request: ___R,
10292 ) -> ::fidl_next::TwoWayFuture<'_, super::Unlink, ___T>
10293 where
10294 ___R: ::fidl_next::Encode<
10295 crate::wire::DirectoryUnlinkRequest<'static>,
10296 <___T as ::fidl_next::Transport>::SendBuffer,
10297 >,
10298 {
10299 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10300 8433556716759383021,
10301 <super::Unlink as ::fidl_next::Method>::FLEXIBILITY,
10302 request,
10303 ))
10304 }
10305
10306 #[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"]
10307 pub fn rename(
10308 &self,
10309
10310 src: impl ::fidl_next::Encode<
10311 ::fidl_next::wire::String<'static>,
10312 <___T as ::fidl_next::Transport>::SendBuffer,
10313 >,
10314
10315 dst_parent_token: impl ::fidl_next::Encode<
10316 ::fdomain_client::fidl_next::wire::Handle,
10317 <___T as ::fidl_next::Transport>::SendBuffer,
10318 >,
10319
10320 dst: impl ::fidl_next::Encode<
10321 ::fidl_next::wire::String<'static>,
10322 <___T as ::fidl_next::Transport>::SendBuffer,
10323 >,
10324 ) -> ::fidl_next::TwoWayFuture<'_, super::Rename, ___T>
10325 where
10326 <___T as ::fidl_next::Transport>::SendBuffer:
10327 ::fidl_next::encoder::InternalHandleEncoder,
10328 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10329 <___T as ::fidl_next::Transport>::SendBuffer:
10330 ::fdomain_client::fidl_next::HandleEncoder,
10331 {
10332 self.rename_with(crate::generic::DirectoryRenameRequest {
10333 src,
10334
10335 dst_parent_token,
10336
10337 dst,
10338 })
10339 }
10340
10341 #[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"]
10342 pub fn rename_with<___R>(
10343 &self,
10344 request: ___R,
10345 ) -> ::fidl_next::TwoWayFuture<'_, super::Rename, ___T>
10346 where
10347 ___R: ::fidl_next::Encode<
10348 crate::wire::DirectoryRenameRequest<'static>,
10349 <___T as ::fidl_next::Transport>::SendBuffer,
10350 >,
10351 {
10352 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10353 8097726607824333022,
10354 <super::Rename as ::fidl_next::Method>::FLEXIBILITY,
10355 request,
10356 ))
10357 }
10358
10359 #[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"]
10360 pub fn create_symlink(
10361 &self,
10362
10363 name: impl ::fidl_next::Encode<
10364 ::fidl_next::wire::String<'static>,
10365 <___T as ::fidl_next::Transport>::SendBuffer,
10366 >,
10367
10368 target: impl ::fidl_next::Encode<
10369 ::fidl_next::wire::Vector<'static, u8>,
10370 <___T as ::fidl_next::Transport>::SendBuffer,
10371 >,
10372
10373 connection: impl ::fidl_next::Encode<
10374 ::fidl_next::ServerEnd<
10375 crate::Symlink,
10376 ::fdomain_client::fidl_next::wire::OptionalHandle,
10377 >,
10378 <___T as ::fidl_next::Transport>::SendBuffer,
10379 >,
10380 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateSymlink, ___T>
10381 where
10382 <___T as ::fidl_next::Transport>::SendBuffer:
10383 ::fidl_next::encoder::InternalHandleEncoder,
10384 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10385 <___T as ::fidl_next::Transport>::SendBuffer:
10386 ::fdomain_client::fidl_next::HandleEncoder,
10387 {
10388 self.create_symlink_with(crate::generic::DirectoryCreateSymlinkRequest {
10389 name,
10390
10391 target,
10392
10393 connection,
10394 })
10395 }
10396
10397 #[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"]
10398 pub fn create_symlink_with<___R>(
10399 &self,
10400 request: ___R,
10401 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateSymlink, ___T>
10402 where
10403 ___R: ::fidl_next::Encode<
10404 crate::wire::DirectoryCreateSymlinkRequest<'static>,
10405 <___T as ::fidl_next::Transport>::SendBuffer,
10406 >,
10407 {
10408 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10409 2435901052462315657,
10410 <super::CreateSymlink as ::fidl_next::Method>::FLEXIBILITY,
10411 request,
10412 ))
10413 }
10414
10415 #[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"]
10416 pub fn watch(
10417 &self,
10418
10419 mask: impl ::fidl_next::Encode<
10420 crate::wire::WatchMask,
10421 <___T as ::fidl_next::Transport>::SendBuffer,
10422 >,
10423
10424 options: impl ::fidl_next::Encode<
10425 ::fidl_next::wire::Uint32,
10426 <___T as ::fidl_next::Transport>::SendBuffer,
10427 >,
10428
10429 watcher: impl ::fidl_next::Encode<
10430 ::fidl_next::ServerEnd<
10431 crate::DirectoryWatcher,
10432 ::fdomain_client::fidl_next::wire::Handle,
10433 >,
10434 <___T as ::fidl_next::Transport>::SendBuffer,
10435 >,
10436 ) -> ::fidl_next::TwoWayFuture<'_, super::Watch, ___T>
10437 where
10438 <___T as ::fidl_next::Transport>::SendBuffer:
10439 ::fidl_next::encoder::InternalHandleEncoder,
10440 <___T as ::fidl_next::Transport>::SendBuffer:
10441 ::fdomain_client::fidl_next::HandleEncoder,
10442 {
10443 self.watch_with(crate::generic::DirectoryWatchRequest { mask, options, watcher })
10444 }
10445
10446 #[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"]
10447 pub fn watch_with<___R>(
10448 &self,
10449 request: ___R,
10450 ) -> ::fidl_next::TwoWayFuture<'_, super::Watch, ___T>
10451 where
10452 ___R: ::fidl_next::Encode<
10453 crate::wire::DirectoryWatchRequest,
10454 <___T as ::fidl_next::Transport>::SendBuffer,
10455 >,
10456 {
10457 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10458 6275512344170098065,
10459 <super::Watch as ::fidl_next::Method>::FLEXIBILITY,
10460 request,
10461 ))
10462 }
10463 }
10464
10465 #[repr(transparent)]
10467 pub struct DirectoryServer<___T: ::fidl_next::Transport> {
10468 server: ::fidl_next::protocol::Server<___T>,
10469 }
10470
10471 impl<___T> DirectoryServer<___T>
10472 where
10473 ___T: ::fidl_next::Transport,
10474 {
10475 #[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"]
10476 pub fn on_open(
10477 &self,
10478
10479 s: impl ::fidl_next::Encode<
10480 ::fidl_next::wire::Int32,
10481 <___T as ::fidl_next::Transport>::SendBuffer,
10482 >,
10483
10484 info: impl ::fidl_next::Encode<
10485 crate::wire_optional::NodeInfoDeprecated<'static>,
10486 <___T as ::fidl_next::Transport>::SendBuffer,
10487 >,
10488 ) -> ::fidl_next::SendFuture<'_, ___T>
10489 where
10490 <___T as ::fidl_next::Transport>::SendBuffer:
10491 ::fidl_next::encoder::InternalHandleEncoder,
10492 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10493 <___T as ::fidl_next::Transport>::SendBuffer:
10494 ::fdomain_client::fidl_next::HandleEncoder,
10495 {
10496 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
10497 }
10498
10499 #[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"]
10500
10501 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
10502 where
10503 ___R: ::fidl_next::Encode<
10504 <super::OnOpen as ::fidl_next::Method>::Request,
10505 <___T as ::fidl_next::Transport>::SendBuffer,
10506 >,
10507 {
10508 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
10509 9207534335756671346,
10510 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
10511 request,
10512 ))
10513 }
10514
10515 #[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"]
10516
10517 pub fn on_representation_with<___R>(
10518 &self,
10519 request: ___R,
10520 ) -> ::fidl_next::SendFuture<'_, ___T>
10521 where
10522 ___R: ::fidl_next::Encode<
10523 <super::OnRepresentation as ::fidl_next::Method>::Request,
10524 <___T as ::fidl_next::Transport>::SendBuffer,
10525 >,
10526 {
10527 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
10528 6679970090861613324,
10529 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
10530 request,
10531 ))
10532 }
10533 }
10534 }
10535}
10536
10537#[diagnostic::on_unimplemented(
10538 note = "If {Self} implements the non-local DirectoryClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
10539)]
10540
10541pub trait DirectoryLocalClientHandler<
10545 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
10546 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10547>
10548{
10549 #[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"]
10550 fn on_open(
10551 &mut self,
10552
10553 request: ::fidl_next::Request<directory::OnOpen, ___T>,
10554 ) -> impl ::core::future::Future<Output = ()>;
10555
10556 #[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"]
10557 fn on_representation(
10558 &mut self,
10559
10560 request: ::fidl_next::Request<directory::OnRepresentation, ___T>,
10561 ) -> impl ::core::future::Future<Output = ()>;
10562
10563 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
10564 ::core::future::ready(())
10565 }
10566}
10567
10568impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Directory
10569where
10570 ___H: DirectoryLocalClientHandler<___T>,
10571 ___T: ::fidl_next::Transport,
10572 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
10573 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10574 Constraint = (),
10575 >,
10576 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
10577 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10578 Constraint = (),
10579 >,
10580{
10581 async fn on_event(
10582 handler: &mut ___H,
10583 ordinal: u64,
10584 flexibility: ::fidl_next::protocol::Flexibility,
10585 body: ::fidl_next::Body<___T>,
10586 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10587 match ordinal {
10588 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
10589 Ok(decoded) => {
10590 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
10591 Ok(())
10592 }
10593 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10594 ordinal: 9207534335756671346,
10595 error,
10596 }),
10597 },
10598
10599 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
10600 Ok(decoded) => {
10601 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
10602 Ok(())
10603 }
10604 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10605 ordinal: 6679970090861613324,
10606 error,
10607 }),
10608 },
10609
10610 ordinal => {
10611 handler.on_unknown_interaction(ordinal).await;
10612 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10613 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10614 } else {
10615 Ok(())
10616 }
10617 }
10618 }
10619 }
10620}
10621
10622#[diagnostic::on_unimplemented(
10623 note = "If {Self} implements the non-local DirectoryServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
10624)]
10625
10626pub trait DirectoryLocalServerHandler<
10630 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
10631 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10632>
10633{
10634 #[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"]
10635 fn advisory_lock(
10636 &mut self,
10637
10638 request: ::fidl_next::Request<directory::AdvisoryLock, ___T>,
10639
10640 responder: ::fidl_next::Responder<directory::AdvisoryLock, ___T>,
10641 ) -> impl ::core::future::Future<Output = ()>;
10642
10643 fn clone(
10644 &mut self,
10645
10646 request: ::fidl_next::Request<directory::Clone, ___T>,
10647 ) -> impl ::core::future::Future<Output = ()>;
10648
10649 #[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"]
10650 fn close(
10651 &mut self,
10652
10653 responder: ::fidl_next::Responder<directory::Close, ___T>,
10654 ) -> impl ::core::future::Future<Output = ()>;
10655
10656 fn query(
10657 &mut self,
10658
10659 responder: ::fidl_next::Responder<directory::Query, ___T>,
10660 ) -> impl ::core::future::Future<Output = ()>;
10661
10662 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
10663 fn deprecated_clone(
10664 &mut self,
10665
10666 request: ::fidl_next::Request<directory::DeprecatedClone, ___T>,
10667 ) -> impl ::core::future::Future<Output = ()>;
10668
10669 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
10670 fn deprecated_get_attr(
10671 &mut self,
10672
10673 responder: ::fidl_next::Responder<directory::DeprecatedGetAttr, ___T>,
10674 ) -> impl ::core::future::Future<Output = ()>;
10675
10676 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
10677 fn deprecated_set_attr(
10678 &mut self,
10679
10680 request: ::fidl_next::Request<directory::DeprecatedSetAttr, ___T>,
10681
10682 responder: ::fidl_next::Responder<directory::DeprecatedSetAttr, ___T>,
10683 ) -> impl ::core::future::Future<Output = ()>;
10684
10685 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
10686 fn deprecated_get_flags(
10687 &mut self,
10688
10689 responder: ::fidl_next::Responder<directory::DeprecatedGetFlags, ___T>,
10690 ) -> impl ::core::future::Future<Output = ()>;
10691
10692 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
10693 fn deprecated_set_flags(
10694 &mut self,
10695
10696 request: ::fidl_next::Request<directory::DeprecatedSetFlags, ___T>,
10697
10698 responder: ::fidl_next::Responder<directory::DeprecatedSetFlags, ___T>,
10699 ) -> impl ::core::future::Future<Output = ()>;
10700
10701 #[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"]
10702 fn get_flags(
10703 &mut self,
10704
10705 responder: ::fidl_next::Responder<directory::GetFlags, ___T>,
10706 ) -> impl ::core::future::Future<Output = ()>;
10707
10708 #[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"]
10709 fn set_flags(
10710 &mut self,
10711
10712 request: ::fidl_next::Request<directory::SetFlags, ___T>,
10713
10714 responder: ::fidl_next::Responder<directory::SetFlags, ___T>,
10715 ) -> impl ::core::future::Future<Output = ()>;
10716
10717 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
10718 fn query_filesystem(
10719 &mut self,
10720
10721 responder: ::fidl_next::Responder<directory::QueryFilesystem, ___T>,
10722 ) -> impl ::core::future::Future<Output = ()>;
10723
10724 #[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"]
10725 fn get_attributes(
10726 &mut self,
10727
10728 request: ::fidl_next::Request<directory::GetAttributes, ___T>,
10729
10730 responder: ::fidl_next::Responder<directory::GetAttributes, ___T>,
10731 ) -> impl ::core::future::Future<Output = ()>;
10732
10733 #[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"]
10734 fn update_attributes(
10735 &mut self,
10736
10737 request: ::fidl_next::Request<directory::UpdateAttributes, ___T>,
10738
10739 responder: ::fidl_next::Responder<directory::UpdateAttributes, ___T>,
10740 ) -> impl ::core::future::Future<Output = ()>;
10741
10742 #[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"]
10743 fn sync(
10744 &mut self,
10745
10746 responder: ::fidl_next::Responder<directory::Sync, ___T>,
10747 ) -> impl ::core::future::Future<Output = ()>;
10748
10749 #[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"]
10750 fn list_extended_attributes(
10751 &mut self,
10752
10753 request: ::fidl_next::Request<directory::ListExtendedAttributes, ___T>,
10754 ) -> impl ::core::future::Future<Output = ()>;
10755
10756 #[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"]
10757 fn get_extended_attribute(
10758 &mut self,
10759
10760 request: ::fidl_next::Request<directory::GetExtendedAttribute, ___T>,
10761
10762 responder: ::fidl_next::Responder<directory::GetExtendedAttribute, ___T>,
10763 ) -> impl ::core::future::Future<Output = ()>;
10764
10765 #[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"]
10766 fn set_extended_attribute(
10767 &mut self,
10768
10769 request: ::fidl_next::Request<directory::SetExtendedAttribute, ___T>,
10770
10771 responder: ::fidl_next::Responder<directory::SetExtendedAttribute, ___T>,
10772 ) -> impl ::core::future::Future<Output = ()>;
10773
10774 #[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"]
10775 fn remove_extended_attribute(
10776 &mut self,
10777
10778 request: ::fidl_next::Request<directory::RemoveExtendedAttribute, ___T>,
10779
10780 responder: ::fidl_next::Responder<directory::RemoveExtendedAttribute, ___T>,
10781 ) -> impl ::core::future::Future<Output = ()>;
10782
10783 #[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"]
10784 fn open(
10785 &mut self,
10786
10787 request: ::fidl_next::Request<directory::Open, ___T>,
10788 ) -> impl ::core::future::Future<Output = ()>;
10789
10790 #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
10791 fn deprecated_open(
10792 &mut self,
10793
10794 request: ::fidl_next::Request<directory::DeprecatedOpen, ___T>,
10795 ) -> impl ::core::future::Future<Output = ()>;
10796
10797 #[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"]
10798 fn read_dirents(
10799 &mut self,
10800
10801 request: ::fidl_next::Request<directory::ReadDirents, ___T>,
10802
10803 responder: ::fidl_next::Responder<directory::ReadDirents, ___T>,
10804 ) -> impl ::core::future::Future<Output = ()>;
10805
10806 #[doc = " Resets the directory seek offset.\n\n This method does not require any rights, similar to ReadDirents.\n"]
10807 fn rewind(
10808 &mut self,
10809
10810 responder: ::fidl_next::Responder<directory::Rewind, ___T>,
10811 ) -> impl ::core::future::Future<Output = ()>;
10812
10813 #[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"]
10814 fn get_token(
10815 &mut self,
10816
10817 responder: ::fidl_next::Responder<directory::GetToken, ___T>,
10818 ) -> impl ::core::future::Future<Output = ()>;
10819
10820 #[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"]
10821 fn link(
10822 &mut self,
10823
10824 request: ::fidl_next::Request<directory::Link, ___T>,
10825
10826 responder: ::fidl_next::Responder<directory::Link, ___T>,
10827 ) -> impl ::core::future::Future<Output = ()>;
10828
10829 #[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"]
10830 fn unlink(
10831 &mut self,
10832
10833 request: ::fidl_next::Request<directory::Unlink, ___T>,
10834
10835 responder: ::fidl_next::Responder<directory::Unlink, ___T>,
10836 ) -> impl ::core::future::Future<Output = ()>;
10837
10838 #[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"]
10839 fn rename(
10840 &mut self,
10841
10842 request: ::fidl_next::Request<directory::Rename, ___T>,
10843
10844 responder: ::fidl_next::Responder<directory::Rename, ___T>,
10845 ) -> impl ::core::future::Future<Output = ()>;
10846
10847 #[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"]
10848 fn create_symlink(
10849 &mut self,
10850
10851 request: ::fidl_next::Request<directory::CreateSymlink, ___T>,
10852
10853 responder: ::fidl_next::Responder<directory::CreateSymlink, ___T>,
10854 ) -> impl ::core::future::Future<Output = ()>;
10855
10856 #[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"]
10857 fn watch(
10858 &mut self,
10859
10860 request: ::fidl_next::Request<directory::Watch, ___T>,
10861
10862 responder: ::fidl_next::Responder<directory::Watch, ___T>,
10863 ) -> impl ::core::future::Future<Output = ()>;
10864
10865 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
10866 ::core::future::ready(())
10867 }
10868}
10869
10870impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Directory
10871where
10872 ___H: DirectoryLocalServerHandler<___T>,
10873 ___T: ::fidl_next::Transport,
10874 for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
10875 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10876 Constraint = (),
10877 >,
10878 for<'de> ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
10879 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10880 Constraint = (),
10881 >,
10882 for<'de> crate::wire::NodeDeprecatedCloneRequest: ::fidl_next::Decode<
10883 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10884 Constraint = (),
10885 >,
10886 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
10887 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10888 Constraint = (),
10889 >,
10890 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
10891 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10892 Constraint = (),
10893 >,
10894 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
10895 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10896 Constraint = (),
10897 >,
10898 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
10899 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10900 Constraint = (),
10901 >,
10902 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
10903 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10904 Constraint = (),
10905 >,
10906 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
10907 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10908 Constraint = (),
10909 >,
10910 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
10911 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10912 Constraint = (),
10913 >,
10914 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
10915 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10916 Constraint = (),
10917 >,
10918 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
10919 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10920 Constraint = (),
10921 >,
10922 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
10923 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10924 Constraint = (),
10925 >,
10926 for<'de> crate::wire::DirectoryDeprecatedOpenRequest<'de>: ::fidl_next::Decode<
10927 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10928 Constraint = (),
10929 >,
10930 for<'de> crate::wire::DirectoryReadDirentsRequest: ::fidl_next::Decode<
10931 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10932 Constraint = (),
10933 >,
10934 for<'de> crate::wire::DirectoryLinkRequest<'de>: ::fidl_next::Decode<
10935 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10936 Constraint = (),
10937 >,
10938 for<'de> crate::wire::DirectoryUnlinkRequest<'de>: ::fidl_next::Decode<
10939 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10940 Constraint = (),
10941 >,
10942 for<'de> crate::wire::DirectoryRenameRequest<'de>: ::fidl_next::Decode<
10943 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10944 Constraint = (),
10945 >,
10946 for<'de> crate::wire::DirectoryCreateSymlinkRequest<'de>: ::fidl_next::Decode<
10947 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10948 Constraint = (),
10949 >,
10950 for<'de> crate::wire::DirectoryWatchRequest: ::fidl_next::Decode<
10951 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10952 Constraint = (),
10953 >,
10954{
10955 async fn on_one_way(
10956 handler: &mut ___H,
10957 ordinal: u64,
10958 flexibility: ::fidl_next::protocol::Flexibility,
10959 body: ::fidl_next::Body<___T>,
10960 ) -> ::core::result::Result<
10961 (),
10962 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10963 > {
10964 match ordinal {
10965 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
10966 Ok(decoded) => {
10967 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
10968 Ok(())
10969 }
10970 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10971 ordinal: 2366825959783828089,
10972 error,
10973 }),
10974 },
10975
10976 6512600400724287855 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
10977 Ok(decoded) => {
10978 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
10979 Ok(())
10980 }
10981 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10982 ordinal: 6512600400724287855,
10983 error,
10984 }),
10985 },
10986
10987 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
10988 Ok(decoded) => {
10989 handler
10990 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
10991 .await;
10992 Ok(())
10993 }
10994 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10995 ordinal: 5431626189872037072,
10996 error,
10997 }),
10998 },
10999
11000 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
11001 Ok(decoded) => {
11002 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
11003 Ok(())
11004 }
11005 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11006 ordinal: 6236883748953765593,
11007 error,
11008 }),
11009 },
11010
11011 3193127272456937152 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
11012 Ok(decoded) => {
11013 handler.deprecated_open(::fidl_next::Request::from_decoded(decoded)).await;
11014 Ok(())
11015 }
11016 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11017 ordinal: 3193127272456937152,
11018 error,
11019 }),
11020 },
11021
11022 ordinal => {
11023 handler.on_unknown_interaction(ordinal).await;
11024 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11025 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11026 } else {
11027 Ok(())
11028 }
11029 }
11030 }
11031 }
11032
11033 async fn on_two_way(
11034 handler: &mut ___H,
11035 ordinal: u64,
11036 flexibility: ::fidl_next::protocol::Flexibility,
11037 body: ::fidl_next::Body<___T>,
11038 responder: ::fidl_next::protocol::Responder<___T>,
11039 ) -> ::core::result::Result<
11040 (),
11041 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11042 > {
11043 match ordinal {
11044 7992130864415541162 => {
11045 let responder = ::fidl_next::Responder::from_untyped(responder);
11046
11047 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11048 Ok(decoded) => {
11049 handler
11050 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
11051 .await;
11052 Ok(())
11053 }
11054 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11055 ordinal: 7992130864415541162,
11056 error,
11057 }),
11058 }
11059 }
11060
11061 6540867515453498750 => {
11062 let responder = ::fidl_next::Responder::from_untyped(responder);
11063
11064 handler.close(responder).await;
11065 Ok(())
11066 }
11067
11068 2763219980499352582 => {
11069 let responder = ::fidl_next::Responder::from_untyped(responder);
11070
11071 handler.query(responder).await;
11072 Ok(())
11073 }
11074
11075 8689798978500614909 => {
11076 let responder = ::fidl_next::Responder::from_untyped(responder);
11077
11078 handler.deprecated_get_attr(responder).await;
11079 Ok(())
11080 }
11081
11082 4721673413776871238 => {
11083 let responder = ::fidl_next::Responder::from_untyped(responder);
11084
11085 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11086 Ok(decoded) => {
11087 handler
11088 .deprecated_set_attr(
11089 ::fidl_next::Request::from_decoded(decoded),
11090 responder,
11091 )
11092 .await;
11093 Ok(())
11094 }
11095 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11096 ordinal: 4721673413776871238,
11097 error,
11098 }),
11099 }
11100 }
11101
11102 6595803110182632097 => {
11103 let responder = ::fidl_next::Responder::from_untyped(responder);
11104
11105 handler.deprecated_get_flags(responder).await;
11106 Ok(())
11107 }
11108
11109 5950864159036794675 => {
11110 let responder = ::fidl_next::Responder::from_untyped(responder);
11111
11112 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11113 Ok(decoded) => {
11114 handler
11115 .deprecated_set_flags(
11116 ::fidl_next::Request::from_decoded(decoded),
11117 responder,
11118 )
11119 .await;
11120 Ok(())
11121 }
11122 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11123 ordinal: 5950864159036794675,
11124 error,
11125 }),
11126 }
11127 }
11128
11129 105530239381466147 => {
11130 let responder = ::fidl_next::Responder::from_untyped(responder);
11131
11132 handler.get_flags(responder).await;
11133 Ok(())
11134 }
11135
11136 6172186066099445416 => {
11137 let responder = ::fidl_next::Responder::from_untyped(responder);
11138
11139 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11140 Ok(decoded) => {
11141 handler
11142 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
11143 .await;
11144 Ok(())
11145 }
11146 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11147 ordinal: 6172186066099445416,
11148 error,
11149 }),
11150 }
11151 }
11152
11153 8013111122914313744 => {
11154 let responder = ::fidl_next::Responder::from_untyped(responder);
11155
11156 handler.query_filesystem(responder).await;
11157 Ok(())
11158 }
11159
11160 4414537700416816443 => {
11161 let responder = ::fidl_next::Responder::from_untyped(responder);
11162
11163 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11164 Ok(decoded) => {
11165 handler
11166 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
11167 .await;
11168 Ok(())
11169 }
11170 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11171 ordinal: 4414537700416816443,
11172 error,
11173 }),
11174 }
11175 }
11176
11177 3677402239314018056 => {
11178 let responder = ::fidl_next::Responder::from_untyped(responder);
11179
11180 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11181 Ok(decoded) => {
11182 handler
11183 .update_attributes(
11184 ::fidl_next::Request::from_decoded(decoded),
11185 responder,
11186 )
11187 .await;
11188 Ok(())
11189 }
11190 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11191 ordinal: 3677402239314018056,
11192 error,
11193 }),
11194 }
11195 }
11196
11197 3196473584242777161 => {
11198 let responder = ::fidl_next::Responder::from_untyped(responder);
11199
11200 handler.sync(responder).await;
11201 Ok(())
11202 }
11203
11204 5043930208506967771 => {
11205 let responder = ::fidl_next::Responder::from_untyped(responder);
11206
11207 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11208 Ok(decoded) => {
11209 handler
11210 .get_extended_attribute(
11211 ::fidl_next::Request::from_decoded(decoded),
11212 responder,
11213 )
11214 .await;
11215 Ok(())
11216 }
11217 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11218 ordinal: 5043930208506967771,
11219 error,
11220 }),
11221 }
11222 }
11223
11224 5374223046099989052 => {
11225 let responder = ::fidl_next::Responder::from_untyped(responder);
11226
11227 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11228 Ok(decoded) => {
11229 handler
11230 .set_extended_attribute(
11231 ::fidl_next::Request::from_decoded(decoded),
11232 responder,
11233 )
11234 .await;
11235 Ok(())
11236 }
11237 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11238 ordinal: 5374223046099989052,
11239 error,
11240 }),
11241 }
11242 }
11243
11244 8794297771444732717 => {
11245 let responder = ::fidl_next::Responder::from_untyped(responder);
11246
11247 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11248 Ok(decoded) => {
11249 handler
11250 .remove_extended_attribute(
11251 ::fidl_next::Request::from_decoded(decoded),
11252 responder,
11253 )
11254 .await;
11255 Ok(())
11256 }
11257 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11258 ordinal: 8794297771444732717,
11259 error,
11260 }),
11261 }
11262 }
11263
11264 3855785432100874762 => {
11265 let responder = ::fidl_next::Responder::from_untyped(responder);
11266
11267 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11268 Ok(decoded) => {
11269 handler
11270 .read_dirents(::fidl_next::Request::from_decoded(decoded), responder)
11271 .await;
11272 Ok(())
11273 }
11274 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11275 ordinal: 3855785432100874762,
11276 error,
11277 }),
11278 }
11279 }
11280
11281 1635123508515392625 => {
11282 let responder = ::fidl_next::Responder::from_untyped(responder);
11283
11284 handler.rewind(responder).await;
11285 Ok(())
11286 }
11287
11288 2787337947777369685 => {
11289 let responder = ::fidl_next::Responder::from_untyped(responder);
11290
11291 handler.get_token(responder).await;
11292 Ok(())
11293 }
11294
11295 8360374984291987687 => {
11296 let responder = ::fidl_next::Responder::from_untyped(responder);
11297
11298 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11299 Ok(decoded) => {
11300 handler.link(::fidl_next::Request::from_decoded(decoded), responder).await;
11301 Ok(())
11302 }
11303 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11304 ordinal: 8360374984291987687,
11305 error,
11306 }),
11307 }
11308 }
11309
11310 8433556716759383021 => {
11311 let responder = ::fidl_next::Responder::from_untyped(responder);
11312
11313 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11314 Ok(decoded) => {
11315 handler
11316 .unlink(::fidl_next::Request::from_decoded(decoded), responder)
11317 .await;
11318 Ok(())
11319 }
11320 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11321 ordinal: 8433556716759383021,
11322 error,
11323 }),
11324 }
11325 }
11326
11327 8097726607824333022 => {
11328 let responder = ::fidl_next::Responder::from_untyped(responder);
11329
11330 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11331 Ok(decoded) => {
11332 handler
11333 .rename(::fidl_next::Request::from_decoded(decoded), responder)
11334 .await;
11335 Ok(())
11336 }
11337 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11338 ordinal: 8097726607824333022,
11339 error,
11340 }),
11341 }
11342 }
11343
11344 2435901052462315657 => {
11345 let responder = ::fidl_next::Responder::from_untyped(responder);
11346
11347 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11348 Ok(decoded) => {
11349 handler
11350 .create_symlink(::fidl_next::Request::from_decoded(decoded), responder)
11351 .await;
11352 Ok(())
11353 }
11354 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11355 ordinal: 2435901052462315657,
11356 error,
11357 }),
11358 }
11359 }
11360
11361 6275512344170098065 => {
11362 let responder = ::fidl_next::Responder::from_untyped(responder);
11363
11364 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11365 Ok(decoded) => {
11366 handler.watch(::fidl_next::Request::from_decoded(decoded), responder).await;
11367 Ok(())
11368 }
11369 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11370 ordinal: 6275512344170098065,
11371 error,
11372 }),
11373 }
11374 }
11375
11376 ordinal => {
11377 handler.on_unknown_interaction(ordinal).await;
11378 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11379 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11380 } else {
11381 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
11382 ordinal,
11383 flexibility,
11384 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
11385 )
11386 .expect("encoding a framework error should never fail")
11387 .await?;
11388 Ok(())
11389 }
11390 }
11391 }
11392 }
11393}
11394
11395pub trait DirectoryClientHandler<
11399 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
11400 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11401>
11402{
11403 #[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"]
11404 fn on_open(
11405 &mut self,
11406
11407 request: ::fidl_next::Request<directory::OnOpen, ___T>,
11408 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11409
11410 #[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"]
11411 fn on_representation(
11412 &mut self,
11413
11414 request: ::fidl_next::Request<directory::OnRepresentation, ___T>,
11415 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11416
11417 fn on_unknown_interaction(
11418 &mut self,
11419 ordinal: u64,
11420 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11421 ::core::future::ready(())
11422 }
11423}
11424
11425impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Directory
11426where
11427 ___H: DirectoryClientHandler<___T> + ::core::marker::Send,
11428 ___T: ::fidl_next::Transport,
11429 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
11430 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11431 Constraint = (),
11432 >,
11433 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
11434 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11435 Constraint = (),
11436 >,
11437{
11438 async fn on_event(
11439 handler: &mut ___H,
11440 ordinal: u64,
11441 flexibility: ::fidl_next::protocol::Flexibility,
11442 body: ::fidl_next::Body<___T>,
11443 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11444 match ordinal {
11445 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
11446 Ok(decoded) => {
11447 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
11448 Ok(())
11449 }
11450 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11451 ordinal: 9207534335756671346,
11452 error,
11453 }),
11454 },
11455
11456 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
11457 Ok(decoded) => {
11458 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
11459 Ok(())
11460 }
11461 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11462 ordinal: 6679970090861613324,
11463 error,
11464 }),
11465 },
11466
11467 ordinal => {
11468 handler.on_unknown_interaction(ordinal).await;
11469 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11470 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11471 } else {
11472 Ok(())
11473 }
11474 }
11475 }
11476 }
11477}
11478
11479pub trait DirectoryServerHandler<
11483 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
11484 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11485>
11486{
11487 #[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"]
11488 fn advisory_lock(
11489 &mut self,
11490
11491 request: ::fidl_next::Request<directory::AdvisoryLock, ___T>,
11492
11493 responder: ::fidl_next::Responder<directory::AdvisoryLock, ___T>,
11494 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11495
11496 fn clone(
11497 &mut self,
11498
11499 request: ::fidl_next::Request<directory::Clone, ___T>,
11500 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11501
11502 #[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"]
11503 fn close(
11504 &mut self,
11505
11506 responder: ::fidl_next::Responder<directory::Close, ___T>,
11507 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11508
11509 fn query(
11510 &mut self,
11511
11512 responder: ::fidl_next::Responder<directory::Query, ___T>,
11513 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11514
11515 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
11516 fn deprecated_clone(
11517 &mut self,
11518
11519 request: ::fidl_next::Request<directory::DeprecatedClone, ___T>,
11520 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11521
11522 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
11523 fn deprecated_get_attr(
11524 &mut self,
11525
11526 responder: ::fidl_next::Responder<directory::DeprecatedGetAttr, ___T>,
11527 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11528
11529 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
11530 fn deprecated_set_attr(
11531 &mut self,
11532
11533 request: ::fidl_next::Request<directory::DeprecatedSetAttr, ___T>,
11534
11535 responder: ::fidl_next::Responder<directory::DeprecatedSetAttr, ___T>,
11536 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11537
11538 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
11539 fn deprecated_get_flags(
11540 &mut self,
11541
11542 responder: ::fidl_next::Responder<directory::DeprecatedGetFlags, ___T>,
11543 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11544
11545 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
11546 fn deprecated_set_flags(
11547 &mut self,
11548
11549 request: ::fidl_next::Request<directory::DeprecatedSetFlags, ___T>,
11550
11551 responder: ::fidl_next::Responder<directory::DeprecatedSetFlags, ___T>,
11552 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11553
11554 #[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"]
11555 fn get_flags(
11556 &mut self,
11557
11558 responder: ::fidl_next::Responder<directory::GetFlags, ___T>,
11559 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
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 fn set_flags(
11563 &mut self,
11564
11565 request: ::fidl_next::Request<directory::SetFlags, ___T>,
11566
11567 responder: ::fidl_next::Responder<directory::SetFlags, ___T>,
11568 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11569
11570 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
11571 fn query_filesystem(
11572 &mut self,
11573
11574 responder: ::fidl_next::Responder<directory::QueryFilesystem, ___T>,
11575 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11576
11577 #[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"]
11578 fn get_attributes(
11579 &mut self,
11580
11581 request: ::fidl_next::Request<directory::GetAttributes, ___T>,
11582
11583 responder: ::fidl_next::Responder<directory::GetAttributes, ___T>,
11584 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11585
11586 #[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"]
11587 fn update_attributes(
11588 &mut self,
11589
11590 request: ::fidl_next::Request<directory::UpdateAttributes, ___T>,
11591
11592 responder: ::fidl_next::Responder<directory::UpdateAttributes, ___T>,
11593 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11594
11595 #[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"]
11596 fn sync(
11597 &mut self,
11598
11599 responder: ::fidl_next::Responder<directory::Sync, ___T>,
11600 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11601
11602 #[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"]
11603 fn list_extended_attributes(
11604 &mut self,
11605
11606 request: ::fidl_next::Request<directory::ListExtendedAttributes, ___T>,
11607 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11608
11609 #[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"]
11610 fn get_extended_attribute(
11611 &mut self,
11612
11613 request: ::fidl_next::Request<directory::GetExtendedAttribute, ___T>,
11614
11615 responder: ::fidl_next::Responder<directory::GetExtendedAttribute, ___T>,
11616 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11617
11618 #[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"]
11619 fn set_extended_attribute(
11620 &mut self,
11621
11622 request: ::fidl_next::Request<directory::SetExtendedAttribute, ___T>,
11623
11624 responder: ::fidl_next::Responder<directory::SetExtendedAttribute, ___T>,
11625 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11626
11627 #[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"]
11628 fn remove_extended_attribute(
11629 &mut self,
11630
11631 request: ::fidl_next::Request<directory::RemoveExtendedAttribute, ___T>,
11632
11633 responder: ::fidl_next::Responder<directory::RemoveExtendedAttribute, ___T>,
11634 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11635
11636 #[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"]
11637 fn open(
11638 &mut self,
11639
11640 request: ::fidl_next::Request<directory::Open, ___T>,
11641 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11642
11643 #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
11644 fn deprecated_open(
11645 &mut self,
11646
11647 request: ::fidl_next::Request<directory::DeprecatedOpen, ___T>,
11648 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11649
11650 #[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"]
11651 fn read_dirents(
11652 &mut self,
11653
11654 request: ::fidl_next::Request<directory::ReadDirents, ___T>,
11655
11656 responder: ::fidl_next::Responder<directory::ReadDirents, ___T>,
11657 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11658
11659 #[doc = " Resets the directory seek offset.\n\n This method does not require any rights, similar to ReadDirents.\n"]
11660 fn rewind(
11661 &mut self,
11662
11663 responder: ::fidl_next::Responder<directory::Rewind, ___T>,
11664 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11665
11666 #[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"]
11667 fn get_token(
11668 &mut self,
11669
11670 responder: ::fidl_next::Responder<directory::GetToken, ___T>,
11671 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11672
11673 #[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"]
11674 fn link(
11675 &mut self,
11676
11677 request: ::fidl_next::Request<directory::Link, ___T>,
11678
11679 responder: ::fidl_next::Responder<directory::Link, ___T>,
11680 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11681
11682 #[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"]
11683 fn unlink(
11684 &mut self,
11685
11686 request: ::fidl_next::Request<directory::Unlink, ___T>,
11687
11688 responder: ::fidl_next::Responder<directory::Unlink, ___T>,
11689 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11690
11691 #[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"]
11692 fn rename(
11693 &mut self,
11694
11695 request: ::fidl_next::Request<directory::Rename, ___T>,
11696
11697 responder: ::fidl_next::Responder<directory::Rename, ___T>,
11698 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11699
11700 #[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"]
11701 fn create_symlink(
11702 &mut self,
11703
11704 request: ::fidl_next::Request<directory::CreateSymlink, ___T>,
11705
11706 responder: ::fidl_next::Responder<directory::CreateSymlink, ___T>,
11707 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11708
11709 #[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"]
11710 fn watch(
11711 &mut self,
11712
11713 request: ::fidl_next::Request<directory::Watch, ___T>,
11714
11715 responder: ::fidl_next::Responder<directory::Watch, ___T>,
11716 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11717
11718 fn on_unknown_interaction(
11719 &mut self,
11720 ordinal: u64,
11721 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11722 ::core::future::ready(())
11723 }
11724}
11725
11726impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Directory
11727where
11728 ___H: DirectoryServerHandler<___T> + ::core::marker::Send,
11729 ___T: ::fidl_next::Transport,
11730 for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
11731 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11732 Constraint = (),
11733 >,
11734 for<'de> ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
11735 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11736 Constraint = (),
11737 >,
11738 for<'de> crate::wire::NodeDeprecatedCloneRequest: ::fidl_next::Decode<
11739 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11740 Constraint = (),
11741 >,
11742 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
11743 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11744 Constraint = (),
11745 >,
11746 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
11747 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11748 Constraint = (),
11749 >,
11750 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
11751 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11752 Constraint = (),
11753 >,
11754 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
11755 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11756 Constraint = (),
11757 >,
11758 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
11759 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11760 Constraint = (),
11761 >,
11762 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
11763 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11764 Constraint = (),
11765 >,
11766 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
11767 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11768 Constraint = (),
11769 >,
11770 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
11771 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11772 Constraint = (),
11773 >,
11774 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
11775 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11776 Constraint = (),
11777 >,
11778 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
11779 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11780 Constraint = (),
11781 >,
11782 for<'de> crate::wire::DirectoryDeprecatedOpenRequest<'de>: ::fidl_next::Decode<
11783 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11784 Constraint = (),
11785 >,
11786 for<'de> crate::wire::DirectoryReadDirentsRequest: ::fidl_next::Decode<
11787 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11788 Constraint = (),
11789 >,
11790 for<'de> crate::wire::DirectoryLinkRequest<'de>: ::fidl_next::Decode<
11791 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11792 Constraint = (),
11793 >,
11794 for<'de> crate::wire::DirectoryUnlinkRequest<'de>: ::fidl_next::Decode<
11795 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11796 Constraint = (),
11797 >,
11798 for<'de> crate::wire::DirectoryRenameRequest<'de>: ::fidl_next::Decode<
11799 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11800 Constraint = (),
11801 >,
11802 for<'de> crate::wire::DirectoryCreateSymlinkRequest<'de>: ::fidl_next::Decode<
11803 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11804 Constraint = (),
11805 >,
11806 for<'de> crate::wire::DirectoryWatchRequest: ::fidl_next::Decode<
11807 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11808 Constraint = (),
11809 >,
11810{
11811 async fn on_one_way(
11812 handler: &mut ___H,
11813 ordinal: u64,
11814 flexibility: ::fidl_next::protocol::Flexibility,
11815 body: ::fidl_next::Body<___T>,
11816 ) -> ::core::result::Result<
11817 (),
11818 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11819 > {
11820 match ordinal {
11821 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
11822 Ok(decoded) => {
11823 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
11824 Ok(())
11825 }
11826 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11827 ordinal: 2366825959783828089,
11828 error,
11829 }),
11830 },
11831
11832 6512600400724287855 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
11833 Ok(decoded) => {
11834 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
11835 Ok(())
11836 }
11837 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11838 ordinal: 6512600400724287855,
11839 error,
11840 }),
11841 },
11842
11843 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
11844 Ok(decoded) => {
11845 handler
11846 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
11847 .await;
11848 Ok(())
11849 }
11850 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11851 ordinal: 5431626189872037072,
11852 error,
11853 }),
11854 },
11855
11856 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
11857 Ok(decoded) => {
11858 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
11859 Ok(())
11860 }
11861 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11862 ordinal: 6236883748953765593,
11863 error,
11864 }),
11865 },
11866
11867 3193127272456937152 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
11868 Ok(decoded) => {
11869 handler.deprecated_open(::fidl_next::Request::from_decoded(decoded)).await;
11870 Ok(())
11871 }
11872 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11873 ordinal: 3193127272456937152,
11874 error,
11875 }),
11876 },
11877
11878 ordinal => {
11879 handler.on_unknown_interaction(ordinal).await;
11880 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11881 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11882 } else {
11883 Ok(())
11884 }
11885 }
11886 }
11887 }
11888
11889 async fn on_two_way(
11890 handler: &mut ___H,
11891 ordinal: u64,
11892 flexibility: ::fidl_next::protocol::Flexibility,
11893 body: ::fidl_next::Body<___T>,
11894 responder: ::fidl_next::protocol::Responder<___T>,
11895 ) -> ::core::result::Result<
11896 (),
11897 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11898 > {
11899 match ordinal {
11900 7992130864415541162 => {
11901 let responder = ::fidl_next::Responder::from_untyped(responder);
11902
11903 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11904 Ok(decoded) => {
11905 handler
11906 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
11907 .await;
11908 Ok(())
11909 }
11910 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11911 ordinal: 7992130864415541162,
11912 error,
11913 }),
11914 }
11915 }
11916
11917 6540867515453498750 => {
11918 let responder = ::fidl_next::Responder::from_untyped(responder);
11919
11920 handler.close(responder).await;
11921 Ok(())
11922 }
11923
11924 2763219980499352582 => {
11925 let responder = ::fidl_next::Responder::from_untyped(responder);
11926
11927 handler.query(responder).await;
11928 Ok(())
11929 }
11930
11931 8689798978500614909 => {
11932 let responder = ::fidl_next::Responder::from_untyped(responder);
11933
11934 handler.deprecated_get_attr(responder).await;
11935 Ok(())
11936 }
11937
11938 4721673413776871238 => {
11939 let responder = ::fidl_next::Responder::from_untyped(responder);
11940
11941 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11942 Ok(decoded) => {
11943 handler
11944 .deprecated_set_attr(
11945 ::fidl_next::Request::from_decoded(decoded),
11946 responder,
11947 )
11948 .await;
11949 Ok(())
11950 }
11951 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11952 ordinal: 4721673413776871238,
11953 error,
11954 }),
11955 }
11956 }
11957
11958 6595803110182632097 => {
11959 let responder = ::fidl_next::Responder::from_untyped(responder);
11960
11961 handler.deprecated_get_flags(responder).await;
11962 Ok(())
11963 }
11964
11965 5950864159036794675 => {
11966 let responder = ::fidl_next::Responder::from_untyped(responder);
11967
11968 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11969 Ok(decoded) => {
11970 handler
11971 .deprecated_set_flags(
11972 ::fidl_next::Request::from_decoded(decoded),
11973 responder,
11974 )
11975 .await;
11976 Ok(())
11977 }
11978 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11979 ordinal: 5950864159036794675,
11980 error,
11981 }),
11982 }
11983 }
11984
11985 105530239381466147 => {
11986 let responder = ::fidl_next::Responder::from_untyped(responder);
11987
11988 handler.get_flags(responder).await;
11989 Ok(())
11990 }
11991
11992 6172186066099445416 => {
11993 let responder = ::fidl_next::Responder::from_untyped(responder);
11994
11995 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11996 Ok(decoded) => {
11997 handler
11998 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
11999 .await;
12000 Ok(())
12001 }
12002 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12003 ordinal: 6172186066099445416,
12004 error,
12005 }),
12006 }
12007 }
12008
12009 8013111122914313744 => {
12010 let responder = ::fidl_next::Responder::from_untyped(responder);
12011
12012 handler.query_filesystem(responder).await;
12013 Ok(())
12014 }
12015
12016 4414537700416816443 => {
12017 let responder = ::fidl_next::Responder::from_untyped(responder);
12018
12019 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12020 Ok(decoded) => {
12021 handler
12022 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
12023 .await;
12024 Ok(())
12025 }
12026 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12027 ordinal: 4414537700416816443,
12028 error,
12029 }),
12030 }
12031 }
12032
12033 3677402239314018056 => {
12034 let responder = ::fidl_next::Responder::from_untyped(responder);
12035
12036 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12037 Ok(decoded) => {
12038 handler
12039 .update_attributes(
12040 ::fidl_next::Request::from_decoded(decoded),
12041 responder,
12042 )
12043 .await;
12044 Ok(())
12045 }
12046 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12047 ordinal: 3677402239314018056,
12048 error,
12049 }),
12050 }
12051 }
12052
12053 3196473584242777161 => {
12054 let responder = ::fidl_next::Responder::from_untyped(responder);
12055
12056 handler.sync(responder).await;
12057 Ok(())
12058 }
12059
12060 5043930208506967771 => {
12061 let responder = ::fidl_next::Responder::from_untyped(responder);
12062
12063 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12064 Ok(decoded) => {
12065 handler
12066 .get_extended_attribute(
12067 ::fidl_next::Request::from_decoded(decoded),
12068 responder,
12069 )
12070 .await;
12071 Ok(())
12072 }
12073 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12074 ordinal: 5043930208506967771,
12075 error,
12076 }),
12077 }
12078 }
12079
12080 5374223046099989052 => {
12081 let responder = ::fidl_next::Responder::from_untyped(responder);
12082
12083 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12084 Ok(decoded) => {
12085 handler
12086 .set_extended_attribute(
12087 ::fidl_next::Request::from_decoded(decoded),
12088 responder,
12089 )
12090 .await;
12091 Ok(())
12092 }
12093 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12094 ordinal: 5374223046099989052,
12095 error,
12096 }),
12097 }
12098 }
12099
12100 8794297771444732717 => {
12101 let responder = ::fidl_next::Responder::from_untyped(responder);
12102
12103 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12104 Ok(decoded) => {
12105 handler
12106 .remove_extended_attribute(
12107 ::fidl_next::Request::from_decoded(decoded),
12108 responder,
12109 )
12110 .await;
12111 Ok(())
12112 }
12113 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12114 ordinal: 8794297771444732717,
12115 error,
12116 }),
12117 }
12118 }
12119
12120 3855785432100874762 => {
12121 let responder = ::fidl_next::Responder::from_untyped(responder);
12122
12123 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12124 Ok(decoded) => {
12125 handler
12126 .read_dirents(::fidl_next::Request::from_decoded(decoded), responder)
12127 .await;
12128 Ok(())
12129 }
12130 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12131 ordinal: 3855785432100874762,
12132 error,
12133 }),
12134 }
12135 }
12136
12137 1635123508515392625 => {
12138 let responder = ::fidl_next::Responder::from_untyped(responder);
12139
12140 handler.rewind(responder).await;
12141 Ok(())
12142 }
12143
12144 2787337947777369685 => {
12145 let responder = ::fidl_next::Responder::from_untyped(responder);
12146
12147 handler.get_token(responder).await;
12148 Ok(())
12149 }
12150
12151 8360374984291987687 => {
12152 let responder = ::fidl_next::Responder::from_untyped(responder);
12153
12154 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12155 Ok(decoded) => {
12156 handler.link(::fidl_next::Request::from_decoded(decoded), responder).await;
12157 Ok(())
12158 }
12159 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12160 ordinal: 8360374984291987687,
12161 error,
12162 }),
12163 }
12164 }
12165
12166 8433556716759383021 => {
12167 let responder = ::fidl_next::Responder::from_untyped(responder);
12168
12169 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12170 Ok(decoded) => {
12171 handler
12172 .unlink(::fidl_next::Request::from_decoded(decoded), responder)
12173 .await;
12174 Ok(())
12175 }
12176 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12177 ordinal: 8433556716759383021,
12178 error,
12179 }),
12180 }
12181 }
12182
12183 8097726607824333022 => {
12184 let responder = ::fidl_next::Responder::from_untyped(responder);
12185
12186 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12187 Ok(decoded) => {
12188 handler
12189 .rename(::fidl_next::Request::from_decoded(decoded), responder)
12190 .await;
12191 Ok(())
12192 }
12193 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12194 ordinal: 8097726607824333022,
12195 error,
12196 }),
12197 }
12198 }
12199
12200 2435901052462315657 => {
12201 let responder = ::fidl_next::Responder::from_untyped(responder);
12202
12203 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12204 Ok(decoded) => {
12205 handler
12206 .create_symlink(::fidl_next::Request::from_decoded(decoded), responder)
12207 .await;
12208 Ok(())
12209 }
12210 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12211 ordinal: 2435901052462315657,
12212 error,
12213 }),
12214 }
12215 }
12216
12217 6275512344170098065 => {
12218 let responder = ::fidl_next::Responder::from_untyped(responder);
12219
12220 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12221 Ok(decoded) => {
12222 handler.watch(::fidl_next::Request::from_decoded(decoded), responder).await;
12223 Ok(())
12224 }
12225 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12226 ordinal: 6275512344170098065,
12227 error,
12228 }),
12229 }
12230 }
12231
12232 ordinal => {
12233 handler.on_unknown_interaction(ordinal).await;
12234 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12235 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12236 } else {
12237 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
12238 ordinal,
12239 flexibility,
12240 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
12241 )
12242 .expect("encoding a framework error should never fail")
12243 .await?;
12244 Ok(())
12245 }
12246 }
12247 }
12248 }
12249}
12250
12251impl<___T> DirectoryClientHandler<___T> for ::fidl_next::IgnoreEvents
12252where
12253 ___T: ::fidl_next::Transport,
12254{
12255 async fn on_open(&mut self, _: ::fidl_next::Request<directory::OnOpen, ___T>) {}
12256
12257 async fn on_representation(
12258 &mut self,
12259
12260 _: ::fidl_next::Request<directory::OnRepresentation, ___T>,
12261 ) {
12262 }
12263
12264 async fn on_unknown_interaction(&mut self, _: u64) {}
12265}
12266
12267impl<___H, ___T> DirectoryLocalClientHandler<___T> for ::fidl_next::Local<___H>
12268where
12269 ___H: DirectoryClientHandler<___T>,
12270 ___T: ::fidl_next::Transport,
12271{
12272 async fn on_open(&mut self, request: ::fidl_next::Request<directory::OnOpen, ___T>) {
12273 ___H::on_open(&mut self.0, request).await
12274 }
12275
12276 async fn on_representation(
12277 &mut self,
12278
12279 request: ::fidl_next::Request<directory::OnRepresentation, ___T>,
12280 ) {
12281 ___H::on_representation(&mut self.0, request).await
12282 }
12283
12284 async fn on_unknown_interaction(&mut self, ordinal: u64) {
12285 ___H::on_unknown_interaction(&mut self.0, ordinal).await
12286 }
12287}
12288
12289impl<___H, ___T> DirectoryLocalServerHandler<___T> for ::fidl_next::Local<___H>
12290where
12291 ___H: DirectoryServerHandler<___T>,
12292 ___T: ::fidl_next::Transport,
12293{
12294 async fn advisory_lock(
12295 &mut self,
12296
12297 request: ::fidl_next::Request<directory::AdvisoryLock, ___T>,
12298
12299 responder: ::fidl_next::Responder<directory::AdvisoryLock, ___T>,
12300 ) {
12301 ___H::advisory_lock(&mut self.0, request, responder).await
12302 }
12303
12304 async fn clone(&mut self, request: ::fidl_next::Request<directory::Clone, ___T>) {
12305 ___H::clone(&mut self.0, request).await
12306 }
12307
12308 async fn close(&mut self, responder: ::fidl_next::Responder<directory::Close, ___T>) {
12309 ___H::close(&mut self.0, responder).await
12310 }
12311
12312 async fn query(&mut self, responder: ::fidl_next::Responder<directory::Query, ___T>) {
12313 ___H::query(&mut self.0, responder).await
12314 }
12315
12316 async fn deprecated_clone(
12317 &mut self,
12318
12319 request: ::fidl_next::Request<directory::DeprecatedClone, ___T>,
12320 ) {
12321 ___H::deprecated_clone(&mut self.0, request).await
12322 }
12323
12324 async fn deprecated_get_attr(
12325 &mut self,
12326
12327 responder: ::fidl_next::Responder<directory::DeprecatedGetAttr, ___T>,
12328 ) {
12329 ___H::deprecated_get_attr(&mut self.0, responder).await
12330 }
12331
12332 async fn deprecated_set_attr(
12333 &mut self,
12334
12335 request: ::fidl_next::Request<directory::DeprecatedSetAttr, ___T>,
12336
12337 responder: ::fidl_next::Responder<directory::DeprecatedSetAttr, ___T>,
12338 ) {
12339 ___H::deprecated_set_attr(&mut self.0, request, responder).await
12340 }
12341
12342 async fn deprecated_get_flags(
12343 &mut self,
12344
12345 responder: ::fidl_next::Responder<directory::DeprecatedGetFlags, ___T>,
12346 ) {
12347 ___H::deprecated_get_flags(&mut self.0, responder).await
12348 }
12349
12350 async fn deprecated_set_flags(
12351 &mut self,
12352
12353 request: ::fidl_next::Request<directory::DeprecatedSetFlags, ___T>,
12354
12355 responder: ::fidl_next::Responder<directory::DeprecatedSetFlags, ___T>,
12356 ) {
12357 ___H::deprecated_set_flags(&mut self.0, request, responder).await
12358 }
12359
12360 async fn get_flags(&mut self, responder: ::fidl_next::Responder<directory::GetFlags, ___T>) {
12361 ___H::get_flags(&mut self.0, responder).await
12362 }
12363
12364 async fn set_flags(
12365 &mut self,
12366
12367 request: ::fidl_next::Request<directory::SetFlags, ___T>,
12368
12369 responder: ::fidl_next::Responder<directory::SetFlags, ___T>,
12370 ) {
12371 ___H::set_flags(&mut self.0, request, responder).await
12372 }
12373
12374 async fn query_filesystem(
12375 &mut self,
12376
12377 responder: ::fidl_next::Responder<directory::QueryFilesystem, ___T>,
12378 ) {
12379 ___H::query_filesystem(&mut self.0, responder).await
12380 }
12381
12382 async fn get_attributes(
12383 &mut self,
12384
12385 request: ::fidl_next::Request<directory::GetAttributes, ___T>,
12386
12387 responder: ::fidl_next::Responder<directory::GetAttributes, ___T>,
12388 ) {
12389 ___H::get_attributes(&mut self.0, request, responder).await
12390 }
12391
12392 async fn update_attributes(
12393 &mut self,
12394
12395 request: ::fidl_next::Request<directory::UpdateAttributes, ___T>,
12396
12397 responder: ::fidl_next::Responder<directory::UpdateAttributes, ___T>,
12398 ) {
12399 ___H::update_attributes(&mut self.0, request, responder).await
12400 }
12401
12402 async fn sync(&mut self, responder: ::fidl_next::Responder<directory::Sync, ___T>) {
12403 ___H::sync(&mut self.0, responder).await
12404 }
12405
12406 async fn list_extended_attributes(
12407 &mut self,
12408
12409 request: ::fidl_next::Request<directory::ListExtendedAttributes, ___T>,
12410 ) {
12411 ___H::list_extended_attributes(&mut self.0, request).await
12412 }
12413
12414 async fn get_extended_attribute(
12415 &mut self,
12416
12417 request: ::fidl_next::Request<directory::GetExtendedAttribute, ___T>,
12418
12419 responder: ::fidl_next::Responder<directory::GetExtendedAttribute, ___T>,
12420 ) {
12421 ___H::get_extended_attribute(&mut self.0, request, responder).await
12422 }
12423
12424 async fn set_extended_attribute(
12425 &mut self,
12426
12427 request: ::fidl_next::Request<directory::SetExtendedAttribute, ___T>,
12428
12429 responder: ::fidl_next::Responder<directory::SetExtendedAttribute, ___T>,
12430 ) {
12431 ___H::set_extended_attribute(&mut self.0, request, responder).await
12432 }
12433
12434 async fn remove_extended_attribute(
12435 &mut self,
12436
12437 request: ::fidl_next::Request<directory::RemoveExtendedAttribute, ___T>,
12438
12439 responder: ::fidl_next::Responder<directory::RemoveExtendedAttribute, ___T>,
12440 ) {
12441 ___H::remove_extended_attribute(&mut self.0, request, responder).await
12442 }
12443
12444 async fn open(&mut self, request: ::fidl_next::Request<directory::Open, ___T>) {
12445 ___H::open(&mut self.0, request).await
12446 }
12447
12448 async fn deprecated_open(
12449 &mut self,
12450
12451 request: ::fidl_next::Request<directory::DeprecatedOpen, ___T>,
12452 ) {
12453 ___H::deprecated_open(&mut self.0, request).await
12454 }
12455
12456 async fn read_dirents(
12457 &mut self,
12458
12459 request: ::fidl_next::Request<directory::ReadDirents, ___T>,
12460
12461 responder: ::fidl_next::Responder<directory::ReadDirents, ___T>,
12462 ) {
12463 ___H::read_dirents(&mut self.0, request, responder).await
12464 }
12465
12466 async fn rewind(&mut self, responder: ::fidl_next::Responder<directory::Rewind, ___T>) {
12467 ___H::rewind(&mut self.0, responder).await
12468 }
12469
12470 async fn get_token(&mut self, responder: ::fidl_next::Responder<directory::GetToken, ___T>) {
12471 ___H::get_token(&mut self.0, responder).await
12472 }
12473
12474 async fn link(
12475 &mut self,
12476
12477 request: ::fidl_next::Request<directory::Link, ___T>,
12478
12479 responder: ::fidl_next::Responder<directory::Link, ___T>,
12480 ) {
12481 ___H::link(&mut self.0, request, responder).await
12482 }
12483
12484 async fn unlink(
12485 &mut self,
12486
12487 request: ::fidl_next::Request<directory::Unlink, ___T>,
12488
12489 responder: ::fidl_next::Responder<directory::Unlink, ___T>,
12490 ) {
12491 ___H::unlink(&mut self.0, request, responder).await
12492 }
12493
12494 async fn rename(
12495 &mut self,
12496
12497 request: ::fidl_next::Request<directory::Rename, ___T>,
12498
12499 responder: ::fidl_next::Responder<directory::Rename, ___T>,
12500 ) {
12501 ___H::rename(&mut self.0, request, responder).await
12502 }
12503
12504 async fn create_symlink(
12505 &mut self,
12506
12507 request: ::fidl_next::Request<directory::CreateSymlink, ___T>,
12508
12509 responder: ::fidl_next::Responder<directory::CreateSymlink, ___T>,
12510 ) {
12511 ___H::create_symlink(&mut self.0, request, responder).await
12512 }
12513
12514 async fn watch(
12515 &mut self,
12516
12517 request: ::fidl_next::Request<directory::Watch, ___T>,
12518
12519 responder: ::fidl_next::Responder<directory::Watch, ___T>,
12520 ) {
12521 ___H::watch(&mut self.0, request, responder).await
12522 }
12523
12524 async fn on_unknown_interaction(&mut self, ordinal: u64) {
12525 ___H::on_unknown_interaction(&mut self.0, ordinal).await
12526 }
12527}
12528
12529#[derive(PartialEq, Debug)]
12531pub struct Linkable;
12532
12533#[cfg(target_os = "fuchsia")]
12534impl ::fidl_next::HasTransport for Linkable {
12535 type Transport = ::fdomain_client::Channel;
12536}
12537
12538pub mod linkable {
12539 pub mod prelude {
12540 pub use crate::{
12541 Linkable, LinkableClientHandler, LinkableLocalClientHandler,
12542 LinkableLocalServerHandler, LinkableServerHandler, linkable,
12543 };
12544
12545 pub use crate::natural::LinkableLinkIntoRequest;
12546
12547 pub use crate::natural::LinkableLinkIntoResponse;
12548 }
12549
12550 pub struct LinkInto;
12551
12552 impl ::fidl_next::Method for LinkInto {
12553 const ORDINAL: u64 = 6121399674497678964;
12554 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12555 ::fidl_next::protocol::Flexibility::Strict;
12556
12557 type Protocol = crate::Linkable;
12558
12559 type Request = crate::wire::LinkableLinkIntoRequest<'static>;
12560 }
12561
12562 impl ::fidl_next::TwoWayMethod for LinkInto {
12563 type Response = ::fidl_next::wire::Result<
12564 'static,
12565 crate::wire::LinkableLinkIntoResponse,
12566 ::fidl_next::wire::Int32,
12567 >;
12568 }
12569
12570 impl<___R> ::fidl_next::Respond<___R> for LinkInto {
12571 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
12572
12573 fn respond(response: ___R) -> Self::Output {
12574 ::core::result::Result::Ok(response)
12575 }
12576 }
12577
12578 impl<___R> ::fidl_next::RespondErr<___R> for LinkInto {
12579 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
12580
12581 fn respond_err(response: ___R) -> Self::Output {
12582 ::core::result::Result::Err(response)
12583 }
12584 }
12585
12586 mod ___detail {
12587 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Linkable
12588 where
12589 ___T: ::fidl_next::Transport,
12590 {
12591 type Client = LinkableClient<___T>;
12592 type Server = LinkableServer<___T>;
12593 }
12594
12595 #[repr(transparent)]
12597 pub struct LinkableClient<___T: ::fidl_next::Transport> {
12598 #[allow(dead_code)]
12599 client: ::fidl_next::protocol::Client<___T>,
12600 }
12601
12602 impl<___T> LinkableClient<___T>
12603 where
12604 ___T: ::fidl_next::Transport,
12605 {
12606 #[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"]
12607 pub fn link_into(
12608 &self,
12609
12610 dst_parent_token: impl ::fidl_next::Encode<
12611 ::fdomain_client::fidl_next::wire::Handle,
12612 <___T as ::fidl_next::Transport>::SendBuffer,
12613 >,
12614
12615 dst: impl ::fidl_next::Encode<
12616 ::fidl_next::wire::String<'static>,
12617 <___T as ::fidl_next::Transport>::SendBuffer,
12618 >,
12619 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
12620 where
12621 <___T as ::fidl_next::Transport>::SendBuffer:
12622 ::fidl_next::encoder::InternalHandleEncoder,
12623 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
12624 <___T as ::fidl_next::Transport>::SendBuffer:
12625 ::fdomain_client::fidl_next::HandleEncoder,
12626 {
12627 self.link_into_with(crate::generic::LinkableLinkIntoRequest {
12628 dst_parent_token,
12629
12630 dst,
12631 })
12632 }
12633
12634 #[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"]
12635 pub fn link_into_with<___R>(
12636 &self,
12637 request: ___R,
12638 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
12639 where
12640 ___R: ::fidl_next::Encode<
12641 crate::wire::LinkableLinkIntoRequest<'static>,
12642 <___T as ::fidl_next::Transport>::SendBuffer,
12643 >,
12644 {
12645 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12646 6121399674497678964,
12647 <super::LinkInto as ::fidl_next::Method>::FLEXIBILITY,
12648 request,
12649 ))
12650 }
12651 }
12652
12653 #[repr(transparent)]
12655 pub struct LinkableServer<___T: ::fidl_next::Transport> {
12656 server: ::fidl_next::protocol::Server<___T>,
12657 }
12658
12659 impl<___T> LinkableServer<___T> where ___T: ::fidl_next::Transport {}
12660 }
12661}
12662
12663#[diagnostic::on_unimplemented(
12664 note = "If {Self} implements the non-local LinkableClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
12665)]
12666
12667pub trait LinkableLocalClientHandler<
12671 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
12672 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12673>
12674{
12675}
12676
12677impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Linkable
12678where
12679 ___H: LinkableLocalClientHandler<___T>,
12680 ___T: ::fidl_next::Transport,
12681{
12682 async fn on_event(
12683 handler: &mut ___H,
12684 ordinal: u64,
12685 flexibility: ::fidl_next::protocol::Flexibility,
12686 body: ::fidl_next::Body<___T>,
12687 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12688 match ordinal {
12689 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12690 }
12691 }
12692}
12693
12694#[diagnostic::on_unimplemented(
12695 note = "If {Self} implements the non-local LinkableServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
12696)]
12697
12698pub trait LinkableLocalServerHandler<
12702 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
12703 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12704>
12705{
12706 #[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"]
12707 fn link_into(
12708 &mut self,
12709
12710 request: ::fidl_next::Request<linkable::LinkInto, ___T>,
12711
12712 responder: ::fidl_next::Responder<linkable::LinkInto, ___T>,
12713 ) -> impl ::core::future::Future<Output = ()>;
12714}
12715
12716impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Linkable
12717where
12718 ___H: LinkableLocalServerHandler<___T>,
12719 ___T: ::fidl_next::Transport,
12720 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
12721 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12722 Constraint = (),
12723 >,
12724{
12725 async fn on_one_way(
12726 handler: &mut ___H,
12727 ordinal: u64,
12728 flexibility: ::fidl_next::protocol::Flexibility,
12729 body: ::fidl_next::Body<___T>,
12730 ) -> ::core::result::Result<
12731 (),
12732 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12733 > {
12734 match ordinal {
12735 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12736 }
12737 }
12738
12739 async fn on_two_way(
12740 handler: &mut ___H,
12741 ordinal: u64,
12742 flexibility: ::fidl_next::protocol::Flexibility,
12743 body: ::fidl_next::Body<___T>,
12744 responder: ::fidl_next::protocol::Responder<___T>,
12745 ) -> ::core::result::Result<
12746 (),
12747 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12748 > {
12749 match ordinal {
12750 6121399674497678964 => {
12751 let responder = ::fidl_next::Responder::from_untyped(responder);
12752
12753 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12754 Ok(decoded) => {
12755 handler
12756 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
12757 .await;
12758 Ok(())
12759 }
12760 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12761 ordinal: 6121399674497678964,
12762 error,
12763 }),
12764 }
12765 }
12766
12767 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12768 }
12769 }
12770}
12771
12772pub trait LinkableClientHandler<
12776 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
12777 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12778>
12779{
12780}
12781
12782impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Linkable
12783where
12784 ___H: LinkableClientHandler<___T> + ::core::marker::Send,
12785 ___T: ::fidl_next::Transport,
12786{
12787 async fn on_event(
12788 handler: &mut ___H,
12789 ordinal: u64,
12790 flexibility: ::fidl_next::protocol::Flexibility,
12791 body: ::fidl_next::Body<___T>,
12792 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12793 match ordinal {
12794 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12795 }
12796 }
12797}
12798
12799pub trait LinkableServerHandler<
12803 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
12804 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12805>
12806{
12807 #[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"]
12808 fn link_into(
12809 &mut self,
12810
12811 request: ::fidl_next::Request<linkable::LinkInto, ___T>,
12812
12813 responder: ::fidl_next::Responder<linkable::LinkInto, ___T>,
12814 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12815}
12816
12817impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Linkable
12818where
12819 ___H: LinkableServerHandler<___T> + ::core::marker::Send,
12820 ___T: ::fidl_next::Transport,
12821 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
12822 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12823 Constraint = (),
12824 >,
12825{
12826 async fn on_one_way(
12827 handler: &mut ___H,
12828 ordinal: u64,
12829 flexibility: ::fidl_next::protocol::Flexibility,
12830 body: ::fidl_next::Body<___T>,
12831 ) -> ::core::result::Result<
12832 (),
12833 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12834 > {
12835 match ordinal {
12836 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12837 }
12838 }
12839
12840 async fn on_two_way(
12841 handler: &mut ___H,
12842 ordinal: u64,
12843 flexibility: ::fidl_next::protocol::Flexibility,
12844 body: ::fidl_next::Body<___T>,
12845 responder: ::fidl_next::protocol::Responder<___T>,
12846 ) -> ::core::result::Result<
12847 (),
12848 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12849 > {
12850 match ordinal {
12851 6121399674497678964 => {
12852 let responder = ::fidl_next::Responder::from_untyped(responder);
12853
12854 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12855 Ok(decoded) => {
12856 handler
12857 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
12858 .await;
12859 Ok(())
12860 }
12861 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12862 ordinal: 6121399674497678964,
12863 error,
12864 }),
12865 }
12866 }
12867
12868 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12869 }
12870 }
12871}
12872
12873impl<___T> LinkableClientHandler<___T> for ::fidl_next::IgnoreEvents where
12874 ___T: ::fidl_next::Transport
12875{
12876}
12877
12878impl<___H, ___T> LinkableLocalClientHandler<___T> for ::fidl_next::Local<___H>
12879where
12880 ___H: LinkableClientHandler<___T>,
12881 ___T: ::fidl_next::Transport,
12882{
12883}
12884
12885impl<___H, ___T> LinkableLocalServerHandler<___T> for ::fidl_next::Local<___H>
12886where
12887 ___H: LinkableServerHandler<___T>,
12888 ___T: ::fidl_next::Transport,
12889{
12890 async fn link_into(
12891 &mut self,
12892
12893 request: ::fidl_next::Request<linkable::LinkInto, ___T>,
12894
12895 responder: ::fidl_next::Responder<linkable::LinkInto, ___T>,
12896 ) {
12897 ___H::link_into(&mut self.0, request, responder).await
12898 }
12899}
12900
12901#[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"]
12903#[derive(PartialEq, Debug)]
12904pub struct File;
12905
12906impl ::fidl_next::Discoverable for File {
12907 const PROTOCOL_NAME: &'static str = "fuchsia.io.File";
12908}
12909
12910#[cfg(target_os = "fuchsia")]
12911impl ::fidl_next::HasTransport for File {
12912 type Transport = ::fdomain_client::Channel;
12913}
12914
12915pub mod file {
12916 pub mod prelude {
12917 pub use crate::{
12918 File, FileClientHandler, FileLocalClientHandler, FileLocalServerHandler,
12919 FileServerHandler, file,
12920 };
12921
12922 pub use crate::natural::AdvisoryLockingAdvisoryLockRequest;
12923
12924 pub use crate::natural::AdvisoryLockingAdvisoryLockResponse;
12925
12926 pub use crate::natural::ExtendedAttributeValue;
12927
12928 pub use crate::natural::FileAllocateRequest;
12929
12930 pub use crate::natural::FileEnableVerityRequest;
12931
12932 pub use crate::natural::FileGetBackingMemoryRequest;
12933
12934 pub use crate::natural::FileInfo;
12935
12936 pub use crate::natural::FileReadAtRequest;
12937
12938 pub use crate::natural::FileResizeRequest;
12939
12940 pub use crate::natural::FileSeekRequest;
12941
12942 pub use crate::natural::FileWriteAtRequest;
12943
12944 pub use crate::natural::FileAllocateResponse;
12945
12946 pub use crate::natural::FileEnableVerityResponse;
12947
12948 pub use crate::natural::FileGetBackingMemoryResponse;
12949
12950 pub use crate::natural::FileReadAtResponse;
12951
12952 pub use crate::natural::FileResizeResponse;
12953
12954 pub use crate::natural::FileSeekResponse;
12955
12956 pub use crate::natural::FileWriteAtResponse;
12957
12958 pub use crate::natural::LinkableLinkIntoRequest;
12959
12960 pub use crate::natural::LinkableLinkIntoResponse;
12961
12962 pub use crate::natural::MutableNodeAttributes;
12963
12964 pub use crate::natural::NodeAttributes2;
12965
12966 pub use crate::natural::NodeDeprecatedCloneRequest;
12967
12968 pub use crate::natural::NodeDeprecatedGetAttrResponse;
12969
12970 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
12971
12972 pub use crate::natural::NodeDeprecatedSetAttrRequest;
12973
12974 pub use crate::natural::NodeDeprecatedSetAttrResponse;
12975
12976 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
12977
12978 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
12979
12980 pub use crate::natural::NodeGetAttributesRequest;
12981
12982 pub use crate::natural::NodeGetExtendedAttributeRequest;
12983
12984 pub use crate::natural::NodeListExtendedAttributesRequest;
12985
12986 pub use crate::natural::NodeOnOpenRequest;
12987
12988 pub use crate::natural::NodeQueryFilesystemResponse;
12989
12990 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
12991
12992 pub use crate::natural::NodeSetExtendedAttributeRequest;
12993
12994 pub use crate::natural::NodeSetFlagsRequest;
12995
12996 pub use crate::natural::NodeGetFlagsResponse;
12997
12998 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
12999
13000 pub use crate::natural::NodeSetExtendedAttributeResponse;
13001
13002 pub use crate::natural::NodeSetFlagsResponse;
13003
13004 pub use crate::natural::NodeSyncResponse;
13005
13006 pub use crate::natural::NodeUpdateAttributesResponse;
13007
13008 pub use crate::natural::ReadableReadRequest;
13009
13010 pub use crate::natural::ReadableReadResponse;
13011
13012 pub use crate::natural::Representation;
13013
13014 pub use crate::natural::WritableWriteRequest;
13015
13016 pub use crate::natural::WritableWriteResponse;
13017
13018 pub use ::fdomain_next_fuchsia_unknown::natural::CloneableCloneRequest;
13019
13020 pub use ::fdomain_next_fuchsia_unknown::natural::CloseableCloseResponse;
13021
13022 pub use ::fdomain_next_fuchsia_unknown::natural::QueryableQueryResponse;
13023 }
13024
13025 pub struct AdvisoryLock;
13026
13027 impl ::fidl_next::Method for AdvisoryLock {
13028 const ORDINAL: u64 = 7992130864415541162;
13029 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13030 ::fidl_next::protocol::Flexibility::Strict;
13031
13032 type Protocol = crate::File;
13033
13034 type Request = crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>;
13035 }
13036
13037 impl ::fidl_next::TwoWayMethod for AdvisoryLock {
13038 type Response = ::fidl_next::wire::Result<
13039 'static,
13040 crate::wire::AdvisoryLockingAdvisoryLockResponse,
13041 ::fidl_next::wire::Int32,
13042 >;
13043 }
13044
13045 impl<___R> ::fidl_next::Respond<___R> for AdvisoryLock {
13046 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13047
13048 fn respond(response: ___R) -> Self::Output {
13049 ::core::result::Result::Ok(response)
13050 }
13051 }
13052
13053 impl<___R> ::fidl_next::RespondErr<___R> for AdvisoryLock {
13054 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13055
13056 fn respond_err(response: ___R) -> Self::Output {
13057 ::core::result::Result::Err(response)
13058 }
13059 }
13060
13061 pub struct LinkInto;
13062
13063 impl ::fidl_next::Method for LinkInto {
13064 const ORDINAL: u64 = 6121399674497678964;
13065 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13066 ::fidl_next::protocol::Flexibility::Strict;
13067
13068 type Protocol = crate::File;
13069
13070 type Request = crate::wire::LinkableLinkIntoRequest<'static>;
13071 }
13072
13073 impl ::fidl_next::TwoWayMethod for LinkInto {
13074 type Response = ::fidl_next::wire::Result<
13075 'static,
13076 crate::wire::LinkableLinkIntoResponse,
13077 ::fidl_next::wire::Int32,
13078 >;
13079 }
13080
13081 impl<___R> ::fidl_next::Respond<___R> for LinkInto {
13082 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13083
13084 fn respond(response: ___R) -> Self::Output {
13085 ::core::result::Result::Ok(response)
13086 }
13087 }
13088
13089 impl<___R> ::fidl_next::RespondErr<___R> for LinkInto {
13090 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13091
13092 fn respond_err(response: ___R) -> Self::Output {
13093 ::core::result::Result::Err(response)
13094 }
13095 }
13096
13097 pub struct Clone;
13098
13099 impl ::fidl_next::Method for Clone {
13100 const ORDINAL: u64 = 2366825959783828089;
13101 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13102 ::fidl_next::protocol::Flexibility::Strict;
13103
13104 type Protocol = crate::File;
13105
13106 type Request = ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest;
13107 }
13108
13109 pub struct Close;
13110
13111 impl ::fidl_next::Method for Close {
13112 const ORDINAL: u64 = 6540867515453498750;
13113 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13114 ::fidl_next::protocol::Flexibility::Strict;
13115
13116 type Protocol = crate::File;
13117
13118 type Request = ::fidl_next::wire::EmptyMessageBody;
13119 }
13120
13121 impl ::fidl_next::TwoWayMethod for Close {
13122 type Response = ::fidl_next::wire::Result<
13123 'static,
13124 ::fdomain_next_fuchsia_unknown::wire::CloseableCloseResponse,
13125 ::fidl_next::wire::Int32,
13126 >;
13127 }
13128
13129 impl<___R> ::fidl_next::Respond<___R> for Close {
13130 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13131
13132 fn respond(response: ___R) -> Self::Output {
13133 ::core::result::Result::Ok(response)
13134 }
13135 }
13136
13137 impl<___R> ::fidl_next::RespondErr<___R> for Close {
13138 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13139
13140 fn respond_err(response: ___R) -> Self::Output {
13141 ::core::result::Result::Err(response)
13142 }
13143 }
13144
13145 pub struct Query;
13146
13147 impl ::fidl_next::Method for Query {
13148 const ORDINAL: u64 = 2763219980499352582;
13149 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13150 ::fidl_next::protocol::Flexibility::Strict;
13151
13152 type Protocol = crate::File;
13153
13154 type Request = ::fidl_next::wire::EmptyMessageBody;
13155 }
13156
13157 impl ::fidl_next::TwoWayMethod for Query {
13158 type Response = ::fdomain_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>;
13159 }
13160
13161 impl<___R> ::fidl_next::Respond<___R> for Query {
13162 type Output = ::fdomain_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>;
13163
13164 fn respond(response: ___R) -> Self::Output {
13165 ::fdomain_next_fuchsia_unknown::generic::QueryableQueryResponse { protocol: response }
13166 }
13167 }
13168
13169 pub struct DeprecatedClone;
13170
13171 impl ::fidl_next::Method for DeprecatedClone {
13172 const ORDINAL: u64 = 6512600400724287855;
13173 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13174 ::fidl_next::protocol::Flexibility::Flexible;
13175
13176 type Protocol = crate::File;
13177
13178 type Request = crate::wire::NodeDeprecatedCloneRequest;
13179 }
13180
13181 pub struct OnOpen;
13182
13183 impl ::fidl_next::Method for OnOpen {
13184 const ORDINAL: u64 = 9207534335756671346;
13185 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13186 ::fidl_next::protocol::Flexibility::Flexible;
13187
13188 type Protocol = crate::File;
13189
13190 type Request = crate::wire::NodeOnOpenRequest<'static>;
13191 }
13192
13193 pub struct DeprecatedGetAttr;
13194
13195 impl ::fidl_next::Method for DeprecatedGetAttr {
13196 const ORDINAL: u64 = 8689798978500614909;
13197 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13198 ::fidl_next::protocol::Flexibility::Strict;
13199
13200 type Protocol = crate::File;
13201
13202 type Request = ::fidl_next::wire::EmptyMessageBody;
13203 }
13204
13205 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
13206 type Response = crate::wire::NodeDeprecatedGetAttrResponse;
13207 }
13208
13209 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
13210 type Output = ___R;
13211
13212 fn respond(response: ___R) -> Self::Output {
13213 response
13214 }
13215 }
13216
13217 pub struct DeprecatedSetAttr;
13218
13219 impl ::fidl_next::Method for DeprecatedSetAttr {
13220 const ORDINAL: u64 = 4721673413776871238;
13221 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13222 ::fidl_next::protocol::Flexibility::Strict;
13223
13224 type Protocol = crate::File;
13225
13226 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
13227 }
13228
13229 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
13230 type Response = crate::wire::NodeDeprecatedSetAttrResponse;
13231 }
13232
13233 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
13234 type Output = crate::generic::NodeDeprecatedSetAttrResponse<___R>;
13235
13236 fn respond(response: ___R) -> Self::Output {
13237 crate::generic::NodeDeprecatedSetAttrResponse { s: response }
13238 }
13239 }
13240
13241 pub struct DeprecatedGetFlags;
13242
13243 impl ::fidl_next::Method for DeprecatedGetFlags {
13244 const ORDINAL: u64 = 6595803110182632097;
13245 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13246 ::fidl_next::protocol::Flexibility::Strict;
13247
13248 type Protocol = crate::File;
13249
13250 type Request = ::fidl_next::wire::EmptyMessageBody;
13251 }
13252
13253 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
13254 type Response = crate::wire::NodeDeprecatedGetFlagsResponse;
13255 }
13256
13257 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
13258 type Output = ___R;
13259
13260 fn respond(response: ___R) -> Self::Output {
13261 response
13262 }
13263 }
13264
13265 pub struct DeprecatedSetFlags;
13266
13267 impl ::fidl_next::Method for DeprecatedSetFlags {
13268 const ORDINAL: u64 = 5950864159036794675;
13269 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13270 ::fidl_next::protocol::Flexibility::Strict;
13271
13272 type Protocol = crate::File;
13273
13274 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
13275 }
13276
13277 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
13278 type Response = crate::wire::NodeDeprecatedSetFlagsResponse;
13279 }
13280
13281 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
13282 type Output = crate::generic::NodeDeprecatedSetFlagsResponse<___R>;
13283
13284 fn respond(response: ___R) -> Self::Output {
13285 crate::generic::NodeDeprecatedSetFlagsResponse { s: response }
13286 }
13287 }
13288
13289 pub struct GetFlags;
13290
13291 impl ::fidl_next::Method for GetFlags {
13292 const ORDINAL: u64 = 105530239381466147;
13293 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13294 ::fidl_next::protocol::Flexibility::Flexible;
13295
13296 type Protocol = crate::File;
13297
13298 type Request = ::fidl_next::wire::EmptyMessageBody;
13299 }
13300
13301 impl ::fidl_next::TwoWayMethod for GetFlags {
13302 type Response = ::fidl_next::wire::FlexibleResult<
13303 'static,
13304 crate::wire::NodeGetFlagsResponse,
13305 ::fidl_next::wire::Int32,
13306 >;
13307 }
13308
13309 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
13310 type Output = ::fidl_next::FlexibleResult<
13311 crate::generic::NodeGetFlagsResponse<___R>,
13312 ::fidl_next::util::Never,
13313 >;
13314
13315 fn respond(response: ___R) -> Self::Output {
13316 ::fidl_next::FlexibleResult::Ok(crate::generic::NodeGetFlagsResponse {
13317 flags: response,
13318 })
13319 }
13320 }
13321
13322 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
13323 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
13324
13325 fn respond_err(response: ___R) -> Self::Output {
13326 ::fidl_next::FlexibleResult::Err(response)
13327 }
13328 }
13329
13330 pub struct SetFlags;
13331
13332 impl ::fidl_next::Method for SetFlags {
13333 const ORDINAL: u64 = 6172186066099445416;
13334 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13335 ::fidl_next::protocol::Flexibility::Flexible;
13336
13337 type Protocol = crate::File;
13338
13339 type Request = crate::wire::NodeSetFlagsRequest;
13340 }
13341
13342 impl ::fidl_next::TwoWayMethod for SetFlags {
13343 type Response = ::fidl_next::wire::FlexibleResult<
13344 'static,
13345 crate::wire::NodeSetFlagsResponse,
13346 ::fidl_next::wire::Int32,
13347 >;
13348 }
13349
13350 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
13351 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
13352
13353 fn respond(response: ___R) -> Self::Output {
13354 ::fidl_next::FlexibleResult::Ok(response)
13355 }
13356 }
13357
13358 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
13359 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
13360
13361 fn respond_err(response: ___R) -> Self::Output {
13362 ::fidl_next::FlexibleResult::Err(response)
13363 }
13364 }
13365
13366 pub struct QueryFilesystem;
13367
13368 impl ::fidl_next::Method for QueryFilesystem {
13369 const ORDINAL: u64 = 8013111122914313744;
13370 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13371 ::fidl_next::protocol::Flexibility::Strict;
13372
13373 type Protocol = crate::File;
13374
13375 type Request = ::fidl_next::wire::EmptyMessageBody;
13376 }
13377
13378 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
13379 type Response = crate::wire::NodeQueryFilesystemResponse<'static>;
13380 }
13381
13382 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
13383 type Output = ___R;
13384
13385 fn respond(response: ___R) -> Self::Output {
13386 response
13387 }
13388 }
13389
13390 pub struct OnRepresentation;
13391
13392 impl ::fidl_next::Method for OnRepresentation {
13393 const ORDINAL: u64 = 6679970090861613324;
13394 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13395 ::fidl_next::protocol::Flexibility::Strict;
13396
13397 type Protocol = crate::File;
13398
13399 type Request = crate::wire::Representation<'static>;
13400 }
13401
13402 pub struct GetAttributes;
13403
13404 impl ::fidl_next::Method for GetAttributes {
13405 const ORDINAL: u64 = 4414537700416816443;
13406 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13407 ::fidl_next::protocol::Flexibility::Strict;
13408
13409 type Protocol = crate::File;
13410
13411 type Request = crate::wire::NodeGetAttributesRequest;
13412 }
13413
13414 impl ::fidl_next::TwoWayMethod for GetAttributes {
13415 type Response = ::fidl_next::wire::Result<
13416 'static,
13417 crate::wire::NodeAttributes2<'static>,
13418 ::fidl_next::wire::Int32,
13419 >;
13420 }
13421
13422 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
13423 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13424
13425 fn respond(response: ___R) -> Self::Output {
13426 ::core::result::Result::Ok(response)
13427 }
13428 }
13429
13430 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
13431 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13432
13433 fn respond_err(response: ___R) -> Self::Output {
13434 ::core::result::Result::Err(response)
13435 }
13436 }
13437
13438 pub struct UpdateAttributes;
13439
13440 impl ::fidl_next::Method for UpdateAttributes {
13441 const ORDINAL: u64 = 3677402239314018056;
13442 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13443 ::fidl_next::protocol::Flexibility::Strict;
13444
13445 type Protocol = crate::File;
13446
13447 type Request = crate::wire::MutableNodeAttributes<'static>;
13448 }
13449
13450 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
13451 type Response = ::fidl_next::wire::Result<
13452 'static,
13453 crate::wire::NodeUpdateAttributesResponse,
13454 ::fidl_next::wire::Int32,
13455 >;
13456 }
13457
13458 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
13459 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13460
13461 fn respond(response: ___R) -> Self::Output {
13462 ::core::result::Result::Ok(response)
13463 }
13464 }
13465
13466 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
13467 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13468
13469 fn respond_err(response: ___R) -> Self::Output {
13470 ::core::result::Result::Err(response)
13471 }
13472 }
13473
13474 pub struct Sync;
13475
13476 impl ::fidl_next::Method for Sync {
13477 const ORDINAL: u64 = 3196473584242777161;
13478 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13479 ::fidl_next::protocol::Flexibility::Strict;
13480
13481 type Protocol = crate::File;
13482
13483 type Request = ::fidl_next::wire::EmptyMessageBody;
13484 }
13485
13486 impl ::fidl_next::TwoWayMethod for Sync {
13487 type Response = ::fidl_next::wire::Result<
13488 'static,
13489 crate::wire::NodeSyncResponse,
13490 ::fidl_next::wire::Int32,
13491 >;
13492 }
13493
13494 impl<___R> ::fidl_next::Respond<___R> for Sync {
13495 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13496
13497 fn respond(response: ___R) -> Self::Output {
13498 ::core::result::Result::Ok(response)
13499 }
13500 }
13501
13502 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
13503 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13504
13505 fn respond_err(response: ___R) -> Self::Output {
13506 ::core::result::Result::Err(response)
13507 }
13508 }
13509
13510 pub struct ListExtendedAttributes;
13511
13512 impl ::fidl_next::Method for ListExtendedAttributes {
13513 const ORDINAL: u64 = 5431626189872037072;
13514 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13515 ::fidl_next::protocol::Flexibility::Strict;
13516
13517 type Protocol = crate::File;
13518
13519 type Request = crate::wire::NodeListExtendedAttributesRequest;
13520 }
13521
13522 pub struct GetExtendedAttribute;
13523
13524 impl ::fidl_next::Method for GetExtendedAttribute {
13525 const ORDINAL: u64 = 5043930208506967771;
13526 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13527 ::fidl_next::protocol::Flexibility::Strict;
13528
13529 type Protocol = crate::File;
13530
13531 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
13532 }
13533
13534 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
13535 type Response = ::fidl_next::wire::Result<
13536 'static,
13537 crate::wire::ExtendedAttributeValue<'static>,
13538 ::fidl_next::wire::Int32,
13539 >;
13540 }
13541
13542 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
13543 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13544
13545 fn respond(response: ___R) -> Self::Output {
13546 ::core::result::Result::Ok(response)
13547 }
13548 }
13549
13550 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
13551 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13552
13553 fn respond_err(response: ___R) -> Self::Output {
13554 ::core::result::Result::Err(response)
13555 }
13556 }
13557
13558 pub struct SetExtendedAttribute;
13559
13560 impl ::fidl_next::Method for SetExtendedAttribute {
13561 const ORDINAL: u64 = 5374223046099989052;
13562 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13563 ::fidl_next::protocol::Flexibility::Strict;
13564
13565 type Protocol = crate::File;
13566
13567 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
13568 }
13569
13570 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
13571 type Response = ::fidl_next::wire::Result<
13572 'static,
13573 crate::wire::NodeSetExtendedAttributeResponse,
13574 ::fidl_next::wire::Int32,
13575 >;
13576 }
13577
13578 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
13579 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13580
13581 fn respond(response: ___R) -> Self::Output {
13582 ::core::result::Result::Ok(response)
13583 }
13584 }
13585
13586 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
13587 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13588
13589 fn respond_err(response: ___R) -> Self::Output {
13590 ::core::result::Result::Err(response)
13591 }
13592 }
13593
13594 pub struct RemoveExtendedAttribute;
13595
13596 impl ::fidl_next::Method for RemoveExtendedAttribute {
13597 const ORDINAL: u64 = 8794297771444732717;
13598 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13599 ::fidl_next::protocol::Flexibility::Strict;
13600
13601 type Protocol = crate::File;
13602
13603 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
13604 }
13605
13606 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
13607 type Response = ::fidl_next::wire::Result<
13608 'static,
13609 crate::wire::NodeRemoveExtendedAttributeResponse,
13610 ::fidl_next::wire::Int32,
13611 >;
13612 }
13613
13614 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
13615 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13616
13617 fn respond(response: ___R) -> Self::Output {
13618 ::core::result::Result::Ok(response)
13619 }
13620 }
13621
13622 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
13623 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13624
13625 fn respond_err(response: ___R) -> Self::Output {
13626 ::core::result::Result::Err(response)
13627 }
13628 }
13629
13630 pub struct Read;
13631
13632 impl ::fidl_next::Method for Read {
13633 const ORDINAL: u64 = 395825947633028830;
13634 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13635 ::fidl_next::protocol::Flexibility::Strict;
13636
13637 type Protocol = crate::File;
13638
13639 type Request = crate::wire::ReadableReadRequest;
13640 }
13641
13642 impl ::fidl_next::TwoWayMethod for Read {
13643 type Response = ::fidl_next::wire::Result<
13644 'static,
13645 crate::wire::ReadableReadResponse<'static>,
13646 ::fidl_next::wire::Int32,
13647 >;
13648 }
13649
13650 impl<___R> ::fidl_next::Respond<___R> for Read {
13651 type Output = ::core::result::Result<
13652 crate::generic::ReadableReadResponse<___R>,
13653 ::fidl_next::util::Never,
13654 >;
13655
13656 fn respond(response: ___R) -> Self::Output {
13657 ::core::result::Result::Ok(crate::generic::ReadableReadResponse { data: response })
13658 }
13659 }
13660
13661 impl<___R> ::fidl_next::RespondErr<___R> for Read {
13662 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13663
13664 fn respond_err(response: ___R) -> Self::Output {
13665 ::core::result::Result::Err(response)
13666 }
13667 }
13668
13669 pub struct Write;
13670
13671 impl ::fidl_next::Method for Write {
13672 const ORDINAL: u64 = 7651971425397809026;
13673 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13674 ::fidl_next::protocol::Flexibility::Strict;
13675
13676 type Protocol = crate::File;
13677
13678 type Request = crate::wire::WritableWriteRequest<'static>;
13679 }
13680
13681 impl ::fidl_next::TwoWayMethod for Write {
13682 type Response = ::fidl_next::wire::Result<
13683 'static,
13684 crate::wire::WritableWriteResponse,
13685 ::fidl_next::wire::Int32,
13686 >;
13687 }
13688
13689 impl<___R> ::fidl_next::Respond<___R> for Write {
13690 type Output = ::core::result::Result<
13691 crate::generic::WritableWriteResponse<___R>,
13692 ::fidl_next::util::Never,
13693 >;
13694
13695 fn respond(response: ___R) -> Self::Output {
13696 ::core::result::Result::Ok(crate::generic::WritableWriteResponse {
13697 actual_count: response,
13698 })
13699 }
13700 }
13701
13702 impl<___R> ::fidl_next::RespondErr<___R> for Write {
13703 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13704
13705 fn respond_err(response: ___R) -> Self::Output {
13706 ::core::result::Result::Err(response)
13707 }
13708 }
13709
13710 pub struct Describe;
13711
13712 impl ::fidl_next::Method for Describe {
13713 const ORDINAL: u64 = 7545125870053689020;
13714 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13715 ::fidl_next::protocol::Flexibility::Strict;
13716
13717 type Protocol = crate::File;
13718
13719 type Request = ::fidl_next::wire::EmptyMessageBody;
13720 }
13721
13722 impl ::fidl_next::TwoWayMethod for Describe {
13723 type Response = crate::wire::FileInfo<'static>;
13724 }
13725
13726 impl<___R> ::fidl_next::Respond<___R> for Describe {
13727 type Output = ___R;
13728
13729 fn respond(response: ___R) -> Self::Output {
13730 response
13731 }
13732 }
13733
13734 pub struct Seek;
13735
13736 impl ::fidl_next::Method for Seek {
13737 const ORDINAL: u64 = 8649041485622956551;
13738 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13739 ::fidl_next::protocol::Flexibility::Strict;
13740
13741 type Protocol = crate::File;
13742
13743 type Request = crate::wire::FileSeekRequest;
13744 }
13745
13746 impl ::fidl_next::TwoWayMethod for Seek {
13747 type Response = ::fidl_next::wire::Result<
13748 'static,
13749 crate::wire::FileSeekResponse,
13750 ::fidl_next::wire::Int32,
13751 >;
13752 }
13753
13754 impl<___R> ::fidl_next::Respond<___R> for Seek {
13755 type Output = ::core::result::Result<
13756 crate::generic::FileSeekResponse<___R>,
13757 ::fidl_next::util::Never,
13758 >;
13759
13760 fn respond(response: ___R) -> Self::Output {
13761 ::core::result::Result::Ok(crate::generic::FileSeekResponse {
13762 offset_from_start: response,
13763 })
13764 }
13765 }
13766
13767 impl<___R> ::fidl_next::RespondErr<___R> for Seek {
13768 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13769
13770 fn respond_err(response: ___R) -> Self::Output {
13771 ::core::result::Result::Err(response)
13772 }
13773 }
13774
13775 pub struct ReadAt;
13776
13777 impl ::fidl_next::Method for ReadAt {
13778 const ORDINAL: u64 = 1587416148701180478;
13779 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13780 ::fidl_next::protocol::Flexibility::Strict;
13781
13782 type Protocol = crate::File;
13783
13784 type Request = crate::wire::FileReadAtRequest;
13785 }
13786
13787 impl ::fidl_next::TwoWayMethod for ReadAt {
13788 type Response = ::fidl_next::wire::Result<
13789 'static,
13790 crate::wire::FileReadAtResponse<'static>,
13791 ::fidl_next::wire::Int32,
13792 >;
13793 }
13794
13795 impl<___R> ::fidl_next::Respond<___R> for ReadAt {
13796 type Output = ::core::result::Result<
13797 crate::generic::FileReadAtResponse<___R>,
13798 ::fidl_next::util::Never,
13799 >;
13800
13801 fn respond(response: ___R) -> Self::Output {
13802 ::core::result::Result::Ok(crate::generic::FileReadAtResponse { data: response })
13803 }
13804 }
13805
13806 impl<___R> ::fidl_next::RespondErr<___R> for ReadAt {
13807 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13808
13809 fn respond_err(response: ___R) -> Self::Output {
13810 ::core::result::Result::Err(response)
13811 }
13812 }
13813
13814 pub struct WriteAt;
13815
13816 impl ::fidl_next::Method for WriteAt {
13817 const ORDINAL: u64 = 8736683935131400491;
13818 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13819 ::fidl_next::protocol::Flexibility::Strict;
13820
13821 type Protocol = crate::File;
13822
13823 type Request = crate::wire::FileWriteAtRequest<'static>;
13824 }
13825
13826 impl ::fidl_next::TwoWayMethod for WriteAt {
13827 type Response = ::fidl_next::wire::Result<
13828 'static,
13829 crate::wire::FileWriteAtResponse,
13830 ::fidl_next::wire::Int32,
13831 >;
13832 }
13833
13834 impl<___R> ::fidl_next::Respond<___R> for WriteAt {
13835 type Output = ::core::result::Result<
13836 crate::generic::FileWriteAtResponse<___R>,
13837 ::fidl_next::util::Never,
13838 >;
13839
13840 fn respond(response: ___R) -> Self::Output {
13841 ::core::result::Result::Ok(crate::generic::FileWriteAtResponse {
13842 actual_count: response,
13843 })
13844 }
13845 }
13846
13847 impl<___R> ::fidl_next::RespondErr<___R> for WriteAt {
13848 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13849
13850 fn respond_err(response: ___R) -> Self::Output {
13851 ::core::result::Result::Err(response)
13852 }
13853 }
13854
13855 pub struct Resize;
13856
13857 impl ::fidl_next::Method for Resize {
13858 const ORDINAL: u64 = 3134648685270758458;
13859 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13860 ::fidl_next::protocol::Flexibility::Strict;
13861
13862 type Protocol = crate::File;
13863
13864 type Request = crate::wire::FileResizeRequest;
13865 }
13866
13867 impl ::fidl_next::TwoWayMethod for Resize {
13868 type Response = ::fidl_next::wire::Result<
13869 'static,
13870 crate::wire::FileResizeResponse,
13871 ::fidl_next::wire::Int32,
13872 >;
13873 }
13874
13875 impl<___R> ::fidl_next::Respond<___R> for Resize {
13876 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13877
13878 fn respond(response: ___R) -> Self::Output {
13879 ::core::result::Result::Ok(response)
13880 }
13881 }
13882
13883 impl<___R> ::fidl_next::RespondErr<___R> for Resize {
13884 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13885
13886 fn respond_err(response: ___R) -> Self::Output {
13887 ::core::result::Result::Err(response)
13888 }
13889 }
13890
13891 pub struct GetBackingMemory;
13892
13893 impl ::fidl_next::Method for GetBackingMemory {
13894 const ORDINAL: u64 = 46911652864194091;
13895 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13896 ::fidl_next::protocol::Flexibility::Strict;
13897
13898 type Protocol = crate::File;
13899
13900 type Request = crate::wire::FileGetBackingMemoryRequest;
13901 }
13902
13903 impl ::fidl_next::TwoWayMethod for GetBackingMemory {
13904 type Response = ::fidl_next::wire::Result<
13905 'static,
13906 crate::wire::FileGetBackingMemoryResponse,
13907 ::fidl_next::wire::Int32,
13908 >;
13909 }
13910
13911 impl<___R> ::fidl_next::Respond<___R> for GetBackingMemory {
13912 type Output = ::core::result::Result<
13913 crate::generic::FileGetBackingMemoryResponse<___R>,
13914 ::fidl_next::util::Never,
13915 >;
13916
13917 fn respond(response: ___R) -> Self::Output {
13918 ::core::result::Result::Ok(crate::generic::FileGetBackingMemoryResponse {
13919 vmo: response,
13920 })
13921 }
13922 }
13923
13924 impl<___R> ::fidl_next::RespondErr<___R> for GetBackingMemory {
13925 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13926
13927 fn respond_err(response: ___R) -> Self::Output {
13928 ::core::result::Result::Err(response)
13929 }
13930 }
13931
13932 pub struct Allocate;
13933
13934 impl ::fidl_next::Method for Allocate {
13935 const ORDINAL: u64 = 8645235848064269614;
13936 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13937 ::fidl_next::protocol::Flexibility::Flexible;
13938
13939 type Protocol = crate::File;
13940
13941 type Request = crate::wire::FileAllocateRequest;
13942 }
13943
13944 impl ::fidl_next::TwoWayMethod for Allocate {
13945 type Response = ::fidl_next::wire::FlexibleResult<
13946 'static,
13947 crate::wire::FileAllocateResponse,
13948 ::fidl_next::wire::Int32,
13949 >;
13950 }
13951
13952 impl<___R> ::fidl_next::Respond<___R> for Allocate {
13953 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
13954
13955 fn respond(response: ___R) -> Self::Output {
13956 ::fidl_next::FlexibleResult::Ok(response)
13957 }
13958 }
13959
13960 impl<___R> ::fidl_next::RespondErr<___R> for Allocate {
13961 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
13962
13963 fn respond_err(response: ___R) -> Self::Output {
13964 ::fidl_next::FlexibleResult::Err(response)
13965 }
13966 }
13967
13968 pub struct EnableVerity;
13969
13970 impl ::fidl_next::Method for EnableVerity {
13971 const ORDINAL: u64 = 3189145313204943035;
13972 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13973 ::fidl_next::protocol::Flexibility::Flexible;
13974
13975 type Protocol = crate::File;
13976
13977 type Request = crate::wire::FileEnableVerityRequest<'static>;
13978 }
13979
13980 impl ::fidl_next::TwoWayMethod for EnableVerity {
13981 type Response = ::fidl_next::wire::FlexibleResult<
13982 'static,
13983 crate::wire::FileEnableVerityResponse,
13984 ::fidl_next::wire::Int32,
13985 >;
13986 }
13987
13988 impl<___R> ::fidl_next::Respond<___R> for EnableVerity {
13989 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
13990
13991 fn respond(response: ___R) -> Self::Output {
13992 ::fidl_next::FlexibleResult::Ok(response)
13993 }
13994 }
13995
13996 impl<___R> ::fidl_next::RespondErr<___R> for EnableVerity {
13997 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
13998
13999 fn respond_err(response: ___R) -> Self::Output {
14000 ::fidl_next::FlexibleResult::Err(response)
14001 }
14002 }
14003
14004 mod ___detail {
14005 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::File
14006 where
14007 ___T: ::fidl_next::Transport,
14008 {
14009 type Client = FileClient<___T>;
14010 type Server = FileServer<___T>;
14011 }
14012
14013 #[repr(transparent)]
14015 pub struct FileClient<___T: ::fidl_next::Transport> {
14016 #[allow(dead_code)]
14017 client: ::fidl_next::protocol::Client<___T>,
14018 }
14019
14020 impl<___T> FileClient<___T>
14021 where
14022 ___T: ::fidl_next::Transport,
14023 {
14024 #[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"]
14025 pub fn advisory_lock(
14026 &self,
14027
14028 request: impl ::fidl_next::Encode<
14029 crate::wire::AdvisoryLockRequest<'static>,
14030 <___T as ::fidl_next::Transport>::SendBuffer,
14031 >,
14032 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
14033 where
14034 <___T as ::fidl_next::Transport>::SendBuffer:
14035 ::fidl_next::encoder::InternalHandleEncoder,
14036 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14037 {
14038 self.advisory_lock_with(crate::generic::AdvisoryLockingAdvisoryLockRequest {
14039 request,
14040 })
14041 }
14042
14043 #[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"]
14044 pub fn advisory_lock_with<___R>(
14045 &self,
14046 request: ___R,
14047 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
14048 where
14049 ___R: ::fidl_next::Encode<
14050 crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
14051 <___T as ::fidl_next::Transport>::SendBuffer,
14052 >,
14053 {
14054 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14055 7992130864415541162,
14056 <super::AdvisoryLock as ::fidl_next::Method>::FLEXIBILITY,
14057 request,
14058 ))
14059 }
14060
14061 #[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"]
14062 pub fn link_into(
14063 &self,
14064
14065 dst_parent_token: impl ::fidl_next::Encode<
14066 ::fdomain_client::fidl_next::wire::Handle,
14067 <___T as ::fidl_next::Transport>::SendBuffer,
14068 >,
14069
14070 dst: impl ::fidl_next::Encode<
14071 ::fidl_next::wire::String<'static>,
14072 <___T as ::fidl_next::Transport>::SendBuffer,
14073 >,
14074 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
14075 where
14076 <___T as ::fidl_next::Transport>::SendBuffer:
14077 ::fidl_next::encoder::InternalHandleEncoder,
14078 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14079 <___T as ::fidl_next::Transport>::SendBuffer:
14080 ::fdomain_client::fidl_next::HandleEncoder,
14081 {
14082 self.link_into_with(crate::generic::LinkableLinkIntoRequest {
14083 dst_parent_token,
14084
14085 dst,
14086 })
14087 }
14088
14089 #[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"]
14090 pub fn link_into_with<___R>(
14091 &self,
14092 request: ___R,
14093 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
14094 where
14095 ___R: ::fidl_next::Encode<
14096 crate::wire::LinkableLinkIntoRequest<'static>,
14097 <___T as ::fidl_next::Transport>::SendBuffer,
14098 >,
14099 {
14100 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14101 6121399674497678964,
14102 <super::LinkInto as ::fidl_next::Method>::FLEXIBILITY,
14103 request,
14104 ))
14105 }
14106
14107 pub fn clone(
14108 &self,
14109
14110 request: impl ::fidl_next::Encode<
14111 ::fidl_next::ServerEnd<
14112 ::fdomain_next_fuchsia_unknown::Cloneable,
14113 ::fdomain_client::fidl_next::wire::Handle,
14114 >,
14115 <___T as ::fidl_next::Transport>::SendBuffer,
14116 >,
14117 ) -> ::fidl_next::SendFuture<'_, ___T>
14118 where
14119 <___T as ::fidl_next::Transport>::SendBuffer:
14120 ::fidl_next::encoder::InternalHandleEncoder,
14121 <___T as ::fidl_next::Transport>::SendBuffer:
14122 ::fdomain_client::fidl_next::HandleEncoder,
14123 {
14124 self.clone_with(::fdomain_next_fuchsia_unknown::generic::CloneableCloneRequest {
14125 request,
14126 })
14127 }
14128
14129 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
14130 where
14131 ___R: ::fidl_next::Encode<
14132 ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest,
14133 <___T as ::fidl_next::Transport>::SendBuffer,
14134 >,
14135 {
14136 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
14137 2366825959783828089,
14138 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
14139 request,
14140 ))
14141 }
14142
14143 #[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"]
14144 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
14145 ::fidl_next::TwoWayFuture::from_untyped(
14146 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14147 6540867515453498750,
14148 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
14149 (),
14150 ),
14151 )
14152 }
14153
14154 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
14155 ::fidl_next::TwoWayFuture::from_untyped(
14156 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14157 2763219980499352582,
14158 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
14159 (),
14160 ),
14161 )
14162 }
14163
14164 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
14165 pub fn deprecated_clone(
14166 &self,
14167
14168 flags: impl ::fidl_next::Encode<
14169 crate::wire::OpenFlags,
14170 <___T as ::fidl_next::Transport>::SendBuffer,
14171 >,
14172
14173 object: impl ::fidl_next::Encode<
14174 ::fidl_next::ServerEnd<crate::Node, ::fdomain_client::fidl_next::wire::Handle>,
14175 <___T as ::fidl_next::Transport>::SendBuffer,
14176 >,
14177 ) -> ::fidl_next::SendFuture<'_, ___T>
14178 where
14179 <___T as ::fidl_next::Transport>::SendBuffer:
14180 ::fidl_next::encoder::InternalHandleEncoder,
14181 <___T as ::fidl_next::Transport>::SendBuffer:
14182 ::fdomain_client::fidl_next::HandleEncoder,
14183 {
14184 self.deprecated_clone_with(crate::generic::NodeDeprecatedCloneRequest {
14185 flags,
14186
14187 object,
14188 })
14189 }
14190
14191 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
14192 pub fn deprecated_clone_with<___R>(
14193 &self,
14194 request: ___R,
14195 ) -> ::fidl_next::SendFuture<'_, ___T>
14196 where
14197 ___R: ::fidl_next::Encode<
14198 crate::wire::NodeDeprecatedCloneRequest,
14199 <___T as ::fidl_next::Transport>::SendBuffer,
14200 >,
14201 {
14202 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
14203 6512600400724287855,
14204 <super::DeprecatedClone as ::fidl_next::Method>::FLEXIBILITY,
14205 request,
14206 ))
14207 }
14208
14209 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
14210 pub fn deprecated_get_attr(
14211 &self,
14212 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
14213 ::fidl_next::TwoWayFuture::from_untyped(
14214 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14215 8689798978500614909,
14216 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
14217 (),
14218 ),
14219 )
14220 }
14221
14222 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
14223 pub fn deprecated_set_attr(
14224 &self,
14225
14226 flags: impl ::fidl_next::Encode<
14227 crate::wire::NodeAttributeFlags,
14228 <___T as ::fidl_next::Transport>::SendBuffer,
14229 >,
14230
14231 attributes: impl ::fidl_next::Encode<
14232 crate::wire::NodeAttributes,
14233 <___T as ::fidl_next::Transport>::SendBuffer,
14234 >,
14235 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
14236 where
14237 <___T as ::fidl_next::Transport>::SendBuffer:
14238 ::fidl_next::encoder::InternalHandleEncoder,
14239 {
14240 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
14241 flags,
14242
14243 attributes,
14244 })
14245 }
14246
14247 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
14248 pub fn deprecated_set_attr_with<___R>(
14249 &self,
14250 request: ___R,
14251 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
14252 where
14253 ___R: ::fidl_next::Encode<
14254 crate::wire::NodeDeprecatedSetAttrRequest,
14255 <___T as ::fidl_next::Transport>::SendBuffer,
14256 >,
14257 {
14258 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14259 4721673413776871238,
14260 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
14261 request,
14262 ))
14263 }
14264
14265 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
14266 pub fn deprecated_get_flags(
14267 &self,
14268 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
14269 ::fidl_next::TwoWayFuture::from_untyped(
14270 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14271 6595803110182632097,
14272 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
14273 (),
14274 ),
14275 )
14276 }
14277
14278 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
14279 pub fn deprecated_set_flags(
14280 &self,
14281
14282 flags: impl ::fidl_next::Encode<
14283 crate::wire::OpenFlags,
14284 <___T as ::fidl_next::Transport>::SendBuffer,
14285 >,
14286 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
14287 where
14288 <___T as ::fidl_next::Transport>::SendBuffer:
14289 ::fidl_next::encoder::InternalHandleEncoder,
14290 {
14291 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
14292 flags,
14293 })
14294 }
14295
14296 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
14297 pub fn deprecated_set_flags_with<___R>(
14298 &self,
14299 request: ___R,
14300 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
14301 where
14302 ___R: ::fidl_next::Encode<
14303 crate::wire::NodeDeprecatedSetFlagsRequest,
14304 <___T as ::fidl_next::Transport>::SendBuffer,
14305 >,
14306 {
14307 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14308 5950864159036794675,
14309 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
14310 request,
14311 ))
14312 }
14313
14314 #[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"]
14315 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
14316 ::fidl_next::TwoWayFuture::from_untyped(
14317 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14318 105530239381466147,
14319 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
14320 (),
14321 ),
14322 )
14323 }
14324
14325 #[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"]
14326 pub fn set_flags(
14327 &self,
14328
14329 flags: impl ::fidl_next::Encode<
14330 crate::wire::Flags,
14331 <___T as ::fidl_next::Transport>::SendBuffer,
14332 >,
14333 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
14334 where
14335 <___T as ::fidl_next::Transport>::SendBuffer:
14336 ::fidl_next::encoder::InternalHandleEncoder,
14337 {
14338 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
14339 }
14340
14341 #[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"]
14342 pub fn set_flags_with<___R>(
14343 &self,
14344 request: ___R,
14345 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
14346 where
14347 ___R: ::fidl_next::Encode<
14348 crate::wire::NodeSetFlagsRequest,
14349 <___T as ::fidl_next::Transport>::SendBuffer,
14350 >,
14351 {
14352 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14353 6172186066099445416,
14354 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
14355 request,
14356 ))
14357 }
14358
14359 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
14360 pub fn query_filesystem(
14361 &self,
14362 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
14363 ::fidl_next::TwoWayFuture::from_untyped(
14364 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14365 8013111122914313744,
14366 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
14367 (),
14368 ),
14369 )
14370 }
14371
14372 #[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"]
14373 pub fn get_attributes(
14374 &self,
14375
14376 query: impl ::fidl_next::Encode<
14377 crate::wire::NodeAttributesQuery,
14378 <___T as ::fidl_next::Transport>::SendBuffer,
14379 >,
14380 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
14381 where
14382 <___T as ::fidl_next::Transport>::SendBuffer:
14383 ::fidl_next::encoder::InternalHandleEncoder,
14384 {
14385 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
14386 }
14387
14388 #[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"]
14389 pub fn get_attributes_with<___R>(
14390 &self,
14391 request: ___R,
14392 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
14393 where
14394 ___R: ::fidl_next::Encode<
14395 crate::wire::NodeGetAttributesRequest,
14396 <___T as ::fidl_next::Transport>::SendBuffer,
14397 >,
14398 {
14399 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14400 4414537700416816443,
14401 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
14402 request,
14403 ))
14404 }
14405
14406 #[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"]
14407 pub fn update_attributes_with<___R>(
14408 &self,
14409 request: ___R,
14410 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
14411 where
14412 ___R: ::fidl_next::Encode<
14413 crate::wire::MutableNodeAttributes<'static>,
14414 <___T as ::fidl_next::Transport>::SendBuffer,
14415 >,
14416 {
14417 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14418 3677402239314018056,
14419 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
14420 request,
14421 ))
14422 }
14423
14424 #[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"]
14425 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
14426 ::fidl_next::TwoWayFuture::from_untyped(
14427 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14428 3196473584242777161,
14429 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
14430 (),
14431 ),
14432 )
14433 }
14434
14435 #[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"]
14436 pub fn list_extended_attributes(
14437 &self,
14438
14439 iterator: impl ::fidl_next::Encode<
14440 ::fidl_next::ServerEnd<
14441 crate::ExtendedAttributeIterator,
14442 ::fdomain_client::fidl_next::wire::Handle,
14443 >,
14444 <___T as ::fidl_next::Transport>::SendBuffer,
14445 >,
14446 ) -> ::fidl_next::SendFuture<'_, ___T>
14447 where
14448 <___T as ::fidl_next::Transport>::SendBuffer:
14449 ::fidl_next::encoder::InternalHandleEncoder,
14450 <___T as ::fidl_next::Transport>::SendBuffer:
14451 ::fdomain_client::fidl_next::HandleEncoder,
14452 {
14453 self.list_extended_attributes_with(
14454 crate::generic::NodeListExtendedAttributesRequest { iterator },
14455 )
14456 }
14457
14458 #[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"]
14459 pub fn list_extended_attributes_with<___R>(
14460 &self,
14461 request: ___R,
14462 ) -> ::fidl_next::SendFuture<'_, ___T>
14463 where
14464 ___R: ::fidl_next::Encode<
14465 crate::wire::NodeListExtendedAttributesRequest,
14466 <___T as ::fidl_next::Transport>::SendBuffer,
14467 >,
14468 {
14469 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
14470 5431626189872037072,
14471 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
14472 request,
14473 ))
14474 }
14475
14476 #[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"]
14477 pub fn get_extended_attribute(
14478 &self,
14479
14480 name: impl ::fidl_next::Encode<
14481 ::fidl_next::wire::Vector<'static, u8>,
14482 <___T as ::fidl_next::Transport>::SendBuffer,
14483 >,
14484 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
14485 where
14486 <___T as ::fidl_next::Transport>::SendBuffer:
14487 ::fidl_next::encoder::InternalHandleEncoder,
14488 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14489 {
14490 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
14491 name,
14492 })
14493 }
14494
14495 #[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"]
14496 pub fn get_extended_attribute_with<___R>(
14497 &self,
14498 request: ___R,
14499 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
14500 where
14501 ___R: ::fidl_next::Encode<
14502 crate::wire::NodeGetExtendedAttributeRequest<'static>,
14503 <___T as ::fidl_next::Transport>::SendBuffer,
14504 >,
14505 {
14506 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14507 5043930208506967771,
14508 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
14509 request,
14510 ))
14511 }
14512
14513 #[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"]
14514 pub fn set_extended_attribute(
14515 &self,
14516
14517 name: impl ::fidl_next::Encode<
14518 ::fidl_next::wire::Vector<'static, u8>,
14519 <___T as ::fidl_next::Transport>::SendBuffer,
14520 >,
14521
14522 value: impl ::fidl_next::Encode<
14523 crate::wire::ExtendedAttributeValue<'static>,
14524 <___T as ::fidl_next::Transport>::SendBuffer,
14525 >,
14526
14527 mode: impl ::fidl_next::Encode<
14528 crate::wire::SetExtendedAttributeMode,
14529 <___T as ::fidl_next::Transport>::SendBuffer,
14530 >,
14531 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
14532 where
14533 <___T as ::fidl_next::Transport>::SendBuffer:
14534 ::fidl_next::encoder::InternalHandleEncoder,
14535 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14536 <___T as ::fidl_next::Transport>::SendBuffer:
14537 ::fdomain_client::fidl_next::HandleEncoder,
14538 {
14539 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
14540 name,
14541
14542 value,
14543
14544 mode,
14545 })
14546 }
14547
14548 #[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"]
14549 pub fn set_extended_attribute_with<___R>(
14550 &self,
14551 request: ___R,
14552 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
14553 where
14554 ___R: ::fidl_next::Encode<
14555 crate::wire::NodeSetExtendedAttributeRequest<'static>,
14556 <___T as ::fidl_next::Transport>::SendBuffer,
14557 >,
14558 {
14559 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14560 5374223046099989052,
14561 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
14562 request,
14563 ))
14564 }
14565
14566 #[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"]
14567 pub fn remove_extended_attribute(
14568 &self,
14569
14570 name: impl ::fidl_next::Encode<
14571 ::fidl_next::wire::Vector<'static, u8>,
14572 <___T as ::fidl_next::Transport>::SendBuffer,
14573 >,
14574 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
14575 where
14576 <___T as ::fidl_next::Transport>::SendBuffer:
14577 ::fidl_next::encoder::InternalHandleEncoder,
14578 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14579 {
14580 self.remove_extended_attribute_with(
14581 crate::generic::NodeRemoveExtendedAttributeRequest { name },
14582 )
14583 }
14584
14585 #[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"]
14586 pub fn remove_extended_attribute_with<___R>(
14587 &self,
14588 request: ___R,
14589 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
14590 where
14591 ___R: ::fidl_next::Encode<
14592 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
14593 <___T as ::fidl_next::Transport>::SendBuffer,
14594 >,
14595 {
14596 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14597 8794297771444732717,
14598 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
14599 request,
14600 ))
14601 }
14602
14603 #[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"]
14604 pub fn read(
14605 &self,
14606
14607 count: impl ::fidl_next::Encode<
14608 ::fidl_next::wire::Uint64,
14609 <___T as ::fidl_next::Transport>::SendBuffer,
14610 >,
14611 ) -> ::fidl_next::TwoWayFuture<'_, super::Read, ___T>
14612 where
14613 <___T as ::fidl_next::Transport>::SendBuffer:
14614 ::fidl_next::encoder::InternalHandleEncoder,
14615 {
14616 self.read_with(crate::generic::ReadableReadRequest { count })
14617 }
14618
14619 #[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"]
14620 pub fn read_with<___R>(
14621 &self,
14622 request: ___R,
14623 ) -> ::fidl_next::TwoWayFuture<'_, super::Read, ___T>
14624 where
14625 ___R: ::fidl_next::Encode<
14626 crate::wire::ReadableReadRequest,
14627 <___T as ::fidl_next::Transport>::SendBuffer,
14628 >,
14629 {
14630 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14631 395825947633028830,
14632 <super::Read as ::fidl_next::Method>::FLEXIBILITY,
14633 request,
14634 ))
14635 }
14636
14637 #[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"]
14638 pub fn write(
14639 &self,
14640
14641 data: impl ::fidl_next::Encode<
14642 ::fidl_next::wire::Vector<'static, u8>,
14643 <___T as ::fidl_next::Transport>::SendBuffer,
14644 >,
14645 ) -> ::fidl_next::TwoWayFuture<'_, super::Write, ___T>
14646 where
14647 <___T as ::fidl_next::Transport>::SendBuffer:
14648 ::fidl_next::encoder::InternalHandleEncoder,
14649 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14650 {
14651 self.write_with(crate::generic::WritableWriteRequest { data })
14652 }
14653
14654 #[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"]
14655 pub fn write_with<___R>(
14656 &self,
14657 request: ___R,
14658 ) -> ::fidl_next::TwoWayFuture<'_, super::Write, ___T>
14659 where
14660 ___R: ::fidl_next::Encode<
14661 crate::wire::WritableWriteRequest<'static>,
14662 <___T as ::fidl_next::Transport>::SendBuffer,
14663 >,
14664 {
14665 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14666 7651971425397809026,
14667 <super::Write as ::fidl_next::Method>::FLEXIBILITY,
14668 request,
14669 ))
14670 }
14671
14672 pub fn describe(&self) -> ::fidl_next::TwoWayFuture<'_, super::Describe, ___T> {
14673 ::fidl_next::TwoWayFuture::from_untyped(
14674 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14675 7545125870053689020,
14676 <super::Describe as ::fidl_next::Method>::FLEXIBILITY,
14677 (),
14678 ),
14679 )
14680 }
14681
14682 #[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"]
14683 pub fn seek(
14684 &self,
14685
14686 origin: impl ::fidl_next::Encode<
14687 crate::wire::SeekOrigin,
14688 <___T as ::fidl_next::Transport>::SendBuffer,
14689 >,
14690
14691 offset: impl ::fidl_next::Encode<
14692 ::fidl_next::wire::Int64,
14693 <___T as ::fidl_next::Transport>::SendBuffer,
14694 >,
14695 ) -> ::fidl_next::TwoWayFuture<'_, super::Seek, ___T>
14696 where
14697 <___T as ::fidl_next::Transport>::SendBuffer:
14698 ::fidl_next::encoder::InternalHandleEncoder,
14699 {
14700 self.seek_with(crate::generic::FileSeekRequest { origin, offset })
14701 }
14702
14703 #[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"]
14704 pub fn seek_with<___R>(
14705 &self,
14706 request: ___R,
14707 ) -> ::fidl_next::TwoWayFuture<'_, super::Seek, ___T>
14708 where
14709 ___R: ::fidl_next::Encode<
14710 crate::wire::FileSeekRequest,
14711 <___T as ::fidl_next::Transport>::SendBuffer,
14712 >,
14713 {
14714 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14715 8649041485622956551,
14716 <super::Seek as ::fidl_next::Method>::FLEXIBILITY,
14717 request,
14718 ))
14719 }
14720
14721 #[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"]
14722 pub fn read_at(
14723 &self,
14724
14725 count: impl ::fidl_next::Encode<
14726 ::fidl_next::wire::Uint64,
14727 <___T as ::fidl_next::Transport>::SendBuffer,
14728 >,
14729
14730 offset: impl ::fidl_next::Encode<
14731 ::fidl_next::wire::Uint64,
14732 <___T as ::fidl_next::Transport>::SendBuffer,
14733 >,
14734 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadAt, ___T>
14735 where
14736 <___T as ::fidl_next::Transport>::SendBuffer:
14737 ::fidl_next::encoder::InternalHandleEncoder,
14738 {
14739 self.read_at_with(crate::generic::FileReadAtRequest { count, offset })
14740 }
14741
14742 #[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"]
14743 pub fn read_at_with<___R>(
14744 &self,
14745 request: ___R,
14746 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadAt, ___T>
14747 where
14748 ___R: ::fidl_next::Encode<
14749 crate::wire::FileReadAtRequest,
14750 <___T as ::fidl_next::Transport>::SendBuffer,
14751 >,
14752 {
14753 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14754 1587416148701180478,
14755 <super::ReadAt as ::fidl_next::Method>::FLEXIBILITY,
14756 request,
14757 ))
14758 }
14759
14760 #[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"]
14761 pub fn write_at(
14762 &self,
14763
14764 data: impl ::fidl_next::Encode<
14765 ::fidl_next::wire::Vector<'static, u8>,
14766 <___T as ::fidl_next::Transport>::SendBuffer,
14767 >,
14768
14769 offset: impl ::fidl_next::Encode<
14770 ::fidl_next::wire::Uint64,
14771 <___T as ::fidl_next::Transport>::SendBuffer,
14772 >,
14773 ) -> ::fidl_next::TwoWayFuture<'_, super::WriteAt, ___T>
14774 where
14775 <___T as ::fidl_next::Transport>::SendBuffer:
14776 ::fidl_next::encoder::InternalHandleEncoder,
14777 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14778 {
14779 self.write_at_with(crate::generic::FileWriteAtRequest { data, offset })
14780 }
14781
14782 #[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"]
14783 pub fn write_at_with<___R>(
14784 &self,
14785 request: ___R,
14786 ) -> ::fidl_next::TwoWayFuture<'_, super::WriteAt, ___T>
14787 where
14788 ___R: ::fidl_next::Encode<
14789 crate::wire::FileWriteAtRequest<'static>,
14790 <___T as ::fidl_next::Transport>::SendBuffer,
14791 >,
14792 {
14793 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14794 8736683935131400491,
14795 <super::WriteAt as ::fidl_next::Method>::FLEXIBILITY,
14796 request,
14797 ))
14798 }
14799
14800 #[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"]
14801 pub fn resize(
14802 &self,
14803
14804 length: impl ::fidl_next::Encode<
14805 ::fidl_next::wire::Uint64,
14806 <___T as ::fidl_next::Transport>::SendBuffer,
14807 >,
14808 ) -> ::fidl_next::TwoWayFuture<'_, super::Resize, ___T>
14809 where
14810 <___T as ::fidl_next::Transport>::SendBuffer:
14811 ::fidl_next::encoder::InternalHandleEncoder,
14812 {
14813 self.resize_with(crate::generic::FileResizeRequest { length })
14814 }
14815
14816 #[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"]
14817 pub fn resize_with<___R>(
14818 &self,
14819 request: ___R,
14820 ) -> ::fidl_next::TwoWayFuture<'_, super::Resize, ___T>
14821 where
14822 ___R: ::fidl_next::Encode<
14823 crate::wire::FileResizeRequest,
14824 <___T as ::fidl_next::Transport>::SendBuffer,
14825 >,
14826 {
14827 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14828 3134648685270758458,
14829 <super::Resize as ::fidl_next::Method>::FLEXIBILITY,
14830 request,
14831 ))
14832 }
14833
14834 #[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"]
14835 pub fn get_backing_memory(
14836 &self,
14837
14838 flags: impl ::fidl_next::Encode<
14839 crate::wire::VmoFlags,
14840 <___T as ::fidl_next::Transport>::SendBuffer,
14841 >,
14842 ) -> ::fidl_next::TwoWayFuture<'_, super::GetBackingMemory, ___T>
14843 where
14844 <___T as ::fidl_next::Transport>::SendBuffer:
14845 ::fidl_next::encoder::InternalHandleEncoder,
14846 {
14847 self.get_backing_memory_with(crate::generic::FileGetBackingMemoryRequest { flags })
14848 }
14849
14850 #[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"]
14851 pub fn get_backing_memory_with<___R>(
14852 &self,
14853 request: ___R,
14854 ) -> ::fidl_next::TwoWayFuture<'_, super::GetBackingMemory, ___T>
14855 where
14856 ___R: ::fidl_next::Encode<
14857 crate::wire::FileGetBackingMemoryRequest,
14858 <___T as ::fidl_next::Transport>::SendBuffer,
14859 >,
14860 {
14861 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14862 46911652864194091,
14863 <super::GetBackingMemory as ::fidl_next::Method>::FLEXIBILITY,
14864 request,
14865 ))
14866 }
14867
14868 #[doc = " Pre-allocate on-disk space for this file.\n"]
14869 pub fn allocate(
14870 &self,
14871
14872 offset: impl ::fidl_next::Encode<
14873 ::fidl_next::wire::Uint64,
14874 <___T as ::fidl_next::Transport>::SendBuffer,
14875 >,
14876
14877 length: impl ::fidl_next::Encode<
14878 ::fidl_next::wire::Uint64,
14879 <___T as ::fidl_next::Transport>::SendBuffer,
14880 >,
14881
14882 mode: impl ::fidl_next::Encode<
14883 crate::wire::AllocateMode,
14884 <___T as ::fidl_next::Transport>::SendBuffer,
14885 >,
14886 ) -> ::fidl_next::TwoWayFuture<'_, super::Allocate, ___T>
14887 where
14888 <___T as ::fidl_next::Transport>::SendBuffer:
14889 ::fidl_next::encoder::InternalHandleEncoder,
14890 <___T as ::fidl_next::Transport>::SendBuffer:
14891 ::fdomain_client::fidl_next::HandleEncoder,
14892 {
14893 self.allocate_with(crate::generic::FileAllocateRequest { offset, length, mode })
14894 }
14895
14896 #[doc = " Pre-allocate on-disk space for this file.\n"]
14897 pub fn allocate_with<___R>(
14898 &self,
14899 request: ___R,
14900 ) -> ::fidl_next::TwoWayFuture<'_, super::Allocate, ___T>
14901 where
14902 ___R: ::fidl_next::Encode<
14903 crate::wire::FileAllocateRequest,
14904 <___T as ::fidl_next::Transport>::SendBuffer,
14905 >,
14906 {
14907 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14908 8645235848064269614,
14909 <super::Allocate as ::fidl_next::Method>::FLEXIBILITY,
14910 request,
14911 ))
14912 }
14913
14914 #[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"]
14915 pub fn enable_verity(
14916 &self,
14917
14918 options: impl ::fidl_next::Encode<
14919 crate::wire::VerificationOptions<'static>,
14920 <___T as ::fidl_next::Transport>::SendBuffer,
14921 >,
14922 ) -> ::fidl_next::TwoWayFuture<'_, super::EnableVerity, ___T>
14923 where
14924 <___T as ::fidl_next::Transport>::SendBuffer:
14925 ::fidl_next::encoder::InternalHandleEncoder,
14926 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14927 <___T as ::fidl_next::Transport>::SendBuffer:
14928 ::fdomain_client::fidl_next::HandleEncoder,
14929 {
14930 self.enable_verity_with(crate::generic::FileEnableVerityRequest { options })
14931 }
14932
14933 #[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"]
14934 pub fn enable_verity_with<___R>(
14935 &self,
14936 request: ___R,
14937 ) -> ::fidl_next::TwoWayFuture<'_, super::EnableVerity, ___T>
14938 where
14939 ___R: ::fidl_next::Encode<
14940 crate::wire::FileEnableVerityRequest<'static>,
14941 <___T as ::fidl_next::Transport>::SendBuffer,
14942 >,
14943 {
14944 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14945 3189145313204943035,
14946 <super::EnableVerity as ::fidl_next::Method>::FLEXIBILITY,
14947 request,
14948 ))
14949 }
14950 }
14951
14952 #[repr(transparent)]
14954 pub struct FileServer<___T: ::fidl_next::Transport> {
14955 server: ::fidl_next::protocol::Server<___T>,
14956 }
14957
14958 impl<___T> FileServer<___T>
14959 where
14960 ___T: ::fidl_next::Transport,
14961 {
14962 #[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"]
14963 pub fn on_open(
14964 &self,
14965
14966 s: impl ::fidl_next::Encode<
14967 ::fidl_next::wire::Int32,
14968 <___T as ::fidl_next::Transport>::SendBuffer,
14969 >,
14970
14971 info: impl ::fidl_next::Encode<
14972 crate::wire_optional::NodeInfoDeprecated<'static>,
14973 <___T as ::fidl_next::Transport>::SendBuffer,
14974 >,
14975 ) -> ::fidl_next::SendFuture<'_, ___T>
14976 where
14977 <___T as ::fidl_next::Transport>::SendBuffer:
14978 ::fidl_next::encoder::InternalHandleEncoder,
14979 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14980 <___T as ::fidl_next::Transport>::SendBuffer:
14981 ::fdomain_client::fidl_next::HandleEncoder,
14982 {
14983 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
14984 }
14985
14986 #[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"]
14987
14988 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
14989 where
14990 ___R: ::fidl_next::Encode<
14991 <super::OnOpen as ::fidl_next::Method>::Request,
14992 <___T as ::fidl_next::Transport>::SendBuffer,
14993 >,
14994 {
14995 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
14996 9207534335756671346,
14997 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
14998 request,
14999 ))
15000 }
15001
15002 #[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"]
15003
15004 pub fn on_representation_with<___R>(
15005 &self,
15006 request: ___R,
15007 ) -> ::fidl_next::SendFuture<'_, ___T>
15008 where
15009 ___R: ::fidl_next::Encode<
15010 <super::OnRepresentation as ::fidl_next::Method>::Request,
15011 <___T as ::fidl_next::Transport>::SendBuffer,
15012 >,
15013 {
15014 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
15015 6679970090861613324,
15016 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
15017 request,
15018 ))
15019 }
15020 }
15021 }
15022}
15023
15024#[diagnostic::on_unimplemented(
15025 note = "If {Self} implements the non-local FileClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
15026)]
15027
15028pub trait FileLocalClientHandler<
15032 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
15033 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15034>
15035{
15036 #[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"]
15037 fn on_open(
15038 &mut self,
15039
15040 request: ::fidl_next::Request<file::OnOpen, ___T>,
15041 ) -> impl ::core::future::Future<Output = ()>;
15042
15043 #[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"]
15044 fn on_representation(
15045 &mut self,
15046
15047 request: ::fidl_next::Request<file::OnRepresentation, ___T>,
15048 ) -> impl ::core::future::Future<Output = ()>;
15049
15050 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
15051 ::core::future::ready(())
15052 }
15053}
15054
15055impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for File
15056where
15057 ___H: FileLocalClientHandler<___T>,
15058 ___T: ::fidl_next::Transport,
15059 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
15060 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15061 Constraint = (),
15062 >,
15063 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
15064 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15065 Constraint = (),
15066 >,
15067{
15068 async fn on_event(
15069 handler: &mut ___H,
15070 ordinal: u64,
15071 flexibility: ::fidl_next::protocol::Flexibility,
15072 body: ::fidl_next::Body<___T>,
15073 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
15074 match ordinal {
15075 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
15076 Ok(decoded) => {
15077 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
15078 Ok(())
15079 }
15080 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15081 ordinal: 9207534335756671346,
15082 error,
15083 }),
15084 },
15085
15086 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
15087 Ok(decoded) => {
15088 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
15089 Ok(())
15090 }
15091 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15092 ordinal: 6679970090861613324,
15093 error,
15094 }),
15095 },
15096
15097 ordinal => {
15098 handler.on_unknown_interaction(ordinal).await;
15099 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
15100 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15101 } else {
15102 Ok(())
15103 }
15104 }
15105 }
15106 }
15107}
15108
15109#[diagnostic::on_unimplemented(
15110 note = "If {Self} implements the non-local FileServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
15111)]
15112
15113pub trait FileLocalServerHandler<
15117 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
15118 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15119>
15120{
15121 #[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"]
15122 fn advisory_lock(
15123 &mut self,
15124
15125 request: ::fidl_next::Request<file::AdvisoryLock, ___T>,
15126
15127 responder: ::fidl_next::Responder<file::AdvisoryLock, ___T>,
15128 ) -> impl ::core::future::Future<Output = ()>;
15129
15130 #[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"]
15131 fn link_into(
15132 &mut self,
15133
15134 request: ::fidl_next::Request<file::LinkInto, ___T>,
15135
15136 responder: ::fidl_next::Responder<file::LinkInto, ___T>,
15137 ) -> impl ::core::future::Future<Output = ()>;
15138
15139 fn clone(
15140 &mut self,
15141
15142 request: ::fidl_next::Request<file::Clone, ___T>,
15143 ) -> impl ::core::future::Future<Output = ()>;
15144
15145 #[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"]
15146 fn close(
15147 &mut self,
15148
15149 responder: ::fidl_next::Responder<file::Close, ___T>,
15150 ) -> impl ::core::future::Future<Output = ()>;
15151
15152 fn query(
15153 &mut self,
15154
15155 responder: ::fidl_next::Responder<file::Query, ___T>,
15156 ) -> impl ::core::future::Future<Output = ()>;
15157
15158 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
15159 fn deprecated_clone(
15160 &mut self,
15161
15162 request: ::fidl_next::Request<file::DeprecatedClone, ___T>,
15163 ) -> impl ::core::future::Future<Output = ()>;
15164
15165 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
15166 fn deprecated_get_attr(
15167 &mut self,
15168
15169 responder: ::fidl_next::Responder<file::DeprecatedGetAttr, ___T>,
15170 ) -> impl ::core::future::Future<Output = ()>;
15171
15172 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
15173 fn deprecated_set_attr(
15174 &mut self,
15175
15176 request: ::fidl_next::Request<file::DeprecatedSetAttr, ___T>,
15177
15178 responder: ::fidl_next::Responder<file::DeprecatedSetAttr, ___T>,
15179 ) -> impl ::core::future::Future<Output = ()>;
15180
15181 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
15182 fn deprecated_get_flags(
15183 &mut self,
15184
15185 responder: ::fidl_next::Responder<file::DeprecatedGetFlags, ___T>,
15186 ) -> impl ::core::future::Future<Output = ()>;
15187
15188 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
15189 fn deprecated_set_flags(
15190 &mut self,
15191
15192 request: ::fidl_next::Request<file::DeprecatedSetFlags, ___T>,
15193
15194 responder: ::fidl_next::Responder<file::DeprecatedSetFlags, ___T>,
15195 ) -> impl ::core::future::Future<Output = ()>;
15196
15197 #[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"]
15198 fn get_flags(
15199 &mut self,
15200
15201 responder: ::fidl_next::Responder<file::GetFlags, ___T>,
15202 ) -> impl ::core::future::Future<Output = ()>;
15203
15204 #[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"]
15205 fn set_flags(
15206 &mut self,
15207
15208 request: ::fidl_next::Request<file::SetFlags, ___T>,
15209
15210 responder: ::fidl_next::Responder<file::SetFlags, ___T>,
15211 ) -> impl ::core::future::Future<Output = ()>;
15212
15213 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
15214 fn query_filesystem(
15215 &mut self,
15216
15217 responder: ::fidl_next::Responder<file::QueryFilesystem, ___T>,
15218 ) -> impl ::core::future::Future<Output = ()>;
15219
15220 #[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"]
15221 fn get_attributes(
15222 &mut self,
15223
15224 request: ::fidl_next::Request<file::GetAttributes, ___T>,
15225
15226 responder: ::fidl_next::Responder<file::GetAttributes, ___T>,
15227 ) -> impl ::core::future::Future<Output = ()>;
15228
15229 #[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"]
15230 fn update_attributes(
15231 &mut self,
15232
15233 request: ::fidl_next::Request<file::UpdateAttributes, ___T>,
15234
15235 responder: ::fidl_next::Responder<file::UpdateAttributes, ___T>,
15236 ) -> impl ::core::future::Future<Output = ()>;
15237
15238 #[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"]
15239 fn sync(
15240 &mut self,
15241
15242 responder: ::fidl_next::Responder<file::Sync, ___T>,
15243 ) -> impl ::core::future::Future<Output = ()>;
15244
15245 #[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"]
15246 fn list_extended_attributes(
15247 &mut self,
15248
15249 request: ::fidl_next::Request<file::ListExtendedAttributes, ___T>,
15250 ) -> impl ::core::future::Future<Output = ()>;
15251
15252 #[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"]
15253 fn get_extended_attribute(
15254 &mut self,
15255
15256 request: ::fidl_next::Request<file::GetExtendedAttribute, ___T>,
15257
15258 responder: ::fidl_next::Responder<file::GetExtendedAttribute, ___T>,
15259 ) -> impl ::core::future::Future<Output = ()>;
15260
15261 #[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"]
15262 fn set_extended_attribute(
15263 &mut self,
15264
15265 request: ::fidl_next::Request<file::SetExtendedAttribute, ___T>,
15266
15267 responder: ::fidl_next::Responder<file::SetExtendedAttribute, ___T>,
15268 ) -> impl ::core::future::Future<Output = ()>;
15269
15270 #[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"]
15271 fn remove_extended_attribute(
15272 &mut self,
15273
15274 request: ::fidl_next::Request<file::RemoveExtendedAttribute, ___T>,
15275
15276 responder: ::fidl_next::Responder<file::RemoveExtendedAttribute, ___T>,
15277 ) -> impl ::core::future::Future<Output = ()>;
15278
15279 #[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"]
15280 fn read(
15281 &mut self,
15282
15283 request: ::fidl_next::Request<file::Read, ___T>,
15284
15285 responder: ::fidl_next::Responder<file::Read, ___T>,
15286 ) -> impl ::core::future::Future<Output = ()>;
15287
15288 #[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"]
15289 fn write(
15290 &mut self,
15291
15292 request: ::fidl_next::Request<file::Write, ___T>,
15293
15294 responder: ::fidl_next::Responder<file::Write, ___T>,
15295 ) -> impl ::core::future::Future<Output = ()>;
15296
15297 fn describe(
15298 &mut self,
15299
15300 responder: ::fidl_next::Responder<file::Describe, ___T>,
15301 ) -> impl ::core::future::Future<Output = ()>;
15302
15303 #[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"]
15304 fn seek(
15305 &mut self,
15306
15307 request: ::fidl_next::Request<file::Seek, ___T>,
15308
15309 responder: ::fidl_next::Responder<file::Seek, ___T>,
15310 ) -> impl ::core::future::Future<Output = ()>;
15311
15312 #[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"]
15313 fn read_at(
15314 &mut self,
15315
15316 request: ::fidl_next::Request<file::ReadAt, ___T>,
15317
15318 responder: ::fidl_next::Responder<file::ReadAt, ___T>,
15319 ) -> impl ::core::future::Future<Output = ()>;
15320
15321 #[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"]
15322 fn write_at(
15323 &mut self,
15324
15325 request: ::fidl_next::Request<file::WriteAt, ___T>,
15326
15327 responder: ::fidl_next::Responder<file::WriteAt, ___T>,
15328 ) -> impl ::core::future::Future<Output = ()>;
15329
15330 #[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"]
15331 fn resize(
15332 &mut self,
15333
15334 request: ::fidl_next::Request<file::Resize, ___T>,
15335
15336 responder: ::fidl_next::Responder<file::Resize, ___T>,
15337 ) -> impl ::core::future::Future<Output = ()>;
15338
15339 #[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"]
15340 fn get_backing_memory(
15341 &mut self,
15342
15343 request: ::fidl_next::Request<file::GetBackingMemory, ___T>,
15344
15345 responder: ::fidl_next::Responder<file::GetBackingMemory, ___T>,
15346 ) -> impl ::core::future::Future<Output = ()>;
15347
15348 #[doc = " Pre-allocate on-disk space for this file.\n"]
15349 fn allocate(
15350 &mut self,
15351
15352 request: ::fidl_next::Request<file::Allocate, ___T>,
15353
15354 responder: ::fidl_next::Responder<file::Allocate, ___T>,
15355 ) -> impl ::core::future::Future<Output = ()>;
15356
15357 #[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"]
15358 fn enable_verity(
15359 &mut self,
15360
15361 request: ::fidl_next::Request<file::EnableVerity, ___T>,
15362
15363 responder: ::fidl_next::Responder<file::EnableVerity, ___T>,
15364 ) -> impl ::core::future::Future<Output = ()>;
15365
15366 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
15367 ::core::future::ready(())
15368 }
15369}
15370
15371impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for File
15372where
15373 ___H: FileLocalServerHandler<___T>,
15374 ___T: ::fidl_next::Transport,
15375 for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
15376 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15377 Constraint = (),
15378 >,
15379 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
15380 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15381 Constraint = (),
15382 >,
15383 for<'de> ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
15384 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15385 Constraint = (),
15386 >,
15387 for<'de> crate::wire::NodeDeprecatedCloneRequest: ::fidl_next::Decode<
15388 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15389 Constraint = (),
15390 >,
15391 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
15392 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15393 Constraint = (),
15394 >,
15395 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
15396 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15397 Constraint = (),
15398 >,
15399 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
15400 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15401 Constraint = (),
15402 >,
15403 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
15404 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15405 Constraint = (),
15406 >,
15407 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
15408 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15409 Constraint = (),
15410 >,
15411 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
15412 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15413 Constraint = (),
15414 >,
15415 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
15416 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15417 Constraint = (),
15418 >,
15419 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
15420 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15421 Constraint = (),
15422 >,
15423 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
15424 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15425 Constraint = (),
15426 >,
15427 for<'de> crate::wire::ReadableReadRequest: ::fidl_next::Decode<
15428 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15429 Constraint = (),
15430 >,
15431 for<'de> crate::wire::WritableWriteRequest<'de>: ::fidl_next::Decode<
15432 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15433 Constraint = (),
15434 >,
15435 for<'de> crate::wire::FileSeekRequest: ::fidl_next::Decode<
15436 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15437 Constraint = (),
15438 >,
15439 for<'de> crate::wire::FileReadAtRequest: ::fidl_next::Decode<
15440 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15441 Constraint = (),
15442 >,
15443 for<'de> crate::wire::FileWriteAtRequest<'de>: ::fidl_next::Decode<
15444 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15445 Constraint = (),
15446 >,
15447 for<'de> crate::wire::FileResizeRequest: ::fidl_next::Decode<
15448 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15449 Constraint = (),
15450 >,
15451 for<'de> crate::wire::FileGetBackingMemoryRequest: ::fidl_next::Decode<
15452 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15453 Constraint = (),
15454 >,
15455 for<'de> crate::wire::FileAllocateRequest: ::fidl_next::Decode<
15456 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15457 Constraint = (),
15458 >,
15459 for<'de> crate::wire::FileEnableVerityRequest<'de>: ::fidl_next::Decode<
15460 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15461 Constraint = (),
15462 >,
15463{
15464 async fn on_one_way(
15465 handler: &mut ___H,
15466 ordinal: u64,
15467 flexibility: ::fidl_next::protocol::Flexibility,
15468 body: ::fidl_next::Body<___T>,
15469 ) -> ::core::result::Result<
15470 (),
15471 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15472 > {
15473 match ordinal {
15474 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
15475 Ok(decoded) => {
15476 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
15477 Ok(())
15478 }
15479 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15480 ordinal: 2366825959783828089,
15481 error,
15482 }),
15483 },
15484
15485 6512600400724287855 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
15486 Ok(decoded) => {
15487 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
15488 Ok(())
15489 }
15490 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15491 ordinal: 6512600400724287855,
15492 error,
15493 }),
15494 },
15495
15496 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
15497 Ok(decoded) => {
15498 handler
15499 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
15500 .await;
15501 Ok(())
15502 }
15503 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15504 ordinal: 5431626189872037072,
15505 error,
15506 }),
15507 },
15508
15509 ordinal => {
15510 handler.on_unknown_interaction(ordinal).await;
15511 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
15512 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15513 } else {
15514 Ok(())
15515 }
15516 }
15517 }
15518 }
15519
15520 async fn on_two_way(
15521 handler: &mut ___H,
15522 ordinal: u64,
15523 flexibility: ::fidl_next::protocol::Flexibility,
15524 body: ::fidl_next::Body<___T>,
15525 responder: ::fidl_next::protocol::Responder<___T>,
15526 ) -> ::core::result::Result<
15527 (),
15528 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15529 > {
15530 match ordinal {
15531 7992130864415541162 => {
15532 let responder = ::fidl_next::Responder::from_untyped(responder);
15533
15534 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15535 Ok(decoded) => {
15536 handler
15537 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
15538 .await;
15539 Ok(())
15540 }
15541 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15542 ordinal: 7992130864415541162,
15543 error,
15544 }),
15545 }
15546 }
15547
15548 6121399674497678964 => {
15549 let responder = ::fidl_next::Responder::from_untyped(responder);
15550
15551 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15552 Ok(decoded) => {
15553 handler
15554 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
15555 .await;
15556 Ok(())
15557 }
15558 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15559 ordinal: 6121399674497678964,
15560 error,
15561 }),
15562 }
15563 }
15564
15565 6540867515453498750 => {
15566 let responder = ::fidl_next::Responder::from_untyped(responder);
15567
15568 handler.close(responder).await;
15569 Ok(())
15570 }
15571
15572 2763219980499352582 => {
15573 let responder = ::fidl_next::Responder::from_untyped(responder);
15574
15575 handler.query(responder).await;
15576 Ok(())
15577 }
15578
15579 8689798978500614909 => {
15580 let responder = ::fidl_next::Responder::from_untyped(responder);
15581
15582 handler.deprecated_get_attr(responder).await;
15583 Ok(())
15584 }
15585
15586 4721673413776871238 => {
15587 let responder = ::fidl_next::Responder::from_untyped(responder);
15588
15589 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15590 Ok(decoded) => {
15591 handler
15592 .deprecated_set_attr(
15593 ::fidl_next::Request::from_decoded(decoded),
15594 responder,
15595 )
15596 .await;
15597 Ok(())
15598 }
15599 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15600 ordinal: 4721673413776871238,
15601 error,
15602 }),
15603 }
15604 }
15605
15606 6595803110182632097 => {
15607 let responder = ::fidl_next::Responder::from_untyped(responder);
15608
15609 handler.deprecated_get_flags(responder).await;
15610 Ok(())
15611 }
15612
15613 5950864159036794675 => {
15614 let responder = ::fidl_next::Responder::from_untyped(responder);
15615
15616 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15617 Ok(decoded) => {
15618 handler
15619 .deprecated_set_flags(
15620 ::fidl_next::Request::from_decoded(decoded),
15621 responder,
15622 )
15623 .await;
15624 Ok(())
15625 }
15626 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15627 ordinal: 5950864159036794675,
15628 error,
15629 }),
15630 }
15631 }
15632
15633 105530239381466147 => {
15634 let responder = ::fidl_next::Responder::from_untyped(responder);
15635
15636 handler.get_flags(responder).await;
15637 Ok(())
15638 }
15639
15640 6172186066099445416 => {
15641 let responder = ::fidl_next::Responder::from_untyped(responder);
15642
15643 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15644 Ok(decoded) => {
15645 handler
15646 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
15647 .await;
15648 Ok(())
15649 }
15650 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15651 ordinal: 6172186066099445416,
15652 error,
15653 }),
15654 }
15655 }
15656
15657 8013111122914313744 => {
15658 let responder = ::fidl_next::Responder::from_untyped(responder);
15659
15660 handler.query_filesystem(responder).await;
15661 Ok(())
15662 }
15663
15664 4414537700416816443 => {
15665 let responder = ::fidl_next::Responder::from_untyped(responder);
15666
15667 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15668 Ok(decoded) => {
15669 handler
15670 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
15671 .await;
15672 Ok(())
15673 }
15674 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15675 ordinal: 4414537700416816443,
15676 error,
15677 }),
15678 }
15679 }
15680
15681 3677402239314018056 => {
15682 let responder = ::fidl_next::Responder::from_untyped(responder);
15683
15684 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15685 Ok(decoded) => {
15686 handler
15687 .update_attributes(
15688 ::fidl_next::Request::from_decoded(decoded),
15689 responder,
15690 )
15691 .await;
15692 Ok(())
15693 }
15694 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15695 ordinal: 3677402239314018056,
15696 error,
15697 }),
15698 }
15699 }
15700
15701 3196473584242777161 => {
15702 let responder = ::fidl_next::Responder::from_untyped(responder);
15703
15704 handler.sync(responder).await;
15705 Ok(())
15706 }
15707
15708 5043930208506967771 => {
15709 let responder = ::fidl_next::Responder::from_untyped(responder);
15710
15711 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15712 Ok(decoded) => {
15713 handler
15714 .get_extended_attribute(
15715 ::fidl_next::Request::from_decoded(decoded),
15716 responder,
15717 )
15718 .await;
15719 Ok(())
15720 }
15721 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15722 ordinal: 5043930208506967771,
15723 error,
15724 }),
15725 }
15726 }
15727
15728 5374223046099989052 => {
15729 let responder = ::fidl_next::Responder::from_untyped(responder);
15730
15731 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15732 Ok(decoded) => {
15733 handler
15734 .set_extended_attribute(
15735 ::fidl_next::Request::from_decoded(decoded),
15736 responder,
15737 )
15738 .await;
15739 Ok(())
15740 }
15741 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15742 ordinal: 5374223046099989052,
15743 error,
15744 }),
15745 }
15746 }
15747
15748 8794297771444732717 => {
15749 let responder = ::fidl_next::Responder::from_untyped(responder);
15750
15751 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15752 Ok(decoded) => {
15753 handler
15754 .remove_extended_attribute(
15755 ::fidl_next::Request::from_decoded(decoded),
15756 responder,
15757 )
15758 .await;
15759 Ok(())
15760 }
15761 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15762 ordinal: 8794297771444732717,
15763 error,
15764 }),
15765 }
15766 }
15767
15768 395825947633028830 => {
15769 let responder = ::fidl_next::Responder::from_untyped(responder);
15770
15771 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15772 Ok(decoded) => {
15773 handler.read(::fidl_next::Request::from_decoded(decoded), responder).await;
15774 Ok(())
15775 }
15776 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15777 ordinal: 395825947633028830,
15778 error,
15779 }),
15780 }
15781 }
15782
15783 7651971425397809026 => {
15784 let responder = ::fidl_next::Responder::from_untyped(responder);
15785
15786 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15787 Ok(decoded) => {
15788 handler.write(::fidl_next::Request::from_decoded(decoded), responder).await;
15789 Ok(())
15790 }
15791 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15792 ordinal: 7651971425397809026,
15793 error,
15794 }),
15795 }
15796 }
15797
15798 7545125870053689020 => {
15799 let responder = ::fidl_next::Responder::from_untyped(responder);
15800
15801 handler.describe(responder).await;
15802 Ok(())
15803 }
15804
15805 8649041485622956551 => {
15806 let responder = ::fidl_next::Responder::from_untyped(responder);
15807
15808 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15809 Ok(decoded) => {
15810 handler.seek(::fidl_next::Request::from_decoded(decoded), responder).await;
15811 Ok(())
15812 }
15813 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15814 ordinal: 8649041485622956551,
15815 error,
15816 }),
15817 }
15818 }
15819
15820 1587416148701180478 => {
15821 let responder = ::fidl_next::Responder::from_untyped(responder);
15822
15823 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15824 Ok(decoded) => {
15825 handler
15826 .read_at(::fidl_next::Request::from_decoded(decoded), responder)
15827 .await;
15828 Ok(())
15829 }
15830 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15831 ordinal: 1587416148701180478,
15832 error,
15833 }),
15834 }
15835 }
15836
15837 8736683935131400491 => {
15838 let responder = ::fidl_next::Responder::from_untyped(responder);
15839
15840 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15841 Ok(decoded) => {
15842 handler
15843 .write_at(::fidl_next::Request::from_decoded(decoded), responder)
15844 .await;
15845 Ok(())
15846 }
15847 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15848 ordinal: 8736683935131400491,
15849 error,
15850 }),
15851 }
15852 }
15853
15854 3134648685270758458 => {
15855 let responder = ::fidl_next::Responder::from_untyped(responder);
15856
15857 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15858 Ok(decoded) => {
15859 handler
15860 .resize(::fidl_next::Request::from_decoded(decoded), responder)
15861 .await;
15862 Ok(())
15863 }
15864 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15865 ordinal: 3134648685270758458,
15866 error,
15867 }),
15868 }
15869 }
15870
15871 46911652864194091 => {
15872 let responder = ::fidl_next::Responder::from_untyped(responder);
15873
15874 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15875 Ok(decoded) => {
15876 handler
15877 .get_backing_memory(
15878 ::fidl_next::Request::from_decoded(decoded),
15879 responder,
15880 )
15881 .await;
15882 Ok(())
15883 }
15884 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15885 ordinal: 46911652864194091,
15886 error,
15887 }),
15888 }
15889 }
15890
15891 8645235848064269614 => {
15892 let responder = ::fidl_next::Responder::from_untyped(responder);
15893
15894 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15895 Ok(decoded) => {
15896 handler
15897 .allocate(::fidl_next::Request::from_decoded(decoded), responder)
15898 .await;
15899 Ok(())
15900 }
15901 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15902 ordinal: 8645235848064269614,
15903 error,
15904 }),
15905 }
15906 }
15907
15908 3189145313204943035 => {
15909 let responder = ::fidl_next::Responder::from_untyped(responder);
15910
15911 match ::fidl_next::AsDecoderExt::into_decoded(body) {
15912 Ok(decoded) => {
15913 handler
15914 .enable_verity(::fidl_next::Request::from_decoded(decoded), responder)
15915 .await;
15916 Ok(())
15917 }
15918 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15919 ordinal: 3189145313204943035,
15920 error,
15921 }),
15922 }
15923 }
15924
15925 ordinal => {
15926 handler.on_unknown_interaction(ordinal).await;
15927 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
15928 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15929 } else {
15930 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
15931 ordinal,
15932 flexibility,
15933 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
15934 )
15935 .expect("encoding a framework error should never fail")
15936 .await?;
15937 Ok(())
15938 }
15939 }
15940 }
15941 }
15942}
15943
15944pub trait FileClientHandler<
15948 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
15949 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15950>
15951{
15952 #[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"]
15953 fn on_open(
15954 &mut self,
15955
15956 request: ::fidl_next::Request<file::OnOpen, ___T>,
15957 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
15958
15959 #[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"]
15960 fn on_representation(
15961 &mut self,
15962
15963 request: ::fidl_next::Request<file::OnRepresentation, ___T>,
15964 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
15965
15966 fn on_unknown_interaction(
15967 &mut self,
15968 ordinal: u64,
15969 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
15970 ::core::future::ready(())
15971 }
15972}
15973
15974impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for File
15975where
15976 ___H: FileClientHandler<___T> + ::core::marker::Send,
15977 ___T: ::fidl_next::Transport,
15978 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
15979 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15980 Constraint = (),
15981 >,
15982 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
15983 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15984 Constraint = (),
15985 >,
15986{
15987 async fn on_event(
15988 handler: &mut ___H,
15989 ordinal: u64,
15990 flexibility: ::fidl_next::protocol::Flexibility,
15991 body: ::fidl_next::Body<___T>,
15992 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
15993 match ordinal {
15994 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
15995 Ok(decoded) => {
15996 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
15997 Ok(())
15998 }
15999 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16000 ordinal: 9207534335756671346,
16001 error,
16002 }),
16003 },
16004
16005 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
16006 Ok(decoded) => {
16007 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
16008 Ok(())
16009 }
16010 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16011 ordinal: 6679970090861613324,
16012 error,
16013 }),
16014 },
16015
16016 ordinal => {
16017 handler.on_unknown_interaction(ordinal).await;
16018 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
16019 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16020 } else {
16021 Ok(())
16022 }
16023 }
16024 }
16025 }
16026}
16027
16028pub trait FileServerHandler<
16032 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
16033 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
16034>
16035{
16036 #[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"]
16037 fn advisory_lock(
16038 &mut self,
16039
16040 request: ::fidl_next::Request<file::AdvisoryLock, ___T>,
16041
16042 responder: ::fidl_next::Responder<file::AdvisoryLock, ___T>,
16043 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16044
16045 #[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"]
16046 fn link_into(
16047 &mut self,
16048
16049 request: ::fidl_next::Request<file::LinkInto, ___T>,
16050
16051 responder: ::fidl_next::Responder<file::LinkInto, ___T>,
16052 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16053
16054 fn clone(
16055 &mut self,
16056
16057 request: ::fidl_next::Request<file::Clone, ___T>,
16058 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16059
16060 #[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"]
16061 fn close(
16062 &mut self,
16063
16064 responder: ::fidl_next::Responder<file::Close, ___T>,
16065 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16066
16067 fn query(
16068 &mut self,
16069
16070 responder: ::fidl_next::Responder<file::Query, ___T>,
16071 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16072
16073 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
16074 fn deprecated_clone(
16075 &mut self,
16076
16077 request: ::fidl_next::Request<file::DeprecatedClone, ___T>,
16078 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16079
16080 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
16081 fn deprecated_get_attr(
16082 &mut self,
16083
16084 responder: ::fidl_next::Responder<file::DeprecatedGetAttr, ___T>,
16085 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16086
16087 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
16088 fn deprecated_set_attr(
16089 &mut self,
16090
16091 request: ::fidl_next::Request<file::DeprecatedSetAttr, ___T>,
16092
16093 responder: ::fidl_next::Responder<file::DeprecatedSetAttr, ___T>,
16094 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16095
16096 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
16097 fn deprecated_get_flags(
16098 &mut self,
16099
16100 responder: ::fidl_next::Responder<file::DeprecatedGetFlags, ___T>,
16101 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16102
16103 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
16104 fn deprecated_set_flags(
16105 &mut self,
16106
16107 request: ::fidl_next::Request<file::DeprecatedSetFlags, ___T>,
16108
16109 responder: ::fidl_next::Responder<file::DeprecatedSetFlags, ___T>,
16110 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16111
16112 #[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"]
16113 fn get_flags(
16114 &mut self,
16115
16116 responder: ::fidl_next::Responder<file::GetFlags, ___T>,
16117 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16118
16119 #[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"]
16120 fn set_flags(
16121 &mut self,
16122
16123 request: ::fidl_next::Request<file::SetFlags, ___T>,
16124
16125 responder: ::fidl_next::Responder<file::SetFlags, ___T>,
16126 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16127
16128 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
16129 fn query_filesystem(
16130 &mut self,
16131
16132 responder: ::fidl_next::Responder<file::QueryFilesystem, ___T>,
16133 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16134
16135 #[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"]
16136 fn get_attributes(
16137 &mut self,
16138
16139 request: ::fidl_next::Request<file::GetAttributes, ___T>,
16140
16141 responder: ::fidl_next::Responder<file::GetAttributes, ___T>,
16142 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16143
16144 #[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"]
16145 fn update_attributes(
16146 &mut self,
16147
16148 request: ::fidl_next::Request<file::UpdateAttributes, ___T>,
16149
16150 responder: ::fidl_next::Responder<file::UpdateAttributes, ___T>,
16151 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16152
16153 #[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"]
16154 fn sync(
16155 &mut self,
16156
16157 responder: ::fidl_next::Responder<file::Sync, ___T>,
16158 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16159
16160 #[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"]
16161 fn list_extended_attributes(
16162 &mut self,
16163
16164 request: ::fidl_next::Request<file::ListExtendedAttributes, ___T>,
16165 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16166
16167 #[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"]
16168 fn get_extended_attribute(
16169 &mut self,
16170
16171 request: ::fidl_next::Request<file::GetExtendedAttribute, ___T>,
16172
16173 responder: ::fidl_next::Responder<file::GetExtendedAttribute, ___T>,
16174 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16175
16176 #[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"]
16177 fn set_extended_attribute(
16178 &mut self,
16179
16180 request: ::fidl_next::Request<file::SetExtendedAttribute, ___T>,
16181
16182 responder: ::fidl_next::Responder<file::SetExtendedAttribute, ___T>,
16183 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16184
16185 #[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"]
16186 fn remove_extended_attribute(
16187 &mut self,
16188
16189 request: ::fidl_next::Request<file::RemoveExtendedAttribute, ___T>,
16190
16191 responder: ::fidl_next::Responder<file::RemoveExtendedAttribute, ___T>,
16192 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16193
16194 #[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"]
16195 fn read(
16196 &mut self,
16197
16198 request: ::fidl_next::Request<file::Read, ___T>,
16199
16200 responder: ::fidl_next::Responder<file::Read, ___T>,
16201 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16202
16203 #[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"]
16204 fn write(
16205 &mut self,
16206
16207 request: ::fidl_next::Request<file::Write, ___T>,
16208
16209 responder: ::fidl_next::Responder<file::Write, ___T>,
16210 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16211
16212 fn describe(
16213 &mut self,
16214
16215 responder: ::fidl_next::Responder<file::Describe, ___T>,
16216 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16217
16218 #[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"]
16219 fn seek(
16220 &mut self,
16221
16222 request: ::fidl_next::Request<file::Seek, ___T>,
16223
16224 responder: ::fidl_next::Responder<file::Seek, ___T>,
16225 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16226
16227 #[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"]
16228 fn read_at(
16229 &mut self,
16230
16231 request: ::fidl_next::Request<file::ReadAt, ___T>,
16232
16233 responder: ::fidl_next::Responder<file::ReadAt, ___T>,
16234 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16235
16236 #[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"]
16237 fn write_at(
16238 &mut self,
16239
16240 request: ::fidl_next::Request<file::WriteAt, ___T>,
16241
16242 responder: ::fidl_next::Responder<file::WriteAt, ___T>,
16243 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16244
16245 #[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"]
16246 fn resize(
16247 &mut self,
16248
16249 request: ::fidl_next::Request<file::Resize, ___T>,
16250
16251 responder: ::fidl_next::Responder<file::Resize, ___T>,
16252 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16253
16254 #[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"]
16255 fn get_backing_memory(
16256 &mut self,
16257
16258 request: ::fidl_next::Request<file::GetBackingMemory, ___T>,
16259
16260 responder: ::fidl_next::Responder<file::GetBackingMemory, ___T>,
16261 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16262
16263 #[doc = " Pre-allocate on-disk space for this file.\n"]
16264 fn allocate(
16265 &mut self,
16266
16267 request: ::fidl_next::Request<file::Allocate, ___T>,
16268
16269 responder: ::fidl_next::Responder<file::Allocate, ___T>,
16270 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16271
16272 #[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"]
16273 fn enable_verity(
16274 &mut self,
16275
16276 request: ::fidl_next::Request<file::EnableVerity, ___T>,
16277
16278 responder: ::fidl_next::Responder<file::EnableVerity, ___T>,
16279 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16280
16281 fn on_unknown_interaction(
16282 &mut self,
16283 ordinal: u64,
16284 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
16285 ::core::future::ready(())
16286 }
16287}
16288
16289impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for File
16290where
16291 ___H: FileServerHandler<___T> + ::core::marker::Send,
16292 ___T: ::fidl_next::Transport,
16293 for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
16294 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16295 Constraint = (),
16296 >,
16297 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
16298 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16299 Constraint = (),
16300 >,
16301 for<'de> ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
16302 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16303 Constraint = (),
16304 >,
16305 for<'de> crate::wire::NodeDeprecatedCloneRequest: ::fidl_next::Decode<
16306 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16307 Constraint = (),
16308 >,
16309 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
16310 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16311 Constraint = (),
16312 >,
16313 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
16314 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16315 Constraint = (),
16316 >,
16317 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
16318 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16319 Constraint = (),
16320 >,
16321 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
16322 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16323 Constraint = (),
16324 >,
16325 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
16326 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16327 Constraint = (),
16328 >,
16329 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
16330 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16331 Constraint = (),
16332 >,
16333 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
16334 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16335 Constraint = (),
16336 >,
16337 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
16338 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16339 Constraint = (),
16340 >,
16341 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
16342 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16343 Constraint = (),
16344 >,
16345 for<'de> crate::wire::ReadableReadRequest: ::fidl_next::Decode<
16346 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16347 Constraint = (),
16348 >,
16349 for<'de> crate::wire::WritableWriteRequest<'de>: ::fidl_next::Decode<
16350 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16351 Constraint = (),
16352 >,
16353 for<'de> crate::wire::FileSeekRequest: ::fidl_next::Decode<
16354 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16355 Constraint = (),
16356 >,
16357 for<'de> crate::wire::FileReadAtRequest: ::fidl_next::Decode<
16358 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16359 Constraint = (),
16360 >,
16361 for<'de> crate::wire::FileWriteAtRequest<'de>: ::fidl_next::Decode<
16362 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16363 Constraint = (),
16364 >,
16365 for<'de> crate::wire::FileResizeRequest: ::fidl_next::Decode<
16366 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16367 Constraint = (),
16368 >,
16369 for<'de> crate::wire::FileGetBackingMemoryRequest: ::fidl_next::Decode<
16370 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16371 Constraint = (),
16372 >,
16373 for<'de> crate::wire::FileAllocateRequest: ::fidl_next::Decode<
16374 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16375 Constraint = (),
16376 >,
16377 for<'de> crate::wire::FileEnableVerityRequest<'de>: ::fidl_next::Decode<
16378 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16379 Constraint = (),
16380 >,
16381{
16382 async fn on_one_way(
16383 handler: &mut ___H,
16384 ordinal: u64,
16385 flexibility: ::fidl_next::protocol::Flexibility,
16386 body: ::fidl_next::Body<___T>,
16387 ) -> ::core::result::Result<
16388 (),
16389 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16390 > {
16391 match ordinal {
16392 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
16393 Ok(decoded) => {
16394 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
16395 Ok(())
16396 }
16397 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16398 ordinal: 2366825959783828089,
16399 error,
16400 }),
16401 },
16402
16403 6512600400724287855 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
16404 Ok(decoded) => {
16405 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
16406 Ok(())
16407 }
16408 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16409 ordinal: 6512600400724287855,
16410 error,
16411 }),
16412 },
16413
16414 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
16415 Ok(decoded) => {
16416 handler
16417 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
16418 .await;
16419 Ok(())
16420 }
16421 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16422 ordinal: 5431626189872037072,
16423 error,
16424 }),
16425 },
16426
16427 ordinal => {
16428 handler.on_unknown_interaction(ordinal).await;
16429 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
16430 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16431 } else {
16432 Ok(())
16433 }
16434 }
16435 }
16436 }
16437
16438 async fn on_two_way(
16439 handler: &mut ___H,
16440 ordinal: u64,
16441 flexibility: ::fidl_next::protocol::Flexibility,
16442 body: ::fidl_next::Body<___T>,
16443 responder: ::fidl_next::protocol::Responder<___T>,
16444 ) -> ::core::result::Result<
16445 (),
16446 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16447 > {
16448 match ordinal {
16449 7992130864415541162 => {
16450 let responder = ::fidl_next::Responder::from_untyped(responder);
16451
16452 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16453 Ok(decoded) => {
16454 handler
16455 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
16456 .await;
16457 Ok(())
16458 }
16459 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16460 ordinal: 7992130864415541162,
16461 error,
16462 }),
16463 }
16464 }
16465
16466 6121399674497678964 => {
16467 let responder = ::fidl_next::Responder::from_untyped(responder);
16468
16469 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16470 Ok(decoded) => {
16471 handler
16472 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
16473 .await;
16474 Ok(())
16475 }
16476 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16477 ordinal: 6121399674497678964,
16478 error,
16479 }),
16480 }
16481 }
16482
16483 6540867515453498750 => {
16484 let responder = ::fidl_next::Responder::from_untyped(responder);
16485
16486 handler.close(responder).await;
16487 Ok(())
16488 }
16489
16490 2763219980499352582 => {
16491 let responder = ::fidl_next::Responder::from_untyped(responder);
16492
16493 handler.query(responder).await;
16494 Ok(())
16495 }
16496
16497 8689798978500614909 => {
16498 let responder = ::fidl_next::Responder::from_untyped(responder);
16499
16500 handler.deprecated_get_attr(responder).await;
16501 Ok(())
16502 }
16503
16504 4721673413776871238 => {
16505 let responder = ::fidl_next::Responder::from_untyped(responder);
16506
16507 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16508 Ok(decoded) => {
16509 handler
16510 .deprecated_set_attr(
16511 ::fidl_next::Request::from_decoded(decoded),
16512 responder,
16513 )
16514 .await;
16515 Ok(())
16516 }
16517 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16518 ordinal: 4721673413776871238,
16519 error,
16520 }),
16521 }
16522 }
16523
16524 6595803110182632097 => {
16525 let responder = ::fidl_next::Responder::from_untyped(responder);
16526
16527 handler.deprecated_get_flags(responder).await;
16528 Ok(())
16529 }
16530
16531 5950864159036794675 => {
16532 let responder = ::fidl_next::Responder::from_untyped(responder);
16533
16534 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16535 Ok(decoded) => {
16536 handler
16537 .deprecated_set_flags(
16538 ::fidl_next::Request::from_decoded(decoded),
16539 responder,
16540 )
16541 .await;
16542 Ok(())
16543 }
16544 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16545 ordinal: 5950864159036794675,
16546 error,
16547 }),
16548 }
16549 }
16550
16551 105530239381466147 => {
16552 let responder = ::fidl_next::Responder::from_untyped(responder);
16553
16554 handler.get_flags(responder).await;
16555 Ok(())
16556 }
16557
16558 6172186066099445416 => {
16559 let responder = ::fidl_next::Responder::from_untyped(responder);
16560
16561 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16562 Ok(decoded) => {
16563 handler
16564 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
16565 .await;
16566 Ok(())
16567 }
16568 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16569 ordinal: 6172186066099445416,
16570 error,
16571 }),
16572 }
16573 }
16574
16575 8013111122914313744 => {
16576 let responder = ::fidl_next::Responder::from_untyped(responder);
16577
16578 handler.query_filesystem(responder).await;
16579 Ok(())
16580 }
16581
16582 4414537700416816443 => {
16583 let responder = ::fidl_next::Responder::from_untyped(responder);
16584
16585 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16586 Ok(decoded) => {
16587 handler
16588 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
16589 .await;
16590 Ok(())
16591 }
16592 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16593 ordinal: 4414537700416816443,
16594 error,
16595 }),
16596 }
16597 }
16598
16599 3677402239314018056 => {
16600 let responder = ::fidl_next::Responder::from_untyped(responder);
16601
16602 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16603 Ok(decoded) => {
16604 handler
16605 .update_attributes(
16606 ::fidl_next::Request::from_decoded(decoded),
16607 responder,
16608 )
16609 .await;
16610 Ok(())
16611 }
16612 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16613 ordinal: 3677402239314018056,
16614 error,
16615 }),
16616 }
16617 }
16618
16619 3196473584242777161 => {
16620 let responder = ::fidl_next::Responder::from_untyped(responder);
16621
16622 handler.sync(responder).await;
16623 Ok(())
16624 }
16625
16626 5043930208506967771 => {
16627 let responder = ::fidl_next::Responder::from_untyped(responder);
16628
16629 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16630 Ok(decoded) => {
16631 handler
16632 .get_extended_attribute(
16633 ::fidl_next::Request::from_decoded(decoded),
16634 responder,
16635 )
16636 .await;
16637 Ok(())
16638 }
16639 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16640 ordinal: 5043930208506967771,
16641 error,
16642 }),
16643 }
16644 }
16645
16646 5374223046099989052 => {
16647 let responder = ::fidl_next::Responder::from_untyped(responder);
16648
16649 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16650 Ok(decoded) => {
16651 handler
16652 .set_extended_attribute(
16653 ::fidl_next::Request::from_decoded(decoded),
16654 responder,
16655 )
16656 .await;
16657 Ok(())
16658 }
16659 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16660 ordinal: 5374223046099989052,
16661 error,
16662 }),
16663 }
16664 }
16665
16666 8794297771444732717 => {
16667 let responder = ::fidl_next::Responder::from_untyped(responder);
16668
16669 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16670 Ok(decoded) => {
16671 handler
16672 .remove_extended_attribute(
16673 ::fidl_next::Request::from_decoded(decoded),
16674 responder,
16675 )
16676 .await;
16677 Ok(())
16678 }
16679 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16680 ordinal: 8794297771444732717,
16681 error,
16682 }),
16683 }
16684 }
16685
16686 395825947633028830 => {
16687 let responder = ::fidl_next::Responder::from_untyped(responder);
16688
16689 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16690 Ok(decoded) => {
16691 handler.read(::fidl_next::Request::from_decoded(decoded), responder).await;
16692 Ok(())
16693 }
16694 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16695 ordinal: 395825947633028830,
16696 error,
16697 }),
16698 }
16699 }
16700
16701 7651971425397809026 => {
16702 let responder = ::fidl_next::Responder::from_untyped(responder);
16703
16704 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16705 Ok(decoded) => {
16706 handler.write(::fidl_next::Request::from_decoded(decoded), responder).await;
16707 Ok(())
16708 }
16709 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16710 ordinal: 7651971425397809026,
16711 error,
16712 }),
16713 }
16714 }
16715
16716 7545125870053689020 => {
16717 let responder = ::fidl_next::Responder::from_untyped(responder);
16718
16719 handler.describe(responder).await;
16720 Ok(())
16721 }
16722
16723 8649041485622956551 => {
16724 let responder = ::fidl_next::Responder::from_untyped(responder);
16725
16726 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16727 Ok(decoded) => {
16728 handler.seek(::fidl_next::Request::from_decoded(decoded), responder).await;
16729 Ok(())
16730 }
16731 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16732 ordinal: 8649041485622956551,
16733 error,
16734 }),
16735 }
16736 }
16737
16738 1587416148701180478 => {
16739 let responder = ::fidl_next::Responder::from_untyped(responder);
16740
16741 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16742 Ok(decoded) => {
16743 handler
16744 .read_at(::fidl_next::Request::from_decoded(decoded), responder)
16745 .await;
16746 Ok(())
16747 }
16748 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16749 ordinal: 1587416148701180478,
16750 error,
16751 }),
16752 }
16753 }
16754
16755 8736683935131400491 => {
16756 let responder = ::fidl_next::Responder::from_untyped(responder);
16757
16758 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16759 Ok(decoded) => {
16760 handler
16761 .write_at(::fidl_next::Request::from_decoded(decoded), responder)
16762 .await;
16763 Ok(())
16764 }
16765 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16766 ordinal: 8736683935131400491,
16767 error,
16768 }),
16769 }
16770 }
16771
16772 3134648685270758458 => {
16773 let responder = ::fidl_next::Responder::from_untyped(responder);
16774
16775 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16776 Ok(decoded) => {
16777 handler
16778 .resize(::fidl_next::Request::from_decoded(decoded), responder)
16779 .await;
16780 Ok(())
16781 }
16782 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16783 ordinal: 3134648685270758458,
16784 error,
16785 }),
16786 }
16787 }
16788
16789 46911652864194091 => {
16790 let responder = ::fidl_next::Responder::from_untyped(responder);
16791
16792 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16793 Ok(decoded) => {
16794 handler
16795 .get_backing_memory(
16796 ::fidl_next::Request::from_decoded(decoded),
16797 responder,
16798 )
16799 .await;
16800 Ok(())
16801 }
16802 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16803 ordinal: 46911652864194091,
16804 error,
16805 }),
16806 }
16807 }
16808
16809 8645235848064269614 => {
16810 let responder = ::fidl_next::Responder::from_untyped(responder);
16811
16812 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16813 Ok(decoded) => {
16814 handler
16815 .allocate(::fidl_next::Request::from_decoded(decoded), responder)
16816 .await;
16817 Ok(())
16818 }
16819 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16820 ordinal: 8645235848064269614,
16821 error,
16822 }),
16823 }
16824 }
16825
16826 3189145313204943035 => {
16827 let responder = ::fidl_next::Responder::from_untyped(responder);
16828
16829 match ::fidl_next::AsDecoderExt::into_decoded(body) {
16830 Ok(decoded) => {
16831 handler
16832 .enable_verity(::fidl_next::Request::from_decoded(decoded), responder)
16833 .await;
16834 Ok(())
16835 }
16836 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16837 ordinal: 3189145313204943035,
16838 error,
16839 }),
16840 }
16841 }
16842
16843 ordinal => {
16844 handler.on_unknown_interaction(ordinal).await;
16845 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
16846 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16847 } else {
16848 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
16849 ordinal,
16850 flexibility,
16851 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
16852 )
16853 .expect("encoding a framework error should never fail")
16854 .await?;
16855 Ok(())
16856 }
16857 }
16858 }
16859 }
16860}
16861
16862impl<___T> FileClientHandler<___T> for ::fidl_next::IgnoreEvents
16863where
16864 ___T: ::fidl_next::Transport,
16865{
16866 async fn on_open(&mut self, _: ::fidl_next::Request<file::OnOpen, ___T>) {}
16867
16868 async fn on_representation(&mut self, _: ::fidl_next::Request<file::OnRepresentation, ___T>) {}
16869
16870 async fn on_unknown_interaction(&mut self, _: u64) {}
16871}
16872
16873impl<___H, ___T> FileLocalClientHandler<___T> for ::fidl_next::Local<___H>
16874where
16875 ___H: FileClientHandler<___T>,
16876 ___T: ::fidl_next::Transport,
16877{
16878 async fn on_open(&mut self, request: ::fidl_next::Request<file::OnOpen, ___T>) {
16879 ___H::on_open(&mut self.0, request).await
16880 }
16881
16882 async fn on_representation(
16883 &mut self,
16884
16885 request: ::fidl_next::Request<file::OnRepresentation, ___T>,
16886 ) {
16887 ___H::on_representation(&mut self.0, request).await
16888 }
16889
16890 async fn on_unknown_interaction(&mut self, ordinal: u64) {
16891 ___H::on_unknown_interaction(&mut self.0, ordinal).await
16892 }
16893}
16894
16895impl<___H, ___T> FileLocalServerHandler<___T> for ::fidl_next::Local<___H>
16896where
16897 ___H: FileServerHandler<___T>,
16898 ___T: ::fidl_next::Transport,
16899{
16900 async fn advisory_lock(
16901 &mut self,
16902
16903 request: ::fidl_next::Request<file::AdvisoryLock, ___T>,
16904
16905 responder: ::fidl_next::Responder<file::AdvisoryLock, ___T>,
16906 ) {
16907 ___H::advisory_lock(&mut self.0, request, responder).await
16908 }
16909
16910 async fn link_into(
16911 &mut self,
16912
16913 request: ::fidl_next::Request<file::LinkInto, ___T>,
16914
16915 responder: ::fidl_next::Responder<file::LinkInto, ___T>,
16916 ) {
16917 ___H::link_into(&mut self.0, request, responder).await
16918 }
16919
16920 async fn clone(&mut self, request: ::fidl_next::Request<file::Clone, ___T>) {
16921 ___H::clone(&mut self.0, request).await
16922 }
16923
16924 async fn close(&mut self, responder: ::fidl_next::Responder<file::Close, ___T>) {
16925 ___H::close(&mut self.0, responder).await
16926 }
16927
16928 async fn query(&mut self, responder: ::fidl_next::Responder<file::Query, ___T>) {
16929 ___H::query(&mut self.0, responder).await
16930 }
16931
16932 async fn deprecated_clone(
16933 &mut self,
16934
16935 request: ::fidl_next::Request<file::DeprecatedClone, ___T>,
16936 ) {
16937 ___H::deprecated_clone(&mut self.0, request).await
16938 }
16939
16940 async fn deprecated_get_attr(
16941 &mut self,
16942
16943 responder: ::fidl_next::Responder<file::DeprecatedGetAttr, ___T>,
16944 ) {
16945 ___H::deprecated_get_attr(&mut self.0, responder).await
16946 }
16947
16948 async fn deprecated_set_attr(
16949 &mut self,
16950
16951 request: ::fidl_next::Request<file::DeprecatedSetAttr, ___T>,
16952
16953 responder: ::fidl_next::Responder<file::DeprecatedSetAttr, ___T>,
16954 ) {
16955 ___H::deprecated_set_attr(&mut self.0, request, responder).await
16956 }
16957
16958 async fn deprecated_get_flags(
16959 &mut self,
16960
16961 responder: ::fidl_next::Responder<file::DeprecatedGetFlags, ___T>,
16962 ) {
16963 ___H::deprecated_get_flags(&mut self.0, responder).await
16964 }
16965
16966 async fn deprecated_set_flags(
16967 &mut self,
16968
16969 request: ::fidl_next::Request<file::DeprecatedSetFlags, ___T>,
16970
16971 responder: ::fidl_next::Responder<file::DeprecatedSetFlags, ___T>,
16972 ) {
16973 ___H::deprecated_set_flags(&mut self.0, request, responder).await
16974 }
16975
16976 async fn get_flags(&mut self, responder: ::fidl_next::Responder<file::GetFlags, ___T>) {
16977 ___H::get_flags(&mut self.0, responder).await
16978 }
16979
16980 async fn set_flags(
16981 &mut self,
16982
16983 request: ::fidl_next::Request<file::SetFlags, ___T>,
16984
16985 responder: ::fidl_next::Responder<file::SetFlags, ___T>,
16986 ) {
16987 ___H::set_flags(&mut self.0, request, responder).await
16988 }
16989
16990 async fn query_filesystem(
16991 &mut self,
16992
16993 responder: ::fidl_next::Responder<file::QueryFilesystem, ___T>,
16994 ) {
16995 ___H::query_filesystem(&mut self.0, responder).await
16996 }
16997
16998 async fn get_attributes(
16999 &mut self,
17000
17001 request: ::fidl_next::Request<file::GetAttributes, ___T>,
17002
17003 responder: ::fidl_next::Responder<file::GetAttributes, ___T>,
17004 ) {
17005 ___H::get_attributes(&mut self.0, request, responder).await
17006 }
17007
17008 async fn update_attributes(
17009 &mut self,
17010
17011 request: ::fidl_next::Request<file::UpdateAttributes, ___T>,
17012
17013 responder: ::fidl_next::Responder<file::UpdateAttributes, ___T>,
17014 ) {
17015 ___H::update_attributes(&mut self.0, request, responder).await
17016 }
17017
17018 async fn sync(&mut self, responder: ::fidl_next::Responder<file::Sync, ___T>) {
17019 ___H::sync(&mut self.0, responder).await
17020 }
17021
17022 async fn list_extended_attributes(
17023 &mut self,
17024
17025 request: ::fidl_next::Request<file::ListExtendedAttributes, ___T>,
17026 ) {
17027 ___H::list_extended_attributes(&mut self.0, request).await
17028 }
17029
17030 async fn get_extended_attribute(
17031 &mut self,
17032
17033 request: ::fidl_next::Request<file::GetExtendedAttribute, ___T>,
17034
17035 responder: ::fidl_next::Responder<file::GetExtendedAttribute, ___T>,
17036 ) {
17037 ___H::get_extended_attribute(&mut self.0, request, responder).await
17038 }
17039
17040 async fn set_extended_attribute(
17041 &mut self,
17042
17043 request: ::fidl_next::Request<file::SetExtendedAttribute, ___T>,
17044
17045 responder: ::fidl_next::Responder<file::SetExtendedAttribute, ___T>,
17046 ) {
17047 ___H::set_extended_attribute(&mut self.0, request, responder).await
17048 }
17049
17050 async fn remove_extended_attribute(
17051 &mut self,
17052
17053 request: ::fidl_next::Request<file::RemoveExtendedAttribute, ___T>,
17054
17055 responder: ::fidl_next::Responder<file::RemoveExtendedAttribute, ___T>,
17056 ) {
17057 ___H::remove_extended_attribute(&mut self.0, request, responder).await
17058 }
17059
17060 async fn read(
17061 &mut self,
17062
17063 request: ::fidl_next::Request<file::Read, ___T>,
17064
17065 responder: ::fidl_next::Responder<file::Read, ___T>,
17066 ) {
17067 ___H::read(&mut self.0, request, responder).await
17068 }
17069
17070 async fn write(
17071 &mut self,
17072
17073 request: ::fidl_next::Request<file::Write, ___T>,
17074
17075 responder: ::fidl_next::Responder<file::Write, ___T>,
17076 ) {
17077 ___H::write(&mut self.0, request, responder).await
17078 }
17079
17080 async fn describe(&mut self, responder: ::fidl_next::Responder<file::Describe, ___T>) {
17081 ___H::describe(&mut self.0, responder).await
17082 }
17083
17084 async fn seek(
17085 &mut self,
17086
17087 request: ::fidl_next::Request<file::Seek, ___T>,
17088
17089 responder: ::fidl_next::Responder<file::Seek, ___T>,
17090 ) {
17091 ___H::seek(&mut self.0, request, responder).await
17092 }
17093
17094 async fn read_at(
17095 &mut self,
17096
17097 request: ::fidl_next::Request<file::ReadAt, ___T>,
17098
17099 responder: ::fidl_next::Responder<file::ReadAt, ___T>,
17100 ) {
17101 ___H::read_at(&mut self.0, request, responder).await
17102 }
17103
17104 async fn write_at(
17105 &mut self,
17106
17107 request: ::fidl_next::Request<file::WriteAt, ___T>,
17108
17109 responder: ::fidl_next::Responder<file::WriteAt, ___T>,
17110 ) {
17111 ___H::write_at(&mut self.0, request, responder).await
17112 }
17113
17114 async fn resize(
17115 &mut self,
17116
17117 request: ::fidl_next::Request<file::Resize, ___T>,
17118
17119 responder: ::fidl_next::Responder<file::Resize, ___T>,
17120 ) {
17121 ___H::resize(&mut self.0, request, responder).await
17122 }
17123
17124 async fn get_backing_memory(
17125 &mut self,
17126
17127 request: ::fidl_next::Request<file::GetBackingMemory, ___T>,
17128
17129 responder: ::fidl_next::Responder<file::GetBackingMemory, ___T>,
17130 ) {
17131 ___H::get_backing_memory(&mut self.0, request, responder).await
17132 }
17133
17134 async fn allocate(
17135 &mut self,
17136
17137 request: ::fidl_next::Request<file::Allocate, ___T>,
17138
17139 responder: ::fidl_next::Responder<file::Allocate, ___T>,
17140 ) {
17141 ___H::allocate(&mut self.0, request, responder).await
17142 }
17143
17144 async fn enable_verity(
17145 &mut self,
17146
17147 request: ::fidl_next::Request<file::EnableVerity, ___T>,
17148
17149 responder: ::fidl_next::Responder<file::EnableVerity, ___T>,
17150 ) {
17151 ___H::enable_verity(&mut self.0, request, responder).await
17152 }
17153
17154 async fn on_unknown_interaction(&mut self, ordinal: u64) {
17155 ___H::on_unknown_interaction(&mut self.0, ordinal).await
17156 }
17157}
17158
17159#[doc = " A [\'Node\'] which contains a symbolic link.\n"]
17161#[derive(PartialEq, Debug)]
17162pub struct Symlink;
17163
17164impl ::fidl_next::Discoverable for Symlink {
17165 const PROTOCOL_NAME: &'static str = "fuchsia.io.Symlink";
17166}
17167
17168#[cfg(target_os = "fuchsia")]
17169impl ::fidl_next::HasTransport for Symlink {
17170 type Transport = ::fdomain_client::Channel;
17171}
17172
17173pub mod symlink {
17174 pub mod prelude {
17175 pub use crate::{
17176 Symlink, SymlinkClientHandler, SymlinkLocalClientHandler, SymlinkLocalServerHandler,
17177 SymlinkServerHandler, symlink,
17178 };
17179
17180 pub use crate::natural::ExtendedAttributeValue;
17181
17182 pub use crate::natural::LinkableLinkIntoRequest;
17183
17184 pub use crate::natural::LinkableLinkIntoResponse;
17185
17186 pub use crate::natural::MutableNodeAttributes;
17187
17188 pub use crate::natural::NodeAttributes2;
17189
17190 pub use crate::natural::NodeDeprecatedCloneRequest;
17191
17192 pub use crate::natural::NodeDeprecatedGetAttrResponse;
17193
17194 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
17195
17196 pub use crate::natural::NodeDeprecatedSetAttrRequest;
17197
17198 pub use crate::natural::NodeDeprecatedSetAttrResponse;
17199
17200 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
17201
17202 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
17203
17204 pub use crate::natural::NodeGetAttributesRequest;
17205
17206 pub use crate::natural::NodeGetExtendedAttributeRequest;
17207
17208 pub use crate::natural::NodeListExtendedAttributesRequest;
17209
17210 pub use crate::natural::NodeOnOpenRequest;
17211
17212 pub use crate::natural::NodeQueryFilesystemResponse;
17213
17214 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
17215
17216 pub use crate::natural::NodeSetExtendedAttributeRequest;
17217
17218 pub use crate::natural::NodeSetFlagsRequest;
17219
17220 pub use crate::natural::NodeGetFlagsResponse;
17221
17222 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
17223
17224 pub use crate::natural::NodeSetExtendedAttributeResponse;
17225
17226 pub use crate::natural::NodeSetFlagsResponse;
17227
17228 pub use crate::natural::NodeSyncResponse;
17229
17230 pub use crate::natural::NodeUpdateAttributesResponse;
17231
17232 pub use crate::natural::OpenableOpenRequest;
17233
17234 pub use crate::natural::Representation;
17235
17236 pub use crate::natural::SymlinkInfo;
17237
17238 pub use ::fdomain_next_fuchsia_unknown::natural::CloneableCloneRequest;
17239
17240 pub use ::fdomain_next_fuchsia_unknown::natural::CloseableCloseResponse;
17241
17242 pub use ::fdomain_next_fuchsia_unknown::natural::QueryableQueryResponse;
17243 }
17244
17245 pub struct LinkInto;
17246
17247 impl ::fidl_next::Method for LinkInto {
17248 const ORDINAL: u64 = 6121399674497678964;
17249 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17250 ::fidl_next::protocol::Flexibility::Strict;
17251
17252 type Protocol = crate::Symlink;
17253
17254 type Request = crate::wire::LinkableLinkIntoRequest<'static>;
17255 }
17256
17257 impl ::fidl_next::TwoWayMethod for LinkInto {
17258 type Response = ::fidl_next::wire::Result<
17259 'static,
17260 crate::wire::LinkableLinkIntoResponse,
17261 ::fidl_next::wire::Int32,
17262 >;
17263 }
17264
17265 impl<___R> ::fidl_next::Respond<___R> for LinkInto {
17266 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
17267
17268 fn respond(response: ___R) -> Self::Output {
17269 ::core::result::Result::Ok(response)
17270 }
17271 }
17272
17273 impl<___R> ::fidl_next::RespondErr<___R> for LinkInto {
17274 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
17275
17276 fn respond_err(response: ___R) -> Self::Output {
17277 ::core::result::Result::Err(response)
17278 }
17279 }
17280
17281 pub struct Clone;
17282
17283 impl ::fidl_next::Method for Clone {
17284 const ORDINAL: u64 = 2366825959783828089;
17285 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17286 ::fidl_next::protocol::Flexibility::Strict;
17287
17288 type Protocol = crate::Symlink;
17289
17290 type Request = ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest;
17291 }
17292
17293 pub struct Close;
17294
17295 impl ::fidl_next::Method for Close {
17296 const ORDINAL: u64 = 6540867515453498750;
17297 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17298 ::fidl_next::protocol::Flexibility::Strict;
17299
17300 type Protocol = crate::Symlink;
17301
17302 type Request = ::fidl_next::wire::EmptyMessageBody;
17303 }
17304
17305 impl ::fidl_next::TwoWayMethod for Close {
17306 type Response = ::fidl_next::wire::Result<
17307 'static,
17308 ::fdomain_next_fuchsia_unknown::wire::CloseableCloseResponse,
17309 ::fidl_next::wire::Int32,
17310 >;
17311 }
17312
17313 impl<___R> ::fidl_next::Respond<___R> for Close {
17314 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
17315
17316 fn respond(response: ___R) -> Self::Output {
17317 ::core::result::Result::Ok(response)
17318 }
17319 }
17320
17321 impl<___R> ::fidl_next::RespondErr<___R> for Close {
17322 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
17323
17324 fn respond_err(response: ___R) -> Self::Output {
17325 ::core::result::Result::Err(response)
17326 }
17327 }
17328
17329 pub struct Query;
17330
17331 impl ::fidl_next::Method for Query {
17332 const ORDINAL: u64 = 2763219980499352582;
17333 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17334 ::fidl_next::protocol::Flexibility::Strict;
17335
17336 type Protocol = crate::Symlink;
17337
17338 type Request = ::fidl_next::wire::EmptyMessageBody;
17339 }
17340
17341 impl ::fidl_next::TwoWayMethod for Query {
17342 type Response = ::fdomain_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>;
17343 }
17344
17345 impl<___R> ::fidl_next::Respond<___R> for Query {
17346 type Output = ::fdomain_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>;
17347
17348 fn respond(response: ___R) -> Self::Output {
17349 ::fdomain_next_fuchsia_unknown::generic::QueryableQueryResponse { protocol: response }
17350 }
17351 }
17352
17353 pub struct DeprecatedClone;
17354
17355 impl ::fidl_next::Method for DeprecatedClone {
17356 const ORDINAL: u64 = 6512600400724287855;
17357 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17358 ::fidl_next::protocol::Flexibility::Flexible;
17359
17360 type Protocol = crate::Symlink;
17361
17362 type Request = crate::wire::NodeDeprecatedCloneRequest;
17363 }
17364
17365 pub struct OnOpen;
17366
17367 impl ::fidl_next::Method for OnOpen {
17368 const ORDINAL: u64 = 9207534335756671346;
17369 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17370 ::fidl_next::protocol::Flexibility::Flexible;
17371
17372 type Protocol = crate::Symlink;
17373
17374 type Request = crate::wire::NodeOnOpenRequest<'static>;
17375 }
17376
17377 pub struct DeprecatedGetAttr;
17378
17379 impl ::fidl_next::Method for DeprecatedGetAttr {
17380 const ORDINAL: u64 = 8689798978500614909;
17381 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17382 ::fidl_next::protocol::Flexibility::Strict;
17383
17384 type Protocol = crate::Symlink;
17385
17386 type Request = ::fidl_next::wire::EmptyMessageBody;
17387 }
17388
17389 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
17390 type Response = crate::wire::NodeDeprecatedGetAttrResponse;
17391 }
17392
17393 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
17394 type Output = ___R;
17395
17396 fn respond(response: ___R) -> Self::Output {
17397 response
17398 }
17399 }
17400
17401 pub struct DeprecatedSetAttr;
17402
17403 impl ::fidl_next::Method for DeprecatedSetAttr {
17404 const ORDINAL: u64 = 4721673413776871238;
17405 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17406 ::fidl_next::protocol::Flexibility::Strict;
17407
17408 type Protocol = crate::Symlink;
17409
17410 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
17411 }
17412
17413 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
17414 type Response = crate::wire::NodeDeprecatedSetAttrResponse;
17415 }
17416
17417 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
17418 type Output = crate::generic::NodeDeprecatedSetAttrResponse<___R>;
17419
17420 fn respond(response: ___R) -> Self::Output {
17421 crate::generic::NodeDeprecatedSetAttrResponse { s: response }
17422 }
17423 }
17424
17425 pub struct DeprecatedGetFlags;
17426
17427 impl ::fidl_next::Method for DeprecatedGetFlags {
17428 const ORDINAL: u64 = 6595803110182632097;
17429 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17430 ::fidl_next::protocol::Flexibility::Strict;
17431
17432 type Protocol = crate::Symlink;
17433
17434 type Request = ::fidl_next::wire::EmptyMessageBody;
17435 }
17436
17437 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
17438 type Response = crate::wire::NodeDeprecatedGetFlagsResponse;
17439 }
17440
17441 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
17442 type Output = ___R;
17443
17444 fn respond(response: ___R) -> Self::Output {
17445 response
17446 }
17447 }
17448
17449 pub struct DeprecatedSetFlags;
17450
17451 impl ::fidl_next::Method for DeprecatedSetFlags {
17452 const ORDINAL: u64 = 5950864159036794675;
17453 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17454 ::fidl_next::protocol::Flexibility::Strict;
17455
17456 type Protocol = crate::Symlink;
17457
17458 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
17459 }
17460
17461 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
17462 type Response = crate::wire::NodeDeprecatedSetFlagsResponse;
17463 }
17464
17465 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
17466 type Output = crate::generic::NodeDeprecatedSetFlagsResponse<___R>;
17467
17468 fn respond(response: ___R) -> Self::Output {
17469 crate::generic::NodeDeprecatedSetFlagsResponse { s: response }
17470 }
17471 }
17472
17473 pub struct GetFlags;
17474
17475 impl ::fidl_next::Method for GetFlags {
17476 const ORDINAL: u64 = 105530239381466147;
17477 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17478 ::fidl_next::protocol::Flexibility::Flexible;
17479
17480 type Protocol = crate::Symlink;
17481
17482 type Request = ::fidl_next::wire::EmptyMessageBody;
17483 }
17484
17485 impl ::fidl_next::TwoWayMethod for GetFlags {
17486 type Response = ::fidl_next::wire::FlexibleResult<
17487 'static,
17488 crate::wire::NodeGetFlagsResponse,
17489 ::fidl_next::wire::Int32,
17490 >;
17491 }
17492
17493 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
17494 type Output = ::fidl_next::FlexibleResult<
17495 crate::generic::NodeGetFlagsResponse<___R>,
17496 ::fidl_next::util::Never,
17497 >;
17498
17499 fn respond(response: ___R) -> Self::Output {
17500 ::fidl_next::FlexibleResult::Ok(crate::generic::NodeGetFlagsResponse {
17501 flags: response,
17502 })
17503 }
17504 }
17505
17506 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
17507 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
17508
17509 fn respond_err(response: ___R) -> Self::Output {
17510 ::fidl_next::FlexibleResult::Err(response)
17511 }
17512 }
17513
17514 pub struct SetFlags;
17515
17516 impl ::fidl_next::Method for SetFlags {
17517 const ORDINAL: u64 = 6172186066099445416;
17518 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17519 ::fidl_next::protocol::Flexibility::Flexible;
17520
17521 type Protocol = crate::Symlink;
17522
17523 type Request = crate::wire::NodeSetFlagsRequest;
17524 }
17525
17526 impl ::fidl_next::TwoWayMethod for SetFlags {
17527 type Response = ::fidl_next::wire::FlexibleResult<
17528 'static,
17529 crate::wire::NodeSetFlagsResponse,
17530 ::fidl_next::wire::Int32,
17531 >;
17532 }
17533
17534 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
17535 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
17536
17537 fn respond(response: ___R) -> Self::Output {
17538 ::fidl_next::FlexibleResult::Ok(response)
17539 }
17540 }
17541
17542 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
17543 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
17544
17545 fn respond_err(response: ___R) -> Self::Output {
17546 ::fidl_next::FlexibleResult::Err(response)
17547 }
17548 }
17549
17550 pub struct QueryFilesystem;
17551
17552 impl ::fidl_next::Method for QueryFilesystem {
17553 const ORDINAL: u64 = 8013111122914313744;
17554 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17555 ::fidl_next::protocol::Flexibility::Strict;
17556
17557 type Protocol = crate::Symlink;
17558
17559 type Request = ::fidl_next::wire::EmptyMessageBody;
17560 }
17561
17562 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
17563 type Response = crate::wire::NodeQueryFilesystemResponse<'static>;
17564 }
17565
17566 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
17567 type Output = ___R;
17568
17569 fn respond(response: ___R) -> Self::Output {
17570 response
17571 }
17572 }
17573
17574 pub struct OnRepresentation;
17575
17576 impl ::fidl_next::Method for OnRepresentation {
17577 const ORDINAL: u64 = 6679970090861613324;
17578 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17579 ::fidl_next::protocol::Flexibility::Strict;
17580
17581 type Protocol = crate::Symlink;
17582
17583 type Request = crate::wire::Representation<'static>;
17584 }
17585
17586 pub struct GetAttributes;
17587
17588 impl ::fidl_next::Method for GetAttributes {
17589 const ORDINAL: u64 = 4414537700416816443;
17590 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17591 ::fidl_next::protocol::Flexibility::Strict;
17592
17593 type Protocol = crate::Symlink;
17594
17595 type Request = crate::wire::NodeGetAttributesRequest;
17596 }
17597
17598 impl ::fidl_next::TwoWayMethod for GetAttributes {
17599 type Response = ::fidl_next::wire::Result<
17600 'static,
17601 crate::wire::NodeAttributes2<'static>,
17602 ::fidl_next::wire::Int32,
17603 >;
17604 }
17605
17606 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
17607 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
17608
17609 fn respond(response: ___R) -> Self::Output {
17610 ::core::result::Result::Ok(response)
17611 }
17612 }
17613
17614 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
17615 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
17616
17617 fn respond_err(response: ___R) -> Self::Output {
17618 ::core::result::Result::Err(response)
17619 }
17620 }
17621
17622 pub struct UpdateAttributes;
17623
17624 impl ::fidl_next::Method for UpdateAttributes {
17625 const ORDINAL: u64 = 3677402239314018056;
17626 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17627 ::fidl_next::protocol::Flexibility::Strict;
17628
17629 type Protocol = crate::Symlink;
17630
17631 type Request = crate::wire::MutableNodeAttributes<'static>;
17632 }
17633
17634 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
17635 type Response = ::fidl_next::wire::Result<
17636 'static,
17637 crate::wire::NodeUpdateAttributesResponse,
17638 ::fidl_next::wire::Int32,
17639 >;
17640 }
17641
17642 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
17643 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
17644
17645 fn respond(response: ___R) -> Self::Output {
17646 ::core::result::Result::Ok(response)
17647 }
17648 }
17649
17650 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
17651 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
17652
17653 fn respond_err(response: ___R) -> Self::Output {
17654 ::core::result::Result::Err(response)
17655 }
17656 }
17657
17658 pub struct Sync;
17659
17660 impl ::fidl_next::Method for Sync {
17661 const ORDINAL: u64 = 3196473584242777161;
17662 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17663 ::fidl_next::protocol::Flexibility::Strict;
17664
17665 type Protocol = crate::Symlink;
17666
17667 type Request = ::fidl_next::wire::EmptyMessageBody;
17668 }
17669
17670 impl ::fidl_next::TwoWayMethod for Sync {
17671 type Response = ::fidl_next::wire::Result<
17672 'static,
17673 crate::wire::NodeSyncResponse,
17674 ::fidl_next::wire::Int32,
17675 >;
17676 }
17677
17678 impl<___R> ::fidl_next::Respond<___R> for Sync {
17679 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
17680
17681 fn respond(response: ___R) -> Self::Output {
17682 ::core::result::Result::Ok(response)
17683 }
17684 }
17685
17686 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
17687 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
17688
17689 fn respond_err(response: ___R) -> Self::Output {
17690 ::core::result::Result::Err(response)
17691 }
17692 }
17693
17694 pub struct ListExtendedAttributes;
17695
17696 impl ::fidl_next::Method for ListExtendedAttributes {
17697 const ORDINAL: u64 = 5431626189872037072;
17698 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17699 ::fidl_next::protocol::Flexibility::Strict;
17700
17701 type Protocol = crate::Symlink;
17702
17703 type Request = crate::wire::NodeListExtendedAttributesRequest;
17704 }
17705
17706 pub struct GetExtendedAttribute;
17707
17708 impl ::fidl_next::Method for GetExtendedAttribute {
17709 const ORDINAL: u64 = 5043930208506967771;
17710 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17711 ::fidl_next::protocol::Flexibility::Strict;
17712
17713 type Protocol = crate::Symlink;
17714
17715 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
17716 }
17717
17718 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
17719 type Response = ::fidl_next::wire::Result<
17720 'static,
17721 crate::wire::ExtendedAttributeValue<'static>,
17722 ::fidl_next::wire::Int32,
17723 >;
17724 }
17725
17726 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
17727 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
17728
17729 fn respond(response: ___R) -> Self::Output {
17730 ::core::result::Result::Ok(response)
17731 }
17732 }
17733
17734 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
17735 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
17736
17737 fn respond_err(response: ___R) -> Self::Output {
17738 ::core::result::Result::Err(response)
17739 }
17740 }
17741
17742 pub struct SetExtendedAttribute;
17743
17744 impl ::fidl_next::Method for SetExtendedAttribute {
17745 const ORDINAL: u64 = 5374223046099989052;
17746 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17747 ::fidl_next::protocol::Flexibility::Strict;
17748
17749 type Protocol = crate::Symlink;
17750
17751 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
17752 }
17753
17754 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
17755 type Response = ::fidl_next::wire::Result<
17756 'static,
17757 crate::wire::NodeSetExtendedAttributeResponse,
17758 ::fidl_next::wire::Int32,
17759 >;
17760 }
17761
17762 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
17763 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
17764
17765 fn respond(response: ___R) -> Self::Output {
17766 ::core::result::Result::Ok(response)
17767 }
17768 }
17769
17770 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
17771 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
17772
17773 fn respond_err(response: ___R) -> Self::Output {
17774 ::core::result::Result::Err(response)
17775 }
17776 }
17777
17778 pub struct RemoveExtendedAttribute;
17779
17780 impl ::fidl_next::Method for RemoveExtendedAttribute {
17781 const ORDINAL: u64 = 8794297771444732717;
17782 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17783 ::fidl_next::protocol::Flexibility::Strict;
17784
17785 type Protocol = crate::Symlink;
17786
17787 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
17788 }
17789
17790 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
17791 type Response = ::fidl_next::wire::Result<
17792 'static,
17793 crate::wire::NodeRemoveExtendedAttributeResponse,
17794 ::fidl_next::wire::Int32,
17795 >;
17796 }
17797
17798 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
17799 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
17800
17801 fn respond(response: ___R) -> Self::Output {
17802 ::core::result::Result::Ok(response)
17803 }
17804 }
17805
17806 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
17807 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
17808
17809 fn respond_err(response: ___R) -> Self::Output {
17810 ::core::result::Result::Err(response)
17811 }
17812 }
17813
17814 pub struct Open;
17815
17816 impl ::fidl_next::Method for Open {
17817 const ORDINAL: u64 = 6236883748953765593;
17818 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17819 ::fidl_next::protocol::Flexibility::Flexible;
17820
17821 type Protocol = crate::Symlink;
17822
17823 type Request = crate::wire::OpenableOpenRequest<'static>;
17824 }
17825
17826 pub struct Describe;
17827
17828 impl ::fidl_next::Method for Describe {
17829 const ORDINAL: u64 = 8371117097481679347;
17830 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17831 ::fidl_next::protocol::Flexibility::Flexible;
17832
17833 type Protocol = crate::Symlink;
17834
17835 type Request = ::fidl_next::wire::EmptyMessageBody;
17836 }
17837
17838 impl ::fidl_next::TwoWayMethod for Describe {
17839 type Response = ::fidl_next::wire::Flexible<'static, crate::wire::SymlinkInfo<'static>>;
17840 }
17841
17842 impl<___R> ::fidl_next::Respond<___R> for Describe {
17843 type Output = ::fidl_next::Flexible<___R>;
17844
17845 fn respond(response: ___R) -> Self::Output {
17846 ::fidl_next::Flexible::Ok(response)
17847 }
17848 }
17849
17850 mod ___detail {
17851 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Symlink
17852 where
17853 ___T: ::fidl_next::Transport,
17854 {
17855 type Client = SymlinkClient<___T>;
17856 type Server = SymlinkServer<___T>;
17857 }
17858
17859 #[repr(transparent)]
17861 pub struct SymlinkClient<___T: ::fidl_next::Transport> {
17862 #[allow(dead_code)]
17863 client: ::fidl_next::protocol::Client<___T>,
17864 }
17865
17866 impl<___T> SymlinkClient<___T>
17867 where
17868 ___T: ::fidl_next::Transport,
17869 {
17870 #[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"]
17871 pub fn link_into(
17872 &self,
17873
17874 dst_parent_token: impl ::fidl_next::Encode<
17875 ::fdomain_client::fidl_next::wire::Handle,
17876 <___T as ::fidl_next::Transport>::SendBuffer,
17877 >,
17878
17879 dst: impl ::fidl_next::Encode<
17880 ::fidl_next::wire::String<'static>,
17881 <___T as ::fidl_next::Transport>::SendBuffer,
17882 >,
17883 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
17884 where
17885 <___T as ::fidl_next::Transport>::SendBuffer:
17886 ::fidl_next::encoder::InternalHandleEncoder,
17887 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
17888 <___T as ::fidl_next::Transport>::SendBuffer:
17889 ::fdomain_client::fidl_next::HandleEncoder,
17890 {
17891 self.link_into_with(crate::generic::LinkableLinkIntoRequest {
17892 dst_parent_token,
17893
17894 dst,
17895 })
17896 }
17897
17898 #[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"]
17899 pub fn link_into_with<___R>(
17900 &self,
17901 request: ___R,
17902 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
17903 where
17904 ___R: ::fidl_next::Encode<
17905 crate::wire::LinkableLinkIntoRequest<'static>,
17906 <___T as ::fidl_next::Transport>::SendBuffer,
17907 >,
17908 {
17909 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17910 6121399674497678964,
17911 <super::LinkInto as ::fidl_next::Method>::FLEXIBILITY,
17912 request,
17913 ))
17914 }
17915
17916 pub fn clone(
17917 &self,
17918
17919 request: impl ::fidl_next::Encode<
17920 ::fidl_next::ServerEnd<
17921 ::fdomain_next_fuchsia_unknown::Cloneable,
17922 ::fdomain_client::fidl_next::wire::Handle,
17923 >,
17924 <___T as ::fidl_next::Transport>::SendBuffer,
17925 >,
17926 ) -> ::fidl_next::SendFuture<'_, ___T>
17927 where
17928 <___T as ::fidl_next::Transport>::SendBuffer:
17929 ::fidl_next::encoder::InternalHandleEncoder,
17930 <___T as ::fidl_next::Transport>::SendBuffer:
17931 ::fdomain_client::fidl_next::HandleEncoder,
17932 {
17933 self.clone_with(::fdomain_next_fuchsia_unknown::generic::CloneableCloneRequest {
17934 request,
17935 })
17936 }
17937
17938 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
17939 where
17940 ___R: ::fidl_next::Encode<
17941 ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest,
17942 <___T as ::fidl_next::Transport>::SendBuffer,
17943 >,
17944 {
17945 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
17946 2366825959783828089,
17947 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
17948 request,
17949 ))
17950 }
17951
17952 #[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"]
17953 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
17954 ::fidl_next::TwoWayFuture::from_untyped(
17955 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
17956 6540867515453498750,
17957 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
17958 (),
17959 ),
17960 )
17961 }
17962
17963 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
17964 ::fidl_next::TwoWayFuture::from_untyped(
17965 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
17966 2763219980499352582,
17967 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
17968 (),
17969 ),
17970 )
17971 }
17972
17973 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
17974 pub fn deprecated_clone(
17975 &self,
17976
17977 flags: impl ::fidl_next::Encode<
17978 crate::wire::OpenFlags,
17979 <___T as ::fidl_next::Transport>::SendBuffer,
17980 >,
17981
17982 object: impl ::fidl_next::Encode<
17983 ::fidl_next::ServerEnd<crate::Node, ::fdomain_client::fidl_next::wire::Handle>,
17984 <___T as ::fidl_next::Transport>::SendBuffer,
17985 >,
17986 ) -> ::fidl_next::SendFuture<'_, ___T>
17987 where
17988 <___T as ::fidl_next::Transport>::SendBuffer:
17989 ::fidl_next::encoder::InternalHandleEncoder,
17990 <___T as ::fidl_next::Transport>::SendBuffer:
17991 ::fdomain_client::fidl_next::HandleEncoder,
17992 {
17993 self.deprecated_clone_with(crate::generic::NodeDeprecatedCloneRequest {
17994 flags,
17995
17996 object,
17997 })
17998 }
17999
18000 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
18001 pub fn deprecated_clone_with<___R>(
18002 &self,
18003 request: ___R,
18004 ) -> ::fidl_next::SendFuture<'_, ___T>
18005 where
18006 ___R: ::fidl_next::Encode<
18007 crate::wire::NodeDeprecatedCloneRequest,
18008 <___T as ::fidl_next::Transport>::SendBuffer,
18009 >,
18010 {
18011 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
18012 6512600400724287855,
18013 <super::DeprecatedClone as ::fidl_next::Method>::FLEXIBILITY,
18014 request,
18015 ))
18016 }
18017
18018 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
18019 pub fn deprecated_get_attr(
18020 &self,
18021 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
18022 ::fidl_next::TwoWayFuture::from_untyped(
18023 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18024 8689798978500614909,
18025 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
18026 (),
18027 ),
18028 )
18029 }
18030
18031 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
18032 pub fn deprecated_set_attr(
18033 &self,
18034
18035 flags: impl ::fidl_next::Encode<
18036 crate::wire::NodeAttributeFlags,
18037 <___T as ::fidl_next::Transport>::SendBuffer,
18038 >,
18039
18040 attributes: impl ::fidl_next::Encode<
18041 crate::wire::NodeAttributes,
18042 <___T as ::fidl_next::Transport>::SendBuffer,
18043 >,
18044 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
18045 where
18046 <___T as ::fidl_next::Transport>::SendBuffer:
18047 ::fidl_next::encoder::InternalHandleEncoder,
18048 {
18049 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
18050 flags,
18051
18052 attributes,
18053 })
18054 }
18055
18056 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
18057 pub fn deprecated_set_attr_with<___R>(
18058 &self,
18059 request: ___R,
18060 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
18061 where
18062 ___R: ::fidl_next::Encode<
18063 crate::wire::NodeDeprecatedSetAttrRequest,
18064 <___T as ::fidl_next::Transport>::SendBuffer,
18065 >,
18066 {
18067 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18068 4721673413776871238,
18069 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
18070 request,
18071 ))
18072 }
18073
18074 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
18075 pub fn deprecated_get_flags(
18076 &self,
18077 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
18078 ::fidl_next::TwoWayFuture::from_untyped(
18079 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18080 6595803110182632097,
18081 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
18082 (),
18083 ),
18084 )
18085 }
18086
18087 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
18088 pub fn deprecated_set_flags(
18089 &self,
18090
18091 flags: impl ::fidl_next::Encode<
18092 crate::wire::OpenFlags,
18093 <___T as ::fidl_next::Transport>::SendBuffer,
18094 >,
18095 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
18096 where
18097 <___T as ::fidl_next::Transport>::SendBuffer:
18098 ::fidl_next::encoder::InternalHandleEncoder,
18099 {
18100 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
18101 flags,
18102 })
18103 }
18104
18105 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
18106 pub fn deprecated_set_flags_with<___R>(
18107 &self,
18108 request: ___R,
18109 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
18110 where
18111 ___R: ::fidl_next::Encode<
18112 crate::wire::NodeDeprecatedSetFlagsRequest,
18113 <___T as ::fidl_next::Transport>::SendBuffer,
18114 >,
18115 {
18116 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18117 5950864159036794675,
18118 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
18119 request,
18120 ))
18121 }
18122
18123 #[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"]
18124 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
18125 ::fidl_next::TwoWayFuture::from_untyped(
18126 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18127 105530239381466147,
18128 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
18129 (),
18130 ),
18131 )
18132 }
18133
18134 #[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"]
18135 pub fn set_flags(
18136 &self,
18137
18138 flags: impl ::fidl_next::Encode<
18139 crate::wire::Flags,
18140 <___T as ::fidl_next::Transport>::SendBuffer,
18141 >,
18142 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
18143 where
18144 <___T as ::fidl_next::Transport>::SendBuffer:
18145 ::fidl_next::encoder::InternalHandleEncoder,
18146 {
18147 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
18148 }
18149
18150 #[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"]
18151 pub fn set_flags_with<___R>(
18152 &self,
18153 request: ___R,
18154 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
18155 where
18156 ___R: ::fidl_next::Encode<
18157 crate::wire::NodeSetFlagsRequest,
18158 <___T as ::fidl_next::Transport>::SendBuffer,
18159 >,
18160 {
18161 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18162 6172186066099445416,
18163 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
18164 request,
18165 ))
18166 }
18167
18168 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
18169 pub fn query_filesystem(
18170 &self,
18171 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
18172 ::fidl_next::TwoWayFuture::from_untyped(
18173 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18174 8013111122914313744,
18175 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
18176 (),
18177 ),
18178 )
18179 }
18180
18181 #[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"]
18182 pub fn get_attributes(
18183 &self,
18184
18185 query: impl ::fidl_next::Encode<
18186 crate::wire::NodeAttributesQuery,
18187 <___T as ::fidl_next::Transport>::SendBuffer,
18188 >,
18189 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
18190 where
18191 <___T as ::fidl_next::Transport>::SendBuffer:
18192 ::fidl_next::encoder::InternalHandleEncoder,
18193 {
18194 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
18195 }
18196
18197 #[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"]
18198 pub fn get_attributes_with<___R>(
18199 &self,
18200 request: ___R,
18201 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
18202 where
18203 ___R: ::fidl_next::Encode<
18204 crate::wire::NodeGetAttributesRequest,
18205 <___T as ::fidl_next::Transport>::SendBuffer,
18206 >,
18207 {
18208 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18209 4414537700416816443,
18210 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
18211 request,
18212 ))
18213 }
18214
18215 #[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"]
18216 pub fn update_attributes_with<___R>(
18217 &self,
18218 request: ___R,
18219 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
18220 where
18221 ___R: ::fidl_next::Encode<
18222 crate::wire::MutableNodeAttributes<'static>,
18223 <___T as ::fidl_next::Transport>::SendBuffer,
18224 >,
18225 {
18226 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18227 3677402239314018056,
18228 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
18229 request,
18230 ))
18231 }
18232
18233 #[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"]
18234 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
18235 ::fidl_next::TwoWayFuture::from_untyped(
18236 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18237 3196473584242777161,
18238 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
18239 (),
18240 ),
18241 )
18242 }
18243
18244 #[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"]
18245 pub fn list_extended_attributes(
18246 &self,
18247
18248 iterator: impl ::fidl_next::Encode<
18249 ::fidl_next::ServerEnd<
18250 crate::ExtendedAttributeIterator,
18251 ::fdomain_client::fidl_next::wire::Handle,
18252 >,
18253 <___T as ::fidl_next::Transport>::SendBuffer,
18254 >,
18255 ) -> ::fidl_next::SendFuture<'_, ___T>
18256 where
18257 <___T as ::fidl_next::Transport>::SendBuffer:
18258 ::fidl_next::encoder::InternalHandleEncoder,
18259 <___T as ::fidl_next::Transport>::SendBuffer:
18260 ::fdomain_client::fidl_next::HandleEncoder,
18261 {
18262 self.list_extended_attributes_with(
18263 crate::generic::NodeListExtendedAttributesRequest { iterator },
18264 )
18265 }
18266
18267 #[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"]
18268 pub fn list_extended_attributes_with<___R>(
18269 &self,
18270 request: ___R,
18271 ) -> ::fidl_next::SendFuture<'_, ___T>
18272 where
18273 ___R: ::fidl_next::Encode<
18274 crate::wire::NodeListExtendedAttributesRequest,
18275 <___T as ::fidl_next::Transport>::SendBuffer,
18276 >,
18277 {
18278 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
18279 5431626189872037072,
18280 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
18281 request,
18282 ))
18283 }
18284
18285 #[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"]
18286 pub fn get_extended_attribute(
18287 &self,
18288
18289 name: impl ::fidl_next::Encode<
18290 ::fidl_next::wire::Vector<'static, u8>,
18291 <___T as ::fidl_next::Transport>::SendBuffer,
18292 >,
18293 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
18294 where
18295 <___T as ::fidl_next::Transport>::SendBuffer:
18296 ::fidl_next::encoder::InternalHandleEncoder,
18297 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18298 {
18299 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
18300 name,
18301 })
18302 }
18303
18304 #[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"]
18305 pub fn get_extended_attribute_with<___R>(
18306 &self,
18307 request: ___R,
18308 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
18309 where
18310 ___R: ::fidl_next::Encode<
18311 crate::wire::NodeGetExtendedAttributeRequest<'static>,
18312 <___T as ::fidl_next::Transport>::SendBuffer,
18313 >,
18314 {
18315 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18316 5043930208506967771,
18317 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
18318 request,
18319 ))
18320 }
18321
18322 #[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"]
18323 pub fn set_extended_attribute(
18324 &self,
18325
18326 name: impl ::fidl_next::Encode<
18327 ::fidl_next::wire::Vector<'static, u8>,
18328 <___T as ::fidl_next::Transport>::SendBuffer,
18329 >,
18330
18331 value: impl ::fidl_next::Encode<
18332 crate::wire::ExtendedAttributeValue<'static>,
18333 <___T as ::fidl_next::Transport>::SendBuffer,
18334 >,
18335
18336 mode: impl ::fidl_next::Encode<
18337 crate::wire::SetExtendedAttributeMode,
18338 <___T as ::fidl_next::Transport>::SendBuffer,
18339 >,
18340 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
18341 where
18342 <___T as ::fidl_next::Transport>::SendBuffer:
18343 ::fidl_next::encoder::InternalHandleEncoder,
18344 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18345 <___T as ::fidl_next::Transport>::SendBuffer:
18346 ::fdomain_client::fidl_next::HandleEncoder,
18347 {
18348 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
18349 name,
18350
18351 value,
18352
18353 mode,
18354 })
18355 }
18356
18357 #[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"]
18358 pub fn set_extended_attribute_with<___R>(
18359 &self,
18360 request: ___R,
18361 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
18362 where
18363 ___R: ::fidl_next::Encode<
18364 crate::wire::NodeSetExtendedAttributeRequest<'static>,
18365 <___T as ::fidl_next::Transport>::SendBuffer,
18366 >,
18367 {
18368 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18369 5374223046099989052,
18370 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
18371 request,
18372 ))
18373 }
18374
18375 #[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"]
18376 pub fn remove_extended_attribute(
18377 &self,
18378
18379 name: impl ::fidl_next::Encode<
18380 ::fidl_next::wire::Vector<'static, u8>,
18381 <___T as ::fidl_next::Transport>::SendBuffer,
18382 >,
18383 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
18384 where
18385 <___T as ::fidl_next::Transport>::SendBuffer:
18386 ::fidl_next::encoder::InternalHandleEncoder,
18387 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18388 {
18389 self.remove_extended_attribute_with(
18390 crate::generic::NodeRemoveExtendedAttributeRequest { name },
18391 )
18392 }
18393
18394 #[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"]
18395 pub fn remove_extended_attribute_with<___R>(
18396 &self,
18397 request: ___R,
18398 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
18399 where
18400 ___R: ::fidl_next::Encode<
18401 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
18402 <___T as ::fidl_next::Transport>::SendBuffer,
18403 >,
18404 {
18405 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18406 8794297771444732717,
18407 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
18408 request,
18409 ))
18410 }
18411
18412 #[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"]
18413 pub fn open(
18414 &self,
18415
18416 path: impl ::fidl_next::Encode<
18417 ::fidl_next::wire::String<'static>,
18418 <___T as ::fidl_next::Transport>::SendBuffer,
18419 >,
18420
18421 flags: impl ::fidl_next::Encode<
18422 crate::wire::Flags,
18423 <___T as ::fidl_next::Transport>::SendBuffer,
18424 >,
18425
18426 options: impl ::fidl_next::Encode<
18427 crate::wire::Options<'static>,
18428 <___T as ::fidl_next::Transport>::SendBuffer,
18429 >,
18430
18431 object: impl ::fidl_next::Encode<
18432 ::fdomain_client::fidl_next::wire::Handle,
18433 <___T as ::fidl_next::Transport>::SendBuffer,
18434 >,
18435 ) -> ::fidl_next::SendFuture<'_, ___T>
18436 where
18437 <___T as ::fidl_next::Transport>::SendBuffer:
18438 ::fidl_next::encoder::InternalHandleEncoder,
18439 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18440 <___T as ::fidl_next::Transport>::SendBuffer:
18441 ::fdomain_client::fidl_next::HandleEncoder,
18442 {
18443 self.open_with(crate::generic::OpenableOpenRequest { path, flags, options, object })
18444 }
18445
18446 #[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"]
18447 pub fn open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
18448 where
18449 ___R: ::fidl_next::Encode<
18450 crate::wire::OpenableOpenRequest<'static>,
18451 <___T as ::fidl_next::Transport>::SendBuffer,
18452 >,
18453 {
18454 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
18455 6236883748953765593,
18456 <super::Open as ::fidl_next::Method>::FLEXIBILITY,
18457 request,
18458 ))
18459 }
18460
18461 pub fn describe(&self) -> ::fidl_next::TwoWayFuture<'_, super::Describe, ___T> {
18462 ::fidl_next::TwoWayFuture::from_untyped(
18463 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18464 8371117097481679347,
18465 <super::Describe as ::fidl_next::Method>::FLEXIBILITY,
18466 (),
18467 ),
18468 )
18469 }
18470 }
18471
18472 #[repr(transparent)]
18474 pub struct SymlinkServer<___T: ::fidl_next::Transport> {
18475 server: ::fidl_next::protocol::Server<___T>,
18476 }
18477
18478 impl<___T> SymlinkServer<___T>
18479 where
18480 ___T: ::fidl_next::Transport,
18481 {
18482 #[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"]
18483 pub fn on_open(
18484 &self,
18485
18486 s: impl ::fidl_next::Encode<
18487 ::fidl_next::wire::Int32,
18488 <___T as ::fidl_next::Transport>::SendBuffer,
18489 >,
18490
18491 info: impl ::fidl_next::Encode<
18492 crate::wire_optional::NodeInfoDeprecated<'static>,
18493 <___T as ::fidl_next::Transport>::SendBuffer,
18494 >,
18495 ) -> ::fidl_next::SendFuture<'_, ___T>
18496 where
18497 <___T as ::fidl_next::Transport>::SendBuffer:
18498 ::fidl_next::encoder::InternalHandleEncoder,
18499 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18500 <___T as ::fidl_next::Transport>::SendBuffer:
18501 ::fdomain_client::fidl_next::HandleEncoder,
18502 {
18503 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
18504 }
18505
18506 #[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"]
18507
18508 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
18509 where
18510 ___R: ::fidl_next::Encode<
18511 <super::OnOpen as ::fidl_next::Method>::Request,
18512 <___T as ::fidl_next::Transport>::SendBuffer,
18513 >,
18514 {
18515 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
18516 9207534335756671346,
18517 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
18518 request,
18519 ))
18520 }
18521
18522 #[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"]
18523
18524 pub fn on_representation_with<___R>(
18525 &self,
18526 request: ___R,
18527 ) -> ::fidl_next::SendFuture<'_, ___T>
18528 where
18529 ___R: ::fidl_next::Encode<
18530 <super::OnRepresentation as ::fidl_next::Method>::Request,
18531 <___T as ::fidl_next::Transport>::SendBuffer,
18532 >,
18533 {
18534 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
18535 6679970090861613324,
18536 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
18537 request,
18538 ))
18539 }
18540 }
18541 }
18542}
18543
18544#[diagnostic::on_unimplemented(
18545 note = "If {Self} implements the non-local SymlinkClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
18546)]
18547
18548pub trait SymlinkLocalClientHandler<
18552 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
18553 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18554>
18555{
18556 #[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"]
18557 fn on_open(
18558 &mut self,
18559
18560 request: ::fidl_next::Request<symlink::OnOpen, ___T>,
18561 ) -> impl ::core::future::Future<Output = ()>;
18562
18563 #[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"]
18564 fn on_representation(
18565 &mut self,
18566
18567 request: ::fidl_next::Request<symlink::OnRepresentation, ___T>,
18568 ) -> impl ::core::future::Future<Output = ()>;
18569
18570 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
18571 ::core::future::ready(())
18572 }
18573}
18574
18575impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Symlink
18576where
18577 ___H: SymlinkLocalClientHandler<___T>,
18578 ___T: ::fidl_next::Transport,
18579 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
18580 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18581 Constraint = (),
18582 >,
18583 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
18584 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18585 Constraint = (),
18586 >,
18587{
18588 async fn on_event(
18589 handler: &mut ___H,
18590 ordinal: u64,
18591 flexibility: ::fidl_next::protocol::Flexibility,
18592 body: ::fidl_next::Body<___T>,
18593 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18594 match ordinal {
18595 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
18596 Ok(decoded) => {
18597 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
18598 Ok(())
18599 }
18600 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18601 ordinal: 9207534335756671346,
18602 error,
18603 }),
18604 },
18605
18606 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
18607 Ok(decoded) => {
18608 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
18609 Ok(())
18610 }
18611 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18612 ordinal: 6679970090861613324,
18613 error,
18614 }),
18615 },
18616
18617 ordinal => {
18618 handler.on_unknown_interaction(ordinal).await;
18619 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18620 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18621 } else {
18622 Ok(())
18623 }
18624 }
18625 }
18626 }
18627}
18628
18629#[diagnostic::on_unimplemented(
18630 note = "If {Self} implements the non-local SymlinkServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
18631)]
18632
18633pub trait SymlinkLocalServerHandler<
18637 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
18638 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18639>
18640{
18641 #[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"]
18642 fn link_into(
18643 &mut self,
18644
18645 request: ::fidl_next::Request<symlink::LinkInto, ___T>,
18646
18647 responder: ::fidl_next::Responder<symlink::LinkInto, ___T>,
18648 ) -> impl ::core::future::Future<Output = ()>;
18649
18650 fn clone(
18651 &mut self,
18652
18653 request: ::fidl_next::Request<symlink::Clone, ___T>,
18654 ) -> impl ::core::future::Future<Output = ()>;
18655
18656 #[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"]
18657 fn close(
18658 &mut self,
18659
18660 responder: ::fidl_next::Responder<symlink::Close, ___T>,
18661 ) -> impl ::core::future::Future<Output = ()>;
18662
18663 fn query(
18664 &mut self,
18665
18666 responder: ::fidl_next::Responder<symlink::Query, ___T>,
18667 ) -> impl ::core::future::Future<Output = ()>;
18668
18669 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
18670 fn deprecated_clone(
18671 &mut self,
18672
18673 request: ::fidl_next::Request<symlink::DeprecatedClone, ___T>,
18674 ) -> impl ::core::future::Future<Output = ()>;
18675
18676 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
18677 fn deprecated_get_attr(
18678 &mut self,
18679
18680 responder: ::fidl_next::Responder<symlink::DeprecatedGetAttr, ___T>,
18681 ) -> impl ::core::future::Future<Output = ()>;
18682
18683 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
18684 fn deprecated_set_attr(
18685 &mut self,
18686
18687 request: ::fidl_next::Request<symlink::DeprecatedSetAttr, ___T>,
18688
18689 responder: ::fidl_next::Responder<symlink::DeprecatedSetAttr, ___T>,
18690 ) -> impl ::core::future::Future<Output = ()>;
18691
18692 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
18693 fn deprecated_get_flags(
18694 &mut self,
18695
18696 responder: ::fidl_next::Responder<symlink::DeprecatedGetFlags, ___T>,
18697 ) -> impl ::core::future::Future<Output = ()>;
18698
18699 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
18700 fn deprecated_set_flags(
18701 &mut self,
18702
18703 request: ::fidl_next::Request<symlink::DeprecatedSetFlags, ___T>,
18704
18705 responder: ::fidl_next::Responder<symlink::DeprecatedSetFlags, ___T>,
18706 ) -> impl ::core::future::Future<Output = ()>;
18707
18708 #[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"]
18709 fn get_flags(
18710 &mut self,
18711
18712 responder: ::fidl_next::Responder<symlink::GetFlags, ___T>,
18713 ) -> impl ::core::future::Future<Output = ()>;
18714
18715 #[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"]
18716 fn set_flags(
18717 &mut self,
18718
18719 request: ::fidl_next::Request<symlink::SetFlags, ___T>,
18720
18721 responder: ::fidl_next::Responder<symlink::SetFlags, ___T>,
18722 ) -> impl ::core::future::Future<Output = ()>;
18723
18724 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
18725 fn query_filesystem(
18726 &mut self,
18727
18728 responder: ::fidl_next::Responder<symlink::QueryFilesystem, ___T>,
18729 ) -> impl ::core::future::Future<Output = ()>;
18730
18731 #[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"]
18732 fn get_attributes(
18733 &mut self,
18734
18735 request: ::fidl_next::Request<symlink::GetAttributes, ___T>,
18736
18737 responder: ::fidl_next::Responder<symlink::GetAttributes, ___T>,
18738 ) -> impl ::core::future::Future<Output = ()>;
18739
18740 #[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"]
18741 fn update_attributes(
18742 &mut self,
18743
18744 request: ::fidl_next::Request<symlink::UpdateAttributes, ___T>,
18745
18746 responder: ::fidl_next::Responder<symlink::UpdateAttributes, ___T>,
18747 ) -> impl ::core::future::Future<Output = ()>;
18748
18749 #[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"]
18750 fn sync(
18751 &mut self,
18752
18753 responder: ::fidl_next::Responder<symlink::Sync, ___T>,
18754 ) -> impl ::core::future::Future<Output = ()>;
18755
18756 #[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"]
18757 fn list_extended_attributes(
18758 &mut self,
18759
18760 request: ::fidl_next::Request<symlink::ListExtendedAttributes, ___T>,
18761 ) -> impl ::core::future::Future<Output = ()>;
18762
18763 #[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"]
18764 fn get_extended_attribute(
18765 &mut self,
18766
18767 request: ::fidl_next::Request<symlink::GetExtendedAttribute, ___T>,
18768
18769 responder: ::fidl_next::Responder<symlink::GetExtendedAttribute, ___T>,
18770 ) -> impl ::core::future::Future<Output = ()>;
18771
18772 #[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"]
18773 fn set_extended_attribute(
18774 &mut self,
18775
18776 request: ::fidl_next::Request<symlink::SetExtendedAttribute, ___T>,
18777
18778 responder: ::fidl_next::Responder<symlink::SetExtendedAttribute, ___T>,
18779 ) -> impl ::core::future::Future<Output = ()>;
18780
18781 #[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"]
18782 fn remove_extended_attribute(
18783 &mut self,
18784
18785 request: ::fidl_next::Request<symlink::RemoveExtendedAttribute, ___T>,
18786
18787 responder: ::fidl_next::Responder<symlink::RemoveExtendedAttribute, ___T>,
18788 ) -> impl ::core::future::Future<Output = ()>;
18789
18790 #[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"]
18791 fn open(
18792 &mut self,
18793
18794 request: ::fidl_next::Request<symlink::Open, ___T>,
18795 ) -> impl ::core::future::Future<Output = ()>;
18796
18797 fn describe(
18798 &mut self,
18799
18800 responder: ::fidl_next::Responder<symlink::Describe, ___T>,
18801 ) -> impl ::core::future::Future<Output = ()>;
18802
18803 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
18804 ::core::future::ready(())
18805 }
18806}
18807
18808impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Symlink
18809where
18810 ___H: SymlinkLocalServerHandler<___T>,
18811 ___T: ::fidl_next::Transport,
18812 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
18813 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18814 Constraint = (),
18815 >,
18816 for<'de> ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
18817 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18818 Constraint = (),
18819 >,
18820 for<'de> crate::wire::NodeDeprecatedCloneRequest: ::fidl_next::Decode<
18821 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18822 Constraint = (),
18823 >,
18824 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
18825 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18826 Constraint = (),
18827 >,
18828 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
18829 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18830 Constraint = (),
18831 >,
18832 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
18833 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18834 Constraint = (),
18835 >,
18836 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
18837 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18838 Constraint = (),
18839 >,
18840 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
18841 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18842 Constraint = (),
18843 >,
18844 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
18845 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18846 Constraint = (),
18847 >,
18848 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
18849 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18850 Constraint = (),
18851 >,
18852 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
18853 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18854 Constraint = (),
18855 >,
18856 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
18857 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18858 Constraint = (),
18859 >,
18860 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
18861 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18862 Constraint = (),
18863 >,
18864{
18865 async fn on_one_way(
18866 handler: &mut ___H,
18867 ordinal: u64,
18868 flexibility: ::fidl_next::protocol::Flexibility,
18869 body: ::fidl_next::Body<___T>,
18870 ) -> ::core::result::Result<
18871 (),
18872 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18873 > {
18874 match ordinal {
18875 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
18876 Ok(decoded) => {
18877 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
18878 Ok(())
18879 }
18880 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18881 ordinal: 2366825959783828089,
18882 error,
18883 }),
18884 },
18885
18886 6512600400724287855 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
18887 Ok(decoded) => {
18888 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
18889 Ok(())
18890 }
18891 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18892 ordinal: 6512600400724287855,
18893 error,
18894 }),
18895 },
18896
18897 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
18898 Ok(decoded) => {
18899 handler
18900 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
18901 .await;
18902 Ok(())
18903 }
18904 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18905 ordinal: 5431626189872037072,
18906 error,
18907 }),
18908 },
18909
18910 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
18911 Ok(decoded) => {
18912 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
18913 Ok(())
18914 }
18915 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18916 ordinal: 6236883748953765593,
18917 error,
18918 }),
18919 },
18920
18921 ordinal => {
18922 handler.on_unknown_interaction(ordinal).await;
18923 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18924 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18925 } else {
18926 Ok(())
18927 }
18928 }
18929 }
18930 }
18931
18932 async fn on_two_way(
18933 handler: &mut ___H,
18934 ordinal: u64,
18935 flexibility: ::fidl_next::protocol::Flexibility,
18936 body: ::fidl_next::Body<___T>,
18937 responder: ::fidl_next::protocol::Responder<___T>,
18938 ) -> ::core::result::Result<
18939 (),
18940 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18941 > {
18942 match ordinal {
18943 6121399674497678964 => {
18944 let responder = ::fidl_next::Responder::from_untyped(responder);
18945
18946 match ::fidl_next::AsDecoderExt::into_decoded(body) {
18947 Ok(decoded) => {
18948 handler
18949 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
18950 .await;
18951 Ok(())
18952 }
18953 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18954 ordinal: 6121399674497678964,
18955 error,
18956 }),
18957 }
18958 }
18959
18960 6540867515453498750 => {
18961 let responder = ::fidl_next::Responder::from_untyped(responder);
18962
18963 handler.close(responder).await;
18964 Ok(())
18965 }
18966
18967 2763219980499352582 => {
18968 let responder = ::fidl_next::Responder::from_untyped(responder);
18969
18970 handler.query(responder).await;
18971 Ok(())
18972 }
18973
18974 8689798978500614909 => {
18975 let responder = ::fidl_next::Responder::from_untyped(responder);
18976
18977 handler.deprecated_get_attr(responder).await;
18978 Ok(())
18979 }
18980
18981 4721673413776871238 => {
18982 let responder = ::fidl_next::Responder::from_untyped(responder);
18983
18984 match ::fidl_next::AsDecoderExt::into_decoded(body) {
18985 Ok(decoded) => {
18986 handler
18987 .deprecated_set_attr(
18988 ::fidl_next::Request::from_decoded(decoded),
18989 responder,
18990 )
18991 .await;
18992 Ok(())
18993 }
18994 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18995 ordinal: 4721673413776871238,
18996 error,
18997 }),
18998 }
18999 }
19000
19001 6595803110182632097 => {
19002 let responder = ::fidl_next::Responder::from_untyped(responder);
19003
19004 handler.deprecated_get_flags(responder).await;
19005 Ok(())
19006 }
19007
19008 5950864159036794675 => {
19009 let responder = ::fidl_next::Responder::from_untyped(responder);
19010
19011 match ::fidl_next::AsDecoderExt::into_decoded(body) {
19012 Ok(decoded) => {
19013 handler
19014 .deprecated_set_flags(
19015 ::fidl_next::Request::from_decoded(decoded),
19016 responder,
19017 )
19018 .await;
19019 Ok(())
19020 }
19021 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19022 ordinal: 5950864159036794675,
19023 error,
19024 }),
19025 }
19026 }
19027
19028 105530239381466147 => {
19029 let responder = ::fidl_next::Responder::from_untyped(responder);
19030
19031 handler.get_flags(responder).await;
19032 Ok(())
19033 }
19034
19035 6172186066099445416 => {
19036 let responder = ::fidl_next::Responder::from_untyped(responder);
19037
19038 match ::fidl_next::AsDecoderExt::into_decoded(body) {
19039 Ok(decoded) => {
19040 handler
19041 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
19042 .await;
19043 Ok(())
19044 }
19045 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19046 ordinal: 6172186066099445416,
19047 error,
19048 }),
19049 }
19050 }
19051
19052 8013111122914313744 => {
19053 let responder = ::fidl_next::Responder::from_untyped(responder);
19054
19055 handler.query_filesystem(responder).await;
19056 Ok(())
19057 }
19058
19059 4414537700416816443 => {
19060 let responder = ::fidl_next::Responder::from_untyped(responder);
19061
19062 match ::fidl_next::AsDecoderExt::into_decoded(body) {
19063 Ok(decoded) => {
19064 handler
19065 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
19066 .await;
19067 Ok(())
19068 }
19069 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19070 ordinal: 4414537700416816443,
19071 error,
19072 }),
19073 }
19074 }
19075
19076 3677402239314018056 => {
19077 let responder = ::fidl_next::Responder::from_untyped(responder);
19078
19079 match ::fidl_next::AsDecoderExt::into_decoded(body) {
19080 Ok(decoded) => {
19081 handler
19082 .update_attributes(
19083 ::fidl_next::Request::from_decoded(decoded),
19084 responder,
19085 )
19086 .await;
19087 Ok(())
19088 }
19089 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19090 ordinal: 3677402239314018056,
19091 error,
19092 }),
19093 }
19094 }
19095
19096 3196473584242777161 => {
19097 let responder = ::fidl_next::Responder::from_untyped(responder);
19098
19099 handler.sync(responder).await;
19100 Ok(())
19101 }
19102
19103 5043930208506967771 => {
19104 let responder = ::fidl_next::Responder::from_untyped(responder);
19105
19106 match ::fidl_next::AsDecoderExt::into_decoded(body) {
19107 Ok(decoded) => {
19108 handler
19109 .get_extended_attribute(
19110 ::fidl_next::Request::from_decoded(decoded),
19111 responder,
19112 )
19113 .await;
19114 Ok(())
19115 }
19116 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19117 ordinal: 5043930208506967771,
19118 error,
19119 }),
19120 }
19121 }
19122
19123 5374223046099989052 => {
19124 let responder = ::fidl_next::Responder::from_untyped(responder);
19125
19126 match ::fidl_next::AsDecoderExt::into_decoded(body) {
19127 Ok(decoded) => {
19128 handler
19129 .set_extended_attribute(
19130 ::fidl_next::Request::from_decoded(decoded),
19131 responder,
19132 )
19133 .await;
19134 Ok(())
19135 }
19136 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19137 ordinal: 5374223046099989052,
19138 error,
19139 }),
19140 }
19141 }
19142
19143 8794297771444732717 => {
19144 let responder = ::fidl_next::Responder::from_untyped(responder);
19145
19146 match ::fidl_next::AsDecoderExt::into_decoded(body) {
19147 Ok(decoded) => {
19148 handler
19149 .remove_extended_attribute(
19150 ::fidl_next::Request::from_decoded(decoded),
19151 responder,
19152 )
19153 .await;
19154 Ok(())
19155 }
19156 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19157 ordinal: 8794297771444732717,
19158 error,
19159 }),
19160 }
19161 }
19162
19163 8371117097481679347 => {
19164 let responder = ::fidl_next::Responder::from_untyped(responder);
19165
19166 handler.describe(responder).await;
19167 Ok(())
19168 }
19169
19170 ordinal => {
19171 handler.on_unknown_interaction(ordinal).await;
19172 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19173 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19174 } else {
19175 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
19176 ordinal,
19177 flexibility,
19178 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
19179 )
19180 .expect("encoding a framework error should never fail")
19181 .await?;
19182 Ok(())
19183 }
19184 }
19185 }
19186 }
19187}
19188
19189pub trait SymlinkClientHandler<
19193 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
19194 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19195>
19196{
19197 #[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"]
19198 fn on_open(
19199 &mut self,
19200
19201 request: ::fidl_next::Request<symlink::OnOpen, ___T>,
19202 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19203
19204 #[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"]
19205 fn on_representation(
19206 &mut self,
19207
19208 request: ::fidl_next::Request<symlink::OnRepresentation, ___T>,
19209 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19210
19211 fn on_unknown_interaction(
19212 &mut self,
19213 ordinal: u64,
19214 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19215 ::core::future::ready(())
19216 }
19217}
19218
19219impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Symlink
19220where
19221 ___H: SymlinkClientHandler<___T> + ::core::marker::Send,
19222 ___T: ::fidl_next::Transport,
19223 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
19224 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19225 Constraint = (),
19226 >,
19227 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
19228 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19229 Constraint = (),
19230 >,
19231{
19232 async fn on_event(
19233 handler: &mut ___H,
19234 ordinal: u64,
19235 flexibility: ::fidl_next::protocol::Flexibility,
19236 body: ::fidl_next::Body<___T>,
19237 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
19238 match ordinal {
19239 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
19240 Ok(decoded) => {
19241 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
19242 Ok(())
19243 }
19244 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19245 ordinal: 9207534335756671346,
19246 error,
19247 }),
19248 },
19249
19250 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
19251 Ok(decoded) => {
19252 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
19253 Ok(())
19254 }
19255 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19256 ordinal: 6679970090861613324,
19257 error,
19258 }),
19259 },
19260
19261 ordinal => {
19262 handler.on_unknown_interaction(ordinal).await;
19263 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19264 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19265 } else {
19266 Ok(())
19267 }
19268 }
19269 }
19270 }
19271}
19272
19273pub trait SymlinkServerHandler<
19277 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
19278 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19279>
19280{
19281 #[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"]
19282 fn link_into(
19283 &mut self,
19284
19285 request: ::fidl_next::Request<symlink::LinkInto, ___T>,
19286
19287 responder: ::fidl_next::Responder<symlink::LinkInto, ___T>,
19288 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19289
19290 fn clone(
19291 &mut self,
19292
19293 request: ::fidl_next::Request<symlink::Clone, ___T>,
19294 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19295
19296 #[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"]
19297 fn close(
19298 &mut self,
19299
19300 responder: ::fidl_next::Responder<symlink::Close, ___T>,
19301 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19302
19303 fn query(
19304 &mut self,
19305
19306 responder: ::fidl_next::Responder<symlink::Query, ___T>,
19307 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19308
19309 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
19310 fn deprecated_clone(
19311 &mut self,
19312
19313 request: ::fidl_next::Request<symlink::DeprecatedClone, ___T>,
19314 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19315
19316 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
19317 fn deprecated_get_attr(
19318 &mut self,
19319
19320 responder: ::fidl_next::Responder<symlink::DeprecatedGetAttr, ___T>,
19321 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19322
19323 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
19324 fn deprecated_set_attr(
19325 &mut self,
19326
19327 request: ::fidl_next::Request<symlink::DeprecatedSetAttr, ___T>,
19328
19329 responder: ::fidl_next::Responder<symlink::DeprecatedSetAttr, ___T>,
19330 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19331
19332 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
19333 fn deprecated_get_flags(
19334 &mut self,
19335
19336 responder: ::fidl_next::Responder<symlink::DeprecatedGetFlags, ___T>,
19337 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19338
19339 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
19340 fn deprecated_set_flags(
19341 &mut self,
19342
19343 request: ::fidl_next::Request<symlink::DeprecatedSetFlags, ___T>,
19344
19345 responder: ::fidl_next::Responder<symlink::DeprecatedSetFlags, ___T>,
19346 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19347
19348 #[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"]
19349 fn get_flags(
19350 &mut self,
19351
19352 responder: ::fidl_next::Responder<symlink::GetFlags, ___T>,
19353 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19354
19355 #[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"]
19356 fn set_flags(
19357 &mut self,
19358
19359 request: ::fidl_next::Request<symlink::SetFlags, ___T>,
19360
19361 responder: ::fidl_next::Responder<symlink::SetFlags, ___T>,
19362 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19363
19364 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
19365 fn query_filesystem(
19366 &mut self,
19367
19368 responder: ::fidl_next::Responder<symlink::QueryFilesystem, ___T>,
19369 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19370
19371 #[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"]
19372 fn get_attributes(
19373 &mut self,
19374
19375 request: ::fidl_next::Request<symlink::GetAttributes, ___T>,
19376
19377 responder: ::fidl_next::Responder<symlink::GetAttributes, ___T>,
19378 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19379
19380 #[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"]
19381 fn update_attributes(
19382 &mut self,
19383
19384 request: ::fidl_next::Request<symlink::UpdateAttributes, ___T>,
19385
19386 responder: ::fidl_next::Responder<symlink::UpdateAttributes, ___T>,
19387 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19388
19389 #[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"]
19390 fn sync(
19391 &mut self,
19392
19393 responder: ::fidl_next::Responder<symlink::Sync, ___T>,
19394 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19395
19396 #[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"]
19397 fn list_extended_attributes(
19398 &mut self,
19399
19400 request: ::fidl_next::Request<symlink::ListExtendedAttributes, ___T>,
19401 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19402
19403 #[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"]
19404 fn get_extended_attribute(
19405 &mut self,
19406
19407 request: ::fidl_next::Request<symlink::GetExtendedAttribute, ___T>,
19408
19409 responder: ::fidl_next::Responder<symlink::GetExtendedAttribute, ___T>,
19410 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19411
19412 #[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"]
19413 fn set_extended_attribute(
19414 &mut self,
19415
19416 request: ::fidl_next::Request<symlink::SetExtendedAttribute, ___T>,
19417
19418 responder: ::fidl_next::Responder<symlink::SetExtendedAttribute, ___T>,
19419 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19420
19421 #[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"]
19422 fn remove_extended_attribute(
19423 &mut self,
19424
19425 request: ::fidl_next::Request<symlink::RemoveExtendedAttribute, ___T>,
19426
19427 responder: ::fidl_next::Responder<symlink::RemoveExtendedAttribute, ___T>,
19428 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19429
19430 #[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"]
19431 fn open(
19432 &mut self,
19433
19434 request: ::fidl_next::Request<symlink::Open, ___T>,
19435 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19436
19437 fn describe(
19438 &mut self,
19439
19440 responder: ::fidl_next::Responder<symlink::Describe, ___T>,
19441 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19442
19443 fn on_unknown_interaction(
19444 &mut self,
19445 ordinal: u64,
19446 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19447 ::core::future::ready(())
19448 }
19449}
19450
19451impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Symlink
19452where
19453 ___H: SymlinkServerHandler<___T> + ::core::marker::Send,
19454 ___T: ::fidl_next::Transport,
19455 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
19456 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19457 Constraint = (),
19458 >,
19459 for<'de> ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
19460 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19461 Constraint = (),
19462 >,
19463 for<'de> crate::wire::NodeDeprecatedCloneRequest: ::fidl_next::Decode<
19464 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19465 Constraint = (),
19466 >,
19467 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
19468 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19469 Constraint = (),
19470 >,
19471 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
19472 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19473 Constraint = (),
19474 >,
19475 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
19476 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19477 Constraint = (),
19478 >,
19479 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
19480 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19481 Constraint = (),
19482 >,
19483 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
19484 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19485 Constraint = (),
19486 >,
19487 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
19488 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19489 Constraint = (),
19490 >,
19491 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
19492 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19493 Constraint = (),
19494 >,
19495 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
19496 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19497 Constraint = (),
19498 >,
19499 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
19500 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19501 Constraint = (),
19502 >,
19503 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
19504 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19505 Constraint = (),
19506 >,
19507{
19508 async fn on_one_way(
19509 handler: &mut ___H,
19510 ordinal: u64,
19511 flexibility: ::fidl_next::protocol::Flexibility,
19512 body: ::fidl_next::Body<___T>,
19513 ) -> ::core::result::Result<
19514 (),
19515 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19516 > {
19517 match ordinal {
19518 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
19519 Ok(decoded) => {
19520 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
19521 Ok(())
19522 }
19523 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19524 ordinal: 2366825959783828089,
19525 error,
19526 }),
19527 },
19528
19529 6512600400724287855 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
19530 Ok(decoded) => {
19531 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
19532 Ok(())
19533 }
19534 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19535 ordinal: 6512600400724287855,
19536 error,
19537 }),
19538 },
19539
19540 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
19541 Ok(decoded) => {
19542 handler
19543 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
19544 .await;
19545 Ok(())
19546 }
19547 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19548 ordinal: 5431626189872037072,
19549 error,
19550 }),
19551 },
19552
19553 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
19554 Ok(decoded) => {
19555 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
19556 Ok(())
19557 }
19558 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19559 ordinal: 6236883748953765593,
19560 error,
19561 }),
19562 },
19563
19564 ordinal => {
19565 handler.on_unknown_interaction(ordinal).await;
19566 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19567 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19568 } else {
19569 Ok(())
19570 }
19571 }
19572 }
19573 }
19574
19575 async fn on_two_way(
19576 handler: &mut ___H,
19577 ordinal: u64,
19578 flexibility: ::fidl_next::protocol::Flexibility,
19579 body: ::fidl_next::Body<___T>,
19580 responder: ::fidl_next::protocol::Responder<___T>,
19581 ) -> ::core::result::Result<
19582 (),
19583 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19584 > {
19585 match ordinal {
19586 6121399674497678964 => {
19587 let responder = ::fidl_next::Responder::from_untyped(responder);
19588
19589 match ::fidl_next::AsDecoderExt::into_decoded(body) {
19590 Ok(decoded) => {
19591 handler
19592 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
19593 .await;
19594 Ok(())
19595 }
19596 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19597 ordinal: 6121399674497678964,
19598 error,
19599 }),
19600 }
19601 }
19602
19603 6540867515453498750 => {
19604 let responder = ::fidl_next::Responder::from_untyped(responder);
19605
19606 handler.close(responder).await;
19607 Ok(())
19608 }
19609
19610 2763219980499352582 => {
19611 let responder = ::fidl_next::Responder::from_untyped(responder);
19612
19613 handler.query(responder).await;
19614 Ok(())
19615 }
19616
19617 8689798978500614909 => {
19618 let responder = ::fidl_next::Responder::from_untyped(responder);
19619
19620 handler.deprecated_get_attr(responder).await;
19621 Ok(())
19622 }
19623
19624 4721673413776871238 => {
19625 let responder = ::fidl_next::Responder::from_untyped(responder);
19626
19627 match ::fidl_next::AsDecoderExt::into_decoded(body) {
19628 Ok(decoded) => {
19629 handler
19630 .deprecated_set_attr(
19631 ::fidl_next::Request::from_decoded(decoded),
19632 responder,
19633 )
19634 .await;
19635 Ok(())
19636 }
19637 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19638 ordinal: 4721673413776871238,
19639 error,
19640 }),
19641 }
19642 }
19643
19644 6595803110182632097 => {
19645 let responder = ::fidl_next::Responder::from_untyped(responder);
19646
19647 handler.deprecated_get_flags(responder).await;
19648 Ok(())
19649 }
19650
19651 5950864159036794675 => {
19652 let responder = ::fidl_next::Responder::from_untyped(responder);
19653
19654 match ::fidl_next::AsDecoderExt::into_decoded(body) {
19655 Ok(decoded) => {
19656 handler
19657 .deprecated_set_flags(
19658 ::fidl_next::Request::from_decoded(decoded),
19659 responder,
19660 )
19661 .await;
19662 Ok(())
19663 }
19664 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19665 ordinal: 5950864159036794675,
19666 error,
19667 }),
19668 }
19669 }
19670
19671 105530239381466147 => {
19672 let responder = ::fidl_next::Responder::from_untyped(responder);
19673
19674 handler.get_flags(responder).await;
19675 Ok(())
19676 }
19677
19678 6172186066099445416 => {
19679 let responder = ::fidl_next::Responder::from_untyped(responder);
19680
19681 match ::fidl_next::AsDecoderExt::into_decoded(body) {
19682 Ok(decoded) => {
19683 handler
19684 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
19685 .await;
19686 Ok(())
19687 }
19688 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19689 ordinal: 6172186066099445416,
19690 error,
19691 }),
19692 }
19693 }
19694
19695 8013111122914313744 => {
19696 let responder = ::fidl_next::Responder::from_untyped(responder);
19697
19698 handler.query_filesystem(responder).await;
19699 Ok(())
19700 }
19701
19702 4414537700416816443 => {
19703 let responder = ::fidl_next::Responder::from_untyped(responder);
19704
19705 match ::fidl_next::AsDecoderExt::into_decoded(body) {
19706 Ok(decoded) => {
19707 handler
19708 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
19709 .await;
19710 Ok(())
19711 }
19712 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19713 ordinal: 4414537700416816443,
19714 error,
19715 }),
19716 }
19717 }
19718
19719 3677402239314018056 => {
19720 let responder = ::fidl_next::Responder::from_untyped(responder);
19721
19722 match ::fidl_next::AsDecoderExt::into_decoded(body) {
19723 Ok(decoded) => {
19724 handler
19725 .update_attributes(
19726 ::fidl_next::Request::from_decoded(decoded),
19727 responder,
19728 )
19729 .await;
19730 Ok(())
19731 }
19732 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19733 ordinal: 3677402239314018056,
19734 error,
19735 }),
19736 }
19737 }
19738
19739 3196473584242777161 => {
19740 let responder = ::fidl_next::Responder::from_untyped(responder);
19741
19742 handler.sync(responder).await;
19743 Ok(())
19744 }
19745
19746 5043930208506967771 => {
19747 let responder = ::fidl_next::Responder::from_untyped(responder);
19748
19749 match ::fidl_next::AsDecoderExt::into_decoded(body) {
19750 Ok(decoded) => {
19751 handler
19752 .get_extended_attribute(
19753 ::fidl_next::Request::from_decoded(decoded),
19754 responder,
19755 )
19756 .await;
19757 Ok(())
19758 }
19759 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19760 ordinal: 5043930208506967771,
19761 error,
19762 }),
19763 }
19764 }
19765
19766 5374223046099989052 => {
19767 let responder = ::fidl_next::Responder::from_untyped(responder);
19768
19769 match ::fidl_next::AsDecoderExt::into_decoded(body) {
19770 Ok(decoded) => {
19771 handler
19772 .set_extended_attribute(
19773 ::fidl_next::Request::from_decoded(decoded),
19774 responder,
19775 )
19776 .await;
19777 Ok(())
19778 }
19779 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19780 ordinal: 5374223046099989052,
19781 error,
19782 }),
19783 }
19784 }
19785
19786 8794297771444732717 => {
19787 let responder = ::fidl_next::Responder::from_untyped(responder);
19788
19789 match ::fidl_next::AsDecoderExt::into_decoded(body) {
19790 Ok(decoded) => {
19791 handler
19792 .remove_extended_attribute(
19793 ::fidl_next::Request::from_decoded(decoded),
19794 responder,
19795 )
19796 .await;
19797 Ok(())
19798 }
19799 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19800 ordinal: 8794297771444732717,
19801 error,
19802 }),
19803 }
19804 }
19805
19806 8371117097481679347 => {
19807 let responder = ::fidl_next::Responder::from_untyped(responder);
19808
19809 handler.describe(responder).await;
19810 Ok(())
19811 }
19812
19813 ordinal => {
19814 handler.on_unknown_interaction(ordinal).await;
19815 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19816 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19817 } else {
19818 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
19819 ordinal,
19820 flexibility,
19821 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
19822 )
19823 .expect("encoding a framework error should never fail")
19824 .await?;
19825 Ok(())
19826 }
19827 }
19828 }
19829 }
19830}
19831
19832impl<___T> SymlinkClientHandler<___T> for ::fidl_next::IgnoreEvents
19833where
19834 ___T: ::fidl_next::Transport,
19835{
19836 async fn on_open(&mut self, _: ::fidl_next::Request<symlink::OnOpen, ___T>) {}
19837
19838 async fn on_representation(
19839 &mut self,
19840
19841 _: ::fidl_next::Request<symlink::OnRepresentation, ___T>,
19842 ) {
19843 }
19844
19845 async fn on_unknown_interaction(&mut self, _: u64) {}
19846}
19847
19848impl<___H, ___T> SymlinkLocalClientHandler<___T> for ::fidl_next::Local<___H>
19849where
19850 ___H: SymlinkClientHandler<___T>,
19851 ___T: ::fidl_next::Transport,
19852{
19853 async fn on_open(&mut self, request: ::fidl_next::Request<symlink::OnOpen, ___T>) {
19854 ___H::on_open(&mut self.0, request).await
19855 }
19856
19857 async fn on_representation(
19858 &mut self,
19859
19860 request: ::fidl_next::Request<symlink::OnRepresentation, ___T>,
19861 ) {
19862 ___H::on_representation(&mut self.0, request).await
19863 }
19864
19865 async fn on_unknown_interaction(&mut self, ordinal: u64) {
19866 ___H::on_unknown_interaction(&mut self.0, ordinal).await
19867 }
19868}
19869
19870impl<___H, ___T> SymlinkLocalServerHandler<___T> for ::fidl_next::Local<___H>
19871where
19872 ___H: SymlinkServerHandler<___T>,
19873 ___T: ::fidl_next::Transport,
19874{
19875 async fn link_into(
19876 &mut self,
19877
19878 request: ::fidl_next::Request<symlink::LinkInto, ___T>,
19879
19880 responder: ::fidl_next::Responder<symlink::LinkInto, ___T>,
19881 ) {
19882 ___H::link_into(&mut self.0, request, responder).await
19883 }
19884
19885 async fn clone(&mut self, request: ::fidl_next::Request<symlink::Clone, ___T>) {
19886 ___H::clone(&mut self.0, request).await
19887 }
19888
19889 async fn close(&mut self, responder: ::fidl_next::Responder<symlink::Close, ___T>) {
19890 ___H::close(&mut self.0, responder).await
19891 }
19892
19893 async fn query(&mut self, responder: ::fidl_next::Responder<symlink::Query, ___T>) {
19894 ___H::query(&mut self.0, responder).await
19895 }
19896
19897 async fn deprecated_clone(
19898 &mut self,
19899
19900 request: ::fidl_next::Request<symlink::DeprecatedClone, ___T>,
19901 ) {
19902 ___H::deprecated_clone(&mut self.0, request).await
19903 }
19904
19905 async fn deprecated_get_attr(
19906 &mut self,
19907
19908 responder: ::fidl_next::Responder<symlink::DeprecatedGetAttr, ___T>,
19909 ) {
19910 ___H::deprecated_get_attr(&mut self.0, responder).await
19911 }
19912
19913 async fn deprecated_set_attr(
19914 &mut self,
19915
19916 request: ::fidl_next::Request<symlink::DeprecatedSetAttr, ___T>,
19917
19918 responder: ::fidl_next::Responder<symlink::DeprecatedSetAttr, ___T>,
19919 ) {
19920 ___H::deprecated_set_attr(&mut self.0, request, responder).await
19921 }
19922
19923 async fn deprecated_get_flags(
19924 &mut self,
19925
19926 responder: ::fidl_next::Responder<symlink::DeprecatedGetFlags, ___T>,
19927 ) {
19928 ___H::deprecated_get_flags(&mut self.0, responder).await
19929 }
19930
19931 async fn deprecated_set_flags(
19932 &mut self,
19933
19934 request: ::fidl_next::Request<symlink::DeprecatedSetFlags, ___T>,
19935
19936 responder: ::fidl_next::Responder<symlink::DeprecatedSetFlags, ___T>,
19937 ) {
19938 ___H::deprecated_set_flags(&mut self.0, request, responder).await
19939 }
19940
19941 async fn get_flags(&mut self, responder: ::fidl_next::Responder<symlink::GetFlags, ___T>) {
19942 ___H::get_flags(&mut self.0, responder).await
19943 }
19944
19945 async fn set_flags(
19946 &mut self,
19947
19948 request: ::fidl_next::Request<symlink::SetFlags, ___T>,
19949
19950 responder: ::fidl_next::Responder<symlink::SetFlags, ___T>,
19951 ) {
19952 ___H::set_flags(&mut self.0, request, responder).await
19953 }
19954
19955 async fn query_filesystem(
19956 &mut self,
19957
19958 responder: ::fidl_next::Responder<symlink::QueryFilesystem, ___T>,
19959 ) {
19960 ___H::query_filesystem(&mut self.0, responder).await
19961 }
19962
19963 async fn get_attributes(
19964 &mut self,
19965
19966 request: ::fidl_next::Request<symlink::GetAttributes, ___T>,
19967
19968 responder: ::fidl_next::Responder<symlink::GetAttributes, ___T>,
19969 ) {
19970 ___H::get_attributes(&mut self.0, request, responder).await
19971 }
19972
19973 async fn update_attributes(
19974 &mut self,
19975
19976 request: ::fidl_next::Request<symlink::UpdateAttributes, ___T>,
19977
19978 responder: ::fidl_next::Responder<symlink::UpdateAttributes, ___T>,
19979 ) {
19980 ___H::update_attributes(&mut self.0, request, responder).await
19981 }
19982
19983 async fn sync(&mut self, responder: ::fidl_next::Responder<symlink::Sync, ___T>) {
19984 ___H::sync(&mut self.0, responder).await
19985 }
19986
19987 async fn list_extended_attributes(
19988 &mut self,
19989
19990 request: ::fidl_next::Request<symlink::ListExtendedAttributes, ___T>,
19991 ) {
19992 ___H::list_extended_attributes(&mut self.0, request).await
19993 }
19994
19995 async fn get_extended_attribute(
19996 &mut self,
19997
19998 request: ::fidl_next::Request<symlink::GetExtendedAttribute, ___T>,
19999
20000 responder: ::fidl_next::Responder<symlink::GetExtendedAttribute, ___T>,
20001 ) {
20002 ___H::get_extended_attribute(&mut self.0, request, responder).await
20003 }
20004
20005 async fn set_extended_attribute(
20006 &mut self,
20007
20008 request: ::fidl_next::Request<symlink::SetExtendedAttribute, ___T>,
20009
20010 responder: ::fidl_next::Responder<symlink::SetExtendedAttribute, ___T>,
20011 ) {
20012 ___H::set_extended_attribute(&mut self.0, request, responder).await
20013 }
20014
20015 async fn remove_extended_attribute(
20016 &mut self,
20017
20018 request: ::fidl_next::Request<symlink::RemoveExtendedAttribute, ___T>,
20019
20020 responder: ::fidl_next::Responder<symlink::RemoveExtendedAttribute, ___T>,
20021 ) {
20022 ___H::remove_extended_attribute(&mut self.0, request, responder).await
20023 }
20024
20025 async fn open(&mut self, request: ::fidl_next::Request<symlink::Open, ___T>) {
20026 ___H::open(&mut self.0, request).await
20027 }
20028
20029 async fn describe(&mut self, responder: ::fidl_next::Responder<symlink::Describe, ___T>) {
20030 ___H::describe(&mut self.0, responder).await
20031 }
20032
20033 async fn on_unknown_interaction(&mut self, ordinal: u64) {
20034 ___H::on_unknown_interaction(&mut self.0, ordinal).await
20035 }
20036}
20037
20038pub use fidl_next_common_fuchsia_io::*;