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: ::fidl_next::fuchsia::HandleEncoder,
28 {
29 #[inline]
30 fn encode(
31 mut self,
32 encoder: &mut ___E,
33 out: &mut ::core::mem::MaybeUninit<crate::wire::ConnectionInfo<'static>>,
34 _: (),
35 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
36 ::fidl_next::munge!(let crate::wire::ConnectionInfo { table } = out);
37
38 let max_ord = self.__max_ordinal();
39
40 let mut out = ::core::mem::MaybeUninit::<::fidl_next::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: ::fidl_next::fuchsia::zx::Status,
96
97 pub token: ::core::option::Option<::fidl_next::fuchsia::zx::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: ::fidl_next::fuchsia::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 ::fidl_next::fuchsia::zx::Status as ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>
115 >::COPY_OPTIMIZATION.is_enabled()
116
117 && <
118 ::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalNullableHandle, ___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 ::fidl_next::fuchsia::zx::Status as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::Status>
191 >::COPY_OPTIMIZATION.is_enabled()
192
193 && <
194 ::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::OptionalNullableHandle>
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: ::fidl_next::fuchsia::zx::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: ::fidl_next::fuchsia::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 = ::fidl_next::fuchsia::zx::Event;
305
306 #[derive(Debug, PartialEq)]
307 pub struct DirectoryRenameRequest {
308 pub src: ::std::string::String,
309
310 pub dst_parent_token: ::fidl_next::fuchsia::zx::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: ::fidl_next::fuchsia::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:
410 ::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fidl_next::fuchsia::zx::Channel>,
411 }
412
413 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryWatchRequest, ___E>
414 for DirectoryWatchRequest
415 where
416 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
417 ___E: ::fidl_next::fuchsia::HandleEncoder,
418 {
419 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
420 Self,
421 crate::wire::DirectoryWatchRequest,
422 > = unsafe {
423 ::fidl_next::CopyOptimization::enable_if(
424 true
425
426 && <
427 crate::natural::WatchMask as ::fidl_next::Encode<crate::wire::WatchMask, ___E>
428 >::COPY_OPTIMIZATION.is_enabled()
429
430 && <
431 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
432 >::COPY_OPTIMIZATION.is_enabled()
433
434 && <
435 ::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fidl_next::fuchsia::zx::Channel> as ::fidl_next::Encode<::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fidl_next::wire::fuchsia::Channel>, ___E>
436 >::COPY_OPTIMIZATION.is_enabled()
437
438 )
439 };
440
441 #[inline]
442 fn encode(
443 self,
444 encoder_: &mut ___E,
445 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchRequest>,
446 _: (),
447 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
448 ::fidl_next::munge! {
449 let crate::wire::DirectoryWatchRequest {
450 mask,
451 options,
452 watcher,
453
454 } = out_;
455 }
456
457 ::fidl_next::Encode::encode(self.mask, encoder_, mask, ())?;
458
459 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mask.as_mut_ptr()) };
460
461 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
462
463 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
464
465 ::fidl_next::Encode::encode(self.watcher, encoder_, watcher, ())?;
466
467 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(watcher.as_mut_ptr()) };
468
469 Ok(())
470 }
471 }
472
473 unsafe impl<___E>
474 ::fidl_next::EncodeOption<
475 ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchRequest>,
476 ___E,
477 > for DirectoryWatchRequest
478 where
479 ___E: ::fidl_next::Encoder + ?Sized,
480 DirectoryWatchRequest: ::fidl_next::Encode<crate::wire::DirectoryWatchRequest, ___E>,
481 {
482 #[inline]
483 fn encode_option(
484 this: ::core::option::Option<Self>,
485 encoder: &mut ___E,
486 out: &mut ::core::mem::MaybeUninit<
487 ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchRequest>,
488 >,
489 _: (),
490 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
491 if let Some(inner) = this {
492 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
493 ::fidl_next::wire::Box::encode_present(out);
494 } else {
495 ::fidl_next::wire::Box::encode_absent(out);
496 }
497
498 Ok(())
499 }
500 }
501
502 impl ::fidl_next::FromWire<crate::wire::DirectoryWatchRequest> for DirectoryWatchRequest {
503 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
504 crate::wire::DirectoryWatchRequest,
505 Self,
506 > = unsafe {
507 ::fidl_next::CopyOptimization::enable_if(
508 true && <crate::natural::WatchMask as ::fidl_next::FromWire<
509 crate::wire::WatchMask,
510 >>::COPY_OPTIMIZATION
511 .is_enabled()
512 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
513 .is_enabled()
514 && <::fidl_next::ServerEnd<
515 crate::DirectoryWatcher,
516 ::fidl_next::fuchsia::zx::Channel,
517 > as ::fidl_next::FromWire<
518 ::fidl_next::ServerEnd<
519 crate::DirectoryWatcher,
520 ::fidl_next::wire::fuchsia::Channel,
521 >,
522 >>::COPY_OPTIMIZATION
523 .is_enabled(),
524 )
525 };
526
527 #[inline]
528 fn from_wire(wire: crate::wire::DirectoryWatchRequest) -> Self {
529 Self {
530 mask: ::fidl_next::FromWire::from_wire(wire.mask),
531
532 options: ::fidl_next::FromWire::from_wire(wire.options),
533
534 watcher: ::fidl_next::FromWire::from_wire(wire.watcher),
535 }
536 }
537 }
538
539 #[derive(Debug, PartialEq)]
540 #[repr(C)]
541 pub struct NodeListExtendedAttributesRequest {
542 pub iterator: ::fidl_next::ServerEnd<
543 crate::ExtendedAttributeIterator,
544 ::fidl_next::fuchsia::zx::Channel,
545 >,
546 }
547
548 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeListExtendedAttributesRequest, ___E>
549 for NodeListExtendedAttributesRequest
550 where
551 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
552 ___E: ::fidl_next::fuchsia::HandleEncoder,
553 {
554 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
555 Self,
556 crate::wire::NodeListExtendedAttributesRequest,
557 > = unsafe {
558 ::fidl_next::CopyOptimization::enable_if(
559 true && <::fidl_next::ServerEnd<
560 crate::ExtendedAttributeIterator,
561 ::fidl_next::fuchsia::zx::Channel,
562 > as ::fidl_next::Encode<
563 ::fidl_next::ServerEnd<
564 crate::ExtendedAttributeIterator,
565 ::fidl_next::wire::fuchsia::Channel,
566 >,
567 ___E,
568 >>::COPY_OPTIMIZATION
569 .is_enabled(),
570 )
571 };
572
573 #[inline]
574 fn encode(
575 self,
576 encoder_: &mut ___E,
577 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeListExtendedAttributesRequest>,
578 _: (),
579 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
580 ::fidl_next::munge! {
581 let crate::wire::NodeListExtendedAttributesRequest {
582 iterator,
583
584 } = out_;
585 }
586
587 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
588
589 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
590
591 Ok(())
592 }
593 }
594
595 unsafe impl<___E>
596 ::fidl_next::EncodeOption<
597 ::fidl_next::wire::Box<'static, crate::wire::NodeListExtendedAttributesRequest>,
598 ___E,
599 > for NodeListExtendedAttributesRequest
600 where
601 ___E: ::fidl_next::Encoder + ?Sized,
602 NodeListExtendedAttributesRequest:
603 ::fidl_next::Encode<crate::wire::NodeListExtendedAttributesRequest, ___E>,
604 {
605 #[inline]
606 fn encode_option(
607 this: ::core::option::Option<Self>,
608 encoder: &mut ___E,
609 out: &mut ::core::mem::MaybeUninit<
610 ::fidl_next::wire::Box<'static, crate::wire::NodeListExtendedAttributesRequest>,
611 >,
612 _: (),
613 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
614 if let Some(inner) = this {
615 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
616 ::fidl_next::wire::Box::encode_present(out);
617 } else {
618 ::fidl_next::wire::Box::encode_absent(out);
619 }
620
621 Ok(())
622 }
623 }
624
625 impl ::fidl_next::FromWire<crate::wire::NodeListExtendedAttributesRequest>
626 for NodeListExtendedAttributesRequest
627 {
628 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
629 crate::wire::NodeListExtendedAttributesRequest,
630 Self,
631 > = unsafe {
632 ::fidl_next::CopyOptimization::enable_if(
633 true && <::fidl_next::ServerEnd<
634 crate::ExtendedAttributeIterator,
635 ::fidl_next::fuchsia::zx::Channel,
636 > as ::fidl_next::FromWire<
637 ::fidl_next::ServerEnd<
638 crate::ExtendedAttributeIterator,
639 ::fidl_next::wire::fuchsia::Channel,
640 >,
641 >>::COPY_OPTIMIZATION
642 .is_enabled(),
643 )
644 };
645
646 #[inline]
647 fn from_wire(wire: crate::wire::NodeListExtendedAttributesRequest) -> Self {
648 Self { iterator: ::fidl_next::FromWire::from_wire(wire.iterator) }
649 }
650 }
651
652 #[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"]
653 #[derive(Debug, PartialEq)]
654 pub enum ExtendedAttributeValue {
655 Bytes(::std::vec::Vec<u8>),
656
657 Buffer(::fidl_next::fuchsia::zx::Vmo),
658
659 UnknownOrdinal_(u64),
660 }
661
662 impl ExtendedAttributeValue {
663 pub fn is_unknown(&self) -> bool {
664 #[allow(unreachable_patterns)]
665 match self {
666 Self::UnknownOrdinal_(_) => true,
667 _ => false,
668 }
669 }
670 }
671
672 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExtendedAttributeValue<'static>, ___E>
673 for ExtendedAttributeValue
674 where
675 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
676 ___E: ::fidl_next::Encoder,
677 ___E: ::fidl_next::fuchsia::HandleEncoder,
678 {
679 #[inline]
680 fn encode(
681 self,
682 encoder: &mut ___E,
683 out: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedAttributeValue<'static>>,
684 _: (),
685 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
686 ::fidl_next::munge!(let crate::wire::ExtendedAttributeValue { raw, _phantom: _ } = out);
687
688 match self {
689 Self::Bytes(value) => ::fidl_next::wire::Union::encode_as::<
690 ___E,
691 ::fidl_next::wire::Vector<'static, u8>,
692 >(value, 1, encoder, raw, (32768, ()))?,
693
694 Self::Buffer(value) => ::fidl_next::wire::Union::encode_as::<
695 ___E,
696 ::fidl_next::wire::fuchsia::Vmo,
697 >(value, 2, encoder, raw, ())?,
698
699 Self::UnknownOrdinal_(ordinal) => {
700 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
701 }
702 }
703
704 Ok(())
705 }
706 }
707
708 unsafe impl<___E>
709 ::fidl_next::EncodeOption<crate::wire_optional::ExtendedAttributeValue<'static>, ___E>
710 for ExtendedAttributeValue
711 where
712 ___E: ?Sized,
713 ExtendedAttributeValue:
714 ::fidl_next::Encode<crate::wire::ExtendedAttributeValue<'static>, ___E>,
715 {
716 #[inline]
717 fn encode_option(
718 this: ::core::option::Option<Self>,
719 encoder: &mut ___E,
720 out: &mut ::core::mem::MaybeUninit<
721 crate::wire_optional::ExtendedAttributeValue<'static>,
722 >,
723 _: (),
724 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
725 ::fidl_next::munge!(let crate::wire_optional::ExtendedAttributeValue { raw, _phantom: _ } = &mut *out);
726
727 if let Some(inner) = this {
728 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
729 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
730 } else {
731 ::fidl_next::wire::Union::encode_absent(raw);
732 }
733
734 Ok(())
735 }
736 }
737
738 impl<'de> ::fidl_next::FromWire<crate::wire::ExtendedAttributeValue<'de>>
739 for ExtendedAttributeValue
740 {
741 #[inline]
742 fn from_wire(wire: crate::wire::ExtendedAttributeValue<'de>) -> Self {
743 let wire = ::core::mem::ManuallyDrop::new(wire);
744 match wire.raw.ordinal() {
745 1 => Self::Bytes(::fidl_next::FromWire::from_wire(unsafe {
746 wire.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
747 })),
748
749 2 => Self::Buffer(::fidl_next::FromWire::from_wire(unsafe {
750 wire.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::Vmo>()
751 })),
752
753 ord => return Self::UnknownOrdinal_(ord as u64),
754 }
755 }
756 }
757
758 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ExtendedAttributeValue<'de>>
759 for ExtendedAttributeValue
760 {
761 #[inline]
762 fn from_wire_option(
763 wire: crate::wire_optional::ExtendedAttributeValue<'de>,
764 ) -> ::core::option::Option<Self> {
765 if let Some(inner) = wire.into_option() {
766 Some(::fidl_next::FromWire::from_wire(inner))
767 } else {
768 None
769 }
770 }
771 }
772
773 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ExtendedAttributeValue<'de>>
774 for Box<ExtendedAttributeValue>
775 {
776 #[inline]
777 fn from_wire_option(
778 wire: crate::wire_optional::ExtendedAttributeValue<'de>,
779 ) -> ::core::option::Option<Self> {
780 <ExtendedAttributeValue as ::fidl_next::FromWireOption<
781 crate::wire_optional::ExtendedAttributeValue<'de>,
782 >>::from_wire_option(wire)
783 .map(Box::new)
784 }
785 }
786
787 #[derive(Debug, PartialEq)]
788 pub struct NodeSetExtendedAttributeRequest {
789 pub name: ::std::vec::Vec<u8>,
790
791 pub value: crate::natural::ExtendedAttributeValue,
792
793 pub mode: crate::natural::SetExtendedAttributeMode,
794 }
795
796 unsafe impl<___E>
797 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeRequest<'static>, ___E>
798 for NodeSetExtendedAttributeRequest
799 where
800 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
801 ___E: ::fidl_next::Encoder,
802 ___E: ::fidl_next::fuchsia::HandleEncoder,
803 {
804 #[inline]
805 fn encode(
806 self,
807 encoder_: &mut ___E,
808 out_: &mut ::core::mem::MaybeUninit<
809 crate::wire::NodeSetExtendedAttributeRequest<'static>,
810 >,
811 _: (),
812 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
813 ::fidl_next::munge! {
814 let crate::wire::NodeSetExtendedAttributeRequest {
815 name,
816 value,
817 mode,
818
819 } = out_;
820 }
821
822 ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
823
824 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
825 ::fidl_next::Constrained::validate(_field, (255, ()))?;
826
827 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
828
829 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
830
831 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
832
833 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
834
835 Ok(())
836 }
837 }
838
839 unsafe impl<___E>
840 ::fidl_next::EncodeOption<
841 ::fidl_next::wire::Box<'static, crate::wire::NodeSetExtendedAttributeRequest<'static>>,
842 ___E,
843 > for NodeSetExtendedAttributeRequest
844 where
845 ___E: ::fidl_next::Encoder + ?Sized,
846 NodeSetExtendedAttributeRequest:
847 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeRequest<'static>, ___E>,
848 {
849 #[inline]
850 fn encode_option(
851 this: ::core::option::Option<Self>,
852 encoder: &mut ___E,
853 out: &mut ::core::mem::MaybeUninit<
854 ::fidl_next::wire::Box<
855 'static,
856 crate::wire::NodeSetExtendedAttributeRequest<'static>,
857 >,
858 >,
859 _: (),
860 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
861 if let Some(inner) = this {
862 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
863 ::fidl_next::wire::Box::encode_present(out);
864 } else {
865 ::fidl_next::wire::Box::encode_absent(out);
866 }
867
868 Ok(())
869 }
870 }
871
872 impl<'de> ::fidl_next::FromWire<crate::wire::NodeSetExtendedAttributeRequest<'de>>
873 for NodeSetExtendedAttributeRequest
874 {
875 #[inline]
876 fn from_wire(wire: crate::wire::NodeSetExtendedAttributeRequest<'de>) -> Self {
877 Self {
878 name: ::fidl_next::FromWire::from_wire(wire.name),
879
880 value: ::fidl_next::FromWire::from_wire(wire.value),
881
882 mode: ::fidl_next::FromWire::from_wire(wire.mode),
883 }
884 }
885 }
886
887 #[doc = " Auxiliary data for the file representation of a node.\n"]
888 #[derive(Debug, Default, PartialEq)]
889 pub struct FileInfo {
890 pub is_append: ::core::option::Option<bool>,
891
892 pub observer: ::core::option::Option<::fidl_next::fuchsia::zx::Event>,
893
894 pub stream: ::core::option::Option<::fidl_next::fuchsia::zx::Stream>,
895
896 pub attributes: ::core::option::Option<crate::natural::NodeAttributes2>,
897 }
898
899 impl FileInfo {
900 fn __max_ordinal(&self) -> usize {
901 if self.attributes.is_some() {
902 return 4;
903 }
904
905 if self.stream.is_some() {
906 return 3;
907 }
908
909 if self.observer.is_some() {
910 return 2;
911 }
912
913 if self.is_append.is_some() {
914 return 1;
915 }
916
917 0
918 }
919 }
920
921 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileInfo<'static>, ___E> for FileInfo
922 where
923 ___E: ::fidl_next::Encoder + ?Sized,
924 ___E: ::fidl_next::fuchsia::HandleEncoder,
925 {
926 #[inline]
927 fn encode(
928 mut self,
929 encoder: &mut ___E,
930 out: &mut ::core::mem::MaybeUninit<crate::wire::FileInfo<'static>>,
931 _: (),
932 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
933 ::fidl_next::munge!(let crate::wire::FileInfo { table } = out);
934
935 let max_ord = self.__max_ordinal();
936
937 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
938 ::fidl_next::Wire::zero_padding(&mut out);
939
940 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
941 ::fidl_next::wire::Envelope,
942 >(encoder, max_ord);
943
944 for i in 1..=max_ord {
945 match i {
946 4 => {
947 if let Some(value) = self.attributes.take() {
948 ::fidl_next::wire::Envelope::encode_value::<
949 crate::wire::NodeAttributes2<'static>,
950 ___E,
951 >(
952 value, preallocated.encoder, &mut out, ()
953 )?;
954 } else {
955 ::fidl_next::wire::Envelope::encode_zero(&mut out)
956 }
957 }
958
959 3 => {
960 if let Some(value) = self.stream.take() {
961 ::fidl_next::wire::Envelope::encode_value::<
962 ::fidl_next::wire::fuchsia::Stream,
963 ___E,
964 >(
965 value, preallocated.encoder, &mut out, ()
966 )?;
967 } else {
968 ::fidl_next::wire::Envelope::encode_zero(&mut out)
969 }
970 }
971
972 2 => {
973 if let Some(value) = self.observer.take() {
974 ::fidl_next::wire::Envelope::encode_value::<
975 ::fidl_next::wire::fuchsia::Event,
976 ___E,
977 >(
978 value, preallocated.encoder, &mut out, ()
979 )?;
980 } else {
981 ::fidl_next::wire::Envelope::encode_zero(&mut out)
982 }
983 }
984
985 1 => {
986 if let Some(value) = self.is_append.take() {
987 ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
988 value,
989 preallocated.encoder,
990 &mut out,
991 (),
992 )?;
993 } else {
994 ::fidl_next::wire::Envelope::encode_zero(&mut out)
995 }
996 }
997
998 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
999 }
1000 unsafe {
1001 preallocated.write_next(out.assume_init_ref());
1002 }
1003 }
1004
1005 ::fidl_next::wire::Table::encode_len(table, max_ord);
1006
1007 Ok(())
1008 }
1009 }
1010
1011 impl<'de> ::fidl_next::FromWire<crate::wire::FileInfo<'de>> for FileInfo {
1012 #[inline]
1013 fn from_wire(wire_: crate::wire::FileInfo<'de>) -> Self {
1014 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1015
1016 let is_append = wire_.table.get(1);
1017
1018 let observer = wire_.table.get(2);
1019
1020 let stream = wire_.table.get(3);
1021
1022 let attributes = wire_.table.get(4);
1023
1024 Self {
1025 is_append: is_append.map(|envelope| {
1026 ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
1027 }),
1028
1029 observer: observer.map(|envelope| {
1030 ::fidl_next::FromWire::from_wire(unsafe {
1031 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Event>()
1032 })
1033 }),
1034
1035 stream: stream.map(|envelope| {
1036 ::fidl_next::FromWire::from_wire(unsafe {
1037 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Stream>()
1038 })
1039 }),
1040
1041 attributes: attributes.map(|envelope| {
1042 ::fidl_next::FromWire::from_wire(unsafe {
1043 envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
1044 })
1045 }),
1046 }
1047 }
1048 }
1049
1050 #[derive(Debug, PartialEq)]
1051 pub enum Representation {
1052 Node(crate::natural::NodeInfo),
1053
1054 Directory(crate::natural::DirectoryInfo),
1055
1056 File(crate::natural::FileInfo),
1057
1058 Symlink(crate::natural::SymlinkInfo),
1059
1060 UnknownOrdinal_(u64),
1061 }
1062
1063 impl Representation {
1064 pub fn is_unknown(&self) -> bool {
1065 #[allow(unreachable_patterns)]
1066 match self {
1067 Self::UnknownOrdinal_(_) => true,
1068 _ => false,
1069 }
1070 }
1071 }
1072
1073 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Representation<'static>, ___E> for Representation
1074 where
1075 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1076 ___E: ::fidl_next::Encoder,
1077 ___E: ::fidl_next::fuchsia::HandleEncoder,
1078 {
1079 #[inline]
1080 fn encode(
1081 self,
1082 encoder: &mut ___E,
1083 out: &mut ::core::mem::MaybeUninit<crate::wire::Representation<'static>>,
1084 _: (),
1085 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1086 ::fidl_next::munge!(let crate::wire::Representation { raw, _phantom: _ } = out);
1087
1088 match self {
1089 Self::Node(value) => ::fidl_next::wire::Union::encode_as::<
1090 ___E,
1091 crate::wire::NodeInfo<'static>,
1092 >(value, 1, encoder, raw, ())?,
1093
1094 Self::Directory(value) => ::fidl_next::wire::Union::encode_as::<
1095 ___E,
1096 crate::wire::DirectoryInfo<'static>,
1097 >(value, 2, encoder, raw, ())?,
1098
1099 Self::File(value) => ::fidl_next::wire::Union::encode_as::<
1100 ___E,
1101 crate::wire::FileInfo<'static>,
1102 >(value, 3, encoder, raw, ())?,
1103
1104 Self::Symlink(value) => ::fidl_next::wire::Union::encode_as::<
1105 ___E,
1106 crate::wire::SymlinkInfo<'static>,
1107 >(value, 4, encoder, raw, ())?,
1108
1109 Self::UnknownOrdinal_(ordinal) => {
1110 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
1111 }
1112 }
1113
1114 Ok(())
1115 }
1116 }
1117
1118 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::Representation<'static>, ___E>
1119 for Representation
1120 where
1121 ___E: ?Sized,
1122 Representation: ::fidl_next::Encode<crate::wire::Representation<'static>, ___E>,
1123 {
1124 #[inline]
1125 fn encode_option(
1126 this: ::core::option::Option<Self>,
1127 encoder: &mut ___E,
1128 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::Representation<'static>>,
1129 _: (),
1130 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1131 ::fidl_next::munge!(let crate::wire_optional::Representation { raw, _phantom: _ } = &mut *out);
1132
1133 if let Some(inner) = this {
1134 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
1135 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
1136 } else {
1137 ::fidl_next::wire::Union::encode_absent(raw);
1138 }
1139
1140 Ok(())
1141 }
1142 }
1143
1144 impl<'de> ::fidl_next::FromWire<crate::wire::Representation<'de>> for Representation {
1145 #[inline]
1146 fn from_wire(wire: crate::wire::Representation<'de>) -> Self {
1147 let wire = ::core::mem::ManuallyDrop::new(wire);
1148 match wire.raw.ordinal() {
1149 1 => Self::Node(::fidl_next::FromWire::from_wire(unsafe {
1150 wire.raw.get().read_unchecked::<crate::wire::NodeInfo<'de>>()
1151 })),
1152
1153 2 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
1154 wire.raw.get().read_unchecked::<crate::wire::DirectoryInfo<'de>>()
1155 })),
1156
1157 3 => Self::File(::fidl_next::FromWire::from_wire(unsafe {
1158 wire.raw.get().read_unchecked::<crate::wire::FileInfo<'de>>()
1159 })),
1160
1161 4 => Self::Symlink(::fidl_next::FromWire::from_wire(unsafe {
1162 wire.raw.get().read_unchecked::<crate::wire::SymlinkInfo<'de>>()
1163 })),
1164
1165 ord => return Self::UnknownOrdinal_(ord as u64),
1166 }
1167 }
1168 }
1169
1170 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Representation<'de>>
1171 for Representation
1172 {
1173 #[inline]
1174 fn from_wire_option(
1175 wire: crate::wire_optional::Representation<'de>,
1176 ) -> ::core::option::Option<Self> {
1177 if let Some(inner) = wire.into_option() {
1178 Some(::fidl_next::FromWire::from_wire(inner))
1179 } else {
1180 None
1181 }
1182 }
1183 }
1184
1185 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Representation<'de>>
1186 for Box<Representation>
1187 {
1188 #[inline]
1189 fn from_wire_option(
1190 wire: crate::wire_optional::Representation<'de>,
1191 ) -> ::core::option::Option<Self> {
1192 <Representation as ::fidl_next::FromWireOption<
1193 crate::wire_optional::Representation<'de>,
1194 >>::from_wire_option(wire)
1195 .map(Box::new)
1196 }
1197 }
1198
1199 #[derive(Debug, PartialEq)]
1200 pub struct OpenableOpenRequest {
1201 pub path: ::std::string::String,
1202
1203 pub flags: crate::natural::Flags,
1204
1205 pub options: crate::natural::Options,
1206
1207 pub object: ::fidl_next::fuchsia::zx::Channel,
1208 }
1209
1210 unsafe impl<___E> ::fidl_next::Encode<crate::wire::OpenableOpenRequest<'static>, ___E>
1211 for OpenableOpenRequest
1212 where
1213 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1214 ___E: ::fidl_next::Encoder,
1215 ___E: ::fidl_next::fuchsia::HandleEncoder,
1216 {
1217 #[inline]
1218 fn encode(
1219 self,
1220 encoder_: &mut ___E,
1221 out_: &mut ::core::mem::MaybeUninit<crate::wire::OpenableOpenRequest<'static>>,
1222 _: (),
1223 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1224 ::fidl_next::munge! {
1225 let crate::wire::OpenableOpenRequest {
1226 path,
1227 flags,
1228 options,
1229 object,
1230
1231 } = out_;
1232 }
1233
1234 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
1235
1236 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
1237 ::fidl_next::Constrained::validate(_field, 4095)?;
1238
1239 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
1240
1241 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
1242
1243 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
1244
1245 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
1246
1247 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
1248
1249 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
1250
1251 Ok(())
1252 }
1253 }
1254
1255 unsafe impl<___E>
1256 ::fidl_next::EncodeOption<
1257 ::fidl_next::wire::Box<'static, crate::wire::OpenableOpenRequest<'static>>,
1258 ___E,
1259 > for OpenableOpenRequest
1260 where
1261 ___E: ::fidl_next::Encoder + ?Sized,
1262 OpenableOpenRequest: ::fidl_next::Encode<crate::wire::OpenableOpenRequest<'static>, ___E>,
1263 {
1264 #[inline]
1265 fn encode_option(
1266 this: ::core::option::Option<Self>,
1267 encoder: &mut ___E,
1268 out: &mut ::core::mem::MaybeUninit<
1269 ::fidl_next::wire::Box<'static, crate::wire::OpenableOpenRequest<'static>>,
1270 >,
1271 _: (),
1272 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1273 if let Some(inner) = this {
1274 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1275 ::fidl_next::wire::Box::encode_present(out);
1276 } else {
1277 ::fidl_next::wire::Box::encode_absent(out);
1278 }
1279
1280 Ok(())
1281 }
1282 }
1283
1284 impl<'de> ::fidl_next::FromWire<crate::wire::OpenableOpenRequest<'de>> for OpenableOpenRequest {
1285 #[inline]
1286 fn from_wire(wire: crate::wire::OpenableOpenRequest<'de>) -> Self {
1287 Self {
1288 path: ::fidl_next::FromWire::from_wire(wire.path),
1289
1290 flags: ::fidl_next::FromWire::from_wire(wire.flags),
1291
1292 options: ::fidl_next::FromWire::from_wire(wire.options),
1293
1294 object: ::fidl_next::FromWire::from_wire(wire.object),
1295 }
1296 }
1297 }
1298
1299 #[derive(Debug, PartialEq)]
1300 #[repr(C)]
1301 pub struct NodeDeprecatedCloneRequest {
1302 pub flags: crate::natural::OpenFlags,
1303
1304 pub object: ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::zx::Channel>,
1305 }
1306
1307 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedCloneRequest, ___E>
1308 for NodeDeprecatedCloneRequest
1309 where
1310 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1311 ___E: ::fidl_next::fuchsia::HandleEncoder,
1312 {
1313 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1314 Self,
1315 crate::wire::NodeDeprecatedCloneRequest,
1316 > = unsafe {
1317 ::fidl_next::CopyOptimization::enable_if(
1318 true
1319
1320 && <
1321 crate::natural::OpenFlags as ::fidl_next::Encode<crate::wire::OpenFlags, ___E>
1322 >::COPY_OPTIMIZATION.is_enabled()
1323
1324 && <
1325 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::zx::Channel> as ::fidl_next::Encode<::fidl_next::ServerEnd<crate::Node, ::fidl_next::wire::fuchsia::Channel>, ___E>
1326 >::COPY_OPTIMIZATION.is_enabled()
1327
1328 )
1329 };
1330
1331 #[inline]
1332 fn encode(
1333 self,
1334 encoder_: &mut ___E,
1335 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedCloneRequest>,
1336 _: (),
1337 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1338 ::fidl_next::munge! {
1339 let crate::wire::NodeDeprecatedCloneRequest {
1340 flags,
1341 object,
1342
1343 } = out_;
1344 }
1345
1346 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
1347
1348 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
1349
1350 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
1351
1352 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
1353
1354 Ok(())
1355 }
1356 }
1357
1358 unsafe impl<___E>
1359 ::fidl_next::EncodeOption<
1360 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedCloneRequest>,
1361 ___E,
1362 > for NodeDeprecatedCloneRequest
1363 where
1364 ___E: ::fidl_next::Encoder + ?Sized,
1365 NodeDeprecatedCloneRequest:
1366 ::fidl_next::Encode<crate::wire::NodeDeprecatedCloneRequest, ___E>,
1367 {
1368 #[inline]
1369 fn encode_option(
1370 this: ::core::option::Option<Self>,
1371 encoder: &mut ___E,
1372 out: &mut ::core::mem::MaybeUninit<
1373 ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedCloneRequest>,
1374 >,
1375 _: (),
1376 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1377 if let Some(inner) = this {
1378 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1379 ::fidl_next::wire::Box::encode_present(out);
1380 } else {
1381 ::fidl_next::wire::Box::encode_absent(out);
1382 }
1383
1384 Ok(())
1385 }
1386 }
1387
1388 impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedCloneRequest> for NodeDeprecatedCloneRequest {
1389 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1390 crate::wire::NodeDeprecatedCloneRequest,
1391 Self,
1392 > = unsafe {
1393 ::fidl_next::CopyOptimization::enable_if(
1394 true
1395
1396 && <
1397 crate::natural::OpenFlags as ::fidl_next::FromWire<crate::wire::OpenFlags>
1398 >::COPY_OPTIMIZATION.is_enabled()
1399
1400 && <
1401 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::zx::Channel> as ::fidl_next::FromWire<::fidl_next::ServerEnd<crate::Node, ::fidl_next::wire::fuchsia::Channel>>
1402 >::COPY_OPTIMIZATION.is_enabled()
1403
1404 )
1405 };
1406
1407 #[inline]
1408 fn from_wire(wire: crate::wire::NodeDeprecatedCloneRequest) -> Self {
1409 Self {
1410 flags: ::fidl_next::FromWire::from_wire(wire.flags),
1411
1412 object: ::fidl_next::FromWire::from_wire(wire.object),
1413 }
1414 }
1415 }
1416
1417 #[derive(Debug, PartialEq)]
1418 pub struct NodeOnOpenRequest {
1419 pub s: ::fidl_next::fuchsia::zx::Status,
1420
1421 pub info: ::core::option::Option<::std::boxed::Box<crate::natural::NodeInfoDeprecated>>,
1422 }
1423
1424 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeOnOpenRequest<'static>, ___E>
1425 for NodeOnOpenRequest
1426 where
1427 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1428 ___E: ::fidl_next::Encoder,
1429 ___E: ::fidl_next::fuchsia::HandleEncoder,
1430 {
1431 #[inline]
1432 fn encode(
1433 self,
1434 encoder_: &mut ___E,
1435 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeOnOpenRequest<'static>>,
1436 _: (),
1437 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1438 ::fidl_next::munge! {
1439 let crate::wire::NodeOnOpenRequest {
1440 s,
1441 info,
1442
1443 } = out_;
1444 }
1445
1446 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
1447
1448 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
1449
1450 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
1451
1452 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
1453
1454 Ok(())
1455 }
1456 }
1457
1458 unsafe impl<___E>
1459 ::fidl_next::EncodeOption<
1460 ::fidl_next::wire::Box<'static, crate::wire::NodeOnOpenRequest<'static>>,
1461 ___E,
1462 > for NodeOnOpenRequest
1463 where
1464 ___E: ::fidl_next::Encoder + ?Sized,
1465 NodeOnOpenRequest: ::fidl_next::Encode<crate::wire::NodeOnOpenRequest<'static>, ___E>,
1466 {
1467 #[inline]
1468 fn encode_option(
1469 this: ::core::option::Option<Self>,
1470 encoder: &mut ___E,
1471 out: &mut ::core::mem::MaybeUninit<
1472 ::fidl_next::wire::Box<'static, crate::wire::NodeOnOpenRequest<'static>>,
1473 >,
1474 _: (),
1475 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1476 if let Some(inner) = this {
1477 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1478 ::fidl_next::wire::Box::encode_present(out);
1479 } else {
1480 ::fidl_next::wire::Box::encode_absent(out);
1481 }
1482
1483 Ok(())
1484 }
1485 }
1486
1487 impl<'de> ::fidl_next::FromWire<crate::wire::NodeOnOpenRequest<'de>> for NodeOnOpenRequest {
1488 #[inline]
1489 fn from_wire(wire: crate::wire::NodeOnOpenRequest<'de>) -> Self {
1490 Self {
1491 s: ::fidl_next::FromWire::from_wire(wire.s),
1492
1493 info: ::fidl_next::FromWire::from_wire(wire.info),
1494 }
1495 }
1496 }
1497
1498 #[derive(Debug, PartialEq)]
1499 pub struct DirectoryDeprecatedOpenRequest {
1500 pub flags: crate::natural::OpenFlags,
1501
1502 pub mode: crate::natural::ModeType,
1503
1504 pub path: ::std::string::String,
1505
1506 pub object: ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::zx::Channel>,
1507 }
1508
1509 unsafe impl<___E>
1510 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedOpenRequest<'static>, ___E>
1511 for DirectoryDeprecatedOpenRequest
1512 where
1513 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1514 ___E: ::fidl_next::Encoder,
1515 ___E: ::fidl_next::fuchsia::HandleEncoder,
1516 {
1517 #[inline]
1518 fn encode(
1519 self,
1520 encoder_: &mut ___E,
1521 out_: &mut ::core::mem::MaybeUninit<
1522 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
1523 >,
1524 _: (),
1525 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1526 ::fidl_next::munge! {
1527 let crate::wire::DirectoryDeprecatedOpenRequest {
1528 flags,
1529 mode,
1530 path,
1531 object,
1532
1533 } = out_;
1534 }
1535
1536 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
1537
1538 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
1539
1540 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
1541
1542 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
1543
1544 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
1545
1546 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
1547 ::fidl_next::Constrained::validate(_field, 4095)?;
1548
1549 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
1550
1551 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
1552
1553 Ok(())
1554 }
1555 }
1556
1557 unsafe impl<___E>
1558 ::fidl_next::EncodeOption<
1559 ::fidl_next::wire::Box<'static, crate::wire::DirectoryDeprecatedOpenRequest<'static>>,
1560 ___E,
1561 > for DirectoryDeprecatedOpenRequest
1562 where
1563 ___E: ::fidl_next::Encoder + ?Sized,
1564 DirectoryDeprecatedOpenRequest:
1565 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedOpenRequest<'static>, ___E>,
1566 {
1567 #[inline]
1568 fn encode_option(
1569 this: ::core::option::Option<Self>,
1570 encoder: &mut ___E,
1571 out: &mut ::core::mem::MaybeUninit<
1572 ::fidl_next::wire::Box<
1573 'static,
1574 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
1575 >,
1576 >,
1577 _: (),
1578 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1579 if let Some(inner) = this {
1580 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1581 ::fidl_next::wire::Box::encode_present(out);
1582 } else {
1583 ::fidl_next::wire::Box::encode_absent(out);
1584 }
1585
1586 Ok(())
1587 }
1588 }
1589
1590 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryDeprecatedOpenRequest<'de>>
1591 for DirectoryDeprecatedOpenRequest
1592 {
1593 #[inline]
1594 fn from_wire(wire: crate::wire::DirectoryDeprecatedOpenRequest<'de>) -> Self {
1595 Self {
1596 flags: ::fidl_next::FromWire::from_wire(wire.flags),
1597
1598 mode: ::fidl_next::FromWire::from_wire(wire.mode),
1599
1600 path: ::fidl_next::FromWire::from_wire(wire.path),
1601
1602 object: ::fidl_next::FromWire::from_wire(wire.object),
1603 }
1604 }
1605 }
1606
1607 #[derive(Debug, PartialEq)]
1608 pub struct DirectoryCreateSymlinkRequest {
1609 pub name: ::std::string::String,
1610
1611 pub target: ::std::vec::Vec<u8>,
1612
1613 pub connection: ::core::option::Option<
1614 ::fidl_next::ServerEnd<crate::Symlink, ::fidl_next::fuchsia::zx::Channel>,
1615 >,
1616 }
1617
1618 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkRequest<'static>, ___E>
1619 for DirectoryCreateSymlinkRequest
1620 where
1621 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1622 ___E: ::fidl_next::Encoder,
1623 ___E: ::fidl_next::fuchsia::HandleEncoder,
1624 {
1625 #[inline]
1626 fn encode(
1627 self,
1628 encoder_: &mut ___E,
1629 out_: &mut ::core::mem::MaybeUninit<
1630 crate::wire::DirectoryCreateSymlinkRequest<'static>,
1631 >,
1632 _: (),
1633 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1634 ::fidl_next::munge! {
1635 let crate::wire::DirectoryCreateSymlinkRequest {
1636 name,
1637 target,
1638 connection,
1639
1640 } = out_;
1641 }
1642
1643 ::fidl_next::Encode::encode(self.name, encoder_, name, 255)?;
1644
1645 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
1646 ::fidl_next::Constrained::validate(_field, 255)?;
1647
1648 ::fidl_next::Encode::encode(self.target, encoder_, target, (4095, ()))?;
1649
1650 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(target.as_mut_ptr()) };
1651 ::fidl_next::Constrained::validate(_field, (4095, ()))?;
1652
1653 ::fidl_next::Encode::encode(self.connection, encoder_, connection, ())?;
1654
1655 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(connection.as_mut_ptr()) };
1656
1657 Ok(())
1658 }
1659 }
1660
1661 unsafe impl<___E>
1662 ::fidl_next::EncodeOption<
1663 ::fidl_next::wire::Box<'static, crate::wire::DirectoryCreateSymlinkRequest<'static>>,
1664 ___E,
1665 > for DirectoryCreateSymlinkRequest
1666 where
1667 ___E: ::fidl_next::Encoder + ?Sized,
1668 DirectoryCreateSymlinkRequest:
1669 ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkRequest<'static>, ___E>,
1670 {
1671 #[inline]
1672 fn encode_option(
1673 this: ::core::option::Option<Self>,
1674 encoder: &mut ___E,
1675 out: &mut ::core::mem::MaybeUninit<
1676 ::fidl_next::wire::Box<
1677 'static,
1678 crate::wire::DirectoryCreateSymlinkRequest<'static>,
1679 >,
1680 >,
1681 _: (),
1682 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1683 if let Some(inner) = this {
1684 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1685 ::fidl_next::wire::Box::encode_present(out);
1686 } else {
1687 ::fidl_next::wire::Box::encode_absent(out);
1688 }
1689
1690 Ok(())
1691 }
1692 }
1693
1694 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryCreateSymlinkRequest<'de>>
1695 for DirectoryCreateSymlinkRequest
1696 {
1697 #[inline]
1698 fn from_wire(wire: crate::wire::DirectoryCreateSymlinkRequest<'de>) -> Self {
1699 Self {
1700 name: ::fidl_next::FromWire::from_wire(wire.name),
1701
1702 target: ::fidl_next::FromWire::from_wire(wire.target),
1703
1704 connection: ::fidl_next::FromWire::from_wire(wire.connection),
1705 }
1706 }
1707 }
1708
1709 #[derive(Debug, PartialEq)]
1710 #[repr(C)]
1711 pub struct FileGetBackingMemoryResponse {
1712 pub vmo: ::fidl_next::fuchsia::zx::Vmo,
1713 }
1714
1715 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryResponse, ___E>
1716 for FileGetBackingMemoryResponse
1717 where
1718 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1719 ___E: ::fidl_next::fuchsia::HandleEncoder,
1720 {
1721 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1722 Self,
1723 crate::wire::FileGetBackingMemoryResponse,
1724 > = unsafe {
1725 ::fidl_next::CopyOptimization::enable_if(
1726 true && <::fidl_next::fuchsia::zx::Vmo as ::fidl_next::Encode<
1727 ::fidl_next::wire::fuchsia::Vmo,
1728 ___E,
1729 >>::COPY_OPTIMIZATION
1730 .is_enabled(),
1731 )
1732 };
1733
1734 #[inline]
1735 fn encode(
1736 self,
1737 encoder_: &mut ___E,
1738 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryResponse>,
1739 _: (),
1740 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1741 ::fidl_next::munge! {
1742 let crate::wire::FileGetBackingMemoryResponse {
1743 vmo,
1744
1745 } = out_;
1746 }
1747
1748 ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
1749
1750 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vmo.as_mut_ptr()) };
1751
1752 Ok(())
1753 }
1754 }
1755
1756 unsafe impl<___E>
1757 ::fidl_next::EncodeOption<
1758 ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryResponse>,
1759 ___E,
1760 > for FileGetBackingMemoryResponse
1761 where
1762 ___E: ::fidl_next::Encoder + ?Sized,
1763 FileGetBackingMemoryResponse:
1764 ::fidl_next::Encode<crate::wire::FileGetBackingMemoryResponse, ___E>,
1765 {
1766 #[inline]
1767 fn encode_option(
1768 this: ::core::option::Option<Self>,
1769 encoder: &mut ___E,
1770 out: &mut ::core::mem::MaybeUninit<
1771 ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryResponse>,
1772 >,
1773 _: (),
1774 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1775 if let Some(inner) = this {
1776 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1777 ::fidl_next::wire::Box::encode_present(out);
1778 } else {
1779 ::fidl_next::wire::Box::encode_absent(out);
1780 }
1781
1782 Ok(())
1783 }
1784 }
1785
1786 impl ::fidl_next::FromWire<crate::wire::FileGetBackingMemoryResponse>
1787 for FileGetBackingMemoryResponse
1788 {
1789 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1790 crate::wire::FileGetBackingMemoryResponse,
1791 Self,
1792 > = unsafe {
1793 ::fidl_next::CopyOptimization::enable_if(
1794 true && <::fidl_next::fuchsia::zx::Vmo as ::fidl_next::FromWire<
1795 ::fidl_next::wire::fuchsia::Vmo,
1796 >>::COPY_OPTIMIZATION
1797 .is_enabled(),
1798 )
1799 };
1800
1801 #[inline]
1802 fn from_wire(wire: crate::wire::FileGetBackingMemoryResponse) -> Self {
1803 Self { vmo: ::fidl_next::FromWire::from_wire(wire.vmo) }
1804 }
1805 }
1806
1807 #[derive(Debug, PartialEq)]
1808 pub struct LinkableLinkIntoRequest {
1809 pub dst_parent_token: ::fidl_next::fuchsia::zx::Event,
1810
1811 pub dst: ::std::string::String,
1812 }
1813
1814 unsafe impl<___E> ::fidl_next::Encode<crate::wire::LinkableLinkIntoRequest<'static>, ___E>
1815 for LinkableLinkIntoRequest
1816 where
1817 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1818 ___E: ::fidl_next::Encoder,
1819 ___E: ::fidl_next::fuchsia::HandleEncoder,
1820 {
1821 #[inline]
1822 fn encode(
1823 self,
1824 encoder_: &mut ___E,
1825 out_: &mut ::core::mem::MaybeUninit<crate::wire::LinkableLinkIntoRequest<'static>>,
1826 _: (),
1827 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1828 ::fidl_next::munge! {
1829 let crate::wire::LinkableLinkIntoRequest {
1830 dst_parent_token,
1831 dst,
1832
1833 } = out_;
1834 }
1835
1836 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
1837
1838 let mut _field =
1839 unsafe { ::fidl_next::Slot::new_unchecked(dst_parent_token.as_mut_ptr()) };
1840
1841 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
1842
1843 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dst.as_mut_ptr()) };
1844 ::fidl_next::Constrained::validate(_field, 255)?;
1845
1846 Ok(())
1847 }
1848 }
1849
1850 unsafe impl<___E>
1851 ::fidl_next::EncodeOption<
1852 ::fidl_next::wire::Box<'static, crate::wire::LinkableLinkIntoRequest<'static>>,
1853 ___E,
1854 > for LinkableLinkIntoRequest
1855 where
1856 ___E: ::fidl_next::Encoder + ?Sized,
1857 LinkableLinkIntoRequest:
1858 ::fidl_next::Encode<crate::wire::LinkableLinkIntoRequest<'static>, ___E>,
1859 {
1860 #[inline]
1861 fn encode_option(
1862 this: ::core::option::Option<Self>,
1863 encoder: &mut ___E,
1864 out: &mut ::core::mem::MaybeUninit<
1865 ::fidl_next::wire::Box<'static, crate::wire::LinkableLinkIntoRequest<'static>>,
1866 >,
1867 _: (),
1868 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1869 if let Some(inner) = this {
1870 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1871 ::fidl_next::wire::Box::encode_present(out);
1872 } else {
1873 ::fidl_next::wire::Box::encode_absent(out);
1874 }
1875
1876 Ok(())
1877 }
1878 }
1879
1880 impl<'de> ::fidl_next::FromWire<crate::wire::LinkableLinkIntoRequest<'de>>
1881 for LinkableLinkIntoRequest
1882 {
1883 #[inline]
1884 fn from_wire(wire: crate::wire::LinkableLinkIntoRequest<'de>) -> Self {
1885 Self {
1886 dst_parent_token: ::fidl_next::FromWire::from_wire(wire.dst_parent_token),
1887
1888 dst: ::fidl_next::FromWire::from_wire(wire.dst),
1889 }
1890 }
1891 }
1892
1893 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1894 pub struct FileAllocateRequest {
1895 pub offset: u64,
1896
1897 pub length: u64,
1898
1899 pub mode: crate::natural::AllocateMode,
1900 }
1901
1902 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileAllocateRequest, ___E>
1903 for FileAllocateRequest
1904 where
1905 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1906 ___E: ::fidl_next::fuchsia::HandleEncoder,
1907 {
1908 #[inline]
1909 fn encode(
1910 self,
1911 encoder_: &mut ___E,
1912 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileAllocateRequest>,
1913 _: (),
1914 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1915 ::fidl_next::munge! {
1916 let crate::wire::FileAllocateRequest {
1917 offset,
1918 length,
1919 mode,
1920
1921 } = out_;
1922 }
1923
1924 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
1925
1926 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
1927
1928 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
1929
1930 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
1931
1932 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
1933
1934 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
1935
1936 Ok(())
1937 }
1938 }
1939
1940 unsafe impl<___E>
1941 ::fidl_next::EncodeOption<
1942 ::fidl_next::wire::Box<'static, crate::wire::FileAllocateRequest>,
1943 ___E,
1944 > for FileAllocateRequest
1945 where
1946 ___E: ::fidl_next::Encoder + ?Sized,
1947 FileAllocateRequest: ::fidl_next::Encode<crate::wire::FileAllocateRequest, ___E>,
1948 {
1949 #[inline]
1950 fn encode_option(
1951 this: ::core::option::Option<Self>,
1952 encoder: &mut ___E,
1953 out: &mut ::core::mem::MaybeUninit<
1954 ::fidl_next::wire::Box<'static, crate::wire::FileAllocateRequest>,
1955 >,
1956 _: (),
1957 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1958 if let Some(inner) = this {
1959 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1960 ::fidl_next::wire::Box::encode_present(out);
1961 } else {
1962 ::fidl_next::wire::Box::encode_absent(out);
1963 }
1964
1965 Ok(())
1966 }
1967 }
1968
1969 impl ::fidl_next::FromWire<crate::wire::FileAllocateRequest> for FileAllocateRequest {
1970 #[inline]
1971 fn from_wire(wire: crate::wire::FileAllocateRequest) -> Self {
1972 Self {
1973 offset: ::fidl_next::FromWire::from_wire(wire.offset),
1974
1975 length: ::fidl_next::FromWire::from_wire(wire.length),
1976
1977 mode: ::fidl_next::FromWire::from_wire(wire.mode),
1978 }
1979 }
1980 }
1981
1982 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1983 pub struct FileEnableVerityRequest {
1984 pub options: crate::natural::VerificationOptions,
1985 }
1986
1987 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileEnableVerityRequest<'static>, ___E>
1988 for FileEnableVerityRequest
1989 where
1990 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1991 ___E: ::fidl_next::Encoder,
1992 ___E: ::fidl_next::fuchsia::HandleEncoder,
1993 {
1994 #[inline]
1995 fn encode(
1996 self,
1997 encoder_: &mut ___E,
1998 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileEnableVerityRequest<'static>>,
1999 _: (),
2000 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2001 ::fidl_next::munge! {
2002 let crate::wire::FileEnableVerityRequest {
2003 options,
2004
2005 } = out_;
2006 }
2007
2008 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
2009
2010 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
2011
2012 Ok(())
2013 }
2014 }
2015
2016 unsafe impl<___E>
2017 ::fidl_next::EncodeOption<
2018 ::fidl_next::wire::Box<'static, crate::wire::FileEnableVerityRequest<'static>>,
2019 ___E,
2020 > for FileEnableVerityRequest
2021 where
2022 ___E: ::fidl_next::Encoder + ?Sized,
2023 FileEnableVerityRequest:
2024 ::fidl_next::Encode<crate::wire::FileEnableVerityRequest<'static>, ___E>,
2025 {
2026 #[inline]
2027 fn encode_option(
2028 this: ::core::option::Option<Self>,
2029 encoder: &mut ___E,
2030 out: &mut ::core::mem::MaybeUninit<
2031 ::fidl_next::wire::Box<'static, crate::wire::FileEnableVerityRequest<'static>>,
2032 >,
2033 _: (),
2034 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2035 if let Some(inner) = this {
2036 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2037 ::fidl_next::wire::Box::encode_present(out);
2038 } else {
2039 ::fidl_next::wire::Box::encode_absent(out);
2040 }
2041
2042 Ok(())
2043 }
2044 }
2045
2046 impl<'de> ::fidl_next::FromWire<crate::wire::FileEnableVerityRequest<'de>>
2047 for FileEnableVerityRequest
2048 {
2049 #[inline]
2050 fn from_wire(wire: crate::wire::FileEnableVerityRequest<'de>) -> Self {
2051 Self { options: ::fidl_next::FromWire::from_wire(wire.options) }
2052 }
2053 }
2054
2055 #[derive(Debug, PartialEq)]
2056 #[repr(C)]
2057 pub struct FileObject {
2058 pub event: ::core::option::Option<::fidl_next::fuchsia::zx::Event>,
2059
2060 pub stream: ::core::option::Option<::fidl_next::fuchsia::zx::Stream>,
2061 }
2062
2063 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileObject, ___E> for FileObject
2064 where
2065 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2066 ___E: ::fidl_next::fuchsia::HandleEncoder,
2067 {
2068 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::FileObject> = unsafe {
2069 ::fidl_next::CopyOptimization::enable_if(
2070 true
2071
2072 && <
2073 ::core::option::Option<::fidl_next::fuchsia::zx::Event> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalEvent, ___E>
2074 >::COPY_OPTIMIZATION.is_enabled()
2075
2076 && <
2077 ::core::option::Option<::fidl_next::fuchsia::zx::Stream> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalStream, ___E>
2078 >::COPY_OPTIMIZATION.is_enabled()
2079
2080 )
2081 };
2082
2083 #[inline]
2084 fn encode(
2085 self,
2086 encoder_: &mut ___E,
2087 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileObject>,
2088 _: (),
2089 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2090 ::fidl_next::munge! {
2091 let crate::wire::FileObject {
2092 event,
2093 stream,
2094
2095 } = out_;
2096 }
2097
2098 ::fidl_next::Encode::encode(self.event, encoder_, event, ())?;
2099
2100 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(event.as_mut_ptr()) };
2101
2102 ::fidl_next::Encode::encode(self.stream, encoder_, stream, ())?;
2103
2104 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(stream.as_mut_ptr()) };
2105
2106 Ok(())
2107 }
2108 }
2109
2110 unsafe impl<___E>
2111 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::FileObject>, ___E>
2112 for FileObject
2113 where
2114 ___E: ::fidl_next::Encoder + ?Sized,
2115 FileObject: ::fidl_next::Encode<crate::wire::FileObject, ___E>,
2116 {
2117 #[inline]
2118 fn encode_option(
2119 this: ::core::option::Option<Self>,
2120 encoder: &mut ___E,
2121 out: &mut ::core::mem::MaybeUninit<
2122 ::fidl_next::wire::Box<'static, crate::wire::FileObject>,
2123 >,
2124 _: (),
2125 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2126 if let Some(inner) = this {
2127 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2128 ::fidl_next::wire::Box::encode_present(out);
2129 } else {
2130 ::fidl_next::wire::Box::encode_absent(out);
2131 }
2132
2133 Ok(())
2134 }
2135 }
2136
2137 impl ::fidl_next::FromWire<crate::wire::FileObject> for FileObject {
2138 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::FileObject, Self> = unsafe {
2139 ::fidl_next::CopyOptimization::enable_if(
2140 true
2141
2142 && <
2143 ::core::option::Option<::fidl_next::fuchsia::zx::Event> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::OptionalEvent>
2144 >::COPY_OPTIMIZATION.is_enabled()
2145
2146 && <
2147 ::core::option::Option<::fidl_next::fuchsia::zx::Stream> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::OptionalStream>
2148 >::COPY_OPTIMIZATION.is_enabled()
2149
2150 )
2151 };
2152
2153 #[inline]
2154 fn from_wire(wire: crate::wire::FileObject) -> Self {
2155 Self {
2156 event: ::fidl_next::FromWire::from_wire(wire.event),
2157
2158 stream: ::fidl_next::FromWire::from_wire(wire.stream),
2159 }
2160 }
2161 }
2162
2163 #[derive(Debug, PartialEq)]
2164 pub enum NodeInfoDeprecated {
2165 Service(crate::natural::Service),
2166
2167 File(crate::natural::FileObject),
2168
2169 Directory(crate::natural::DirectoryObject),
2170
2171 Symlink(crate::natural::SymlinkObject),
2172 }
2173
2174 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeInfoDeprecated<'static>, ___E>
2175 for NodeInfoDeprecated
2176 where
2177 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2178 ___E: ::fidl_next::Encoder,
2179 ___E: ::fidl_next::fuchsia::HandleEncoder,
2180 {
2181 #[inline]
2182 fn encode(
2183 self,
2184 encoder: &mut ___E,
2185 out: &mut ::core::mem::MaybeUninit<crate::wire::NodeInfoDeprecated<'static>>,
2186 _: (),
2187 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2188 ::fidl_next::munge!(let crate::wire::NodeInfoDeprecated { raw, _phantom: _ } = out);
2189
2190 match self {
2191 Self::Service(value) => ::fidl_next::wire::Union::encode_as::<
2192 ___E,
2193 crate::wire::Service,
2194 >(value, 1, encoder, raw, ())?,
2195
2196 Self::File(value) => ::fidl_next::wire::Union::encode_as::<
2197 ___E,
2198 crate::wire::FileObject,
2199 >(value, 2, encoder, raw, ())?,
2200
2201 Self::Directory(value) => ::fidl_next::wire::Union::encode_as::<
2202 ___E,
2203 crate::wire::DirectoryObject,
2204 >(value, 3, encoder, raw, ())?,
2205
2206 Self::Symlink(value) => ::fidl_next::wire::Union::encode_as::<
2207 ___E,
2208 crate::wire::SymlinkObject<'static>,
2209 >(value, 4, encoder, raw, ())?,
2210 }
2211
2212 Ok(())
2213 }
2214 }
2215
2216 unsafe impl<___E>
2217 ::fidl_next::EncodeOption<crate::wire_optional::NodeInfoDeprecated<'static>, ___E>
2218 for NodeInfoDeprecated
2219 where
2220 ___E: ?Sized,
2221 NodeInfoDeprecated: ::fidl_next::Encode<crate::wire::NodeInfoDeprecated<'static>, ___E>,
2222 {
2223 #[inline]
2224 fn encode_option(
2225 this: ::core::option::Option<Self>,
2226 encoder: &mut ___E,
2227 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::NodeInfoDeprecated<'static>>,
2228 _: (),
2229 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2230 ::fidl_next::munge!(let crate::wire_optional::NodeInfoDeprecated { raw, _phantom: _ } = &mut *out);
2231
2232 if let Some(inner) = this {
2233 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2234 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2235 } else {
2236 ::fidl_next::wire::Union::encode_absent(raw);
2237 }
2238
2239 Ok(())
2240 }
2241 }
2242
2243 impl<'de> ::fidl_next::FromWire<crate::wire::NodeInfoDeprecated<'de>> for NodeInfoDeprecated {
2244 #[inline]
2245 fn from_wire(wire: crate::wire::NodeInfoDeprecated<'de>) -> Self {
2246 let wire = ::core::mem::ManuallyDrop::new(wire);
2247 match wire.raw.ordinal() {
2248 1 => Self::Service(::fidl_next::FromWire::from_wire(unsafe {
2249 wire.raw.get().read_unchecked::<crate::wire::Service>()
2250 })),
2251
2252 2 => Self::File(::fidl_next::FromWire::from_wire(unsafe {
2253 wire.raw.get().read_unchecked::<crate::wire::FileObject>()
2254 })),
2255
2256 3 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
2257 wire.raw.get().read_unchecked::<crate::wire::DirectoryObject>()
2258 })),
2259
2260 4 => Self::Symlink(::fidl_next::FromWire::from_wire(unsafe {
2261 wire.raw.get().read_unchecked::<crate::wire::SymlinkObject<'de>>()
2262 })),
2263
2264 _ => unsafe { ::core::hint::unreachable_unchecked() },
2265 }
2266 }
2267 }
2268
2269 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::NodeInfoDeprecated<'de>>
2270 for NodeInfoDeprecated
2271 {
2272 #[inline]
2273 fn from_wire_option(
2274 wire: crate::wire_optional::NodeInfoDeprecated<'de>,
2275 ) -> ::core::option::Option<Self> {
2276 if let Some(inner) = wire.into_option() {
2277 Some(::fidl_next::FromWire::from_wire(inner))
2278 } else {
2279 None
2280 }
2281 }
2282 }
2283
2284 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::NodeInfoDeprecated<'de>>
2285 for Box<NodeInfoDeprecated>
2286 {
2287 #[inline]
2288 fn from_wire_option(
2289 wire: crate::wire_optional::NodeInfoDeprecated<'de>,
2290 ) -> ::core::option::Option<Self> {
2291 <NodeInfoDeprecated as ::fidl_next::FromWireOption<
2292 crate::wire_optional::NodeInfoDeprecated<'de>,
2293 >>::from_wire_option(wire)
2294 .map(Box::new)
2295 }
2296 }
2297}
2298
2299pub mod wire {
2300
2301 pub use fidl_next_common_fuchsia_io::wire::*;
2302
2303 #[repr(C)]
2305 pub struct ConnectionInfo<'de> {
2306 pub(crate) table: ::fidl_next::wire::Table<'de>,
2307 }
2308
2309 impl<'de> Drop for ConnectionInfo<'de> {
2310 fn drop(&mut self) {
2311 let _ = self
2312 .table
2313 .get(1)
2314 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Operations>() });
2315 }
2316 }
2317
2318 impl ::fidl_next::Constrained for ConnectionInfo<'_> {
2319 type Constraint = ();
2320
2321 fn validate(
2322 _: ::fidl_next::Slot<'_, Self>,
2323 _: Self::Constraint,
2324 ) -> Result<(), ::fidl_next::ValidationError> {
2325 Ok(())
2326 }
2327 }
2328
2329 unsafe impl ::fidl_next::Wire for ConnectionInfo<'static> {
2330 type Narrowed<'de> = ConnectionInfo<'de>;
2331
2332 #[inline]
2333 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
2334 ::fidl_next::munge!(let Self { table } = out);
2335 ::fidl_next::wire::Table::zero_padding(table);
2336 }
2337 }
2338
2339 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConnectionInfo<'de>
2340 where
2341 ___D: ::fidl_next::Decoder<'de> + ?Sized,
2342 ___D: ::fidl_next::fuchsia::HandleDecoder,
2343 {
2344 fn decode(
2345 slot: ::fidl_next::Slot<'_, Self>,
2346 decoder: &mut ___D,
2347 _: (),
2348 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2349 ::fidl_next::munge!(let Self { table } = slot);
2350
2351 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
2352 match ordinal {
2353 0 => unsafe { ::core::hint::unreachable_unchecked() },
2354
2355 1 => {
2356 ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Operations>(
2357 slot.as_mut(),
2358 decoder,
2359 (),
2360 )?;
2361
2362 Ok(())
2363 }
2364
2365 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
2366 }
2367 })
2368 }
2369 }
2370
2371 impl<'de> ConnectionInfo<'de> {
2372 pub fn rights(&self) -> ::core::option::Option<&crate::wire::Operations> {
2373 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
2374 }
2375 }
2376
2377 impl<'de> ::core::fmt::Debug for ConnectionInfo<'de> {
2378 fn fmt(
2379 &self,
2380 f: &mut ::core::fmt::Formatter<'_>,
2381 ) -> ::core::result::Result<(), ::core::fmt::Error> {
2382 f.debug_struct("ConnectionInfo").field("rights", &self.rights()).finish()
2383 }
2384 }
2385
2386 impl<'de> ::fidl_next::IntoNatural for ConnectionInfo<'de> {
2387 type Natural = crate::natural::ConnectionInfo;
2388 }
2389
2390 #[derive(Debug)]
2392 #[repr(C)]
2393 pub struct DirectoryGetTokenResponse {
2394 pub s: ::fidl_next::wire::fuchsia::Status,
2395
2396 pub token: ::fidl_next::wire::fuchsia::OptionalNullableHandle,
2397 }
2398
2399 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryGetTokenResponse>(), 8);
2400 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryGetTokenResponse>(), 4);
2401
2402 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryGetTokenResponse, s), 0);
2403
2404 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryGetTokenResponse, token), 4);
2405
2406 impl ::fidl_next::Constrained for DirectoryGetTokenResponse {
2407 type Constraint = ();
2408
2409 fn validate(
2410 _: ::fidl_next::Slot<'_, Self>,
2411 _: Self::Constraint,
2412 ) -> Result<(), ::fidl_next::ValidationError> {
2413 Ok(())
2414 }
2415 }
2416
2417 unsafe impl ::fidl_next::Wire for DirectoryGetTokenResponse {
2418 type Narrowed<'de> = DirectoryGetTokenResponse;
2419
2420 #[inline]
2421 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2422 ::fidl_next::munge! {
2423 let Self {
2424 s,
2425 token,
2426
2427 } = &mut *out_;
2428 }
2429
2430 ::fidl_next::Wire::zero_padding(s);
2431
2432 ::fidl_next::Wire::zero_padding(token);
2433 }
2434 }
2435
2436 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryGetTokenResponse
2437 where
2438 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2439 ___D: ::fidl_next::fuchsia::HandleDecoder,
2440 {
2441 fn decode(
2442 slot_: ::fidl_next::Slot<'_, Self>,
2443 decoder_: &mut ___D,
2444 _: (),
2445 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2446 ::fidl_next::munge! {
2447 let Self {
2448 mut s,
2449 mut token,
2450
2451 } = slot_;
2452 }
2453
2454 let _field = s.as_mut();
2455
2456 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
2457
2458 let _field = token.as_mut();
2459
2460 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
2461
2462 Ok(())
2463 }
2464 }
2465
2466 impl ::fidl_next::IntoNatural for DirectoryGetTokenResponse {
2467 type Natural = crate::natural::DirectoryGetTokenResponse;
2468 }
2469
2470 #[derive(Debug)]
2472 #[repr(C)]
2473 pub struct DirectoryLinkRequest<'de> {
2474 pub src: ::fidl_next::wire::String<'de>,
2475
2476 pub dst_parent_token: ::fidl_next::wire::fuchsia::NullableHandle,
2477
2478 pub dst: ::fidl_next::wire::String<'de>,
2479 }
2480
2481 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryLinkRequest<'_>>(), 40);
2482 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryLinkRequest<'_>>(), 8);
2483
2484 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryLinkRequest<'_>, src), 0);
2485
2486 static_assertions::const_assert_eq!(
2487 std::mem::offset_of!(DirectoryLinkRequest<'_>, dst_parent_token),
2488 16
2489 );
2490
2491 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryLinkRequest<'_>, dst), 24);
2492
2493 impl ::fidl_next::Constrained for DirectoryLinkRequest<'_> {
2494 type Constraint = ();
2495
2496 fn validate(
2497 _: ::fidl_next::Slot<'_, Self>,
2498 _: Self::Constraint,
2499 ) -> Result<(), ::fidl_next::ValidationError> {
2500 Ok(())
2501 }
2502 }
2503
2504 unsafe impl ::fidl_next::Wire for DirectoryLinkRequest<'static> {
2505 type Narrowed<'de> = DirectoryLinkRequest<'de>;
2506
2507 #[inline]
2508 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2509 ::fidl_next::munge! {
2510 let Self {
2511 src,
2512 dst_parent_token,
2513 dst,
2514
2515 } = &mut *out_;
2516 }
2517
2518 ::fidl_next::Wire::zero_padding(src);
2519
2520 ::fidl_next::Wire::zero_padding(dst_parent_token);
2521
2522 ::fidl_next::Wire::zero_padding(dst);
2523
2524 unsafe {
2525 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
2526 }
2527 }
2528 }
2529
2530 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryLinkRequest<'de>
2531 where
2532 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2533 ___D: ::fidl_next::Decoder<'de>,
2534 ___D: ::fidl_next::fuchsia::HandleDecoder,
2535 {
2536 fn decode(
2537 slot_: ::fidl_next::Slot<'_, Self>,
2538 decoder_: &mut ___D,
2539 _: (),
2540 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2541 if slot_.as_bytes()[20..24] != [0u8; 4] {
2542 return Err(::fidl_next::DecodeError::InvalidPadding);
2543 }
2544
2545 ::fidl_next::munge! {
2546 let Self {
2547 mut src,
2548 mut dst_parent_token,
2549 mut dst,
2550
2551 } = slot_;
2552 }
2553
2554 let _field = src.as_mut();
2555 ::fidl_next::Constrained::validate(_field, 255)?;
2556 ::fidl_next::Decode::decode(src.as_mut(), decoder_, 255)?;
2557
2558 let src = unsafe { src.deref_unchecked() };
2559
2560 if src.len() > 255 {
2561 return Err(::fidl_next::DecodeError::VectorTooLong {
2562 size: src.len() as u64,
2563 limit: 255,
2564 });
2565 }
2566
2567 let _field = dst_parent_token.as_mut();
2568
2569 ::fidl_next::Decode::decode(dst_parent_token.as_mut(), decoder_, ())?;
2570
2571 let _field = dst.as_mut();
2572 ::fidl_next::Constrained::validate(_field, 255)?;
2573 ::fidl_next::Decode::decode(dst.as_mut(), decoder_, 255)?;
2574
2575 let dst = unsafe { dst.deref_unchecked() };
2576
2577 if dst.len() > 255 {
2578 return Err(::fidl_next::DecodeError::VectorTooLong {
2579 size: dst.len() as u64,
2580 limit: 255,
2581 });
2582 }
2583
2584 Ok(())
2585 }
2586 }
2587
2588 impl<'de> ::fidl_next::IntoNatural for DirectoryLinkRequest<'de> {
2589 type Natural = crate::natural::DirectoryLinkRequest;
2590 }
2591
2592 pub type Token = ::fidl_next::wire::fuchsia::Event;
2594
2595 #[derive(Debug)]
2597 #[repr(C)]
2598 pub struct DirectoryRenameRequest<'de> {
2599 pub src: ::fidl_next::wire::String<'de>,
2600
2601 pub dst_parent_token: ::fidl_next::wire::fuchsia::Event,
2602
2603 pub dst: ::fidl_next::wire::String<'de>,
2604 }
2605
2606 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryRenameRequest<'_>>(), 40);
2607 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryRenameRequest<'_>>(), 8);
2608
2609 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryRenameRequest<'_>, src), 0);
2610
2611 static_assertions::const_assert_eq!(
2612 std::mem::offset_of!(DirectoryRenameRequest<'_>, dst_parent_token),
2613 16
2614 );
2615
2616 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryRenameRequest<'_>, dst), 24);
2617
2618 impl ::fidl_next::Constrained for DirectoryRenameRequest<'_> {
2619 type Constraint = ();
2620
2621 fn validate(
2622 _: ::fidl_next::Slot<'_, Self>,
2623 _: Self::Constraint,
2624 ) -> Result<(), ::fidl_next::ValidationError> {
2625 Ok(())
2626 }
2627 }
2628
2629 unsafe impl ::fidl_next::Wire for DirectoryRenameRequest<'static> {
2630 type Narrowed<'de> = DirectoryRenameRequest<'de>;
2631
2632 #[inline]
2633 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2634 ::fidl_next::munge! {
2635 let Self {
2636 src,
2637 dst_parent_token,
2638 dst,
2639
2640 } = &mut *out_;
2641 }
2642
2643 ::fidl_next::Wire::zero_padding(src);
2644
2645 ::fidl_next::Wire::zero_padding(dst_parent_token);
2646
2647 ::fidl_next::Wire::zero_padding(dst);
2648
2649 unsafe {
2650 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
2651 }
2652 }
2653 }
2654
2655 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryRenameRequest<'de>
2656 where
2657 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2658 ___D: ::fidl_next::Decoder<'de>,
2659 ___D: ::fidl_next::fuchsia::HandleDecoder,
2660 {
2661 fn decode(
2662 slot_: ::fidl_next::Slot<'_, Self>,
2663 decoder_: &mut ___D,
2664 _: (),
2665 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2666 if slot_.as_bytes()[20..24] != [0u8; 4] {
2667 return Err(::fidl_next::DecodeError::InvalidPadding);
2668 }
2669
2670 ::fidl_next::munge! {
2671 let Self {
2672 mut src,
2673 mut dst_parent_token,
2674 mut dst,
2675
2676 } = slot_;
2677 }
2678
2679 let _field = src.as_mut();
2680 ::fidl_next::Constrained::validate(_field, 255)?;
2681 ::fidl_next::Decode::decode(src.as_mut(), decoder_, 255)?;
2682
2683 let src = unsafe { src.deref_unchecked() };
2684
2685 if src.len() > 255 {
2686 return Err(::fidl_next::DecodeError::VectorTooLong {
2687 size: src.len() as u64,
2688 limit: 255,
2689 });
2690 }
2691
2692 let _field = dst_parent_token.as_mut();
2693
2694 ::fidl_next::Decode::decode(dst_parent_token.as_mut(), decoder_, ())?;
2695
2696 let _field = dst.as_mut();
2697 ::fidl_next::Constrained::validate(_field, 255)?;
2698 ::fidl_next::Decode::decode(dst.as_mut(), decoder_, 255)?;
2699
2700 let dst = unsafe { dst.deref_unchecked() };
2701
2702 if dst.len() > 255 {
2703 return Err(::fidl_next::DecodeError::VectorTooLong {
2704 size: dst.len() as u64,
2705 limit: 255,
2706 });
2707 }
2708
2709 Ok(())
2710 }
2711 }
2712
2713 impl<'de> ::fidl_next::IntoNatural for DirectoryRenameRequest<'de> {
2714 type Natural = crate::natural::DirectoryRenameRequest;
2715 }
2716
2717 #[derive(Debug)]
2719 #[repr(C)]
2720 pub struct DirectoryWatchRequest {
2721 pub mask: crate::wire::WatchMask,
2722
2723 pub options: ::fidl_next::wire::Uint32,
2724
2725 pub watcher:
2726 ::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fidl_next::wire::fuchsia::Channel>,
2727 }
2728
2729 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryWatchRequest>(), 12);
2730 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryWatchRequest>(), 4);
2731
2732 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryWatchRequest, mask), 0);
2733
2734 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryWatchRequest, options), 4);
2735
2736 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryWatchRequest, watcher), 8);
2737
2738 impl ::fidl_next::Constrained for DirectoryWatchRequest {
2739 type Constraint = ();
2740
2741 fn validate(
2742 _: ::fidl_next::Slot<'_, Self>,
2743 _: Self::Constraint,
2744 ) -> Result<(), ::fidl_next::ValidationError> {
2745 Ok(())
2746 }
2747 }
2748
2749 unsafe impl ::fidl_next::Wire for DirectoryWatchRequest {
2750 type Narrowed<'de> = DirectoryWatchRequest;
2751
2752 #[inline]
2753 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2754 ::fidl_next::munge! {
2755 let Self {
2756 mask,
2757 options,
2758 watcher,
2759
2760 } = &mut *out_;
2761 }
2762
2763 ::fidl_next::Wire::zero_padding(mask);
2764
2765 ::fidl_next::Wire::zero_padding(options);
2766
2767 ::fidl_next::Wire::zero_padding(watcher);
2768 }
2769 }
2770
2771 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryWatchRequest
2772 where
2773 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2774 ___D: ::fidl_next::fuchsia::HandleDecoder,
2775 {
2776 fn decode(
2777 slot_: ::fidl_next::Slot<'_, Self>,
2778 decoder_: &mut ___D,
2779 _: (),
2780 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2781 ::fidl_next::munge! {
2782 let Self {
2783 mut mask,
2784 mut options,
2785 mut watcher,
2786
2787 } = slot_;
2788 }
2789
2790 let _field = mask.as_mut();
2791
2792 ::fidl_next::Decode::decode(mask.as_mut(), decoder_, ())?;
2793
2794 let _field = options.as_mut();
2795
2796 ::fidl_next::Decode::decode(options.as_mut(), decoder_, ())?;
2797
2798 let _field = watcher.as_mut();
2799
2800 ::fidl_next::Decode::decode(watcher.as_mut(), decoder_, ())?;
2801
2802 Ok(())
2803 }
2804 }
2805
2806 impl ::fidl_next::IntoNatural for DirectoryWatchRequest {
2807 type Natural = crate::natural::DirectoryWatchRequest;
2808 }
2809
2810 #[derive(Debug)]
2812 #[repr(C)]
2813 pub struct NodeListExtendedAttributesRequest {
2814 pub iterator: ::fidl_next::ServerEnd<
2815 crate::ExtendedAttributeIterator,
2816 ::fidl_next::wire::fuchsia::Channel,
2817 >,
2818 }
2819
2820 static_assertions::const_assert_eq!(
2821 std::mem::size_of::<NodeListExtendedAttributesRequest>(),
2822 4
2823 );
2824 static_assertions::const_assert_eq!(
2825 std::mem::align_of::<NodeListExtendedAttributesRequest>(),
2826 4
2827 );
2828
2829 static_assertions::const_assert_eq!(
2830 std::mem::offset_of!(NodeListExtendedAttributesRequest, iterator),
2831 0
2832 );
2833
2834 impl ::fidl_next::Constrained for NodeListExtendedAttributesRequest {
2835 type Constraint = ();
2836
2837 fn validate(
2838 _: ::fidl_next::Slot<'_, Self>,
2839 _: Self::Constraint,
2840 ) -> Result<(), ::fidl_next::ValidationError> {
2841 Ok(())
2842 }
2843 }
2844
2845 unsafe impl ::fidl_next::Wire for NodeListExtendedAttributesRequest {
2846 type Narrowed<'de> = NodeListExtendedAttributesRequest;
2847
2848 #[inline]
2849 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2850 ::fidl_next::munge! {
2851 let Self {
2852 iterator,
2853
2854 } = &mut *out_;
2855 }
2856
2857 ::fidl_next::Wire::zero_padding(iterator);
2858 }
2859 }
2860
2861 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeListExtendedAttributesRequest
2862 where
2863 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2864 ___D: ::fidl_next::fuchsia::HandleDecoder,
2865 {
2866 fn decode(
2867 slot_: ::fidl_next::Slot<'_, Self>,
2868 decoder_: &mut ___D,
2869 _: (),
2870 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2871 ::fidl_next::munge! {
2872 let Self {
2873 mut iterator,
2874
2875 } = slot_;
2876 }
2877
2878 let _field = iterator.as_mut();
2879
2880 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
2881
2882 Ok(())
2883 }
2884 }
2885
2886 impl ::fidl_next::IntoNatural for NodeListExtendedAttributesRequest {
2887 type Natural = crate::natural::NodeListExtendedAttributesRequest;
2888 }
2889
2890 #[repr(transparent)]
2892 pub struct ExtendedAttributeValue<'de> {
2893 pub(crate) raw: ::fidl_next::wire::Union,
2894 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
2895 }
2896
2897 impl<'de> Drop for ExtendedAttributeValue<'de> {
2898 fn drop(&mut self) {
2899 match self.raw.ordinal() {
2900 1 => {
2901 let _ = unsafe {
2902 self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
2903 };
2904 }
2905
2906 2 => {
2907 let _ = unsafe {
2908 self.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::Vmo>()
2909 };
2910 }
2911
2912 _ => (),
2913 }
2914 }
2915 }
2916
2917 impl ::fidl_next::Constrained for ExtendedAttributeValue<'_> {
2918 type Constraint = ();
2919
2920 fn validate(
2921 _: ::fidl_next::Slot<'_, Self>,
2922 _: Self::Constraint,
2923 ) -> Result<(), ::fidl_next::ValidationError> {
2924 Ok(())
2925 }
2926 }
2927
2928 unsafe impl ::fidl_next::Wire for ExtendedAttributeValue<'static> {
2929 type Narrowed<'de> = ExtendedAttributeValue<'de>;
2930
2931 #[inline]
2932 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
2933 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
2934 ::fidl_next::wire::Union::zero_padding(raw);
2935 }
2936 }
2937
2938 pub mod extended_attribute_value {
2939 pub enum Ref<'de> {
2940 Bytes(&'de ::fidl_next::wire::Vector<'de, u8>),
2941
2942 Buffer(&'de ::fidl_next::wire::fuchsia::Vmo),
2943
2944 UnknownOrdinal_(u64),
2945 }
2946 }
2947
2948 impl<'de> ExtendedAttributeValue<'de> {
2949 pub fn as_ref(&self) -> crate::wire::extended_attribute_value::Ref<'_> {
2950 match self.raw.ordinal() {
2951 1 => crate::wire::extended_attribute_value::Ref::Bytes(unsafe {
2952 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
2953 }),
2954
2955 2 => crate::wire::extended_attribute_value::Ref::Buffer(unsafe {
2956 self.raw.get().deref_unchecked::<::fidl_next::wire::fuchsia::Vmo>()
2957 }),
2958
2959 unknown => crate::wire::extended_attribute_value::Ref::UnknownOrdinal_(unknown),
2960 }
2961 }
2962 }
2963
2964 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExtendedAttributeValue<'de>
2965 where
2966 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2967 ___D: ::fidl_next::Decoder<'de>,
2968 ___D: ::fidl_next::fuchsia::HandleDecoder,
2969 {
2970 fn decode(
2971 mut slot: ::fidl_next::Slot<'_, Self>,
2972 decoder: &mut ___D,
2973 _: (),
2974 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2975 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
2976 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
2977 1 => {
2978 ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
2979 raw,
2980 decoder,
2981 (32768, ()),
2982 )?
2983 }
2984
2985 2 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::fuchsia::Vmo>(
2986 raw,
2987 decoder,
2988 (),
2989 )?,
2990
2991 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
2992 }
2993
2994 Ok(())
2995 }
2996 }
2997
2998 impl<'de> ::core::fmt::Debug for ExtendedAttributeValue<'de> {
2999 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3000 match self.raw.ordinal() {
3001 1 => unsafe {
3002 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>().fmt(f)
3003 },
3004 2 => unsafe {
3005 self.raw.get().deref_unchecked::<::fidl_next::wire::fuchsia::Vmo>().fmt(f)
3006 },
3007 _ => unsafe { ::core::hint::unreachable_unchecked() },
3008 }
3009 }
3010 }
3011
3012 impl<'de> ::fidl_next::IntoNatural for ExtendedAttributeValue<'de> {
3013 type Natural = crate::natural::ExtendedAttributeValue;
3014 }
3015
3016 #[derive(Debug)]
3018 #[repr(C)]
3019 pub struct NodeSetExtendedAttributeRequest<'de> {
3020 pub name: ::fidl_next::wire::Vector<'de, u8>,
3021
3022 pub value: crate::wire::ExtendedAttributeValue<'de>,
3023
3024 pub mode: crate::wire::SetExtendedAttributeMode,
3025 }
3026
3027 static_assertions::const_assert_eq!(
3028 std::mem::size_of::<NodeSetExtendedAttributeRequest<'_>>(),
3029 40
3030 );
3031 static_assertions::const_assert_eq!(
3032 std::mem::align_of::<NodeSetExtendedAttributeRequest<'_>>(),
3033 8
3034 );
3035
3036 static_assertions::const_assert_eq!(
3037 std::mem::offset_of!(NodeSetExtendedAttributeRequest<'_>, name),
3038 0
3039 );
3040
3041 static_assertions::const_assert_eq!(
3042 std::mem::offset_of!(NodeSetExtendedAttributeRequest<'_>, value),
3043 16
3044 );
3045
3046 static_assertions::const_assert_eq!(
3047 std::mem::offset_of!(NodeSetExtendedAttributeRequest<'_>, mode),
3048 32
3049 );
3050
3051 impl ::fidl_next::Constrained for NodeSetExtendedAttributeRequest<'_> {
3052 type Constraint = ();
3053
3054 fn validate(
3055 _: ::fidl_next::Slot<'_, Self>,
3056 _: Self::Constraint,
3057 ) -> Result<(), ::fidl_next::ValidationError> {
3058 Ok(())
3059 }
3060 }
3061
3062 unsafe impl ::fidl_next::Wire for NodeSetExtendedAttributeRequest<'static> {
3063 type Narrowed<'de> = NodeSetExtendedAttributeRequest<'de>;
3064
3065 #[inline]
3066 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3067 ::fidl_next::munge! {
3068 let Self {
3069 name,
3070 value,
3071 mode,
3072
3073 } = &mut *out_;
3074 }
3075
3076 ::fidl_next::Wire::zero_padding(name);
3077
3078 ::fidl_next::Wire::zero_padding(value);
3079
3080 ::fidl_next::Wire::zero_padding(mode);
3081
3082 unsafe {
3083 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
3084 }
3085 }
3086 }
3087
3088 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeSetExtendedAttributeRequest<'de>
3089 where
3090 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3091 ___D: ::fidl_next::Decoder<'de>,
3092 ___D: ::fidl_next::fuchsia::HandleDecoder,
3093 {
3094 fn decode(
3095 slot_: ::fidl_next::Slot<'_, Self>,
3096 decoder_: &mut ___D,
3097 _: (),
3098 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3099 if slot_.as_bytes()[36..40] != [0u8; 4] {
3100 return Err(::fidl_next::DecodeError::InvalidPadding);
3101 }
3102
3103 ::fidl_next::munge! {
3104 let Self {
3105 mut name,
3106 mut value,
3107 mut mode,
3108
3109 } = slot_;
3110 }
3111
3112 let _field = name.as_mut();
3113 ::fidl_next::Constrained::validate(_field, (255, ()))?;
3114 ::fidl_next::Decode::decode(name.as_mut(), decoder_, (255, ()))?;
3115
3116 let name = unsafe { name.deref_unchecked() };
3117
3118 if name.len() > 255 {
3119 return Err(::fidl_next::DecodeError::VectorTooLong {
3120 size: name.len() as u64,
3121 limit: 255,
3122 });
3123 }
3124
3125 let _field = value.as_mut();
3126
3127 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
3128
3129 let _field = mode.as_mut();
3130
3131 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
3132
3133 Ok(())
3134 }
3135 }
3136
3137 impl<'de> ::fidl_next::IntoNatural for NodeSetExtendedAttributeRequest<'de> {
3138 type Natural = crate::natural::NodeSetExtendedAttributeRequest;
3139 }
3140
3141 #[repr(C)]
3143 pub struct FileInfo<'de> {
3144 pub(crate) table: ::fidl_next::wire::Table<'de>,
3145 }
3146
3147 impl<'de> Drop for FileInfo<'de> {
3148 fn drop(&mut self) {
3149 let _ = self.table.get(1).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });
3150
3151 let _ = self.table.get(2).map(|envelope| unsafe {
3152 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Event>()
3153 });
3154
3155 let _ = self.table.get(3).map(|envelope| unsafe {
3156 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Stream>()
3157 });
3158
3159 let _ = self.table.get(4).map(|envelope| unsafe {
3160 envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
3161 });
3162 }
3163 }
3164
3165 impl ::fidl_next::Constrained for FileInfo<'_> {
3166 type Constraint = ();
3167
3168 fn validate(
3169 _: ::fidl_next::Slot<'_, Self>,
3170 _: Self::Constraint,
3171 ) -> Result<(), ::fidl_next::ValidationError> {
3172 Ok(())
3173 }
3174 }
3175
3176 unsafe impl ::fidl_next::Wire for FileInfo<'static> {
3177 type Narrowed<'de> = FileInfo<'de>;
3178
3179 #[inline]
3180 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3181 ::fidl_next::munge!(let Self { table } = out);
3182 ::fidl_next::wire::Table::zero_padding(table);
3183 }
3184 }
3185
3186 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for FileInfo<'de>
3187 where
3188 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3189 ___D: ::fidl_next::fuchsia::HandleDecoder,
3190 {
3191 fn decode(
3192 slot: ::fidl_next::Slot<'_, Self>,
3193 decoder: &mut ___D,
3194 _: (),
3195 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3196 ::fidl_next::munge!(let Self { table } = slot);
3197
3198 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3199 match ordinal {
3200 0 => unsafe { ::core::hint::unreachable_unchecked() },
3201
3202 1 => {
3203 ::fidl_next::wire::Envelope::decode_as::<___D, bool>(
3204 slot.as_mut(),
3205 decoder,
3206 (),
3207 )?;
3208
3209 Ok(())
3210 }
3211
3212 2 => {
3213 ::fidl_next::wire::Envelope::decode_as::<
3214 ___D,
3215 ::fidl_next::wire::fuchsia::Event,
3216 >(slot.as_mut(), decoder, ())?;
3217
3218 Ok(())
3219 }
3220
3221 3 => {
3222 ::fidl_next::wire::Envelope::decode_as::<
3223 ___D,
3224 ::fidl_next::wire::fuchsia::Stream,
3225 >(slot.as_mut(), decoder, ())?;
3226
3227 Ok(())
3228 }
3229
3230 4 => {
3231 ::fidl_next::wire::Envelope::decode_as::<
3232 ___D,
3233 crate::wire::NodeAttributes2<'de>,
3234 >(slot.as_mut(), decoder, ())?;
3235
3236 Ok(())
3237 }
3238
3239 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3240 }
3241 })
3242 }
3243 }
3244
3245 impl<'de> FileInfo<'de> {
3246 pub fn is_append(&self) -> ::core::option::Option<&bool> {
3247 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3248 }
3249
3250 pub fn observer(&self) -> ::core::option::Option<&::fidl_next::wire::fuchsia::Event> {
3251 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3252 }
3253
3254 pub fn stream(&self) -> ::core::option::Option<&::fidl_next::wire::fuchsia::Stream> {
3255 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
3256 }
3257
3258 pub fn attributes(&self) -> ::core::option::Option<&crate::wire::NodeAttributes2<'de>> {
3259 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
3260 }
3261 }
3262
3263 impl<'de> ::core::fmt::Debug for FileInfo<'de> {
3264 fn fmt(
3265 &self,
3266 f: &mut ::core::fmt::Formatter<'_>,
3267 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3268 f.debug_struct("FileInfo")
3269 .field("is_append", &self.is_append())
3270 .field("observer", &self.observer())
3271 .field("stream", &self.stream())
3272 .field("attributes", &self.attributes())
3273 .finish()
3274 }
3275 }
3276
3277 impl<'de> ::fidl_next::IntoNatural for FileInfo<'de> {
3278 type Natural = crate::natural::FileInfo;
3279 }
3280
3281 #[repr(transparent)]
3283 pub struct Representation<'de> {
3284 pub(crate) raw: ::fidl_next::wire::Union,
3285 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
3286 }
3287
3288 impl<'de> Drop for Representation<'de> {
3289 fn drop(&mut self) {
3290 match self.raw.ordinal() {
3291 1 => {
3292 let _ =
3293 unsafe { self.raw.get().read_unchecked::<crate::wire::NodeInfo<'de>>() };
3294 }
3295
3296 2 => {
3297 let _ = unsafe {
3298 self.raw.get().read_unchecked::<crate::wire::DirectoryInfo<'de>>()
3299 };
3300 }
3301
3302 3 => {
3303 let _ =
3304 unsafe { self.raw.get().read_unchecked::<crate::wire::FileInfo<'de>>() };
3305 }
3306
3307 4 => {
3308 let _ =
3309 unsafe { self.raw.get().read_unchecked::<crate::wire::SymlinkInfo<'de>>() };
3310 }
3311
3312 _ => (),
3313 }
3314 }
3315 }
3316
3317 impl ::fidl_next::Constrained for Representation<'_> {
3318 type Constraint = ();
3319
3320 fn validate(
3321 _: ::fidl_next::Slot<'_, Self>,
3322 _: Self::Constraint,
3323 ) -> Result<(), ::fidl_next::ValidationError> {
3324 Ok(())
3325 }
3326 }
3327
3328 unsafe impl ::fidl_next::Wire for Representation<'static> {
3329 type Narrowed<'de> = Representation<'de>;
3330
3331 #[inline]
3332 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3333 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
3334 ::fidl_next::wire::Union::zero_padding(raw);
3335 }
3336 }
3337
3338 pub mod representation {
3339 pub enum Ref<'de> {
3340 Node(&'de crate::wire::NodeInfo<'de>),
3341
3342 Directory(&'de crate::wire::DirectoryInfo<'de>),
3343
3344 File(&'de crate::wire::FileInfo<'de>),
3345
3346 Symlink(&'de crate::wire::SymlinkInfo<'de>),
3347
3348 UnknownOrdinal_(u64),
3349 }
3350 }
3351
3352 impl<'de> Representation<'de> {
3353 pub fn as_ref(&self) -> crate::wire::representation::Ref<'_> {
3354 match self.raw.ordinal() {
3355 1 => crate::wire::representation::Ref::Node(unsafe {
3356 self.raw.get().deref_unchecked::<crate::wire::NodeInfo<'_>>()
3357 }),
3358
3359 2 => crate::wire::representation::Ref::Directory(unsafe {
3360 self.raw.get().deref_unchecked::<crate::wire::DirectoryInfo<'_>>()
3361 }),
3362
3363 3 => crate::wire::representation::Ref::File(unsafe {
3364 self.raw.get().deref_unchecked::<crate::wire::FileInfo<'_>>()
3365 }),
3366
3367 4 => crate::wire::representation::Ref::Symlink(unsafe {
3368 self.raw.get().deref_unchecked::<crate::wire::SymlinkInfo<'_>>()
3369 }),
3370
3371 unknown => crate::wire::representation::Ref::UnknownOrdinal_(unknown),
3372 }
3373 }
3374 }
3375
3376 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Representation<'de>
3377 where
3378 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3379 ___D: ::fidl_next::Decoder<'de>,
3380 ___D: ::fidl_next::fuchsia::HandleDecoder,
3381 {
3382 fn decode(
3383 mut slot: ::fidl_next::Slot<'_, Self>,
3384 decoder: &mut ___D,
3385 _: (),
3386 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3387 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
3388 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
3389 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::NodeInfo<'de>>(
3390 raw,
3391 decoder,
3392 (),
3393 )?,
3394
3395 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirectoryInfo<'de>>(
3396 raw,
3397 decoder,
3398 (),
3399 )?,
3400
3401 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::FileInfo<'de>>(
3402 raw,
3403 decoder,
3404 (),
3405 )?,
3406
3407 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SymlinkInfo<'de>>(
3408 raw,
3409 decoder,
3410 (),
3411 )?,
3412
3413 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
3414 }
3415
3416 Ok(())
3417 }
3418 }
3419
3420 impl<'de> ::core::fmt::Debug for Representation<'de> {
3421 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3422 match self.raw.ordinal() {
3423 1 => unsafe {
3424 self.raw.get().deref_unchecked::<crate::wire::NodeInfo<'_>>().fmt(f)
3425 },
3426 2 => unsafe {
3427 self.raw.get().deref_unchecked::<crate::wire::DirectoryInfo<'_>>().fmt(f)
3428 },
3429 3 => unsafe {
3430 self.raw.get().deref_unchecked::<crate::wire::FileInfo<'_>>().fmt(f)
3431 },
3432 4 => unsafe {
3433 self.raw.get().deref_unchecked::<crate::wire::SymlinkInfo<'_>>().fmt(f)
3434 },
3435 _ => unsafe { ::core::hint::unreachable_unchecked() },
3436 }
3437 }
3438 }
3439
3440 impl<'de> ::fidl_next::IntoNatural for Representation<'de> {
3441 type Natural = crate::natural::Representation;
3442 }
3443
3444 #[derive(Debug)]
3446 #[repr(C)]
3447 pub struct OpenableOpenRequest<'de> {
3448 pub path: ::fidl_next::wire::String<'de>,
3449
3450 pub flags: crate::wire::Flags,
3451
3452 pub options: crate::wire::Options<'de>,
3453
3454 pub object: ::fidl_next::wire::fuchsia::Channel,
3455 }
3456
3457 static_assertions::const_assert_eq!(std::mem::size_of::<OpenableOpenRequest<'_>>(), 48);
3458 static_assertions::const_assert_eq!(std::mem::align_of::<OpenableOpenRequest<'_>>(), 8);
3459
3460 static_assertions::const_assert_eq!(std::mem::offset_of!(OpenableOpenRequest<'_>, path), 0);
3461
3462 static_assertions::const_assert_eq!(std::mem::offset_of!(OpenableOpenRequest<'_>, flags), 16);
3463
3464 static_assertions::const_assert_eq!(std::mem::offset_of!(OpenableOpenRequest<'_>, options), 24);
3465
3466 static_assertions::const_assert_eq!(std::mem::offset_of!(OpenableOpenRequest<'_>, object), 40);
3467
3468 impl ::fidl_next::Constrained for OpenableOpenRequest<'_> {
3469 type Constraint = ();
3470
3471 fn validate(
3472 _: ::fidl_next::Slot<'_, Self>,
3473 _: Self::Constraint,
3474 ) -> Result<(), ::fidl_next::ValidationError> {
3475 Ok(())
3476 }
3477 }
3478
3479 unsafe impl ::fidl_next::Wire for OpenableOpenRequest<'static> {
3480 type Narrowed<'de> = OpenableOpenRequest<'de>;
3481
3482 #[inline]
3483 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3484 ::fidl_next::munge! {
3485 let Self {
3486 path,
3487 flags,
3488 options,
3489 object,
3490
3491 } = &mut *out_;
3492 }
3493
3494 ::fidl_next::Wire::zero_padding(path);
3495
3496 ::fidl_next::Wire::zero_padding(flags);
3497
3498 ::fidl_next::Wire::zero_padding(options);
3499
3500 ::fidl_next::Wire::zero_padding(object);
3501
3502 unsafe {
3503 out_.as_mut_ptr().cast::<u8>().add(44).write_bytes(0, 4);
3504 }
3505 }
3506 }
3507
3508 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for OpenableOpenRequest<'de>
3509 where
3510 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3511 ___D: ::fidl_next::Decoder<'de>,
3512 ___D: ::fidl_next::fuchsia::HandleDecoder,
3513 {
3514 fn decode(
3515 slot_: ::fidl_next::Slot<'_, Self>,
3516 decoder_: &mut ___D,
3517 _: (),
3518 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3519 if slot_.as_bytes()[44..48] != [0u8; 4] {
3520 return Err(::fidl_next::DecodeError::InvalidPadding);
3521 }
3522
3523 ::fidl_next::munge! {
3524 let Self {
3525 mut path,
3526 mut flags,
3527 mut options,
3528 mut object,
3529
3530 } = slot_;
3531 }
3532
3533 let _field = path.as_mut();
3534 ::fidl_next::Constrained::validate(_field, 4095)?;
3535 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
3536
3537 let path = unsafe { path.deref_unchecked() };
3538
3539 if path.len() > 4095 {
3540 return Err(::fidl_next::DecodeError::VectorTooLong {
3541 size: path.len() as u64,
3542 limit: 4095,
3543 });
3544 }
3545
3546 let _field = flags.as_mut();
3547
3548 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
3549
3550 let _field = options.as_mut();
3551
3552 ::fidl_next::Decode::decode(options.as_mut(), decoder_, ())?;
3553
3554 let _field = object.as_mut();
3555
3556 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
3557
3558 Ok(())
3559 }
3560 }
3561
3562 impl<'de> ::fidl_next::IntoNatural for OpenableOpenRequest<'de> {
3563 type Natural = crate::natural::OpenableOpenRequest;
3564 }
3565
3566 #[derive(Debug)]
3568 #[repr(C)]
3569 pub struct NodeDeprecatedCloneRequest {
3570 pub flags: crate::wire::OpenFlags,
3571
3572 pub object: ::fidl_next::ServerEnd<crate::Node, ::fidl_next::wire::fuchsia::Channel>,
3573 }
3574
3575 static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedCloneRequest>(), 8);
3576 static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedCloneRequest>(), 4);
3577
3578 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeDeprecatedCloneRequest, flags), 0);
3579
3580 static_assertions::const_assert_eq!(
3581 std::mem::offset_of!(NodeDeprecatedCloneRequest, object),
3582 4
3583 );
3584
3585 impl ::fidl_next::Constrained for NodeDeprecatedCloneRequest {
3586 type Constraint = ();
3587
3588 fn validate(
3589 _: ::fidl_next::Slot<'_, Self>,
3590 _: Self::Constraint,
3591 ) -> Result<(), ::fidl_next::ValidationError> {
3592 Ok(())
3593 }
3594 }
3595
3596 unsafe impl ::fidl_next::Wire for NodeDeprecatedCloneRequest {
3597 type Narrowed<'de> = NodeDeprecatedCloneRequest;
3598
3599 #[inline]
3600 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3601 ::fidl_next::munge! {
3602 let Self {
3603 flags,
3604 object,
3605
3606 } = &mut *out_;
3607 }
3608
3609 ::fidl_next::Wire::zero_padding(flags);
3610
3611 ::fidl_next::Wire::zero_padding(object);
3612 }
3613 }
3614
3615 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedCloneRequest
3616 where
3617 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3618 ___D: ::fidl_next::fuchsia::HandleDecoder,
3619 {
3620 fn decode(
3621 slot_: ::fidl_next::Slot<'_, Self>,
3622 decoder_: &mut ___D,
3623 _: (),
3624 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3625 ::fidl_next::munge! {
3626 let Self {
3627 mut flags,
3628 mut object,
3629
3630 } = slot_;
3631 }
3632
3633 let _field = flags.as_mut();
3634
3635 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
3636
3637 let _field = object.as_mut();
3638
3639 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
3640
3641 Ok(())
3642 }
3643 }
3644
3645 impl ::fidl_next::IntoNatural for NodeDeprecatedCloneRequest {
3646 type Natural = crate::natural::NodeDeprecatedCloneRequest;
3647 }
3648
3649 #[derive(Debug)]
3651 #[repr(C)]
3652 pub struct NodeOnOpenRequest<'de> {
3653 pub s: ::fidl_next::wire::fuchsia::Status,
3654
3655 pub info: crate::wire_optional::NodeInfoDeprecated<'de>,
3656 }
3657
3658 static_assertions::const_assert_eq!(std::mem::size_of::<NodeOnOpenRequest<'_>>(), 24);
3659 static_assertions::const_assert_eq!(std::mem::align_of::<NodeOnOpenRequest<'_>>(), 8);
3660
3661 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeOnOpenRequest<'_>, s), 0);
3662
3663 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeOnOpenRequest<'_>, info), 8);
3664
3665 impl ::fidl_next::Constrained for NodeOnOpenRequest<'_> {
3666 type Constraint = ();
3667
3668 fn validate(
3669 _: ::fidl_next::Slot<'_, Self>,
3670 _: Self::Constraint,
3671 ) -> Result<(), ::fidl_next::ValidationError> {
3672 Ok(())
3673 }
3674 }
3675
3676 unsafe impl ::fidl_next::Wire for NodeOnOpenRequest<'static> {
3677 type Narrowed<'de> = NodeOnOpenRequest<'de>;
3678
3679 #[inline]
3680 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3681 ::fidl_next::munge! {
3682 let Self {
3683 s,
3684 info,
3685
3686 } = &mut *out_;
3687 }
3688
3689 ::fidl_next::Wire::zero_padding(s);
3690
3691 ::fidl_next::Wire::zero_padding(info);
3692
3693 unsafe {
3694 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
3695 }
3696 }
3697 }
3698
3699 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeOnOpenRequest<'de>
3700 where
3701 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3702 ___D: ::fidl_next::Decoder<'de>,
3703 ___D: ::fidl_next::fuchsia::HandleDecoder,
3704 {
3705 fn decode(
3706 slot_: ::fidl_next::Slot<'_, Self>,
3707 decoder_: &mut ___D,
3708 _: (),
3709 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3710 if slot_.as_bytes()[4..8] != [0u8; 4] {
3711 return Err(::fidl_next::DecodeError::InvalidPadding);
3712 }
3713
3714 ::fidl_next::munge! {
3715 let Self {
3716 mut s,
3717 mut info,
3718
3719 } = slot_;
3720 }
3721
3722 let _field = s.as_mut();
3723
3724 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
3725
3726 let _field = info.as_mut();
3727
3728 ::fidl_next::Decode::decode(info.as_mut(), decoder_, ())?;
3729
3730 Ok(())
3731 }
3732 }
3733
3734 impl<'de> ::fidl_next::IntoNatural for NodeOnOpenRequest<'de> {
3735 type Natural = crate::natural::NodeOnOpenRequest;
3736 }
3737
3738 #[derive(Debug)]
3740 #[repr(C)]
3741 pub struct DirectoryDeprecatedOpenRequest<'de> {
3742 pub flags: crate::wire::OpenFlags,
3743
3744 pub mode: crate::wire::ModeType,
3745
3746 pub path: ::fidl_next::wire::String<'de>,
3747
3748 pub object: ::fidl_next::ServerEnd<crate::Node, ::fidl_next::wire::fuchsia::Channel>,
3749 }
3750
3751 static_assertions::const_assert_eq!(
3752 std::mem::size_of::<DirectoryDeprecatedOpenRequest<'_>>(),
3753 32
3754 );
3755 static_assertions::const_assert_eq!(
3756 std::mem::align_of::<DirectoryDeprecatedOpenRequest<'_>>(),
3757 8
3758 );
3759
3760 static_assertions::const_assert_eq!(
3761 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, flags),
3762 0
3763 );
3764
3765 static_assertions::const_assert_eq!(
3766 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, mode),
3767 4
3768 );
3769
3770 static_assertions::const_assert_eq!(
3771 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, path),
3772 8
3773 );
3774
3775 static_assertions::const_assert_eq!(
3776 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, object),
3777 24
3778 );
3779
3780 impl ::fidl_next::Constrained for DirectoryDeprecatedOpenRequest<'_> {
3781 type Constraint = ();
3782
3783 fn validate(
3784 _: ::fidl_next::Slot<'_, Self>,
3785 _: Self::Constraint,
3786 ) -> Result<(), ::fidl_next::ValidationError> {
3787 Ok(())
3788 }
3789 }
3790
3791 unsafe impl ::fidl_next::Wire for DirectoryDeprecatedOpenRequest<'static> {
3792 type Narrowed<'de> = DirectoryDeprecatedOpenRequest<'de>;
3793
3794 #[inline]
3795 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3796 ::fidl_next::munge! {
3797 let Self {
3798 flags,
3799 mode,
3800 path,
3801 object,
3802
3803 } = &mut *out_;
3804 }
3805
3806 ::fidl_next::Wire::zero_padding(flags);
3807
3808 ::fidl_next::Wire::zero_padding(mode);
3809
3810 ::fidl_next::Wire::zero_padding(path);
3811
3812 ::fidl_next::Wire::zero_padding(object);
3813
3814 unsafe {
3815 out_.as_mut_ptr().cast::<u8>().add(28).write_bytes(0, 4);
3816 }
3817 }
3818 }
3819
3820 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryDeprecatedOpenRequest<'de>
3821 where
3822 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3823 ___D: ::fidl_next::Decoder<'de>,
3824 ___D: ::fidl_next::fuchsia::HandleDecoder,
3825 {
3826 fn decode(
3827 slot_: ::fidl_next::Slot<'_, Self>,
3828 decoder_: &mut ___D,
3829 _: (),
3830 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3831 if slot_.as_bytes()[28..32] != [0u8; 4] {
3832 return Err(::fidl_next::DecodeError::InvalidPadding);
3833 }
3834
3835 ::fidl_next::munge! {
3836 let Self {
3837 mut flags,
3838 mut mode,
3839 mut path,
3840 mut object,
3841
3842 } = slot_;
3843 }
3844
3845 let _field = flags.as_mut();
3846
3847 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
3848
3849 let _field = mode.as_mut();
3850
3851 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
3852
3853 let _field = path.as_mut();
3854 ::fidl_next::Constrained::validate(_field, 4095)?;
3855 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
3856
3857 let path = unsafe { path.deref_unchecked() };
3858
3859 if path.len() > 4095 {
3860 return Err(::fidl_next::DecodeError::VectorTooLong {
3861 size: path.len() as u64,
3862 limit: 4095,
3863 });
3864 }
3865
3866 let _field = object.as_mut();
3867
3868 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
3869
3870 Ok(())
3871 }
3872 }
3873
3874 impl<'de> ::fidl_next::IntoNatural for DirectoryDeprecatedOpenRequest<'de> {
3875 type Natural = crate::natural::DirectoryDeprecatedOpenRequest;
3876 }
3877
3878 #[derive(Debug)]
3880 #[repr(C)]
3881 pub struct DirectoryCreateSymlinkRequest<'de> {
3882 pub name: ::fidl_next::wire::String<'de>,
3883
3884 pub target: ::fidl_next::wire::Vector<'de, u8>,
3885
3886 pub connection:
3887 ::fidl_next::ServerEnd<crate::Symlink, ::fidl_next::wire::fuchsia::OptionalChannel>,
3888 }
3889
3890 static_assertions::const_assert_eq!(
3891 std::mem::size_of::<DirectoryCreateSymlinkRequest<'_>>(),
3892 40
3893 );
3894 static_assertions::const_assert_eq!(
3895 std::mem::align_of::<DirectoryCreateSymlinkRequest<'_>>(),
3896 8
3897 );
3898
3899 static_assertions::const_assert_eq!(
3900 std::mem::offset_of!(DirectoryCreateSymlinkRequest<'_>, name),
3901 0
3902 );
3903
3904 static_assertions::const_assert_eq!(
3905 std::mem::offset_of!(DirectoryCreateSymlinkRequest<'_>, target),
3906 16
3907 );
3908
3909 static_assertions::const_assert_eq!(
3910 std::mem::offset_of!(DirectoryCreateSymlinkRequest<'_>, connection),
3911 32
3912 );
3913
3914 impl ::fidl_next::Constrained for DirectoryCreateSymlinkRequest<'_> {
3915 type Constraint = ();
3916
3917 fn validate(
3918 _: ::fidl_next::Slot<'_, Self>,
3919 _: Self::Constraint,
3920 ) -> Result<(), ::fidl_next::ValidationError> {
3921 Ok(())
3922 }
3923 }
3924
3925 unsafe impl ::fidl_next::Wire for DirectoryCreateSymlinkRequest<'static> {
3926 type Narrowed<'de> = DirectoryCreateSymlinkRequest<'de>;
3927
3928 #[inline]
3929 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3930 ::fidl_next::munge! {
3931 let Self {
3932 name,
3933 target,
3934 connection,
3935
3936 } = &mut *out_;
3937 }
3938
3939 ::fidl_next::Wire::zero_padding(name);
3940
3941 ::fidl_next::Wire::zero_padding(target);
3942
3943 ::fidl_next::Wire::zero_padding(connection);
3944
3945 unsafe {
3946 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
3947 }
3948 }
3949 }
3950
3951 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryCreateSymlinkRequest<'de>
3952 where
3953 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3954 ___D: ::fidl_next::Decoder<'de>,
3955 ___D: ::fidl_next::fuchsia::HandleDecoder,
3956 {
3957 fn decode(
3958 slot_: ::fidl_next::Slot<'_, Self>,
3959 decoder_: &mut ___D,
3960 _: (),
3961 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3962 if slot_.as_bytes()[36..40] != [0u8; 4] {
3963 return Err(::fidl_next::DecodeError::InvalidPadding);
3964 }
3965
3966 ::fidl_next::munge! {
3967 let Self {
3968 mut name,
3969 mut target,
3970 mut connection,
3971
3972 } = slot_;
3973 }
3974
3975 let _field = name.as_mut();
3976 ::fidl_next::Constrained::validate(_field, 255)?;
3977 ::fidl_next::Decode::decode(name.as_mut(), decoder_, 255)?;
3978
3979 let name = unsafe { name.deref_unchecked() };
3980
3981 if name.len() > 255 {
3982 return Err(::fidl_next::DecodeError::VectorTooLong {
3983 size: name.len() as u64,
3984 limit: 255,
3985 });
3986 }
3987
3988 let _field = target.as_mut();
3989 ::fidl_next::Constrained::validate(_field, (4095, ()))?;
3990 ::fidl_next::Decode::decode(target.as_mut(), decoder_, (4095, ()))?;
3991
3992 let target = unsafe { target.deref_unchecked() };
3993
3994 if target.len() > 4095 {
3995 return Err(::fidl_next::DecodeError::VectorTooLong {
3996 size: target.len() as u64,
3997 limit: 4095,
3998 });
3999 }
4000
4001 let _field = connection.as_mut();
4002
4003 ::fidl_next::Decode::decode(connection.as_mut(), decoder_, ())?;
4004
4005 Ok(())
4006 }
4007 }
4008
4009 impl<'de> ::fidl_next::IntoNatural for DirectoryCreateSymlinkRequest<'de> {
4010 type Natural = crate::natural::DirectoryCreateSymlinkRequest;
4011 }
4012
4013 #[derive(Debug)]
4015 #[repr(C)]
4016 pub struct FileGetBackingMemoryResponse {
4017 pub vmo: ::fidl_next::wire::fuchsia::Vmo,
4018 }
4019
4020 static_assertions::const_assert_eq!(std::mem::size_of::<FileGetBackingMemoryResponse>(), 4);
4021 static_assertions::const_assert_eq!(std::mem::align_of::<FileGetBackingMemoryResponse>(), 4);
4022
4023 static_assertions::const_assert_eq!(std::mem::offset_of!(FileGetBackingMemoryResponse, vmo), 0);
4024
4025 impl ::fidl_next::Constrained for FileGetBackingMemoryResponse {
4026 type Constraint = ();
4027
4028 fn validate(
4029 _: ::fidl_next::Slot<'_, Self>,
4030 _: Self::Constraint,
4031 ) -> Result<(), ::fidl_next::ValidationError> {
4032 Ok(())
4033 }
4034 }
4035
4036 unsafe impl ::fidl_next::Wire for FileGetBackingMemoryResponse {
4037 type Narrowed<'de> = FileGetBackingMemoryResponse;
4038
4039 #[inline]
4040 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4041 ::fidl_next::munge! {
4042 let Self {
4043 vmo,
4044
4045 } = &mut *out_;
4046 }
4047
4048 ::fidl_next::Wire::zero_padding(vmo);
4049 }
4050 }
4051
4052 unsafe impl<___D> ::fidl_next::Decode<___D> for FileGetBackingMemoryResponse
4053 where
4054 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4055 ___D: ::fidl_next::fuchsia::HandleDecoder,
4056 {
4057 fn decode(
4058 slot_: ::fidl_next::Slot<'_, Self>,
4059 decoder_: &mut ___D,
4060 _: (),
4061 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4062 ::fidl_next::munge! {
4063 let Self {
4064 mut vmo,
4065
4066 } = slot_;
4067 }
4068
4069 let _field = vmo.as_mut();
4070
4071 ::fidl_next::Decode::decode(vmo.as_mut(), decoder_, ())?;
4072
4073 Ok(())
4074 }
4075 }
4076
4077 impl ::fidl_next::IntoNatural for FileGetBackingMemoryResponse {
4078 type Natural = crate::natural::FileGetBackingMemoryResponse;
4079 }
4080
4081 #[derive(Debug)]
4083 #[repr(C)]
4084 pub struct LinkableLinkIntoRequest<'de> {
4085 pub dst_parent_token: ::fidl_next::wire::fuchsia::Event,
4086
4087 pub dst: ::fidl_next::wire::String<'de>,
4088 }
4089
4090 static_assertions::const_assert_eq!(std::mem::size_of::<LinkableLinkIntoRequest<'_>>(), 24);
4091 static_assertions::const_assert_eq!(std::mem::align_of::<LinkableLinkIntoRequest<'_>>(), 8);
4092
4093 static_assertions::const_assert_eq!(
4094 std::mem::offset_of!(LinkableLinkIntoRequest<'_>, dst_parent_token),
4095 0
4096 );
4097
4098 static_assertions::const_assert_eq!(std::mem::offset_of!(LinkableLinkIntoRequest<'_>, dst), 8);
4099
4100 impl ::fidl_next::Constrained for LinkableLinkIntoRequest<'_> {
4101 type Constraint = ();
4102
4103 fn validate(
4104 _: ::fidl_next::Slot<'_, Self>,
4105 _: Self::Constraint,
4106 ) -> Result<(), ::fidl_next::ValidationError> {
4107 Ok(())
4108 }
4109 }
4110
4111 unsafe impl ::fidl_next::Wire for LinkableLinkIntoRequest<'static> {
4112 type Narrowed<'de> = LinkableLinkIntoRequest<'de>;
4113
4114 #[inline]
4115 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4116 ::fidl_next::munge! {
4117 let Self {
4118 dst_parent_token,
4119 dst,
4120
4121 } = &mut *out_;
4122 }
4123
4124 ::fidl_next::Wire::zero_padding(dst_parent_token);
4125
4126 ::fidl_next::Wire::zero_padding(dst);
4127
4128 unsafe {
4129 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
4130 }
4131 }
4132 }
4133
4134 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for LinkableLinkIntoRequest<'de>
4135 where
4136 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4137 ___D: ::fidl_next::Decoder<'de>,
4138 ___D: ::fidl_next::fuchsia::HandleDecoder,
4139 {
4140 fn decode(
4141 slot_: ::fidl_next::Slot<'_, Self>,
4142 decoder_: &mut ___D,
4143 _: (),
4144 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4145 if slot_.as_bytes()[4..8] != [0u8; 4] {
4146 return Err(::fidl_next::DecodeError::InvalidPadding);
4147 }
4148
4149 ::fidl_next::munge! {
4150 let Self {
4151 mut dst_parent_token,
4152 mut dst,
4153
4154 } = slot_;
4155 }
4156
4157 let _field = dst_parent_token.as_mut();
4158
4159 ::fidl_next::Decode::decode(dst_parent_token.as_mut(), decoder_, ())?;
4160
4161 let _field = dst.as_mut();
4162 ::fidl_next::Constrained::validate(_field, 255)?;
4163 ::fidl_next::Decode::decode(dst.as_mut(), decoder_, 255)?;
4164
4165 let dst = unsafe { dst.deref_unchecked() };
4166
4167 if dst.len() > 255 {
4168 return Err(::fidl_next::DecodeError::VectorTooLong {
4169 size: dst.len() as u64,
4170 limit: 255,
4171 });
4172 }
4173
4174 Ok(())
4175 }
4176 }
4177
4178 impl<'de> ::fidl_next::IntoNatural for LinkableLinkIntoRequest<'de> {
4179 type Natural = crate::natural::LinkableLinkIntoRequest;
4180 }
4181
4182 #[derive(Debug)]
4184 #[repr(C)]
4185 pub struct FileAllocateRequest {
4186 pub offset: ::fidl_next::wire::Uint64,
4187
4188 pub length: ::fidl_next::wire::Uint64,
4189
4190 pub mode: crate::wire::AllocateMode,
4191 }
4192
4193 static_assertions::const_assert_eq!(std::mem::size_of::<FileAllocateRequest>(), 24);
4194 static_assertions::const_assert_eq!(std::mem::align_of::<FileAllocateRequest>(), 8);
4195
4196 static_assertions::const_assert_eq!(std::mem::offset_of!(FileAllocateRequest, offset), 0);
4197
4198 static_assertions::const_assert_eq!(std::mem::offset_of!(FileAllocateRequest, length), 8);
4199
4200 static_assertions::const_assert_eq!(std::mem::offset_of!(FileAllocateRequest, mode), 16);
4201
4202 impl ::fidl_next::Constrained for FileAllocateRequest {
4203 type Constraint = ();
4204
4205 fn validate(
4206 _: ::fidl_next::Slot<'_, Self>,
4207 _: Self::Constraint,
4208 ) -> Result<(), ::fidl_next::ValidationError> {
4209 Ok(())
4210 }
4211 }
4212
4213 unsafe impl ::fidl_next::Wire for FileAllocateRequest {
4214 type Narrowed<'de> = FileAllocateRequest;
4215
4216 #[inline]
4217 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4218 ::fidl_next::munge! {
4219 let Self {
4220 offset,
4221 length,
4222 mode,
4223
4224 } = &mut *out_;
4225 }
4226
4227 ::fidl_next::Wire::zero_padding(offset);
4228
4229 ::fidl_next::Wire::zero_padding(length);
4230
4231 ::fidl_next::Wire::zero_padding(mode);
4232
4233 unsafe {
4234 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
4235 }
4236 }
4237 }
4238
4239 unsafe impl<___D> ::fidl_next::Decode<___D> for FileAllocateRequest
4240 where
4241 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4242 ___D: ::fidl_next::fuchsia::HandleDecoder,
4243 {
4244 fn decode(
4245 slot_: ::fidl_next::Slot<'_, Self>,
4246 decoder_: &mut ___D,
4247 _: (),
4248 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4249 if slot_.as_bytes()[20..24] != [0u8; 4] {
4250 return Err(::fidl_next::DecodeError::InvalidPadding);
4251 }
4252
4253 ::fidl_next::munge! {
4254 let Self {
4255 mut offset,
4256 mut length,
4257 mut mode,
4258
4259 } = slot_;
4260 }
4261
4262 let _field = offset.as_mut();
4263
4264 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
4265
4266 let _field = length.as_mut();
4267
4268 ::fidl_next::Decode::decode(length.as_mut(), decoder_, ())?;
4269
4270 let _field = mode.as_mut();
4271
4272 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
4273
4274 Ok(())
4275 }
4276 }
4277
4278 impl ::fidl_next::IntoNatural for FileAllocateRequest {
4279 type Natural = crate::natural::FileAllocateRequest;
4280 }
4281
4282 #[derive(Debug)]
4284 #[repr(C)]
4285 pub struct FileEnableVerityRequest<'de> {
4286 pub options: crate::wire::VerificationOptions<'de>,
4287 }
4288
4289 static_assertions::const_assert_eq!(std::mem::size_of::<FileEnableVerityRequest<'_>>(), 16);
4290 static_assertions::const_assert_eq!(std::mem::align_of::<FileEnableVerityRequest<'_>>(), 8);
4291
4292 static_assertions::const_assert_eq!(
4293 std::mem::offset_of!(FileEnableVerityRequest<'_>, options),
4294 0
4295 );
4296
4297 impl ::fidl_next::Constrained for FileEnableVerityRequest<'_> {
4298 type Constraint = ();
4299
4300 fn validate(
4301 _: ::fidl_next::Slot<'_, Self>,
4302 _: Self::Constraint,
4303 ) -> Result<(), ::fidl_next::ValidationError> {
4304 Ok(())
4305 }
4306 }
4307
4308 unsafe impl ::fidl_next::Wire for FileEnableVerityRequest<'static> {
4309 type Narrowed<'de> = FileEnableVerityRequest<'de>;
4310
4311 #[inline]
4312 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4313 ::fidl_next::munge! {
4314 let Self {
4315 options,
4316
4317 } = &mut *out_;
4318 }
4319
4320 ::fidl_next::Wire::zero_padding(options);
4321 }
4322 }
4323
4324 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for FileEnableVerityRequest<'de>
4325 where
4326 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4327 ___D: ::fidl_next::Decoder<'de>,
4328 ___D: ::fidl_next::fuchsia::HandleDecoder,
4329 {
4330 fn decode(
4331 slot_: ::fidl_next::Slot<'_, Self>,
4332 decoder_: &mut ___D,
4333 _: (),
4334 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4335 ::fidl_next::munge! {
4336 let Self {
4337 mut options,
4338
4339 } = slot_;
4340 }
4341
4342 let _field = options.as_mut();
4343
4344 ::fidl_next::Decode::decode(options.as_mut(), decoder_, ())?;
4345
4346 Ok(())
4347 }
4348 }
4349
4350 impl<'de> ::fidl_next::IntoNatural for FileEnableVerityRequest<'de> {
4351 type Natural = crate::natural::FileEnableVerityRequest;
4352 }
4353
4354 #[derive(Debug)]
4356 #[repr(C)]
4357 pub struct FileObject {
4358 pub event: ::fidl_next::wire::fuchsia::OptionalEvent,
4359
4360 pub stream: ::fidl_next::wire::fuchsia::OptionalStream,
4361 }
4362
4363 static_assertions::const_assert_eq!(std::mem::size_of::<FileObject>(), 8);
4364 static_assertions::const_assert_eq!(std::mem::align_of::<FileObject>(), 4);
4365
4366 static_assertions::const_assert_eq!(std::mem::offset_of!(FileObject, event), 0);
4367
4368 static_assertions::const_assert_eq!(std::mem::offset_of!(FileObject, stream), 4);
4369
4370 impl ::fidl_next::Constrained for FileObject {
4371 type Constraint = ();
4372
4373 fn validate(
4374 _: ::fidl_next::Slot<'_, Self>,
4375 _: Self::Constraint,
4376 ) -> Result<(), ::fidl_next::ValidationError> {
4377 Ok(())
4378 }
4379 }
4380
4381 unsafe impl ::fidl_next::Wire for FileObject {
4382 type Narrowed<'de> = FileObject;
4383
4384 #[inline]
4385 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4386 ::fidl_next::munge! {
4387 let Self {
4388 event,
4389 stream,
4390
4391 } = &mut *out_;
4392 }
4393
4394 ::fidl_next::Wire::zero_padding(event);
4395
4396 ::fidl_next::Wire::zero_padding(stream);
4397 }
4398 }
4399
4400 unsafe impl<___D> ::fidl_next::Decode<___D> for FileObject
4401 where
4402 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4403 ___D: ::fidl_next::fuchsia::HandleDecoder,
4404 {
4405 fn decode(
4406 slot_: ::fidl_next::Slot<'_, Self>,
4407 decoder_: &mut ___D,
4408 _: (),
4409 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4410 ::fidl_next::munge! {
4411 let Self {
4412 mut event,
4413 mut stream,
4414
4415 } = slot_;
4416 }
4417
4418 let _field = event.as_mut();
4419
4420 ::fidl_next::Decode::decode(event.as_mut(), decoder_, ())?;
4421
4422 let _field = stream.as_mut();
4423
4424 ::fidl_next::Decode::decode(stream.as_mut(), decoder_, ())?;
4425
4426 Ok(())
4427 }
4428 }
4429
4430 impl ::fidl_next::IntoNatural for FileObject {
4431 type Natural = crate::natural::FileObject;
4432 }
4433
4434 #[repr(transparent)]
4436 pub struct NodeInfoDeprecated<'de> {
4437 pub(crate) raw: ::fidl_next::wire::Union,
4438 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4439 }
4440
4441 impl<'de> Drop for NodeInfoDeprecated<'de> {
4442 fn drop(&mut self) {
4443 match self.raw.ordinal() {
4444 1 => {
4445 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Service>() };
4446 }
4447
4448 2 => {
4449 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::FileObject>() };
4450 }
4451
4452 3 => {
4453 let _ =
4454 unsafe { self.raw.get().read_unchecked::<crate::wire::DirectoryObject>() };
4455 }
4456
4457 4 => {
4458 let _ = unsafe {
4459 self.raw.get().read_unchecked::<crate::wire::SymlinkObject<'de>>()
4460 };
4461 }
4462
4463 _ => unsafe { ::core::hint::unreachable_unchecked() },
4464 }
4465 }
4466 }
4467
4468 impl ::fidl_next::Constrained for NodeInfoDeprecated<'_> {
4469 type Constraint = ();
4470
4471 fn validate(
4472 _: ::fidl_next::Slot<'_, Self>,
4473 _: Self::Constraint,
4474 ) -> Result<(), ::fidl_next::ValidationError> {
4475 Ok(())
4476 }
4477 }
4478
4479 unsafe impl ::fidl_next::Wire for NodeInfoDeprecated<'static> {
4480 type Narrowed<'de> = NodeInfoDeprecated<'de>;
4481
4482 #[inline]
4483 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4484 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4485 ::fidl_next::wire::Union::zero_padding(raw);
4486 }
4487 }
4488
4489 pub mod node_info_deprecated {
4490 pub enum Ref<'de> {
4491 Service(&'de crate::wire::Service),
4492
4493 File(&'de crate::wire::FileObject),
4494
4495 Directory(&'de crate::wire::DirectoryObject),
4496
4497 Symlink(&'de crate::wire::SymlinkObject<'de>),
4498 }
4499 }
4500
4501 impl<'de> NodeInfoDeprecated<'de> {
4502 pub fn as_ref(&self) -> crate::wire::node_info_deprecated::Ref<'_> {
4503 match self.raw.ordinal() {
4504 1 => crate::wire::node_info_deprecated::Ref::Service(unsafe {
4505 self.raw.get().deref_unchecked::<crate::wire::Service>()
4506 }),
4507
4508 2 => crate::wire::node_info_deprecated::Ref::File(unsafe {
4509 self.raw.get().deref_unchecked::<crate::wire::FileObject>()
4510 }),
4511
4512 3 => crate::wire::node_info_deprecated::Ref::Directory(unsafe {
4513 self.raw.get().deref_unchecked::<crate::wire::DirectoryObject>()
4514 }),
4515
4516 4 => crate::wire::node_info_deprecated::Ref::Symlink(unsafe {
4517 self.raw.get().deref_unchecked::<crate::wire::SymlinkObject<'_>>()
4518 }),
4519
4520 _ => unsafe { ::core::hint::unreachable_unchecked() },
4521 }
4522 }
4523 }
4524
4525 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeInfoDeprecated<'de>
4526 where
4527 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4528 ___D: ::fidl_next::Decoder<'de>,
4529 ___D: ::fidl_next::fuchsia::HandleDecoder,
4530 {
4531 fn decode(
4532 mut slot: ::fidl_next::Slot<'_, Self>,
4533 decoder: &mut ___D,
4534 _: (),
4535 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4536 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4537 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4538 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Service>(
4539 raw,
4540 decoder,
4541 (),
4542 )?,
4543
4544 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::FileObject>(
4545 raw,
4546 decoder,
4547 (),
4548 )?,
4549
4550 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirectoryObject>(
4551 raw,
4552 decoder,
4553 (),
4554 )?,
4555
4556 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SymlinkObject<'de>>(
4557 raw,
4558 decoder,
4559 (),
4560 )?,
4561
4562 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
4563 }
4564
4565 Ok(())
4566 }
4567 }
4568
4569 impl<'de> ::core::fmt::Debug for NodeInfoDeprecated<'de> {
4570 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4571 match self.raw.ordinal() {
4572 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Service>().fmt(f) },
4573 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::FileObject>().fmt(f) },
4574 3 => unsafe {
4575 self.raw.get().deref_unchecked::<crate::wire::DirectoryObject>().fmt(f)
4576 },
4577 4 => unsafe {
4578 self.raw.get().deref_unchecked::<crate::wire::SymlinkObject<'_>>().fmt(f)
4579 },
4580 _ => unsafe { ::core::hint::unreachable_unchecked() },
4581 }
4582 }
4583 }
4584
4585 impl<'de> ::fidl_next::IntoNatural for NodeInfoDeprecated<'de> {
4586 type Natural = crate::natural::NodeInfoDeprecated;
4587 }
4588}
4589
4590pub mod wire_optional {
4591
4592 pub use fidl_next_common_fuchsia_io::wire_optional::*;
4593
4594 #[repr(transparent)]
4595 pub struct ExtendedAttributeValue<'de> {
4596 pub(crate) raw: ::fidl_next::wire::Union,
4597 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4598 }
4599
4600 impl ::fidl_next::Constrained for ExtendedAttributeValue<'_> {
4601 type Constraint = ();
4602
4603 fn validate(
4604 _: ::fidl_next::Slot<'_, Self>,
4605 _: Self::Constraint,
4606 ) -> Result<(), ::fidl_next::ValidationError> {
4607 Ok(())
4608 }
4609 }
4610
4611 unsafe impl ::fidl_next::Wire for ExtendedAttributeValue<'static> {
4612 type Narrowed<'de> = ExtendedAttributeValue<'de>;
4613
4614 #[inline]
4615 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4616 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4617 ::fidl_next::wire::Union::zero_padding(raw);
4618 }
4619 }
4620
4621 impl<'de> ExtendedAttributeValue<'de> {
4622 pub fn is_some(&self) -> bool {
4623 self.raw.is_some()
4624 }
4625
4626 pub fn is_none(&self) -> bool {
4627 self.raw.is_none()
4628 }
4629
4630 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::ExtendedAttributeValue<'de>> {
4631 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
4632 }
4633
4634 pub fn into_option(
4635 self,
4636 ) -> ::core::option::Option<crate::wire::ExtendedAttributeValue<'de>> {
4637 if self.is_some() {
4638 Some(crate::wire::ExtendedAttributeValue {
4639 raw: self.raw,
4640 _phantom: ::core::marker::PhantomData,
4641 })
4642 } else {
4643 None
4644 }
4645 }
4646 }
4647
4648 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExtendedAttributeValue<'de>
4649 where
4650 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4651 ___D: ::fidl_next::Decoder<'de>,
4652 ___D: ::fidl_next::fuchsia::HandleDecoder,
4653 {
4654 fn decode(
4655 mut slot: ::fidl_next::Slot<'_, Self>,
4656 decoder: &mut ___D,
4657 _: (),
4658 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4659 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4660 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4661 1 => {
4662 ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
4663 raw,
4664 decoder,
4665 (32768, ()),
4666 )?
4667 }
4668
4669 2 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::fuchsia::Vmo>(
4670 raw,
4671 decoder,
4672 (),
4673 )?,
4674
4675 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
4676 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4677 }
4678
4679 Ok(())
4680 }
4681 }
4682
4683 impl<'de> ::core::fmt::Debug for ExtendedAttributeValue<'de> {
4684 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4685 self.as_ref().fmt(f)
4686 }
4687 }
4688
4689 impl<'de> ::fidl_next::IntoNatural for ExtendedAttributeValue<'de> {
4690 type Natural = ::core::option::Option<crate::natural::ExtendedAttributeValue>;
4691 }
4692
4693 #[repr(transparent)]
4694 pub struct Representation<'de> {
4695 pub(crate) raw: ::fidl_next::wire::Union,
4696 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4697 }
4698
4699 impl ::fidl_next::Constrained for Representation<'_> {
4700 type Constraint = ();
4701
4702 fn validate(
4703 _: ::fidl_next::Slot<'_, Self>,
4704 _: Self::Constraint,
4705 ) -> Result<(), ::fidl_next::ValidationError> {
4706 Ok(())
4707 }
4708 }
4709
4710 unsafe impl ::fidl_next::Wire for Representation<'static> {
4711 type Narrowed<'de> = Representation<'de>;
4712
4713 #[inline]
4714 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4715 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4716 ::fidl_next::wire::Union::zero_padding(raw);
4717 }
4718 }
4719
4720 impl<'de> Representation<'de> {
4721 pub fn is_some(&self) -> bool {
4722 self.raw.is_some()
4723 }
4724
4725 pub fn is_none(&self) -> bool {
4726 self.raw.is_none()
4727 }
4728
4729 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Representation<'de>> {
4730 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
4731 }
4732
4733 pub fn into_option(self) -> ::core::option::Option<crate::wire::Representation<'de>> {
4734 if self.is_some() {
4735 Some(crate::wire::Representation {
4736 raw: self.raw,
4737 _phantom: ::core::marker::PhantomData,
4738 })
4739 } else {
4740 None
4741 }
4742 }
4743 }
4744
4745 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Representation<'de>
4746 where
4747 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4748 ___D: ::fidl_next::Decoder<'de>,
4749 ___D: ::fidl_next::fuchsia::HandleDecoder,
4750 {
4751 fn decode(
4752 mut slot: ::fidl_next::Slot<'_, Self>,
4753 decoder: &mut ___D,
4754 _: (),
4755 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4756 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4757 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4758 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::NodeInfo<'de>>(
4759 raw,
4760 decoder,
4761 (),
4762 )?,
4763
4764 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirectoryInfo<'de>>(
4765 raw,
4766 decoder,
4767 (),
4768 )?,
4769
4770 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::FileInfo<'de>>(
4771 raw,
4772 decoder,
4773 (),
4774 )?,
4775
4776 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SymlinkInfo<'de>>(
4777 raw,
4778 decoder,
4779 (),
4780 )?,
4781
4782 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
4783 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4784 }
4785
4786 Ok(())
4787 }
4788 }
4789
4790 impl<'de> ::core::fmt::Debug for Representation<'de> {
4791 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4792 self.as_ref().fmt(f)
4793 }
4794 }
4795
4796 impl<'de> ::fidl_next::IntoNatural for Representation<'de> {
4797 type Natural = ::core::option::Option<crate::natural::Representation>;
4798 }
4799
4800 #[repr(transparent)]
4801 pub struct NodeInfoDeprecated<'de> {
4802 pub(crate) raw: ::fidl_next::wire::Union,
4803 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4804 }
4805
4806 impl ::fidl_next::Constrained for NodeInfoDeprecated<'_> {
4807 type Constraint = ();
4808
4809 fn validate(
4810 _: ::fidl_next::Slot<'_, Self>,
4811 _: Self::Constraint,
4812 ) -> Result<(), ::fidl_next::ValidationError> {
4813 Ok(())
4814 }
4815 }
4816
4817 unsafe impl ::fidl_next::Wire for NodeInfoDeprecated<'static> {
4818 type Narrowed<'de> = NodeInfoDeprecated<'de>;
4819
4820 #[inline]
4821 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4822 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4823 ::fidl_next::wire::Union::zero_padding(raw);
4824 }
4825 }
4826
4827 impl<'de> NodeInfoDeprecated<'de> {
4828 pub fn is_some(&self) -> bool {
4829 self.raw.is_some()
4830 }
4831
4832 pub fn is_none(&self) -> bool {
4833 self.raw.is_none()
4834 }
4835
4836 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::NodeInfoDeprecated<'de>> {
4837 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
4838 }
4839
4840 pub fn into_option(self) -> ::core::option::Option<crate::wire::NodeInfoDeprecated<'de>> {
4841 if self.is_some() {
4842 Some(crate::wire::NodeInfoDeprecated {
4843 raw: self.raw,
4844 _phantom: ::core::marker::PhantomData,
4845 })
4846 } else {
4847 None
4848 }
4849 }
4850 }
4851
4852 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeInfoDeprecated<'de>
4853 where
4854 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4855 ___D: ::fidl_next::Decoder<'de>,
4856 ___D: ::fidl_next::fuchsia::HandleDecoder,
4857 {
4858 fn decode(
4859 mut slot: ::fidl_next::Slot<'_, Self>,
4860 decoder: &mut ___D,
4861 _: (),
4862 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4863 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4864 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4865 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Service>(
4866 raw,
4867 decoder,
4868 (),
4869 )?,
4870
4871 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::FileObject>(
4872 raw,
4873 decoder,
4874 (),
4875 )?,
4876
4877 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirectoryObject>(
4878 raw,
4879 decoder,
4880 (),
4881 )?,
4882
4883 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SymlinkObject<'de>>(
4884 raw,
4885 decoder,
4886 (),
4887 )?,
4888
4889 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
4890 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4891 }
4892
4893 Ok(())
4894 }
4895 }
4896
4897 impl<'de> ::core::fmt::Debug for NodeInfoDeprecated<'de> {
4898 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4899 self.as_ref().fmt(f)
4900 }
4901 }
4902
4903 impl<'de> ::fidl_next::IntoNatural for NodeInfoDeprecated<'de> {
4904 type Natural = ::core::option::Option<crate::natural::NodeInfoDeprecated>;
4905 }
4906}
4907
4908pub mod generic {
4909
4910 pub use fidl_next_common_fuchsia_io::generic::*;
4911
4912 pub struct DirectoryGetTokenResponse<T0, T1> {
4914 pub s: T0,
4915
4916 pub token: T1,
4917 }
4918
4919 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DirectoryGetTokenResponse, ___E>
4920 for DirectoryGetTokenResponse<T0, T1>
4921 where
4922 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4923 ___E: ::fidl_next::fuchsia::HandleEncoder,
4924 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
4925 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalNullableHandle, ___E>,
4926 {
4927 #[inline]
4928 fn encode(
4929 self,
4930 encoder_: &mut ___E,
4931 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryGetTokenResponse>,
4932 _: (),
4933 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4934 ::fidl_next::munge! {
4935 let crate::wire::DirectoryGetTokenResponse {
4936 s,
4937 token,
4938
4939 } = out_;
4940 }
4941
4942 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
4943
4944 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
4945
4946 Ok(())
4947 }
4948 }
4949
4950 pub struct DirectoryLinkRequest<T0, T1, T2> {
4952 pub src: T0,
4953
4954 pub dst_parent_token: T1,
4955
4956 pub dst: T2,
4957 }
4958
4959 unsafe impl<___E, T0, T1, T2>
4960 ::fidl_next::Encode<crate::wire::DirectoryLinkRequest<'static>, ___E>
4961 for DirectoryLinkRequest<T0, T1, T2>
4962 where
4963 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4964 ___E: ::fidl_next::Encoder,
4965 ___E: ::fidl_next::fuchsia::HandleEncoder,
4966 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
4967 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::NullableHandle, ___E>,
4968 T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
4969 {
4970 #[inline]
4971 fn encode(
4972 self,
4973 encoder_: &mut ___E,
4974 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkRequest<'static>>,
4975 _: (),
4976 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4977 ::fidl_next::munge! {
4978 let crate::wire::DirectoryLinkRequest {
4979 src,
4980 dst_parent_token,
4981 dst,
4982
4983 } = out_;
4984 }
4985
4986 ::fidl_next::Encode::encode(self.src, encoder_, src, 255)?;
4987
4988 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
4989
4990 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
4991
4992 Ok(())
4993 }
4994 }
4995
4996 pub struct DirectoryRenameRequest<T0, T1, T2> {
4998 pub src: T0,
4999
5000 pub dst_parent_token: T1,
5001
5002 pub dst: T2,
5003 }
5004
5005 unsafe impl<___E, T0, T1, T2>
5006 ::fidl_next::Encode<crate::wire::DirectoryRenameRequest<'static>, ___E>
5007 for DirectoryRenameRequest<T0, T1, T2>
5008 where
5009 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5010 ___E: ::fidl_next::Encoder,
5011 ___E: ::fidl_next::fuchsia::HandleEncoder,
5012 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5013 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
5014 T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5015 {
5016 #[inline]
5017 fn encode(
5018 self,
5019 encoder_: &mut ___E,
5020 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRenameRequest<'static>>,
5021 _: (),
5022 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5023 ::fidl_next::munge! {
5024 let crate::wire::DirectoryRenameRequest {
5025 src,
5026 dst_parent_token,
5027 dst,
5028
5029 } = out_;
5030 }
5031
5032 ::fidl_next::Encode::encode(self.src, encoder_, src, 255)?;
5033
5034 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
5035
5036 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
5037
5038 Ok(())
5039 }
5040 }
5041
5042 pub struct DirectoryWatchRequest<T0, T1, T2> {
5044 pub mask: T0,
5045
5046 pub options: T1,
5047
5048 pub watcher: T2,
5049 }
5050
5051 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::DirectoryWatchRequest, ___E>
5052 for DirectoryWatchRequest<T0, T1, T2>
5053 where
5054 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5055 ___E: ::fidl_next::fuchsia::HandleEncoder,
5056 T0: ::fidl_next::Encode<crate::wire::WatchMask, ___E>,
5057 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
5058 T2: ::fidl_next::Encode<
5059 ::fidl_next::ServerEnd<
5060 crate::DirectoryWatcher,
5061 ::fidl_next::wire::fuchsia::Channel,
5062 >,
5063 ___E,
5064 >,
5065 {
5066 #[inline]
5067 fn encode(
5068 self,
5069 encoder_: &mut ___E,
5070 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchRequest>,
5071 _: (),
5072 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5073 ::fidl_next::munge! {
5074 let crate::wire::DirectoryWatchRequest {
5075 mask,
5076 options,
5077 watcher,
5078
5079 } = out_;
5080 }
5081
5082 ::fidl_next::Encode::encode(self.mask, encoder_, mask, ())?;
5083
5084 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
5085
5086 ::fidl_next::Encode::encode(self.watcher, encoder_, watcher, ())?;
5087
5088 Ok(())
5089 }
5090 }
5091
5092 pub struct NodeListExtendedAttributesRequest<T0> {
5094 pub iterator: T0,
5095 }
5096
5097 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeListExtendedAttributesRequest, ___E>
5098 for NodeListExtendedAttributesRequest<T0>
5099 where
5100 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5101 ___E: ::fidl_next::fuchsia::HandleEncoder,
5102 T0: ::fidl_next::Encode<
5103 ::fidl_next::ServerEnd<
5104 crate::ExtendedAttributeIterator,
5105 ::fidl_next::wire::fuchsia::Channel,
5106 >,
5107 ___E,
5108 >,
5109 {
5110 #[inline]
5111 fn encode(
5112 self,
5113 encoder_: &mut ___E,
5114 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeListExtendedAttributesRequest>,
5115 _: (),
5116 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5117 ::fidl_next::munge! {
5118 let crate::wire::NodeListExtendedAttributesRequest {
5119 iterator,
5120
5121 } = out_;
5122 }
5123
5124 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
5125
5126 Ok(())
5127 }
5128 }
5129
5130 pub struct NodeSetExtendedAttributeRequest<T0, T1, T2> {
5132 pub name: T0,
5133
5134 pub value: T1,
5135
5136 pub mode: T2,
5137 }
5138
5139 unsafe impl<___E, T0, T1, T2>
5140 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeRequest<'static>, ___E>
5141 for NodeSetExtendedAttributeRequest<T0, T1, T2>
5142 where
5143 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5144 ___E: ::fidl_next::Encoder,
5145 ___E: ::fidl_next::fuchsia::HandleEncoder,
5146 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
5147 T1: ::fidl_next::Encode<crate::wire::ExtendedAttributeValue<'static>, ___E>,
5148 T2: ::fidl_next::Encode<crate::wire::SetExtendedAttributeMode, ___E>,
5149 {
5150 #[inline]
5151 fn encode(
5152 self,
5153 encoder_: &mut ___E,
5154 out_: &mut ::core::mem::MaybeUninit<
5155 crate::wire::NodeSetExtendedAttributeRequest<'static>,
5156 >,
5157 _: (),
5158 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5159 ::fidl_next::munge! {
5160 let crate::wire::NodeSetExtendedAttributeRequest {
5161 name,
5162 value,
5163 mode,
5164
5165 } = out_;
5166 }
5167
5168 ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
5169
5170 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
5171
5172 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
5173
5174 Ok(())
5175 }
5176 }
5177
5178 pub struct OpenableOpenRequest<T0, T1, T2, T3> {
5180 pub path: T0,
5181
5182 pub flags: T1,
5183
5184 pub options: T2,
5185
5186 pub object: T3,
5187 }
5188
5189 unsafe impl<___E, T0, T1, T2, T3>
5190 ::fidl_next::Encode<crate::wire::OpenableOpenRequest<'static>, ___E>
5191 for OpenableOpenRequest<T0, T1, T2, T3>
5192 where
5193 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5194 ___E: ::fidl_next::Encoder,
5195 ___E: ::fidl_next::fuchsia::HandleEncoder,
5196 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5197 T1: ::fidl_next::Encode<crate::wire::Flags, ___E>,
5198 T2: ::fidl_next::Encode<crate::wire::Options<'static>, ___E>,
5199 T3: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>,
5200 {
5201 #[inline]
5202 fn encode(
5203 self,
5204 encoder_: &mut ___E,
5205 out_: &mut ::core::mem::MaybeUninit<crate::wire::OpenableOpenRequest<'static>>,
5206 _: (),
5207 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5208 ::fidl_next::munge! {
5209 let crate::wire::OpenableOpenRequest {
5210 path,
5211 flags,
5212 options,
5213 object,
5214
5215 } = out_;
5216 }
5217
5218 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
5219
5220 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
5221
5222 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
5223
5224 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
5225
5226 Ok(())
5227 }
5228 }
5229
5230 pub struct NodeDeprecatedCloneRequest<T0, T1> {
5232 pub flags: T0,
5233
5234 pub object: T1,
5235 }
5236
5237 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeDeprecatedCloneRequest, ___E>
5238 for NodeDeprecatedCloneRequest<T0, T1>
5239 where
5240 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5241 ___E: ::fidl_next::fuchsia::HandleEncoder,
5242 T0: ::fidl_next::Encode<crate::wire::OpenFlags, ___E>,
5243 T1: ::fidl_next::Encode<
5244 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::wire::fuchsia::Channel>,
5245 ___E,
5246 >,
5247 {
5248 #[inline]
5249 fn encode(
5250 self,
5251 encoder_: &mut ___E,
5252 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedCloneRequest>,
5253 _: (),
5254 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5255 ::fidl_next::munge! {
5256 let crate::wire::NodeDeprecatedCloneRequest {
5257 flags,
5258 object,
5259
5260 } = out_;
5261 }
5262
5263 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
5264
5265 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
5266
5267 Ok(())
5268 }
5269 }
5270
5271 pub struct NodeOnOpenRequest<T0, T1> {
5273 pub s: T0,
5274
5275 pub info: T1,
5276 }
5277
5278 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeOnOpenRequest<'static>, ___E>
5279 for NodeOnOpenRequest<T0, T1>
5280 where
5281 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5282 ___E: ::fidl_next::Encoder,
5283 ___E: ::fidl_next::fuchsia::HandleEncoder,
5284 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
5285 T1: ::fidl_next::Encode<crate::wire_optional::NodeInfoDeprecated<'static>, ___E>,
5286 {
5287 #[inline]
5288 fn encode(
5289 self,
5290 encoder_: &mut ___E,
5291 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeOnOpenRequest<'static>>,
5292 _: (),
5293 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5294 ::fidl_next::munge! {
5295 let crate::wire::NodeOnOpenRequest {
5296 s,
5297 info,
5298
5299 } = out_;
5300 }
5301
5302 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
5303
5304 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
5305
5306 Ok(())
5307 }
5308 }
5309
5310 pub struct DirectoryDeprecatedOpenRequest<T0, T1, T2, T3> {
5312 pub flags: T0,
5313
5314 pub mode: T1,
5315
5316 pub path: T2,
5317
5318 pub object: T3,
5319 }
5320
5321 unsafe impl<___E, T0, T1, T2, T3>
5322 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedOpenRequest<'static>, ___E>
5323 for DirectoryDeprecatedOpenRequest<T0, T1, T2, T3>
5324 where
5325 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5326 ___E: ::fidl_next::Encoder,
5327 ___E: ::fidl_next::fuchsia::HandleEncoder,
5328 T0: ::fidl_next::Encode<crate::wire::OpenFlags, ___E>,
5329 T1: ::fidl_next::Encode<crate::wire::ModeType, ___E>,
5330 T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5331 T3: ::fidl_next::Encode<
5332 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::wire::fuchsia::Channel>,
5333 ___E,
5334 >,
5335 {
5336 #[inline]
5337 fn encode(
5338 self,
5339 encoder_: &mut ___E,
5340 out_: &mut ::core::mem::MaybeUninit<
5341 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
5342 >,
5343 _: (),
5344 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5345 ::fidl_next::munge! {
5346 let crate::wire::DirectoryDeprecatedOpenRequest {
5347 flags,
5348 mode,
5349 path,
5350 object,
5351
5352 } = out_;
5353 }
5354
5355 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
5356
5357 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
5358
5359 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
5360
5361 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
5362
5363 Ok(())
5364 }
5365 }
5366
5367 pub struct DirectoryCreateSymlinkRequest<T0, T1, T2> {
5369 pub name: T0,
5370
5371 pub target: T1,
5372
5373 pub connection: T2,
5374 }
5375
5376 unsafe impl<___E, T0, T1, T2>
5377 ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkRequest<'static>, ___E>
5378 for DirectoryCreateSymlinkRequest<T0, T1, T2>
5379 where
5380 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5381 ___E: ::fidl_next::Encoder,
5382 ___E: ::fidl_next::fuchsia::HandleEncoder,
5383 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5384 T1: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
5385 T2: ::fidl_next::Encode<
5386 ::fidl_next::ServerEnd<crate::Symlink, ::fidl_next::wire::fuchsia::OptionalChannel>,
5387 ___E,
5388 >,
5389 {
5390 #[inline]
5391 fn encode(
5392 self,
5393 encoder_: &mut ___E,
5394 out_: &mut ::core::mem::MaybeUninit<
5395 crate::wire::DirectoryCreateSymlinkRequest<'static>,
5396 >,
5397 _: (),
5398 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5399 ::fidl_next::munge! {
5400 let crate::wire::DirectoryCreateSymlinkRequest {
5401 name,
5402 target,
5403 connection,
5404
5405 } = out_;
5406 }
5407
5408 ::fidl_next::Encode::encode(self.name, encoder_, name, 255)?;
5409
5410 ::fidl_next::Encode::encode(self.target, encoder_, target, (4095, ()))?;
5411
5412 ::fidl_next::Encode::encode(self.connection, encoder_, connection, ())?;
5413
5414 Ok(())
5415 }
5416 }
5417
5418 pub struct FileGetBackingMemoryResponse<T0> {
5420 pub vmo: T0,
5421 }
5422
5423 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryResponse, ___E>
5424 for FileGetBackingMemoryResponse<T0>
5425 where
5426 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5427 ___E: ::fidl_next::fuchsia::HandleEncoder,
5428 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>,
5429 {
5430 #[inline]
5431 fn encode(
5432 self,
5433 encoder_: &mut ___E,
5434 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryResponse>,
5435 _: (),
5436 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5437 ::fidl_next::munge! {
5438 let crate::wire::FileGetBackingMemoryResponse {
5439 vmo,
5440
5441 } = out_;
5442 }
5443
5444 ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
5445
5446 Ok(())
5447 }
5448 }
5449
5450 pub struct LinkableLinkIntoRequest<T0, T1> {
5452 pub dst_parent_token: T0,
5453
5454 pub dst: T1,
5455 }
5456
5457 unsafe impl<___E, T0, T1>
5458 ::fidl_next::Encode<crate::wire::LinkableLinkIntoRequest<'static>, ___E>
5459 for LinkableLinkIntoRequest<T0, T1>
5460 where
5461 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5462 ___E: ::fidl_next::Encoder,
5463 ___E: ::fidl_next::fuchsia::HandleEncoder,
5464 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
5465 T1: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5466 {
5467 #[inline]
5468 fn encode(
5469 self,
5470 encoder_: &mut ___E,
5471 out_: &mut ::core::mem::MaybeUninit<crate::wire::LinkableLinkIntoRequest<'static>>,
5472 _: (),
5473 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5474 ::fidl_next::munge! {
5475 let crate::wire::LinkableLinkIntoRequest {
5476 dst_parent_token,
5477 dst,
5478
5479 } = out_;
5480 }
5481
5482 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
5483
5484 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
5485
5486 Ok(())
5487 }
5488 }
5489
5490 pub struct FileAllocateRequest<T0, T1, T2> {
5492 pub offset: T0,
5493
5494 pub length: T1,
5495
5496 pub mode: T2,
5497 }
5498
5499 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::FileAllocateRequest, ___E>
5500 for FileAllocateRequest<T0, T1, T2>
5501 where
5502 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5503 ___E: ::fidl_next::fuchsia::HandleEncoder,
5504 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
5505 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
5506 T2: ::fidl_next::Encode<crate::wire::AllocateMode, ___E>,
5507 {
5508 #[inline]
5509 fn encode(
5510 self,
5511 encoder_: &mut ___E,
5512 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileAllocateRequest>,
5513 _: (),
5514 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5515 ::fidl_next::munge! {
5516 let crate::wire::FileAllocateRequest {
5517 offset,
5518 length,
5519 mode,
5520
5521 } = out_;
5522 }
5523
5524 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
5525
5526 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
5527
5528 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
5529
5530 Ok(())
5531 }
5532 }
5533
5534 pub struct FileEnableVerityRequest<T0> {
5536 pub options: T0,
5537 }
5538
5539 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileEnableVerityRequest<'static>, ___E>
5540 for FileEnableVerityRequest<T0>
5541 where
5542 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5543 ___E: ::fidl_next::Encoder,
5544 ___E: ::fidl_next::fuchsia::HandleEncoder,
5545 T0: ::fidl_next::Encode<crate::wire::VerificationOptions<'static>, ___E>,
5546 {
5547 #[inline]
5548 fn encode(
5549 self,
5550 encoder_: &mut ___E,
5551 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileEnableVerityRequest<'static>>,
5552 _: (),
5553 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5554 ::fidl_next::munge! {
5555 let crate::wire::FileEnableVerityRequest {
5556 options,
5557
5558 } = out_;
5559 }
5560
5561 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
5562
5563 Ok(())
5564 }
5565 }
5566
5567 pub struct FileObject<T0, T1> {
5569 pub event: T0,
5570
5571 pub stream: T1,
5572 }
5573
5574 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::FileObject, ___E> for FileObject<T0, T1>
5575 where
5576 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5577 ___E: ::fidl_next::fuchsia::HandleEncoder,
5578 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalEvent, ___E>,
5579 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalStream, ___E>,
5580 {
5581 #[inline]
5582 fn encode(
5583 self,
5584 encoder_: &mut ___E,
5585 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileObject>,
5586 _: (),
5587 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5588 ::fidl_next::munge! {
5589 let crate::wire::FileObject {
5590 event,
5591 stream,
5592
5593 } = out_;
5594 }
5595
5596 ::fidl_next::Encode::encode(self.event, encoder_, event, ())?;
5597
5598 ::fidl_next::Encode::encode(self.stream, encoder_, stream, ())?;
5599
5600 Ok(())
5601 }
5602 }
5603}
5604
5605pub use self::natural::*;
5606
5607#[doc = " Openable defines a node which is capable of opening other objects.\n"]
5609#[derive(PartialEq, Debug)]
5610pub struct Openable;
5611
5612#[cfg(target_os = "fuchsia")]
5613impl ::fidl_next::HasTransport for Openable {
5614 type Transport = ::fidl_next::fuchsia::zx::Channel;
5615}
5616
5617pub mod openable {
5618 pub mod prelude {
5619 pub use crate::{
5620 Openable, OpenableClientHandler, OpenableLocalClientHandler,
5621 OpenableLocalServerHandler, OpenableServerHandler, openable,
5622 };
5623
5624 pub use crate::natural::OpenableOpenRequest;
5625 }
5626
5627 pub struct Open;
5628
5629 impl ::fidl_next::Method for Open {
5630 const ORDINAL: u64 = 6236883748953765593;
5631 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5632 ::fidl_next::protocol::Flexibility::Flexible;
5633
5634 type Protocol = crate::Openable;
5635
5636 type Request = crate::wire::OpenableOpenRequest<'static>;
5637 }
5638
5639 mod ___detail {
5640 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Openable
5641 where
5642 ___T: ::fidl_next::Transport,
5643 {
5644 type Client = OpenableClient<___T>;
5645 type Server = OpenableServer<___T>;
5646 }
5647
5648 #[repr(transparent)]
5650 pub struct OpenableClient<___T: ::fidl_next::Transport> {
5651 #[allow(dead_code)]
5652 client: ::fidl_next::protocol::Client<___T>,
5653 }
5654
5655 impl<___T> OpenableClient<___T>
5656 where
5657 ___T: ::fidl_next::Transport,
5658 {
5659 #[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"]
5660 pub fn open(
5661 &self,
5662
5663 path: impl ::fidl_next::Encode<
5664 ::fidl_next::wire::String<'static>,
5665 <___T as ::fidl_next::Transport>::SendBuffer,
5666 >,
5667
5668 flags: impl ::fidl_next::Encode<
5669 crate::wire::Flags,
5670 <___T as ::fidl_next::Transport>::SendBuffer,
5671 >,
5672
5673 options: impl ::fidl_next::Encode<
5674 crate::wire::Options<'static>,
5675 <___T as ::fidl_next::Transport>::SendBuffer,
5676 >,
5677
5678 object: impl ::fidl_next::Encode<
5679 ::fidl_next::wire::fuchsia::Channel,
5680 <___T as ::fidl_next::Transport>::SendBuffer,
5681 >,
5682 ) -> ::fidl_next::SendFuture<'_, ___T>
5683 where
5684 <___T as ::fidl_next::Transport>::SendBuffer:
5685 ::fidl_next::encoder::InternalHandleEncoder,
5686 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
5687 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
5688 {
5689 self.open_with(crate::generic::OpenableOpenRequest { path, flags, options, object })
5690 }
5691
5692 #[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"]
5693 pub fn open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
5694 where
5695 ___R: ::fidl_next::Encode<
5696 crate::wire::OpenableOpenRequest<'static>,
5697 <___T as ::fidl_next::Transport>::SendBuffer,
5698 >,
5699 {
5700 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
5701 6236883748953765593,
5702 <super::Open as ::fidl_next::Method>::FLEXIBILITY,
5703 request,
5704 ))
5705 }
5706 }
5707
5708 #[repr(transparent)]
5710 pub struct OpenableServer<___T: ::fidl_next::Transport> {
5711 server: ::fidl_next::protocol::Server<___T>,
5712 }
5713
5714 impl<___T> OpenableServer<___T> where ___T: ::fidl_next::Transport {}
5715 }
5716}
5717
5718#[diagnostic::on_unimplemented(
5719 note = "If {Self} implements the non-local OpenableClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
5720)]
5721
5722pub trait OpenableLocalClientHandler<
5726 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5727 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5728>
5729{
5730 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
5731 ::core::future::ready(())
5732 }
5733}
5734
5735impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Openable
5736where
5737 ___H: OpenableLocalClientHandler<___T>,
5738 ___T: ::fidl_next::Transport,
5739{
5740 async fn on_event(
5741 handler: &mut ___H,
5742 mut message: ::fidl_next::Message<___T>,
5743 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5744 match *message.header().ordinal {
5745 ordinal => {
5746 handler.on_unknown_interaction(ordinal).await;
5747 if ::core::matches!(
5748 message.header().flexibility(),
5749 ::fidl_next::protocol::Flexibility::Strict
5750 ) {
5751 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5752 } else {
5753 Ok(())
5754 }
5755 }
5756 }
5757 }
5758}
5759
5760#[diagnostic::on_unimplemented(
5761 note = "If {Self} implements the non-local OpenableServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
5762)]
5763
5764pub trait OpenableLocalServerHandler<
5768 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5769 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5770>
5771{
5772 #[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"]
5773 fn open(
5774 &mut self,
5775
5776 request: ::fidl_next::Request<openable::Open, ___T>,
5777 ) -> impl ::core::future::Future<Output = ()>;
5778
5779 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
5780 ::core::future::ready(())
5781 }
5782}
5783
5784impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Openable
5785where
5786 ___H: OpenableLocalServerHandler<___T>,
5787 ___T: ::fidl_next::Transport,
5788 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
5789 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5790 Constraint = (),
5791 >,
5792{
5793 async fn on_one_way(
5794 handler: &mut ___H,
5795 mut message: ::fidl_next::Message<___T>,
5796 ) -> ::core::result::Result<
5797 (),
5798 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5799 > {
5800 match *message.header().ordinal {
5801 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
5802 Ok(decoded) => {
5803 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
5804 Ok(())
5805 }
5806 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5807 ordinal: 6236883748953765593,
5808 error,
5809 }),
5810 },
5811
5812 ordinal => {
5813 handler.on_unknown_interaction(ordinal).await;
5814 if ::core::matches!(
5815 message.header().flexibility(),
5816 ::fidl_next::protocol::Flexibility::Strict
5817 ) {
5818 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5819 } else {
5820 Ok(())
5821 }
5822 }
5823 }
5824 }
5825
5826 async fn on_two_way(
5827 handler: &mut ___H,
5828 mut message: ::fidl_next::Message<___T>,
5829 responder: ::fidl_next::protocol::Responder<___T>,
5830 ) -> ::core::result::Result<
5831 (),
5832 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5833 > {
5834 match *message.header().ordinal {
5835 ordinal => {
5836 handler.on_unknown_interaction(ordinal).await;
5837 if ::core::matches!(
5838 message.header().flexibility(),
5839 ::fidl_next::protocol::Flexibility::Strict
5840 ) {
5841 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5842 } else {
5843 responder
5844 .respond_framework_error(
5845 ordinal,
5846 ::fidl_next::FrameworkError::UnknownMethod,
5847 )
5848 .expect("encoding a framework error should never fail")
5849 .await?;
5850 Ok(())
5851 }
5852 }
5853 }
5854 }
5855}
5856
5857pub trait OpenableClientHandler<
5861 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5862 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5863>
5864{
5865 fn on_unknown_interaction(
5866 &mut self,
5867 ordinal: u64,
5868 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
5869 ::core::future::ready(())
5870 }
5871}
5872
5873impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Openable
5874where
5875 ___H: OpenableClientHandler<___T> + ::core::marker::Send,
5876 ___T: ::fidl_next::Transport,
5877{
5878 async fn on_event(
5879 handler: &mut ___H,
5880 mut message: ::fidl_next::Message<___T>,
5881 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5882 match *message.header().ordinal {
5883 ordinal => {
5884 handler.on_unknown_interaction(ordinal).await;
5885 if ::core::matches!(
5886 message.header().flexibility(),
5887 ::fidl_next::protocol::Flexibility::Strict
5888 ) {
5889 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5890 } else {
5891 Ok(())
5892 }
5893 }
5894 }
5895 }
5896}
5897
5898pub trait OpenableServerHandler<
5902 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5903 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5904>
5905{
5906 #[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"]
5907 fn open(
5908 &mut self,
5909
5910 request: ::fidl_next::Request<openable::Open, ___T>,
5911 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5912
5913 fn on_unknown_interaction(
5914 &mut self,
5915 ordinal: u64,
5916 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
5917 ::core::future::ready(())
5918 }
5919}
5920
5921impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Openable
5922where
5923 ___H: OpenableServerHandler<___T> + ::core::marker::Send,
5924 ___T: ::fidl_next::Transport,
5925 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
5926 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5927 Constraint = (),
5928 >,
5929{
5930 async fn on_one_way(
5931 handler: &mut ___H,
5932 mut message: ::fidl_next::Message<___T>,
5933 ) -> ::core::result::Result<
5934 (),
5935 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5936 > {
5937 match *message.header().ordinal {
5938 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
5939 Ok(decoded) => {
5940 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
5941 Ok(())
5942 }
5943 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5944 ordinal: 6236883748953765593,
5945 error,
5946 }),
5947 },
5948
5949 ordinal => {
5950 handler.on_unknown_interaction(ordinal).await;
5951 if ::core::matches!(
5952 message.header().flexibility(),
5953 ::fidl_next::protocol::Flexibility::Strict
5954 ) {
5955 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5956 } else {
5957 Ok(())
5958 }
5959 }
5960 }
5961 }
5962
5963 async fn on_two_way(
5964 handler: &mut ___H,
5965 mut message: ::fidl_next::Message<___T>,
5966 responder: ::fidl_next::protocol::Responder<___T>,
5967 ) -> ::core::result::Result<
5968 (),
5969 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5970 > {
5971 match *message.header().ordinal {
5972 ordinal => {
5973 handler.on_unknown_interaction(ordinal).await;
5974 if ::core::matches!(
5975 message.header().flexibility(),
5976 ::fidl_next::protocol::Flexibility::Strict
5977 ) {
5978 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5979 } else {
5980 responder
5981 .respond_framework_error(
5982 ordinal,
5983 ::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 = ::fidl_next::fuchsia::zx::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 ::fidl_next_fuchsia_unknown::natural::CloneableCloneRequest;
6097
6098 pub use ::fidl_next_fuchsia_unknown::natural::CloseableCloseResponse;
6099
6100 pub use ::fidl_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 = ::fidl_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 ::fidl_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 = ::fidl_next::wire::Strict<
6165 ::fidl_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>,
6166 >;
6167 }
6168
6169 impl<___R> ::fidl_next::Respond<___R> for Query {
6170 type Output =
6171 ::fidl_next::Strict<::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>>;
6172
6173 fn respond(response: ___R) -> Self::Output {
6174 ::fidl_next::Strict(::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse {
6175 protocol: response,
6176 })
6177 }
6178 }
6179
6180 pub struct DeprecatedClone;
6181
6182 impl ::fidl_next::Method for DeprecatedClone {
6183 const ORDINAL: u64 = 6512600400724287855;
6184 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6185 ::fidl_next::protocol::Flexibility::Flexible;
6186
6187 type Protocol = crate::Node;
6188
6189 type Request = crate::wire::NodeDeprecatedCloneRequest;
6190 }
6191
6192 pub struct OnOpen;
6193
6194 impl ::fidl_next::Method for OnOpen {
6195 const ORDINAL: u64 = 9207534335756671346;
6196 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6197 ::fidl_next::protocol::Flexibility::Flexible;
6198
6199 type Protocol = crate::Node;
6200
6201 type Request = crate::wire::NodeOnOpenRequest<'static>;
6202 }
6203
6204 pub struct DeprecatedGetAttr;
6205
6206 impl ::fidl_next::Method for DeprecatedGetAttr {
6207 const ORDINAL: u64 = 8689798978500614909;
6208 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6209 ::fidl_next::protocol::Flexibility::Strict;
6210
6211 type Protocol = crate::Node;
6212
6213 type Request = ::fidl_next::wire::EmptyMessageBody;
6214 }
6215
6216 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
6217 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetAttrResponse>;
6218 }
6219
6220 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
6221 type Output = ::fidl_next::Strict<___R>;
6222
6223 fn respond(response: ___R) -> Self::Output {
6224 ::fidl_next::Strict(response)
6225 }
6226 }
6227
6228 pub struct DeprecatedSetAttr;
6229
6230 impl ::fidl_next::Method for DeprecatedSetAttr {
6231 const ORDINAL: u64 = 4721673413776871238;
6232 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6233 ::fidl_next::protocol::Flexibility::Strict;
6234
6235 type Protocol = crate::Node;
6236
6237 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
6238 }
6239
6240 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
6241 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetAttrResponse>;
6242 }
6243
6244 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
6245 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetAttrResponse<___R>>;
6246
6247 fn respond(response: ___R) -> Self::Output {
6248 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetAttrResponse { s: response })
6249 }
6250 }
6251
6252 pub struct DeprecatedGetFlags;
6253
6254 impl ::fidl_next::Method for DeprecatedGetFlags {
6255 const ORDINAL: u64 = 6595803110182632097;
6256 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6257 ::fidl_next::protocol::Flexibility::Strict;
6258
6259 type Protocol = crate::Node;
6260
6261 type Request = ::fidl_next::wire::EmptyMessageBody;
6262 }
6263
6264 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
6265 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetFlagsResponse>;
6266 }
6267
6268 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
6269 type Output = ::fidl_next::Strict<___R>;
6270
6271 fn respond(response: ___R) -> Self::Output {
6272 ::fidl_next::Strict(response)
6273 }
6274 }
6275
6276 pub struct DeprecatedSetFlags;
6277
6278 impl ::fidl_next::Method for DeprecatedSetFlags {
6279 const ORDINAL: u64 = 5950864159036794675;
6280 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6281 ::fidl_next::protocol::Flexibility::Strict;
6282
6283 type Protocol = crate::Node;
6284
6285 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
6286 }
6287
6288 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
6289 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetFlagsResponse>;
6290 }
6291
6292 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
6293 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetFlagsResponse<___R>>;
6294
6295 fn respond(response: ___R) -> Self::Output {
6296 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetFlagsResponse { s: response })
6297 }
6298 }
6299
6300 pub struct GetFlags;
6301
6302 impl ::fidl_next::Method for GetFlags {
6303 const ORDINAL: u64 = 105530239381466147;
6304 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6305 ::fidl_next::protocol::Flexibility::Flexible;
6306
6307 type Protocol = crate::Node;
6308
6309 type Request = ::fidl_next::wire::EmptyMessageBody;
6310 }
6311
6312 impl ::fidl_next::TwoWayMethod for GetFlags {
6313 type Response = ::fidl_next::wire::Result<
6314 'static,
6315 crate::wire::NodeGetFlagsResponse,
6316 ::fidl_next::wire::fuchsia::Status,
6317 >;
6318 }
6319
6320 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
6321 type Output = ::core::result::Result<
6322 crate::generic::NodeGetFlagsResponse<___R>,
6323 ::fidl_next::util::Never,
6324 >;
6325
6326 fn respond(response: ___R) -> Self::Output {
6327 ::core::result::Result::Ok(crate::generic::NodeGetFlagsResponse { flags: response })
6328 }
6329 }
6330
6331 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
6332 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
6333
6334 fn respond_err(response: ___R) -> Self::Output {
6335 ::core::result::Result::Err(response)
6336 }
6337 }
6338
6339 pub struct SetFlags;
6340
6341 impl ::fidl_next::Method for SetFlags {
6342 const ORDINAL: u64 = 6172186066099445416;
6343 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6344 ::fidl_next::protocol::Flexibility::Flexible;
6345
6346 type Protocol = crate::Node;
6347
6348 type Request = crate::wire::NodeSetFlagsRequest;
6349 }
6350
6351 impl ::fidl_next::TwoWayMethod for SetFlags {
6352 type Response = ::fidl_next::wire::Result<
6353 'static,
6354 crate::wire::NodeSetFlagsResponse,
6355 ::fidl_next::wire::fuchsia::Status,
6356 >;
6357 }
6358
6359 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
6360 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
6361
6362 fn respond(response: ___R) -> Self::Output {
6363 ::core::result::Result::Ok(response)
6364 }
6365 }
6366
6367 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
6368 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
6369
6370 fn respond_err(response: ___R) -> Self::Output {
6371 ::core::result::Result::Err(response)
6372 }
6373 }
6374
6375 pub struct QueryFilesystem;
6376
6377 impl ::fidl_next::Method for QueryFilesystem {
6378 const ORDINAL: u64 = 8013111122914313744;
6379 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6380 ::fidl_next::protocol::Flexibility::Strict;
6381
6382 type Protocol = crate::Node;
6383
6384 type Request = ::fidl_next::wire::EmptyMessageBody;
6385 }
6386
6387 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
6388 type Response =
6389 ::fidl_next::wire::Strict<crate::wire::NodeQueryFilesystemResponse<'static>>;
6390 }
6391
6392 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
6393 type Output = ::fidl_next::Strict<___R>;
6394
6395 fn respond(response: ___R) -> Self::Output {
6396 ::fidl_next::Strict(response)
6397 }
6398 }
6399
6400 pub struct OnRepresentation;
6401
6402 impl ::fidl_next::Method for OnRepresentation {
6403 const ORDINAL: u64 = 6679970090861613324;
6404 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6405 ::fidl_next::protocol::Flexibility::Strict;
6406
6407 type Protocol = crate::Node;
6408
6409 type Request = crate::wire::Representation<'static>;
6410 }
6411
6412 pub struct GetAttributes;
6413
6414 impl ::fidl_next::Method for GetAttributes {
6415 const ORDINAL: u64 = 4414537700416816443;
6416 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6417 ::fidl_next::protocol::Flexibility::Strict;
6418
6419 type Protocol = crate::Node;
6420
6421 type Request = crate::wire::NodeGetAttributesRequest;
6422 }
6423
6424 impl ::fidl_next::TwoWayMethod for GetAttributes {
6425 type Response = ::fidl_next::wire::Result<
6426 'static,
6427 crate::wire::NodeAttributes2<'static>,
6428 ::fidl_next::wire::fuchsia::Status,
6429 >;
6430 }
6431
6432 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
6433 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
6434
6435 fn respond(response: ___R) -> Self::Output {
6436 ::core::result::Result::Ok(response)
6437 }
6438 }
6439
6440 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
6441 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
6442
6443 fn respond_err(response: ___R) -> Self::Output {
6444 ::core::result::Result::Err(response)
6445 }
6446 }
6447
6448 pub struct UpdateAttributes;
6449
6450 impl ::fidl_next::Method for UpdateAttributes {
6451 const ORDINAL: u64 = 3677402239314018056;
6452 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6453 ::fidl_next::protocol::Flexibility::Strict;
6454
6455 type Protocol = crate::Node;
6456
6457 type Request = crate::wire::MutableNodeAttributes<'static>;
6458 }
6459
6460 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
6461 type Response = ::fidl_next::wire::Result<
6462 'static,
6463 crate::wire::NodeUpdateAttributesResponse,
6464 ::fidl_next::wire::fuchsia::Status,
6465 >;
6466 }
6467
6468 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
6469 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
6470
6471 fn respond(response: ___R) -> Self::Output {
6472 ::core::result::Result::Ok(response)
6473 }
6474 }
6475
6476 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
6477 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
6478
6479 fn respond_err(response: ___R) -> Self::Output {
6480 ::core::result::Result::Err(response)
6481 }
6482 }
6483
6484 pub struct Sync;
6485
6486 impl ::fidl_next::Method for Sync {
6487 const ORDINAL: u64 = 3196473584242777161;
6488 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6489 ::fidl_next::protocol::Flexibility::Strict;
6490
6491 type Protocol = crate::Node;
6492
6493 type Request = ::fidl_next::wire::EmptyMessageBody;
6494 }
6495
6496 impl ::fidl_next::TwoWayMethod for Sync {
6497 type Response = ::fidl_next::wire::Result<
6498 'static,
6499 crate::wire::NodeSyncResponse,
6500 ::fidl_next::wire::fuchsia::Status,
6501 >;
6502 }
6503
6504 impl<___R> ::fidl_next::Respond<___R> for Sync {
6505 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
6506
6507 fn respond(response: ___R) -> Self::Output {
6508 ::core::result::Result::Ok(response)
6509 }
6510 }
6511
6512 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
6513 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
6514
6515 fn respond_err(response: ___R) -> Self::Output {
6516 ::core::result::Result::Err(response)
6517 }
6518 }
6519
6520 pub struct ListExtendedAttributes;
6521
6522 impl ::fidl_next::Method for ListExtendedAttributes {
6523 const ORDINAL: u64 = 5431626189872037072;
6524 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6525 ::fidl_next::protocol::Flexibility::Strict;
6526
6527 type Protocol = crate::Node;
6528
6529 type Request = crate::wire::NodeListExtendedAttributesRequest;
6530 }
6531
6532 pub struct GetExtendedAttribute;
6533
6534 impl ::fidl_next::Method for GetExtendedAttribute {
6535 const ORDINAL: u64 = 5043930208506967771;
6536 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6537 ::fidl_next::protocol::Flexibility::Strict;
6538
6539 type Protocol = crate::Node;
6540
6541 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
6542 }
6543
6544 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
6545 type Response = ::fidl_next::wire::Result<
6546 'static,
6547 crate::wire::ExtendedAttributeValue<'static>,
6548 ::fidl_next::wire::fuchsia::Status,
6549 >;
6550 }
6551
6552 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
6553 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
6554
6555 fn respond(response: ___R) -> Self::Output {
6556 ::core::result::Result::Ok(response)
6557 }
6558 }
6559
6560 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
6561 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
6562
6563 fn respond_err(response: ___R) -> Self::Output {
6564 ::core::result::Result::Err(response)
6565 }
6566 }
6567
6568 pub struct SetExtendedAttribute;
6569
6570 impl ::fidl_next::Method for SetExtendedAttribute {
6571 const ORDINAL: u64 = 5374223046099989052;
6572 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6573 ::fidl_next::protocol::Flexibility::Strict;
6574
6575 type Protocol = crate::Node;
6576
6577 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
6578 }
6579
6580 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
6581 type Response = ::fidl_next::wire::Result<
6582 'static,
6583 crate::wire::NodeSetExtendedAttributeResponse,
6584 ::fidl_next::wire::fuchsia::Status,
6585 >;
6586 }
6587
6588 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
6589 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
6590
6591 fn respond(response: ___R) -> Self::Output {
6592 ::core::result::Result::Ok(response)
6593 }
6594 }
6595
6596 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
6597 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
6598
6599 fn respond_err(response: ___R) -> Self::Output {
6600 ::core::result::Result::Err(response)
6601 }
6602 }
6603
6604 pub struct RemoveExtendedAttribute;
6605
6606 impl ::fidl_next::Method for RemoveExtendedAttribute {
6607 const ORDINAL: u64 = 8794297771444732717;
6608 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6609 ::fidl_next::protocol::Flexibility::Strict;
6610
6611 type Protocol = crate::Node;
6612
6613 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
6614 }
6615
6616 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
6617 type Response = ::fidl_next::wire::Result<
6618 'static,
6619 crate::wire::NodeRemoveExtendedAttributeResponse,
6620 ::fidl_next::wire::fuchsia::Status,
6621 >;
6622 }
6623
6624 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
6625 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
6626
6627 fn respond(response: ___R) -> Self::Output {
6628 ::core::result::Result::Ok(response)
6629 }
6630 }
6631
6632 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
6633 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
6634
6635 fn respond_err(response: ___R) -> Self::Output {
6636 ::core::result::Result::Err(response)
6637 }
6638 }
6639
6640 mod ___detail {
6641 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Node
6642 where
6643 ___T: ::fidl_next::Transport,
6644 {
6645 type Client = NodeClient<___T>;
6646 type Server = NodeServer<___T>;
6647 }
6648
6649 #[repr(transparent)]
6651 pub struct NodeClient<___T: ::fidl_next::Transport> {
6652 #[allow(dead_code)]
6653 client: ::fidl_next::protocol::Client<___T>,
6654 }
6655
6656 impl<___T> NodeClient<___T>
6657 where
6658 ___T: ::fidl_next::Transport,
6659 {
6660 pub fn clone(
6661 &self,
6662
6663 request: impl ::fidl_next::Encode<
6664 ::fidl_next::ServerEnd<
6665 ::fidl_next_fuchsia_unknown::Cloneable,
6666 ::fidl_next::wire::fuchsia::Channel,
6667 >,
6668 <___T as ::fidl_next::Transport>::SendBuffer,
6669 >,
6670 ) -> ::fidl_next::SendFuture<'_, ___T>
6671 where
6672 <___T as ::fidl_next::Transport>::SendBuffer:
6673 ::fidl_next::encoder::InternalHandleEncoder,
6674 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
6675 {
6676 self.clone_with(::fidl_next_fuchsia_unknown::generic::CloneableCloneRequest {
6677 request,
6678 })
6679 }
6680
6681 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
6682 where
6683 ___R: ::fidl_next::Encode<
6684 ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest,
6685 <___T as ::fidl_next::Transport>::SendBuffer,
6686 >,
6687 {
6688 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
6689 2366825959783828089,
6690 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
6691 request,
6692 ))
6693 }
6694
6695 #[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"]
6696 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
6697 ::fidl_next::TwoWayFuture::from_untyped(
6698 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
6699 6540867515453498750,
6700 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
6701 (),
6702 ),
6703 )
6704 }
6705
6706 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
6707 ::fidl_next::TwoWayFuture::from_untyped(
6708 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
6709 2763219980499352582,
6710 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
6711 (),
6712 ),
6713 )
6714 }
6715
6716 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
6717 pub fn deprecated_clone(
6718 &self,
6719
6720 flags: impl ::fidl_next::Encode<
6721 crate::wire::OpenFlags,
6722 <___T as ::fidl_next::Transport>::SendBuffer,
6723 >,
6724
6725 object: impl ::fidl_next::Encode<
6726 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::wire::fuchsia::Channel>,
6727 <___T as ::fidl_next::Transport>::SendBuffer,
6728 >,
6729 ) -> ::fidl_next::SendFuture<'_, ___T>
6730 where
6731 <___T as ::fidl_next::Transport>::SendBuffer:
6732 ::fidl_next::encoder::InternalHandleEncoder,
6733 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
6734 {
6735 self.deprecated_clone_with(crate::generic::NodeDeprecatedCloneRequest {
6736 flags,
6737
6738 object,
6739 })
6740 }
6741
6742 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
6743 pub fn deprecated_clone_with<___R>(
6744 &self,
6745 request: ___R,
6746 ) -> ::fidl_next::SendFuture<'_, ___T>
6747 where
6748 ___R: ::fidl_next::Encode<
6749 crate::wire::NodeDeprecatedCloneRequest,
6750 <___T as ::fidl_next::Transport>::SendBuffer,
6751 >,
6752 {
6753 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
6754 6512600400724287855,
6755 <super::DeprecatedClone as ::fidl_next::Method>::FLEXIBILITY,
6756 request,
6757 ))
6758 }
6759
6760 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
6761 pub fn deprecated_get_attr(
6762 &self,
6763 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
6764 ::fidl_next::TwoWayFuture::from_untyped(
6765 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
6766 8689798978500614909,
6767 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
6768 (),
6769 ),
6770 )
6771 }
6772
6773 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
6774 pub fn deprecated_set_attr(
6775 &self,
6776
6777 flags: impl ::fidl_next::Encode<
6778 crate::wire::NodeAttributeFlags,
6779 <___T as ::fidl_next::Transport>::SendBuffer,
6780 >,
6781
6782 attributes: impl ::fidl_next::Encode<
6783 crate::wire::NodeAttributes,
6784 <___T as ::fidl_next::Transport>::SendBuffer,
6785 >,
6786 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
6787 where
6788 <___T as ::fidl_next::Transport>::SendBuffer:
6789 ::fidl_next::encoder::InternalHandleEncoder,
6790 {
6791 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
6792 flags,
6793
6794 attributes,
6795 })
6796 }
6797
6798 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
6799 pub fn deprecated_set_attr_with<___R>(
6800 &self,
6801 request: ___R,
6802 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
6803 where
6804 ___R: ::fidl_next::Encode<
6805 crate::wire::NodeDeprecatedSetAttrRequest,
6806 <___T as ::fidl_next::Transport>::SendBuffer,
6807 >,
6808 {
6809 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6810 4721673413776871238,
6811 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
6812 request,
6813 ))
6814 }
6815
6816 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
6817 pub fn deprecated_get_flags(
6818 &self,
6819 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
6820 ::fidl_next::TwoWayFuture::from_untyped(
6821 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
6822 6595803110182632097,
6823 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
6824 (),
6825 ),
6826 )
6827 }
6828
6829 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
6830 pub fn deprecated_set_flags(
6831 &self,
6832
6833 flags: impl ::fidl_next::Encode<
6834 crate::wire::OpenFlags,
6835 <___T as ::fidl_next::Transport>::SendBuffer,
6836 >,
6837 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
6838 where
6839 <___T as ::fidl_next::Transport>::SendBuffer:
6840 ::fidl_next::encoder::InternalHandleEncoder,
6841 {
6842 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
6843 flags,
6844 })
6845 }
6846
6847 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
6848 pub fn deprecated_set_flags_with<___R>(
6849 &self,
6850 request: ___R,
6851 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
6852 where
6853 ___R: ::fidl_next::Encode<
6854 crate::wire::NodeDeprecatedSetFlagsRequest,
6855 <___T as ::fidl_next::Transport>::SendBuffer,
6856 >,
6857 {
6858 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6859 5950864159036794675,
6860 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
6861 request,
6862 ))
6863 }
6864
6865 #[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"]
6866 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
6867 ::fidl_next::TwoWayFuture::from_untyped(
6868 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
6869 105530239381466147,
6870 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
6871 (),
6872 ),
6873 )
6874 }
6875
6876 #[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"]
6877 pub fn set_flags(
6878 &self,
6879
6880 flags: impl ::fidl_next::Encode<
6881 crate::wire::Flags,
6882 <___T as ::fidl_next::Transport>::SendBuffer,
6883 >,
6884 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
6885 where
6886 <___T as ::fidl_next::Transport>::SendBuffer:
6887 ::fidl_next::encoder::InternalHandleEncoder,
6888 {
6889 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
6890 }
6891
6892 #[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"]
6893 pub fn set_flags_with<___R>(
6894 &self,
6895 request: ___R,
6896 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
6897 where
6898 ___R: ::fidl_next::Encode<
6899 crate::wire::NodeSetFlagsRequest,
6900 <___T as ::fidl_next::Transport>::SendBuffer,
6901 >,
6902 {
6903 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6904 6172186066099445416,
6905 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
6906 request,
6907 ))
6908 }
6909
6910 #[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"]
6911 pub fn query_filesystem(
6912 &self,
6913 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
6914 ::fidl_next::TwoWayFuture::from_untyped(
6915 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
6916 8013111122914313744,
6917 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
6918 (),
6919 ),
6920 )
6921 }
6922
6923 #[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"]
6924 pub fn get_attributes(
6925 &self,
6926
6927 query: impl ::fidl_next::Encode<
6928 crate::wire::NodeAttributesQuery,
6929 <___T as ::fidl_next::Transport>::SendBuffer,
6930 >,
6931 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
6932 where
6933 <___T as ::fidl_next::Transport>::SendBuffer:
6934 ::fidl_next::encoder::InternalHandleEncoder,
6935 {
6936 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
6937 }
6938
6939 #[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"]
6940 pub fn get_attributes_with<___R>(
6941 &self,
6942 request: ___R,
6943 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
6944 where
6945 ___R: ::fidl_next::Encode<
6946 crate::wire::NodeGetAttributesRequest,
6947 <___T as ::fidl_next::Transport>::SendBuffer,
6948 >,
6949 {
6950 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6951 4414537700416816443,
6952 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
6953 request,
6954 ))
6955 }
6956
6957 #[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"]
6958 pub fn update_attributes_with<___R>(
6959 &self,
6960 request: ___R,
6961 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
6962 where
6963 ___R: ::fidl_next::Encode<
6964 crate::wire::MutableNodeAttributes<'static>,
6965 <___T as ::fidl_next::Transport>::SendBuffer,
6966 >,
6967 {
6968 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
6969 3677402239314018056,
6970 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
6971 request,
6972 ))
6973 }
6974
6975 #[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"]
6976 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
6977 ::fidl_next::TwoWayFuture::from_untyped(
6978 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
6979 3196473584242777161,
6980 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
6981 (),
6982 ),
6983 )
6984 }
6985
6986 #[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"]
6987 pub fn list_extended_attributes(
6988 &self,
6989
6990 iterator: impl ::fidl_next::Encode<
6991 ::fidl_next::ServerEnd<
6992 crate::ExtendedAttributeIterator,
6993 ::fidl_next::wire::fuchsia::Channel,
6994 >,
6995 <___T as ::fidl_next::Transport>::SendBuffer,
6996 >,
6997 ) -> ::fidl_next::SendFuture<'_, ___T>
6998 where
6999 <___T as ::fidl_next::Transport>::SendBuffer:
7000 ::fidl_next::encoder::InternalHandleEncoder,
7001 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7002 {
7003 self.list_extended_attributes_with(
7004 crate::generic::NodeListExtendedAttributesRequest { iterator },
7005 )
7006 }
7007
7008 #[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"]
7009 pub fn list_extended_attributes_with<___R>(
7010 &self,
7011 request: ___R,
7012 ) -> ::fidl_next::SendFuture<'_, ___T>
7013 where
7014 ___R: ::fidl_next::Encode<
7015 crate::wire::NodeListExtendedAttributesRequest,
7016 <___T as ::fidl_next::Transport>::SendBuffer,
7017 >,
7018 {
7019 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
7020 5431626189872037072,
7021 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
7022 request,
7023 ))
7024 }
7025
7026 #[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"]
7027 pub fn get_extended_attribute(
7028 &self,
7029
7030 name: impl ::fidl_next::Encode<
7031 ::fidl_next::wire::Vector<'static, u8>,
7032 <___T as ::fidl_next::Transport>::SendBuffer,
7033 >,
7034 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
7035 where
7036 <___T as ::fidl_next::Transport>::SendBuffer:
7037 ::fidl_next::encoder::InternalHandleEncoder,
7038 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
7039 {
7040 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
7041 name,
7042 })
7043 }
7044
7045 #[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"]
7046 pub fn get_extended_attribute_with<___R>(
7047 &self,
7048 request: ___R,
7049 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
7050 where
7051 ___R: ::fidl_next::Encode<
7052 crate::wire::NodeGetExtendedAttributeRequest<'static>,
7053 <___T as ::fidl_next::Transport>::SendBuffer,
7054 >,
7055 {
7056 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7057 5043930208506967771,
7058 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
7059 request,
7060 ))
7061 }
7062
7063 #[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"]
7064 pub fn set_extended_attribute(
7065 &self,
7066
7067 name: impl ::fidl_next::Encode<
7068 ::fidl_next::wire::Vector<'static, u8>,
7069 <___T as ::fidl_next::Transport>::SendBuffer,
7070 >,
7071
7072 value: impl ::fidl_next::Encode<
7073 crate::wire::ExtendedAttributeValue<'static>,
7074 <___T as ::fidl_next::Transport>::SendBuffer,
7075 >,
7076
7077 mode: impl ::fidl_next::Encode<
7078 crate::wire::SetExtendedAttributeMode,
7079 <___T as ::fidl_next::Transport>::SendBuffer,
7080 >,
7081 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
7082 where
7083 <___T as ::fidl_next::Transport>::SendBuffer:
7084 ::fidl_next::encoder::InternalHandleEncoder,
7085 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
7086 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::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::fuchsia::Status,
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: ::fidl_next::fuchsia::HandleEncoder,
7182 {
7183 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
7184 }
7185
7186 #[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"]
7187
7188 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
7189 where
7190 ___R: ::fidl_next::Encode<
7191 <super::OnOpen as ::fidl_next::Method>::Request,
7192 <___T as ::fidl_next::Transport>::SendBuffer,
7193 >,
7194 {
7195 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
7196 9207534335756671346,
7197 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
7198 request,
7199 ))
7200 }
7201
7202 #[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"]
7203
7204 pub fn on_representation_with<___R>(
7205 &self,
7206 request: ___R,
7207 ) -> ::fidl_next::SendFuture<'_, ___T>
7208 where
7209 ___R: ::fidl_next::Encode<
7210 <super::OnRepresentation as ::fidl_next::Method>::Request,
7211 <___T as ::fidl_next::Transport>::SendBuffer,
7212 >,
7213 {
7214 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
7215 6679970090861613324,
7216 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
7217 request,
7218 ))
7219 }
7220 }
7221 }
7222}
7223
7224#[diagnostic::on_unimplemented(
7225 note = "If {Self} implements the non-local NodeClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
7226)]
7227
7228pub trait NodeLocalClientHandler<
7232 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
7233 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
7234>
7235{
7236 #[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"]
7237 fn on_open(
7238 &mut self,
7239
7240 request: ::fidl_next::Request<node::OnOpen, ___T>,
7241 ) -> impl ::core::future::Future<Output = ()>;
7242
7243 #[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"]
7244 fn on_representation(
7245 &mut self,
7246
7247 request: ::fidl_next::Request<node::OnRepresentation, ___T>,
7248 ) -> impl ::core::future::Future<Output = ()>;
7249
7250 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
7251 ::core::future::ready(())
7252 }
7253}
7254
7255impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Node
7256where
7257 ___H: NodeLocalClientHandler<___T>,
7258 ___T: ::fidl_next::Transport,
7259 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
7260 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7261 Constraint = (),
7262 >,
7263 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
7264 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7265 Constraint = (),
7266 >,
7267{
7268 async fn on_event(
7269 handler: &mut ___H,
7270 mut message: ::fidl_next::Message<___T>,
7271 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
7272 match *message.header().ordinal {
7273 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
7274 Ok(decoded) => {
7275 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
7276 Ok(())
7277 }
7278 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7279 ordinal: 9207534335756671346,
7280 error,
7281 }),
7282 },
7283
7284 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
7285 Ok(decoded) => {
7286 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
7287 Ok(())
7288 }
7289 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7290 ordinal: 6679970090861613324,
7291 error,
7292 }),
7293 },
7294
7295 ordinal => {
7296 handler.on_unknown_interaction(ordinal).await;
7297 if ::core::matches!(
7298 message.header().flexibility(),
7299 ::fidl_next::protocol::Flexibility::Strict
7300 ) {
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 = ::fidl_next::fuchsia::zx::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> ::fidl_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 mut message: ::fidl_next::Message<___T>,
7519 ) -> ::core::result::Result<
7520 (),
7521 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
7522 > {
7523 match *message.header().ordinal {
7524 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
7525 Ok(decoded) => {
7526 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
7527 Ok(())
7528 }
7529 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7530 ordinal: 2366825959783828089,
7531 error,
7532 }),
7533 },
7534
7535 6512600400724287855 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
7536 Ok(decoded) => {
7537 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
7538 Ok(())
7539 }
7540 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7541 ordinal: 6512600400724287855,
7542 error,
7543 }),
7544 },
7545
7546 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
7547 Ok(decoded) => {
7548 handler
7549 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
7550 .await;
7551 Ok(())
7552 }
7553 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7554 ordinal: 5431626189872037072,
7555 error,
7556 }),
7557 },
7558
7559 ordinal => {
7560 handler.on_unknown_interaction(ordinal).await;
7561 if ::core::matches!(
7562 message.header().flexibility(),
7563 ::fidl_next::protocol::Flexibility::Strict
7564 ) {
7565 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
7566 } else {
7567 Ok(())
7568 }
7569 }
7570 }
7571 }
7572
7573 async fn on_two_way(
7574 handler: &mut ___H,
7575 mut message: ::fidl_next::Message<___T>,
7576 responder: ::fidl_next::protocol::Responder<___T>,
7577 ) -> ::core::result::Result<
7578 (),
7579 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
7580 > {
7581 match *message.header().ordinal {
7582 6540867515453498750 => {
7583 let responder = ::fidl_next::Responder::from_untyped(responder);
7584
7585 handler.close(responder).await;
7586 Ok(())
7587 }
7588
7589 2763219980499352582 => {
7590 let responder = ::fidl_next::Responder::from_untyped(responder);
7591
7592 handler.query(responder).await;
7593 Ok(())
7594 }
7595
7596 8689798978500614909 => {
7597 let responder = ::fidl_next::Responder::from_untyped(responder);
7598
7599 handler.deprecated_get_attr(responder).await;
7600 Ok(())
7601 }
7602
7603 4721673413776871238 => {
7604 let responder = ::fidl_next::Responder::from_untyped(responder);
7605
7606 match ::fidl_next::AsDecoderExt::into_decoded(message) {
7607 Ok(decoded) => {
7608 handler
7609 .deprecated_set_attr(
7610 ::fidl_next::Request::from_decoded(decoded),
7611 responder,
7612 )
7613 .await;
7614 Ok(())
7615 }
7616 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7617 ordinal: 4721673413776871238,
7618 error,
7619 }),
7620 }
7621 }
7622
7623 6595803110182632097 => {
7624 let responder = ::fidl_next::Responder::from_untyped(responder);
7625
7626 handler.deprecated_get_flags(responder).await;
7627 Ok(())
7628 }
7629
7630 5950864159036794675 => {
7631 let responder = ::fidl_next::Responder::from_untyped(responder);
7632
7633 match ::fidl_next::AsDecoderExt::into_decoded(message) {
7634 Ok(decoded) => {
7635 handler
7636 .deprecated_set_flags(
7637 ::fidl_next::Request::from_decoded(decoded),
7638 responder,
7639 )
7640 .await;
7641 Ok(())
7642 }
7643 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7644 ordinal: 5950864159036794675,
7645 error,
7646 }),
7647 }
7648 }
7649
7650 105530239381466147 => {
7651 let responder = ::fidl_next::Responder::from_untyped(responder);
7652
7653 handler.get_flags(responder).await;
7654 Ok(())
7655 }
7656
7657 6172186066099445416 => {
7658 let responder = ::fidl_next::Responder::from_untyped(responder);
7659
7660 match ::fidl_next::AsDecoderExt::into_decoded(message) {
7661 Ok(decoded) => {
7662 handler
7663 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
7664 .await;
7665 Ok(())
7666 }
7667 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7668 ordinal: 6172186066099445416,
7669 error,
7670 }),
7671 }
7672 }
7673
7674 8013111122914313744 => {
7675 let responder = ::fidl_next::Responder::from_untyped(responder);
7676
7677 handler.query_filesystem(responder).await;
7678 Ok(())
7679 }
7680
7681 4414537700416816443 => {
7682 let responder = ::fidl_next::Responder::from_untyped(responder);
7683
7684 match ::fidl_next::AsDecoderExt::into_decoded(message) {
7685 Ok(decoded) => {
7686 handler
7687 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
7688 .await;
7689 Ok(())
7690 }
7691 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7692 ordinal: 4414537700416816443,
7693 error,
7694 }),
7695 }
7696 }
7697
7698 3677402239314018056 => {
7699 let responder = ::fidl_next::Responder::from_untyped(responder);
7700
7701 match ::fidl_next::AsDecoderExt::into_decoded(message) {
7702 Ok(decoded) => {
7703 handler
7704 .update_attributes(
7705 ::fidl_next::Request::from_decoded(decoded),
7706 responder,
7707 )
7708 .await;
7709 Ok(())
7710 }
7711 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7712 ordinal: 3677402239314018056,
7713 error,
7714 }),
7715 }
7716 }
7717
7718 3196473584242777161 => {
7719 let responder = ::fidl_next::Responder::from_untyped(responder);
7720
7721 handler.sync(responder).await;
7722 Ok(())
7723 }
7724
7725 5043930208506967771 => {
7726 let responder = ::fidl_next::Responder::from_untyped(responder);
7727
7728 match ::fidl_next::AsDecoderExt::into_decoded(message) {
7729 Ok(decoded) => {
7730 handler
7731 .get_extended_attribute(
7732 ::fidl_next::Request::from_decoded(decoded),
7733 responder,
7734 )
7735 .await;
7736 Ok(())
7737 }
7738 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7739 ordinal: 5043930208506967771,
7740 error,
7741 }),
7742 }
7743 }
7744
7745 5374223046099989052 => {
7746 let responder = ::fidl_next::Responder::from_untyped(responder);
7747
7748 match ::fidl_next::AsDecoderExt::into_decoded(message) {
7749 Ok(decoded) => {
7750 handler
7751 .set_extended_attribute(
7752 ::fidl_next::Request::from_decoded(decoded),
7753 responder,
7754 )
7755 .await;
7756 Ok(())
7757 }
7758 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7759 ordinal: 5374223046099989052,
7760 error,
7761 }),
7762 }
7763 }
7764
7765 8794297771444732717 => {
7766 let responder = ::fidl_next::Responder::from_untyped(responder);
7767
7768 match ::fidl_next::AsDecoderExt::into_decoded(message) {
7769 Ok(decoded) => {
7770 handler
7771 .remove_extended_attribute(
7772 ::fidl_next::Request::from_decoded(decoded),
7773 responder,
7774 )
7775 .await;
7776 Ok(())
7777 }
7778 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7779 ordinal: 8794297771444732717,
7780 error,
7781 }),
7782 }
7783 }
7784
7785 ordinal => {
7786 handler.on_unknown_interaction(ordinal).await;
7787 if ::core::matches!(
7788 message.header().flexibility(),
7789 ::fidl_next::protocol::Flexibility::Strict
7790 ) {
7791 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
7792 } else {
7793 responder
7794 .respond_framework_error(
7795 ordinal,
7796 ::fidl_next::FrameworkError::UnknownMethod,
7797 )
7798 .expect("encoding a framework error should never fail")
7799 .await?;
7800 Ok(())
7801 }
7802 }
7803 }
7804 }
7805}
7806
7807pub trait NodeClientHandler<
7811 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
7812 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
7813>
7814{
7815 #[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"]
7816 fn on_open(
7817 &mut self,
7818
7819 request: ::fidl_next::Request<node::OnOpen, ___T>,
7820 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7821
7822 #[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"]
7823 fn on_representation(
7824 &mut self,
7825
7826 request: ::fidl_next::Request<node::OnRepresentation, ___T>,
7827 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7828
7829 fn on_unknown_interaction(
7830 &mut self,
7831 ordinal: u64,
7832 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
7833 ::core::future::ready(())
7834 }
7835}
7836
7837impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Node
7838where
7839 ___H: NodeClientHandler<___T> + ::core::marker::Send,
7840 ___T: ::fidl_next::Transport,
7841 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
7842 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7843 Constraint = (),
7844 >,
7845 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
7846 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7847 Constraint = (),
7848 >,
7849{
7850 async fn on_event(
7851 handler: &mut ___H,
7852 mut message: ::fidl_next::Message<___T>,
7853 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
7854 match *message.header().ordinal {
7855 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
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(message) {
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!(
7880 message.header().flexibility(),
7881 ::fidl_next::protocol::Flexibility::Strict
7882 ) {
7883 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
7884 } else {
7885 Ok(())
7886 }
7887 }
7888 }
7889 }
7890}
7891
7892pub trait NodeServerHandler<
7896 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
7897 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
7898>
7899{
7900 fn clone(
7901 &mut self,
7902
7903 request: ::fidl_next::Request<node::Clone, ___T>,
7904 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7905
7906 #[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"]
7907 fn close(
7908 &mut self,
7909
7910 responder: ::fidl_next::Responder<node::Close, ___T>,
7911 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7912
7913 fn query(
7914 &mut self,
7915
7916 responder: ::fidl_next::Responder<node::Query, ___T>,
7917 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7918
7919 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
7920 fn deprecated_clone(
7921 &mut self,
7922
7923 request: ::fidl_next::Request<node::DeprecatedClone, ___T>,
7924 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7925
7926 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
7927 fn deprecated_get_attr(
7928 &mut self,
7929
7930 responder: ::fidl_next::Responder<node::DeprecatedGetAttr, ___T>,
7931 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7932
7933 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
7934 fn deprecated_set_attr(
7935 &mut self,
7936
7937 request: ::fidl_next::Request<node::DeprecatedSetAttr, ___T>,
7938
7939 responder: ::fidl_next::Responder<node::DeprecatedSetAttr, ___T>,
7940 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7941
7942 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
7943 fn deprecated_get_flags(
7944 &mut self,
7945
7946 responder: ::fidl_next::Responder<node::DeprecatedGetFlags, ___T>,
7947 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7948
7949 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
7950 fn deprecated_set_flags(
7951 &mut self,
7952
7953 request: ::fidl_next::Request<node::DeprecatedSetFlags, ___T>,
7954
7955 responder: ::fidl_next::Responder<node::DeprecatedSetFlags, ___T>,
7956 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7957
7958 #[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"]
7959 fn get_flags(
7960 &mut self,
7961
7962 responder: ::fidl_next::Responder<node::GetFlags, ___T>,
7963 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7964
7965 #[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"]
7966 fn set_flags(
7967 &mut self,
7968
7969 request: ::fidl_next::Request<node::SetFlags, ___T>,
7970
7971 responder: ::fidl_next::Responder<node::SetFlags, ___T>,
7972 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7973
7974 #[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"]
7975 fn query_filesystem(
7976 &mut self,
7977
7978 responder: ::fidl_next::Responder<node::QueryFilesystem, ___T>,
7979 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7980
7981 #[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"]
7982 fn get_attributes(
7983 &mut self,
7984
7985 request: ::fidl_next::Request<node::GetAttributes, ___T>,
7986
7987 responder: ::fidl_next::Responder<node::GetAttributes, ___T>,
7988 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7989
7990 #[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"]
7991 fn update_attributes(
7992 &mut self,
7993
7994 request: ::fidl_next::Request<node::UpdateAttributes, ___T>,
7995
7996 responder: ::fidl_next::Responder<node::UpdateAttributes, ___T>,
7997 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
7998
7999 #[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"]
8000 fn sync(
8001 &mut self,
8002
8003 responder: ::fidl_next::Responder<node::Sync, ___T>,
8004 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8005
8006 #[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"]
8007 fn list_extended_attributes(
8008 &mut self,
8009
8010 request: ::fidl_next::Request<node::ListExtendedAttributes, ___T>,
8011 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8012
8013 #[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"]
8014 fn get_extended_attribute(
8015 &mut self,
8016
8017 request: ::fidl_next::Request<node::GetExtendedAttribute, ___T>,
8018
8019 responder: ::fidl_next::Responder<node::GetExtendedAttribute, ___T>,
8020 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8021
8022 #[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"]
8023 fn set_extended_attribute(
8024 &mut self,
8025
8026 request: ::fidl_next::Request<node::SetExtendedAttribute, ___T>,
8027
8028 responder: ::fidl_next::Responder<node::SetExtendedAttribute, ___T>,
8029 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8030
8031 #[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"]
8032 fn remove_extended_attribute(
8033 &mut self,
8034
8035 request: ::fidl_next::Request<node::RemoveExtendedAttribute, ___T>,
8036
8037 responder: ::fidl_next::Responder<node::RemoveExtendedAttribute, ___T>,
8038 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8039
8040 fn on_unknown_interaction(
8041 &mut self,
8042 ordinal: u64,
8043 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
8044 ::core::future::ready(())
8045 }
8046}
8047
8048impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Node
8049where
8050 ___H: NodeServerHandler<___T> + ::core::marker::Send,
8051 ___T: ::fidl_next::Transport,
8052 for<'de> ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
8053 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8054 Constraint = (),
8055 >,
8056 for<'de> crate::wire::NodeDeprecatedCloneRequest: ::fidl_next::Decode<
8057 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8058 Constraint = (),
8059 >,
8060 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
8061 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8062 Constraint = (),
8063 >,
8064 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
8065 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8066 Constraint = (),
8067 >,
8068 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
8069 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8070 Constraint = (),
8071 >,
8072 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
8073 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8074 Constraint = (),
8075 >,
8076 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
8077 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8078 Constraint = (),
8079 >,
8080 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
8081 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8082 Constraint = (),
8083 >,
8084 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
8085 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8086 Constraint = (),
8087 >,
8088 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
8089 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8090 Constraint = (),
8091 >,
8092 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
8093 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8094 Constraint = (),
8095 >,
8096{
8097 async fn on_one_way(
8098 handler: &mut ___H,
8099 mut message: ::fidl_next::Message<___T>,
8100 ) -> ::core::result::Result<
8101 (),
8102 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8103 > {
8104 match *message.header().ordinal {
8105 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
8106 Ok(decoded) => {
8107 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
8108 Ok(())
8109 }
8110 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8111 ordinal: 2366825959783828089,
8112 error,
8113 }),
8114 },
8115
8116 6512600400724287855 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
8117 Ok(decoded) => {
8118 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
8119 Ok(())
8120 }
8121 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8122 ordinal: 6512600400724287855,
8123 error,
8124 }),
8125 },
8126
8127 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
8128 Ok(decoded) => {
8129 handler
8130 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
8131 .await;
8132 Ok(())
8133 }
8134 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8135 ordinal: 5431626189872037072,
8136 error,
8137 }),
8138 },
8139
8140 ordinal => {
8141 handler.on_unknown_interaction(ordinal).await;
8142 if ::core::matches!(
8143 message.header().flexibility(),
8144 ::fidl_next::protocol::Flexibility::Strict
8145 ) {
8146 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8147 } else {
8148 Ok(())
8149 }
8150 }
8151 }
8152 }
8153
8154 async fn on_two_way(
8155 handler: &mut ___H,
8156 mut message: ::fidl_next::Message<___T>,
8157 responder: ::fidl_next::protocol::Responder<___T>,
8158 ) -> ::core::result::Result<
8159 (),
8160 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8161 > {
8162 match *message.header().ordinal {
8163 6540867515453498750 => {
8164 let responder = ::fidl_next::Responder::from_untyped(responder);
8165
8166 handler.close(responder).await;
8167 Ok(())
8168 }
8169
8170 2763219980499352582 => {
8171 let responder = ::fidl_next::Responder::from_untyped(responder);
8172
8173 handler.query(responder).await;
8174 Ok(())
8175 }
8176
8177 8689798978500614909 => {
8178 let responder = ::fidl_next::Responder::from_untyped(responder);
8179
8180 handler.deprecated_get_attr(responder).await;
8181 Ok(())
8182 }
8183
8184 4721673413776871238 => {
8185 let responder = ::fidl_next::Responder::from_untyped(responder);
8186
8187 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8188 Ok(decoded) => {
8189 handler
8190 .deprecated_set_attr(
8191 ::fidl_next::Request::from_decoded(decoded),
8192 responder,
8193 )
8194 .await;
8195 Ok(())
8196 }
8197 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8198 ordinal: 4721673413776871238,
8199 error,
8200 }),
8201 }
8202 }
8203
8204 6595803110182632097 => {
8205 let responder = ::fidl_next::Responder::from_untyped(responder);
8206
8207 handler.deprecated_get_flags(responder).await;
8208 Ok(())
8209 }
8210
8211 5950864159036794675 => {
8212 let responder = ::fidl_next::Responder::from_untyped(responder);
8213
8214 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8215 Ok(decoded) => {
8216 handler
8217 .deprecated_set_flags(
8218 ::fidl_next::Request::from_decoded(decoded),
8219 responder,
8220 )
8221 .await;
8222 Ok(())
8223 }
8224 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8225 ordinal: 5950864159036794675,
8226 error,
8227 }),
8228 }
8229 }
8230
8231 105530239381466147 => {
8232 let responder = ::fidl_next::Responder::from_untyped(responder);
8233
8234 handler.get_flags(responder).await;
8235 Ok(())
8236 }
8237
8238 6172186066099445416 => {
8239 let responder = ::fidl_next::Responder::from_untyped(responder);
8240
8241 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8242 Ok(decoded) => {
8243 handler
8244 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
8245 .await;
8246 Ok(())
8247 }
8248 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8249 ordinal: 6172186066099445416,
8250 error,
8251 }),
8252 }
8253 }
8254
8255 8013111122914313744 => {
8256 let responder = ::fidl_next::Responder::from_untyped(responder);
8257
8258 handler.query_filesystem(responder).await;
8259 Ok(())
8260 }
8261
8262 4414537700416816443 => {
8263 let responder = ::fidl_next::Responder::from_untyped(responder);
8264
8265 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8266 Ok(decoded) => {
8267 handler
8268 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
8269 .await;
8270 Ok(())
8271 }
8272 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8273 ordinal: 4414537700416816443,
8274 error,
8275 }),
8276 }
8277 }
8278
8279 3677402239314018056 => {
8280 let responder = ::fidl_next::Responder::from_untyped(responder);
8281
8282 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8283 Ok(decoded) => {
8284 handler
8285 .update_attributes(
8286 ::fidl_next::Request::from_decoded(decoded),
8287 responder,
8288 )
8289 .await;
8290 Ok(())
8291 }
8292 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8293 ordinal: 3677402239314018056,
8294 error,
8295 }),
8296 }
8297 }
8298
8299 3196473584242777161 => {
8300 let responder = ::fidl_next::Responder::from_untyped(responder);
8301
8302 handler.sync(responder).await;
8303 Ok(())
8304 }
8305
8306 5043930208506967771 => {
8307 let responder = ::fidl_next::Responder::from_untyped(responder);
8308
8309 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8310 Ok(decoded) => {
8311 handler
8312 .get_extended_attribute(
8313 ::fidl_next::Request::from_decoded(decoded),
8314 responder,
8315 )
8316 .await;
8317 Ok(())
8318 }
8319 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8320 ordinal: 5043930208506967771,
8321 error,
8322 }),
8323 }
8324 }
8325
8326 5374223046099989052 => {
8327 let responder = ::fidl_next::Responder::from_untyped(responder);
8328
8329 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8330 Ok(decoded) => {
8331 handler
8332 .set_extended_attribute(
8333 ::fidl_next::Request::from_decoded(decoded),
8334 responder,
8335 )
8336 .await;
8337 Ok(())
8338 }
8339 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8340 ordinal: 5374223046099989052,
8341 error,
8342 }),
8343 }
8344 }
8345
8346 8794297771444732717 => {
8347 let responder = ::fidl_next::Responder::from_untyped(responder);
8348
8349 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8350 Ok(decoded) => {
8351 handler
8352 .remove_extended_attribute(
8353 ::fidl_next::Request::from_decoded(decoded),
8354 responder,
8355 )
8356 .await;
8357 Ok(())
8358 }
8359 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8360 ordinal: 8794297771444732717,
8361 error,
8362 }),
8363 }
8364 }
8365
8366 ordinal => {
8367 handler.on_unknown_interaction(ordinal).await;
8368 if ::core::matches!(
8369 message.header().flexibility(),
8370 ::fidl_next::protocol::Flexibility::Strict
8371 ) {
8372 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8373 } else {
8374 responder
8375 .respond_framework_error(
8376 ordinal,
8377 ::fidl_next::FrameworkError::UnknownMethod,
8378 )
8379 .expect("encoding a framework error should never fail")
8380 .await?;
8381 Ok(())
8382 }
8383 }
8384 }
8385 }
8386}
8387
8388impl<___T> NodeClientHandler<___T> for ::fidl_next::IgnoreEvents
8389where
8390 ___T: ::fidl_next::Transport,
8391{
8392 async fn on_open(&mut self, _: ::fidl_next::Request<node::OnOpen, ___T>) {}
8393
8394 async fn on_representation(&mut self, _: ::fidl_next::Request<node::OnRepresentation, ___T>) {}
8395
8396 async fn on_unknown_interaction(&mut self, _: u64) {}
8397}
8398
8399impl<___H, ___T> NodeLocalClientHandler<___T> for ::fidl_next::Local<___H>
8400where
8401 ___H: NodeClientHandler<___T>,
8402 ___T: ::fidl_next::Transport,
8403{
8404 async fn on_open(&mut self, request: ::fidl_next::Request<node::OnOpen, ___T>) {
8405 ___H::on_open(&mut self.0, request).await
8406 }
8407
8408 async fn on_representation(
8409 &mut self,
8410
8411 request: ::fidl_next::Request<node::OnRepresentation, ___T>,
8412 ) {
8413 ___H::on_representation(&mut self.0, request).await
8414 }
8415
8416 async fn on_unknown_interaction(&mut self, ordinal: u64) {
8417 ___H::on_unknown_interaction(&mut self.0, ordinal).await
8418 }
8419}
8420
8421impl<___H, ___T> NodeLocalServerHandler<___T> for ::fidl_next::Local<___H>
8422where
8423 ___H: NodeServerHandler<___T>,
8424 ___T: ::fidl_next::Transport,
8425{
8426 async fn clone(&mut self, request: ::fidl_next::Request<node::Clone, ___T>) {
8427 ___H::clone(&mut self.0, request).await
8428 }
8429
8430 async fn close(&mut self, responder: ::fidl_next::Responder<node::Close, ___T>) {
8431 ___H::close(&mut self.0, responder).await
8432 }
8433
8434 async fn query(&mut self, responder: ::fidl_next::Responder<node::Query, ___T>) {
8435 ___H::query(&mut self.0, responder).await
8436 }
8437
8438 async fn deprecated_clone(
8439 &mut self,
8440
8441 request: ::fidl_next::Request<node::DeprecatedClone, ___T>,
8442 ) {
8443 ___H::deprecated_clone(&mut self.0, request).await
8444 }
8445
8446 async fn deprecated_get_attr(
8447 &mut self,
8448
8449 responder: ::fidl_next::Responder<node::DeprecatedGetAttr, ___T>,
8450 ) {
8451 ___H::deprecated_get_attr(&mut self.0, responder).await
8452 }
8453
8454 async fn deprecated_set_attr(
8455 &mut self,
8456
8457 request: ::fidl_next::Request<node::DeprecatedSetAttr, ___T>,
8458
8459 responder: ::fidl_next::Responder<node::DeprecatedSetAttr, ___T>,
8460 ) {
8461 ___H::deprecated_set_attr(&mut self.0, request, responder).await
8462 }
8463
8464 async fn deprecated_get_flags(
8465 &mut self,
8466
8467 responder: ::fidl_next::Responder<node::DeprecatedGetFlags, ___T>,
8468 ) {
8469 ___H::deprecated_get_flags(&mut self.0, responder).await
8470 }
8471
8472 async fn deprecated_set_flags(
8473 &mut self,
8474
8475 request: ::fidl_next::Request<node::DeprecatedSetFlags, ___T>,
8476
8477 responder: ::fidl_next::Responder<node::DeprecatedSetFlags, ___T>,
8478 ) {
8479 ___H::deprecated_set_flags(&mut self.0, request, responder).await
8480 }
8481
8482 async fn get_flags(&mut self, responder: ::fidl_next::Responder<node::GetFlags, ___T>) {
8483 ___H::get_flags(&mut self.0, responder).await
8484 }
8485
8486 async fn set_flags(
8487 &mut self,
8488
8489 request: ::fidl_next::Request<node::SetFlags, ___T>,
8490
8491 responder: ::fidl_next::Responder<node::SetFlags, ___T>,
8492 ) {
8493 ___H::set_flags(&mut self.0, request, responder).await
8494 }
8495
8496 async fn query_filesystem(
8497 &mut self,
8498
8499 responder: ::fidl_next::Responder<node::QueryFilesystem, ___T>,
8500 ) {
8501 ___H::query_filesystem(&mut self.0, responder).await
8502 }
8503
8504 async fn get_attributes(
8505 &mut self,
8506
8507 request: ::fidl_next::Request<node::GetAttributes, ___T>,
8508
8509 responder: ::fidl_next::Responder<node::GetAttributes, ___T>,
8510 ) {
8511 ___H::get_attributes(&mut self.0, request, responder).await
8512 }
8513
8514 async fn update_attributes(
8515 &mut self,
8516
8517 request: ::fidl_next::Request<node::UpdateAttributes, ___T>,
8518
8519 responder: ::fidl_next::Responder<node::UpdateAttributes, ___T>,
8520 ) {
8521 ___H::update_attributes(&mut self.0, request, responder).await
8522 }
8523
8524 async fn sync(&mut self, responder: ::fidl_next::Responder<node::Sync, ___T>) {
8525 ___H::sync(&mut self.0, responder).await
8526 }
8527
8528 async fn list_extended_attributes(
8529 &mut self,
8530
8531 request: ::fidl_next::Request<node::ListExtendedAttributes, ___T>,
8532 ) {
8533 ___H::list_extended_attributes(&mut self.0, request).await
8534 }
8535
8536 async fn get_extended_attribute(
8537 &mut self,
8538
8539 request: ::fidl_next::Request<node::GetExtendedAttribute, ___T>,
8540
8541 responder: ::fidl_next::Responder<node::GetExtendedAttribute, ___T>,
8542 ) {
8543 ___H::get_extended_attribute(&mut self.0, request, responder).await
8544 }
8545
8546 async fn set_extended_attribute(
8547 &mut self,
8548
8549 request: ::fidl_next::Request<node::SetExtendedAttribute, ___T>,
8550
8551 responder: ::fidl_next::Responder<node::SetExtendedAttribute, ___T>,
8552 ) {
8553 ___H::set_extended_attribute(&mut self.0, request, responder).await
8554 }
8555
8556 async fn remove_extended_attribute(
8557 &mut self,
8558
8559 request: ::fidl_next::Request<node::RemoveExtendedAttribute, ___T>,
8560
8561 responder: ::fidl_next::Responder<node::RemoveExtendedAttribute, ___T>,
8562 ) {
8563 ___H::remove_extended_attribute(&mut self.0, request, responder).await
8564 }
8565
8566 async fn on_unknown_interaction(&mut self, ordinal: u64) {
8567 ___H::on_unknown_interaction(&mut self.0, ordinal).await
8568 }
8569}
8570
8571#[doc = " Directory defines a node which is capable of containing other Objects.\n"]
8573#[derive(PartialEq, Debug)]
8574pub struct Directory;
8575
8576impl ::fidl_next::Discoverable for Directory {
8577 const PROTOCOL_NAME: &'static str = "fuchsia.io.Directory";
8578}
8579
8580#[cfg(target_os = "fuchsia")]
8581impl ::fidl_next::HasTransport for Directory {
8582 type Transport = ::fidl_next::fuchsia::zx::Channel;
8583}
8584
8585pub mod directory {
8586 pub mod prelude {
8587 pub use crate::{
8588 Directory, DirectoryClientHandler, DirectoryLocalClientHandler,
8589 DirectoryLocalServerHandler, DirectoryServerHandler, directory,
8590 };
8591
8592 pub use crate::natural::AdvisoryLockingAdvisoryLockRequest;
8593
8594 pub use crate::natural::AdvisoryLockingAdvisoryLockResponse;
8595
8596 pub use crate::natural::DirectoryCreateSymlinkRequest;
8597
8598 pub use crate::natural::DirectoryDeprecatedOpenRequest;
8599
8600 pub use crate::natural::DirectoryGetTokenResponse;
8601
8602 pub use crate::natural::DirectoryLinkRequest;
8603
8604 pub use crate::natural::DirectoryLinkResponse;
8605
8606 pub use crate::natural::DirectoryReadDirentsRequest;
8607
8608 pub use crate::natural::DirectoryReadDirentsResponse;
8609
8610 pub use crate::natural::DirectoryRenameRequest;
8611
8612 pub use crate::natural::DirectoryRewindResponse;
8613
8614 pub use crate::natural::DirectoryUnlinkRequest;
8615
8616 pub use crate::natural::DirectoryWatchRequest;
8617
8618 pub use crate::natural::DirectoryWatchResponse;
8619
8620 pub use crate::natural::DirectoryCreateSymlinkResponse;
8621
8622 pub use crate::natural::DirectoryRenameResponse;
8623
8624 pub use crate::natural::DirectoryUnlinkResponse;
8625
8626 pub use crate::natural::ExtendedAttributeValue;
8627
8628 pub use crate::natural::MutableNodeAttributes;
8629
8630 pub use crate::natural::NodeAttributes2;
8631
8632 pub use crate::natural::NodeDeprecatedCloneRequest;
8633
8634 pub use crate::natural::NodeDeprecatedGetAttrResponse;
8635
8636 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
8637
8638 pub use crate::natural::NodeDeprecatedSetAttrRequest;
8639
8640 pub use crate::natural::NodeDeprecatedSetAttrResponse;
8641
8642 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
8643
8644 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
8645
8646 pub use crate::natural::NodeGetAttributesRequest;
8647
8648 pub use crate::natural::NodeGetExtendedAttributeRequest;
8649
8650 pub use crate::natural::NodeListExtendedAttributesRequest;
8651
8652 pub use crate::natural::NodeOnOpenRequest;
8653
8654 pub use crate::natural::NodeQueryFilesystemResponse;
8655
8656 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
8657
8658 pub use crate::natural::NodeSetExtendedAttributeRequest;
8659
8660 pub use crate::natural::NodeSetFlagsRequest;
8661
8662 pub use crate::natural::NodeGetFlagsResponse;
8663
8664 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
8665
8666 pub use crate::natural::NodeSetExtendedAttributeResponse;
8667
8668 pub use crate::natural::NodeSetFlagsResponse;
8669
8670 pub use crate::natural::NodeSyncResponse;
8671
8672 pub use crate::natural::NodeUpdateAttributesResponse;
8673
8674 pub use crate::natural::OpenableOpenRequest;
8675
8676 pub use crate::natural::Representation;
8677
8678 pub use ::fidl_next_fuchsia_unknown::natural::CloneableCloneRequest;
8679
8680 pub use ::fidl_next_fuchsia_unknown::natural::CloseableCloseResponse;
8681
8682 pub use ::fidl_next_fuchsia_unknown::natural::QueryableQueryResponse;
8683 }
8684
8685 pub struct AdvisoryLock;
8686
8687 impl ::fidl_next::Method for AdvisoryLock {
8688 const ORDINAL: u64 = 7992130864415541162;
8689 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8690 ::fidl_next::protocol::Flexibility::Strict;
8691
8692 type Protocol = crate::Directory;
8693
8694 type Request = crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>;
8695 }
8696
8697 impl ::fidl_next::TwoWayMethod for AdvisoryLock {
8698 type Response = ::fidl_next::wire::Result<
8699 'static,
8700 crate::wire::AdvisoryLockingAdvisoryLockResponse,
8701 ::fidl_next::wire::fuchsia::Status,
8702 >;
8703 }
8704
8705 impl<___R> ::fidl_next::Respond<___R> for AdvisoryLock {
8706 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
8707
8708 fn respond(response: ___R) -> Self::Output {
8709 ::core::result::Result::Ok(response)
8710 }
8711 }
8712
8713 impl<___R> ::fidl_next::RespondErr<___R> for AdvisoryLock {
8714 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
8715
8716 fn respond_err(response: ___R) -> Self::Output {
8717 ::core::result::Result::Err(response)
8718 }
8719 }
8720
8721 pub struct Clone;
8722
8723 impl ::fidl_next::Method for Clone {
8724 const ORDINAL: u64 = 2366825959783828089;
8725 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8726 ::fidl_next::protocol::Flexibility::Strict;
8727
8728 type Protocol = crate::Directory;
8729
8730 type Request = ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest;
8731 }
8732
8733 pub struct Close;
8734
8735 impl ::fidl_next::Method for Close {
8736 const ORDINAL: u64 = 6540867515453498750;
8737 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8738 ::fidl_next::protocol::Flexibility::Strict;
8739
8740 type Protocol = crate::Directory;
8741
8742 type Request = ::fidl_next::wire::EmptyMessageBody;
8743 }
8744
8745 impl ::fidl_next::TwoWayMethod for Close {
8746 type Response = ::fidl_next::wire::Result<
8747 'static,
8748 ::fidl_next_fuchsia_unknown::wire::CloseableCloseResponse,
8749 ::fidl_next::wire::Int32,
8750 >;
8751 }
8752
8753 impl<___R> ::fidl_next::Respond<___R> for Close {
8754 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
8755
8756 fn respond(response: ___R) -> Self::Output {
8757 ::core::result::Result::Ok(response)
8758 }
8759 }
8760
8761 impl<___R> ::fidl_next::RespondErr<___R> for Close {
8762 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
8763
8764 fn respond_err(response: ___R) -> Self::Output {
8765 ::core::result::Result::Err(response)
8766 }
8767 }
8768
8769 pub struct Query;
8770
8771 impl ::fidl_next::Method for Query {
8772 const ORDINAL: u64 = 2763219980499352582;
8773 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8774 ::fidl_next::protocol::Flexibility::Strict;
8775
8776 type Protocol = crate::Directory;
8777
8778 type Request = ::fidl_next::wire::EmptyMessageBody;
8779 }
8780
8781 impl ::fidl_next::TwoWayMethod for Query {
8782 type Response = ::fidl_next::wire::Strict<
8783 ::fidl_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>,
8784 >;
8785 }
8786
8787 impl<___R> ::fidl_next::Respond<___R> for Query {
8788 type Output =
8789 ::fidl_next::Strict<::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>>;
8790
8791 fn respond(response: ___R) -> Self::Output {
8792 ::fidl_next::Strict(::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse {
8793 protocol: response,
8794 })
8795 }
8796 }
8797
8798 pub struct DeprecatedClone;
8799
8800 impl ::fidl_next::Method for DeprecatedClone {
8801 const ORDINAL: u64 = 6512600400724287855;
8802 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8803 ::fidl_next::protocol::Flexibility::Flexible;
8804
8805 type Protocol = crate::Directory;
8806
8807 type Request = crate::wire::NodeDeprecatedCloneRequest;
8808 }
8809
8810 pub struct OnOpen;
8811
8812 impl ::fidl_next::Method for OnOpen {
8813 const ORDINAL: u64 = 9207534335756671346;
8814 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8815 ::fidl_next::protocol::Flexibility::Flexible;
8816
8817 type Protocol = crate::Directory;
8818
8819 type Request = crate::wire::NodeOnOpenRequest<'static>;
8820 }
8821
8822 pub struct DeprecatedGetAttr;
8823
8824 impl ::fidl_next::Method for DeprecatedGetAttr {
8825 const ORDINAL: u64 = 8689798978500614909;
8826 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8827 ::fidl_next::protocol::Flexibility::Strict;
8828
8829 type Protocol = crate::Directory;
8830
8831 type Request = ::fidl_next::wire::EmptyMessageBody;
8832 }
8833
8834 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
8835 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetAttrResponse>;
8836 }
8837
8838 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
8839 type Output = ::fidl_next::Strict<___R>;
8840
8841 fn respond(response: ___R) -> Self::Output {
8842 ::fidl_next::Strict(response)
8843 }
8844 }
8845
8846 pub struct DeprecatedSetAttr;
8847
8848 impl ::fidl_next::Method for DeprecatedSetAttr {
8849 const ORDINAL: u64 = 4721673413776871238;
8850 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8851 ::fidl_next::protocol::Flexibility::Strict;
8852
8853 type Protocol = crate::Directory;
8854
8855 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
8856 }
8857
8858 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
8859 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetAttrResponse>;
8860 }
8861
8862 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
8863 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetAttrResponse<___R>>;
8864
8865 fn respond(response: ___R) -> Self::Output {
8866 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetAttrResponse { s: response })
8867 }
8868 }
8869
8870 pub struct DeprecatedGetFlags;
8871
8872 impl ::fidl_next::Method for DeprecatedGetFlags {
8873 const ORDINAL: u64 = 6595803110182632097;
8874 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8875 ::fidl_next::protocol::Flexibility::Strict;
8876
8877 type Protocol = crate::Directory;
8878
8879 type Request = ::fidl_next::wire::EmptyMessageBody;
8880 }
8881
8882 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
8883 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetFlagsResponse>;
8884 }
8885
8886 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
8887 type Output = ::fidl_next::Strict<___R>;
8888
8889 fn respond(response: ___R) -> Self::Output {
8890 ::fidl_next::Strict(response)
8891 }
8892 }
8893
8894 pub struct DeprecatedSetFlags;
8895
8896 impl ::fidl_next::Method for DeprecatedSetFlags {
8897 const ORDINAL: u64 = 5950864159036794675;
8898 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8899 ::fidl_next::protocol::Flexibility::Strict;
8900
8901 type Protocol = crate::Directory;
8902
8903 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
8904 }
8905
8906 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
8907 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetFlagsResponse>;
8908 }
8909
8910 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
8911 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetFlagsResponse<___R>>;
8912
8913 fn respond(response: ___R) -> Self::Output {
8914 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetFlagsResponse { s: response })
8915 }
8916 }
8917
8918 pub struct GetFlags;
8919
8920 impl ::fidl_next::Method for GetFlags {
8921 const ORDINAL: u64 = 105530239381466147;
8922 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8923 ::fidl_next::protocol::Flexibility::Flexible;
8924
8925 type Protocol = crate::Directory;
8926
8927 type Request = ::fidl_next::wire::EmptyMessageBody;
8928 }
8929
8930 impl ::fidl_next::TwoWayMethod for GetFlags {
8931 type Response = ::fidl_next::wire::Result<
8932 'static,
8933 crate::wire::NodeGetFlagsResponse,
8934 ::fidl_next::wire::fuchsia::Status,
8935 >;
8936 }
8937
8938 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
8939 type Output = ::core::result::Result<
8940 crate::generic::NodeGetFlagsResponse<___R>,
8941 ::fidl_next::util::Never,
8942 >;
8943
8944 fn respond(response: ___R) -> Self::Output {
8945 ::core::result::Result::Ok(crate::generic::NodeGetFlagsResponse { flags: response })
8946 }
8947 }
8948
8949 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
8950 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
8951
8952 fn respond_err(response: ___R) -> Self::Output {
8953 ::core::result::Result::Err(response)
8954 }
8955 }
8956
8957 pub struct SetFlags;
8958
8959 impl ::fidl_next::Method for SetFlags {
8960 const ORDINAL: u64 = 6172186066099445416;
8961 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8962 ::fidl_next::protocol::Flexibility::Flexible;
8963
8964 type Protocol = crate::Directory;
8965
8966 type Request = crate::wire::NodeSetFlagsRequest;
8967 }
8968
8969 impl ::fidl_next::TwoWayMethod for SetFlags {
8970 type Response = ::fidl_next::wire::Result<
8971 'static,
8972 crate::wire::NodeSetFlagsResponse,
8973 ::fidl_next::wire::fuchsia::Status,
8974 >;
8975 }
8976
8977 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
8978 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
8979
8980 fn respond(response: ___R) -> Self::Output {
8981 ::core::result::Result::Ok(response)
8982 }
8983 }
8984
8985 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
8986 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
8987
8988 fn respond_err(response: ___R) -> Self::Output {
8989 ::core::result::Result::Err(response)
8990 }
8991 }
8992
8993 pub struct QueryFilesystem;
8994
8995 impl ::fidl_next::Method for QueryFilesystem {
8996 const ORDINAL: u64 = 8013111122914313744;
8997 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8998 ::fidl_next::protocol::Flexibility::Strict;
8999
9000 type Protocol = crate::Directory;
9001
9002 type Request = ::fidl_next::wire::EmptyMessageBody;
9003 }
9004
9005 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
9006 type Response =
9007 ::fidl_next::wire::Strict<crate::wire::NodeQueryFilesystemResponse<'static>>;
9008 }
9009
9010 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
9011 type Output = ::fidl_next::Strict<___R>;
9012
9013 fn respond(response: ___R) -> Self::Output {
9014 ::fidl_next::Strict(response)
9015 }
9016 }
9017
9018 pub struct OnRepresentation;
9019
9020 impl ::fidl_next::Method for OnRepresentation {
9021 const ORDINAL: u64 = 6679970090861613324;
9022 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9023 ::fidl_next::protocol::Flexibility::Strict;
9024
9025 type Protocol = crate::Directory;
9026
9027 type Request = crate::wire::Representation<'static>;
9028 }
9029
9030 pub struct GetAttributes;
9031
9032 impl ::fidl_next::Method for GetAttributes {
9033 const ORDINAL: u64 = 4414537700416816443;
9034 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9035 ::fidl_next::protocol::Flexibility::Strict;
9036
9037 type Protocol = crate::Directory;
9038
9039 type Request = crate::wire::NodeGetAttributesRequest;
9040 }
9041
9042 impl ::fidl_next::TwoWayMethod for GetAttributes {
9043 type Response = ::fidl_next::wire::Result<
9044 'static,
9045 crate::wire::NodeAttributes2<'static>,
9046 ::fidl_next::wire::fuchsia::Status,
9047 >;
9048 }
9049
9050 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
9051 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9052
9053 fn respond(response: ___R) -> Self::Output {
9054 ::core::result::Result::Ok(response)
9055 }
9056 }
9057
9058 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
9059 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9060
9061 fn respond_err(response: ___R) -> Self::Output {
9062 ::core::result::Result::Err(response)
9063 }
9064 }
9065
9066 pub struct UpdateAttributes;
9067
9068 impl ::fidl_next::Method for UpdateAttributes {
9069 const ORDINAL: u64 = 3677402239314018056;
9070 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9071 ::fidl_next::protocol::Flexibility::Strict;
9072
9073 type Protocol = crate::Directory;
9074
9075 type Request = crate::wire::MutableNodeAttributes<'static>;
9076 }
9077
9078 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
9079 type Response = ::fidl_next::wire::Result<
9080 'static,
9081 crate::wire::NodeUpdateAttributesResponse,
9082 ::fidl_next::wire::fuchsia::Status,
9083 >;
9084 }
9085
9086 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
9087 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9088
9089 fn respond(response: ___R) -> Self::Output {
9090 ::core::result::Result::Ok(response)
9091 }
9092 }
9093
9094 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
9095 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9096
9097 fn respond_err(response: ___R) -> Self::Output {
9098 ::core::result::Result::Err(response)
9099 }
9100 }
9101
9102 pub struct Sync;
9103
9104 impl ::fidl_next::Method for Sync {
9105 const ORDINAL: u64 = 3196473584242777161;
9106 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9107 ::fidl_next::protocol::Flexibility::Strict;
9108
9109 type Protocol = crate::Directory;
9110
9111 type Request = ::fidl_next::wire::EmptyMessageBody;
9112 }
9113
9114 impl ::fidl_next::TwoWayMethod for Sync {
9115 type Response = ::fidl_next::wire::Result<
9116 'static,
9117 crate::wire::NodeSyncResponse,
9118 ::fidl_next::wire::fuchsia::Status,
9119 >;
9120 }
9121
9122 impl<___R> ::fidl_next::Respond<___R> for Sync {
9123 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9124
9125 fn respond(response: ___R) -> Self::Output {
9126 ::core::result::Result::Ok(response)
9127 }
9128 }
9129
9130 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
9131 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9132
9133 fn respond_err(response: ___R) -> Self::Output {
9134 ::core::result::Result::Err(response)
9135 }
9136 }
9137
9138 pub struct ListExtendedAttributes;
9139
9140 impl ::fidl_next::Method for ListExtendedAttributes {
9141 const ORDINAL: u64 = 5431626189872037072;
9142 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9143 ::fidl_next::protocol::Flexibility::Strict;
9144
9145 type Protocol = crate::Directory;
9146
9147 type Request = crate::wire::NodeListExtendedAttributesRequest;
9148 }
9149
9150 pub struct GetExtendedAttribute;
9151
9152 impl ::fidl_next::Method for GetExtendedAttribute {
9153 const ORDINAL: u64 = 5043930208506967771;
9154 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9155 ::fidl_next::protocol::Flexibility::Strict;
9156
9157 type Protocol = crate::Directory;
9158
9159 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
9160 }
9161
9162 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
9163 type Response = ::fidl_next::wire::Result<
9164 'static,
9165 crate::wire::ExtendedAttributeValue<'static>,
9166 ::fidl_next::wire::fuchsia::Status,
9167 >;
9168 }
9169
9170 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
9171 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9172
9173 fn respond(response: ___R) -> Self::Output {
9174 ::core::result::Result::Ok(response)
9175 }
9176 }
9177
9178 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
9179 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9180
9181 fn respond_err(response: ___R) -> Self::Output {
9182 ::core::result::Result::Err(response)
9183 }
9184 }
9185
9186 pub struct SetExtendedAttribute;
9187
9188 impl ::fidl_next::Method for SetExtendedAttribute {
9189 const ORDINAL: u64 = 5374223046099989052;
9190 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9191 ::fidl_next::protocol::Flexibility::Strict;
9192
9193 type Protocol = crate::Directory;
9194
9195 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
9196 }
9197
9198 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
9199 type Response = ::fidl_next::wire::Result<
9200 'static,
9201 crate::wire::NodeSetExtendedAttributeResponse,
9202 ::fidl_next::wire::fuchsia::Status,
9203 >;
9204 }
9205
9206 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
9207 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9208
9209 fn respond(response: ___R) -> Self::Output {
9210 ::core::result::Result::Ok(response)
9211 }
9212 }
9213
9214 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
9215 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9216
9217 fn respond_err(response: ___R) -> Self::Output {
9218 ::core::result::Result::Err(response)
9219 }
9220 }
9221
9222 pub struct RemoveExtendedAttribute;
9223
9224 impl ::fidl_next::Method for RemoveExtendedAttribute {
9225 const ORDINAL: u64 = 8794297771444732717;
9226 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9227 ::fidl_next::protocol::Flexibility::Strict;
9228
9229 type Protocol = crate::Directory;
9230
9231 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
9232 }
9233
9234 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
9235 type Response = ::fidl_next::wire::Result<
9236 'static,
9237 crate::wire::NodeRemoveExtendedAttributeResponse,
9238 ::fidl_next::wire::fuchsia::Status,
9239 >;
9240 }
9241
9242 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
9243 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9244
9245 fn respond(response: ___R) -> Self::Output {
9246 ::core::result::Result::Ok(response)
9247 }
9248 }
9249
9250 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
9251 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9252
9253 fn respond_err(response: ___R) -> Self::Output {
9254 ::core::result::Result::Err(response)
9255 }
9256 }
9257
9258 pub struct Open;
9259
9260 impl ::fidl_next::Method for Open {
9261 const ORDINAL: u64 = 6236883748953765593;
9262 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9263 ::fidl_next::protocol::Flexibility::Flexible;
9264
9265 type Protocol = crate::Directory;
9266
9267 type Request = crate::wire::OpenableOpenRequest<'static>;
9268 }
9269
9270 pub struct DeprecatedOpen;
9271
9272 impl ::fidl_next::Method for DeprecatedOpen {
9273 const ORDINAL: u64 = 3193127272456937152;
9274 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9275 ::fidl_next::protocol::Flexibility::Flexible;
9276
9277 type Protocol = crate::Directory;
9278
9279 type Request = crate::wire::DirectoryDeprecatedOpenRequest<'static>;
9280 }
9281
9282 pub struct ReadDirents;
9283
9284 impl ::fidl_next::Method for ReadDirents {
9285 const ORDINAL: u64 = 3855785432100874762;
9286 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9287 ::fidl_next::protocol::Flexibility::Strict;
9288
9289 type Protocol = crate::Directory;
9290
9291 type Request = crate::wire::DirectoryReadDirentsRequest;
9292 }
9293
9294 impl ::fidl_next::TwoWayMethod for ReadDirents {
9295 type Response =
9296 ::fidl_next::wire::Strict<crate::wire::DirectoryReadDirentsResponse<'static>>;
9297 }
9298
9299 impl<___R> ::fidl_next::Respond<___R> for ReadDirents {
9300 type Output = ::fidl_next::Strict<___R>;
9301
9302 fn respond(response: ___R) -> Self::Output {
9303 ::fidl_next::Strict(response)
9304 }
9305 }
9306
9307 pub struct Rewind;
9308
9309 impl ::fidl_next::Method for Rewind {
9310 const ORDINAL: u64 = 1635123508515392625;
9311 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9312 ::fidl_next::protocol::Flexibility::Strict;
9313
9314 type Protocol = crate::Directory;
9315
9316 type Request = ::fidl_next::wire::EmptyMessageBody;
9317 }
9318
9319 impl ::fidl_next::TwoWayMethod for Rewind {
9320 type Response = ::fidl_next::wire::Strict<crate::wire::DirectoryRewindResponse>;
9321 }
9322
9323 impl<___R> ::fidl_next::Respond<___R> for Rewind {
9324 type Output = ::fidl_next::Strict<crate::generic::DirectoryRewindResponse<___R>>;
9325
9326 fn respond(response: ___R) -> Self::Output {
9327 ::fidl_next::Strict(crate::generic::DirectoryRewindResponse { s: response })
9328 }
9329 }
9330
9331 pub struct GetToken;
9332
9333 impl ::fidl_next::Method for GetToken {
9334 const ORDINAL: u64 = 2787337947777369685;
9335 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9336 ::fidl_next::protocol::Flexibility::Strict;
9337
9338 type Protocol = crate::Directory;
9339
9340 type Request = ::fidl_next::wire::EmptyMessageBody;
9341 }
9342
9343 impl ::fidl_next::TwoWayMethod for GetToken {
9344 type Response = ::fidl_next::wire::Strict<crate::wire::DirectoryGetTokenResponse>;
9345 }
9346
9347 impl<___R> ::fidl_next::Respond<___R> for GetToken {
9348 type Output = ::fidl_next::Strict<___R>;
9349
9350 fn respond(response: ___R) -> Self::Output {
9351 ::fidl_next::Strict(response)
9352 }
9353 }
9354
9355 pub struct Link;
9356
9357 impl ::fidl_next::Method for Link {
9358 const ORDINAL: u64 = 8360374984291987687;
9359 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9360 ::fidl_next::protocol::Flexibility::Strict;
9361
9362 type Protocol = crate::Directory;
9363
9364 type Request = crate::wire::DirectoryLinkRequest<'static>;
9365 }
9366
9367 impl ::fidl_next::TwoWayMethod for Link {
9368 type Response = ::fidl_next::wire::Strict<crate::wire::DirectoryLinkResponse>;
9369 }
9370
9371 impl<___R> ::fidl_next::Respond<___R> for Link {
9372 type Output = ::fidl_next::Strict<crate::generic::DirectoryLinkResponse<___R>>;
9373
9374 fn respond(response: ___R) -> Self::Output {
9375 ::fidl_next::Strict(crate::generic::DirectoryLinkResponse { s: response })
9376 }
9377 }
9378
9379 pub struct Unlink;
9380
9381 impl ::fidl_next::Method for Unlink {
9382 const ORDINAL: u64 = 8433556716759383021;
9383 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9384 ::fidl_next::protocol::Flexibility::Strict;
9385
9386 type Protocol = crate::Directory;
9387
9388 type Request = crate::wire::DirectoryUnlinkRequest<'static>;
9389 }
9390
9391 impl ::fidl_next::TwoWayMethod for Unlink {
9392 type Response = ::fidl_next::wire::Result<
9393 'static,
9394 crate::wire::DirectoryUnlinkResponse,
9395 ::fidl_next::wire::fuchsia::Status,
9396 >;
9397 }
9398
9399 impl<___R> ::fidl_next::Respond<___R> for Unlink {
9400 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9401
9402 fn respond(response: ___R) -> Self::Output {
9403 ::core::result::Result::Ok(response)
9404 }
9405 }
9406
9407 impl<___R> ::fidl_next::RespondErr<___R> for Unlink {
9408 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9409
9410 fn respond_err(response: ___R) -> Self::Output {
9411 ::core::result::Result::Err(response)
9412 }
9413 }
9414
9415 pub struct Rename;
9416
9417 impl ::fidl_next::Method for Rename {
9418 const ORDINAL: u64 = 8097726607824333022;
9419 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9420 ::fidl_next::protocol::Flexibility::Strict;
9421
9422 type Protocol = crate::Directory;
9423
9424 type Request = crate::wire::DirectoryRenameRequest<'static>;
9425 }
9426
9427 impl ::fidl_next::TwoWayMethod for Rename {
9428 type Response = ::fidl_next::wire::Result<
9429 'static,
9430 crate::wire::DirectoryRenameResponse,
9431 ::fidl_next::wire::fuchsia::Status,
9432 >;
9433 }
9434
9435 impl<___R> ::fidl_next::Respond<___R> for Rename {
9436 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9437
9438 fn respond(response: ___R) -> Self::Output {
9439 ::core::result::Result::Ok(response)
9440 }
9441 }
9442
9443 impl<___R> ::fidl_next::RespondErr<___R> for Rename {
9444 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9445
9446 fn respond_err(response: ___R) -> Self::Output {
9447 ::core::result::Result::Err(response)
9448 }
9449 }
9450
9451 pub struct CreateSymlink;
9452
9453 impl ::fidl_next::Method for CreateSymlink {
9454 const ORDINAL: u64 = 2435901052462315657;
9455 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9456 ::fidl_next::protocol::Flexibility::Strict;
9457
9458 type Protocol = crate::Directory;
9459
9460 type Request = crate::wire::DirectoryCreateSymlinkRequest<'static>;
9461 }
9462
9463 impl ::fidl_next::TwoWayMethod for CreateSymlink {
9464 type Response = ::fidl_next::wire::Result<
9465 'static,
9466 crate::wire::DirectoryCreateSymlinkResponse,
9467 ::fidl_next::wire::fuchsia::Status,
9468 >;
9469 }
9470
9471 impl<___R> ::fidl_next::Respond<___R> for CreateSymlink {
9472 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9473
9474 fn respond(response: ___R) -> Self::Output {
9475 ::core::result::Result::Ok(response)
9476 }
9477 }
9478
9479 impl<___R> ::fidl_next::RespondErr<___R> for CreateSymlink {
9480 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9481
9482 fn respond_err(response: ___R) -> Self::Output {
9483 ::core::result::Result::Err(response)
9484 }
9485 }
9486
9487 pub struct Watch;
9488
9489 impl ::fidl_next::Method for Watch {
9490 const ORDINAL: u64 = 6275512344170098065;
9491 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9492 ::fidl_next::protocol::Flexibility::Strict;
9493
9494 type Protocol = crate::Directory;
9495
9496 type Request = crate::wire::DirectoryWatchRequest;
9497 }
9498
9499 impl ::fidl_next::TwoWayMethod for Watch {
9500 type Response = ::fidl_next::wire::Strict<crate::wire::DirectoryWatchResponse>;
9501 }
9502
9503 impl<___R> ::fidl_next::Respond<___R> for Watch {
9504 type Output = ::fidl_next::Strict<crate::generic::DirectoryWatchResponse<___R>>;
9505
9506 fn respond(response: ___R) -> Self::Output {
9507 ::fidl_next::Strict(crate::generic::DirectoryWatchResponse { s: response })
9508 }
9509 }
9510
9511 mod ___detail {
9512 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Directory
9513 where
9514 ___T: ::fidl_next::Transport,
9515 {
9516 type Client = DirectoryClient<___T>;
9517 type Server = DirectoryServer<___T>;
9518 }
9519
9520 #[repr(transparent)]
9522 pub struct DirectoryClient<___T: ::fidl_next::Transport> {
9523 #[allow(dead_code)]
9524 client: ::fidl_next::protocol::Client<___T>,
9525 }
9526
9527 impl<___T> DirectoryClient<___T>
9528 where
9529 ___T: ::fidl_next::Transport,
9530 {
9531 #[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"]
9532 pub fn advisory_lock(
9533 &self,
9534
9535 request: impl ::fidl_next::Encode<
9536 crate::wire::AdvisoryLockRequest<'static>,
9537 <___T as ::fidl_next::Transport>::SendBuffer,
9538 >,
9539 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
9540 where
9541 <___T as ::fidl_next::Transport>::SendBuffer:
9542 ::fidl_next::encoder::InternalHandleEncoder,
9543 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9544 {
9545 self.advisory_lock_with(crate::generic::AdvisoryLockingAdvisoryLockRequest {
9546 request,
9547 })
9548 }
9549
9550 #[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"]
9551 pub fn advisory_lock_with<___R>(
9552 &self,
9553 request: ___R,
9554 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
9555 where
9556 ___R: ::fidl_next::Encode<
9557 crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
9558 <___T as ::fidl_next::Transport>::SendBuffer,
9559 >,
9560 {
9561 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9562 7992130864415541162,
9563 <super::AdvisoryLock as ::fidl_next::Method>::FLEXIBILITY,
9564 request,
9565 ))
9566 }
9567
9568 pub fn clone(
9569 &self,
9570
9571 request: impl ::fidl_next::Encode<
9572 ::fidl_next::ServerEnd<
9573 ::fidl_next_fuchsia_unknown::Cloneable,
9574 ::fidl_next::wire::fuchsia::Channel,
9575 >,
9576 <___T as ::fidl_next::Transport>::SendBuffer,
9577 >,
9578 ) -> ::fidl_next::SendFuture<'_, ___T>
9579 where
9580 <___T as ::fidl_next::Transport>::SendBuffer:
9581 ::fidl_next::encoder::InternalHandleEncoder,
9582 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9583 {
9584 self.clone_with(::fidl_next_fuchsia_unknown::generic::CloneableCloneRequest {
9585 request,
9586 })
9587 }
9588
9589 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
9590 where
9591 ___R: ::fidl_next::Encode<
9592 ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest,
9593 <___T as ::fidl_next::Transport>::SendBuffer,
9594 >,
9595 {
9596 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
9597 2366825959783828089,
9598 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
9599 request,
9600 ))
9601 }
9602
9603 #[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"]
9604 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
9605 ::fidl_next::TwoWayFuture::from_untyped(
9606 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9607 6540867515453498750,
9608 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
9609 (),
9610 ),
9611 )
9612 }
9613
9614 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
9615 ::fidl_next::TwoWayFuture::from_untyped(
9616 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9617 2763219980499352582,
9618 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
9619 (),
9620 ),
9621 )
9622 }
9623
9624 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
9625 pub fn deprecated_clone(
9626 &self,
9627
9628 flags: impl ::fidl_next::Encode<
9629 crate::wire::OpenFlags,
9630 <___T as ::fidl_next::Transport>::SendBuffer,
9631 >,
9632
9633 object: impl ::fidl_next::Encode<
9634 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::wire::fuchsia::Channel>,
9635 <___T as ::fidl_next::Transport>::SendBuffer,
9636 >,
9637 ) -> ::fidl_next::SendFuture<'_, ___T>
9638 where
9639 <___T as ::fidl_next::Transport>::SendBuffer:
9640 ::fidl_next::encoder::InternalHandleEncoder,
9641 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9642 {
9643 self.deprecated_clone_with(crate::generic::NodeDeprecatedCloneRequest {
9644 flags,
9645
9646 object,
9647 })
9648 }
9649
9650 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
9651 pub fn deprecated_clone_with<___R>(
9652 &self,
9653 request: ___R,
9654 ) -> ::fidl_next::SendFuture<'_, ___T>
9655 where
9656 ___R: ::fidl_next::Encode<
9657 crate::wire::NodeDeprecatedCloneRequest,
9658 <___T as ::fidl_next::Transport>::SendBuffer,
9659 >,
9660 {
9661 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
9662 6512600400724287855,
9663 <super::DeprecatedClone as ::fidl_next::Method>::FLEXIBILITY,
9664 request,
9665 ))
9666 }
9667
9668 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
9669 pub fn deprecated_get_attr(
9670 &self,
9671 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
9672 ::fidl_next::TwoWayFuture::from_untyped(
9673 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9674 8689798978500614909,
9675 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
9676 (),
9677 ),
9678 )
9679 }
9680
9681 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
9682 pub fn deprecated_set_attr(
9683 &self,
9684
9685 flags: impl ::fidl_next::Encode<
9686 crate::wire::NodeAttributeFlags,
9687 <___T as ::fidl_next::Transport>::SendBuffer,
9688 >,
9689
9690 attributes: impl ::fidl_next::Encode<
9691 crate::wire::NodeAttributes,
9692 <___T as ::fidl_next::Transport>::SendBuffer,
9693 >,
9694 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
9695 where
9696 <___T as ::fidl_next::Transport>::SendBuffer:
9697 ::fidl_next::encoder::InternalHandleEncoder,
9698 {
9699 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
9700 flags,
9701
9702 attributes,
9703 })
9704 }
9705
9706 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
9707 pub fn deprecated_set_attr_with<___R>(
9708 &self,
9709 request: ___R,
9710 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
9711 where
9712 ___R: ::fidl_next::Encode<
9713 crate::wire::NodeDeprecatedSetAttrRequest,
9714 <___T as ::fidl_next::Transport>::SendBuffer,
9715 >,
9716 {
9717 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9718 4721673413776871238,
9719 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
9720 request,
9721 ))
9722 }
9723
9724 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
9725 pub fn deprecated_get_flags(
9726 &self,
9727 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
9728 ::fidl_next::TwoWayFuture::from_untyped(
9729 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9730 6595803110182632097,
9731 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
9732 (),
9733 ),
9734 )
9735 }
9736
9737 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
9738 pub fn deprecated_set_flags(
9739 &self,
9740
9741 flags: impl ::fidl_next::Encode<
9742 crate::wire::OpenFlags,
9743 <___T as ::fidl_next::Transport>::SendBuffer,
9744 >,
9745 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
9746 where
9747 <___T as ::fidl_next::Transport>::SendBuffer:
9748 ::fidl_next::encoder::InternalHandleEncoder,
9749 {
9750 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
9751 flags,
9752 })
9753 }
9754
9755 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
9756 pub fn deprecated_set_flags_with<___R>(
9757 &self,
9758 request: ___R,
9759 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
9760 where
9761 ___R: ::fidl_next::Encode<
9762 crate::wire::NodeDeprecatedSetFlagsRequest,
9763 <___T as ::fidl_next::Transport>::SendBuffer,
9764 >,
9765 {
9766 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9767 5950864159036794675,
9768 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
9769 request,
9770 ))
9771 }
9772
9773 #[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"]
9774 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
9775 ::fidl_next::TwoWayFuture::from_untyped(
9776 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9777 105530239381466147,
9778 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
9779 (),
9780 ),
9781 )
9782 }
9783
9784 #[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"]
9785 pub fn set_flags(
9786 &self,
9787
9788 flags: impl ::fidl_next::Encode<
9789 crate::wire::Flags,
9790 <___T as ::fidl_next::Transport>::SendBuffer,
9791 >,
9792 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
9793 where
9794 <___T as ::fidl_next::Transport>::SendBuffer:
9795 ::fidl_next::encoder::InternalHandleEncoder,
9796 {
9797 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
9798 }
9799
9800 #[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"]
9801 pub fn set_flags_with<___R>(
9802 &self,
9803 request: ___R,
9804 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
9805 where
9806 ___R: ::fidl_next::Encode<
9807 crate::wire::NodeSetFlagsRequest,
9808 <___T as ::fidl_next::Transport>::SendBuffer,
9809 >,
9810 {
9811 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9812 6172186066099445416,
9813 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
9814 request,
9815 ))
9816 }
9817
9818 #[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"]
9819 pub fn query_filesystem(
9820 &self,
9821 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
9822 ::fidl_next::TwoWayFuture::from_untyped(
9823 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9824 8013111122914313744,
9825 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
9826 (),
9827 ),
9828 )
9829 }
9830
9831 #[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"]
9832 pub fn get_attributes(
9833 &self,
9834
9835 query: impl ::fidl_next::Encode<
9836 crate::wire::NodeAttributesQuery,
9837 <___T as ::fidl_next::Transport>::SendBuffer,
9838 >,
9839 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
9840 where
9841 <___T as ::fidl_next::Transport>::SendBuffer:
9842 ::fidl_next::encoder::InternalHandleEncoder,
9843 {
9844 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
9845 }
9846
9847 #[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"]
9848 pub fn get_attributes_with<___R>(
9849 &self,
9850 request: ___R,
9851 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
9852 where
9853 ___R: ::fidl_next::Encode<
9854 crate::wire::NodeGetAttributesRequest,
9855 <___T as ::fidl_next::Transport>::SendBuffer,
9856 >,
9857 {
9858 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9859 4414537700416816443,
9860 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
9861 request,
9862 ))
9863 }
9864
9865 #[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"]
9866 pub fn update_attributes_with<___R>(
9867 &self,
9868 request: ___R,
9869 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
9870 where
9871 ___R: ::fidl_next::Encode<
9872 crate::wire::MutableNodeAttributes<'static>,
9873 <___T as ::fidl_next::Transport>::SendBuffer,
9874 >,
9875 {
9876 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9877 3677402239314018056,
9878 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
9879 request,
9880 ))
9881 }
9882
9883 #[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"]
9884 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
9885 ::fidl_next::TwoWayFuture::from_untyped(
9886 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9887 3196473584242777161,
9888 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
9889 (),
9890 ),
9891 )
9892 }
9893
9894 #[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"]
9895 pub fn list_extended_attributes(
9896 &self,
9897
9898 iterator: impl ::fidl_next::Encode<
9899 ::fidl_next::ServerEnd<
9900 crate::ExtendedAttributeIterator,
9901 ::fidl_next::wire::fuchsia::Channel,
9902 >,
9903 <___T as ::fidl_next::Transport>::SendBuffer,
9904 >,
9905 ) -> ::fidl_next::SendFuture<'_, ___T>
9906 where
9907 <___T as ::fidl_next::Transport>::SendBuffer:
9908 ::fidl_next::encoder::InternalHandleEncoder,
9909 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9910 {
9911 self.list_extended_attributes_with(
9912 crate::generic::NodeListExtendedAttributesRequest { iterator },
9913 )
9914 }
9915
9916 #[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"]
9917 pub fn list_extended_attributes_with<___R>(
9918 &self,
9919 request: ___R,
9920 ) -> ::fidl_next::SendFuture<'_, ___T>
9921 where
9922 ___R: ::fidl_next::Encode<
9923 crate::wire::NodeListExtendedAttributesRequest,
9924 <___T as ::fidl_next::Transport>::SendBuffer,
9925 >,
9926 {
9927 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
9928 5431626189872037072,
9929 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
9930 request,
9931 ))
9932 }
9933
9934 #[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"]
9935 pub fn get_extended_attribute(
9936 &self,
9937
9938 name: impl ::fidl_next::Encode<
9939 ::fidl_next::wire::Vector<'static, u8>,
9940 <___T as ::fidl_next::Transport>::SendBuffer,
9941 >,
9942 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
9943 where
9944 <___T as ::fidl_next::Transport>::SendBuffer:
9945 ::fidl_next::encoder::InternalHandleEncoder,
9946 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9947 {
9948 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
9949 name,
9950 })
9951 }
9952
9953 #[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"]
9954 pub fn get_extended_attribute_with<___R>(
9955 &self,
9956 request: ___R,
9957 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
9958 where
9959 ___R: ::fidl_next::Encode<
9960 crate::wire::NodeGetExtendedAttributeRequest<'static>,
9961 <___T as ::fidl_next::Transport>::SendBuffer,
9962 >,
9963 {
9964 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9965 5043930208506967771,
9966 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
9967 request,
9968 ))
9969 }
9970
9971 #[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"]
9972 pub fn set_extended_attribute(
9973 &self,
9974
9975 name: impl ::fidl_next::Encode<
9976 ::fidl_next::wire::Vector<'static, u8>,
9977 <___T as ::fidl_next::Transport>::SendBuffer,
9978 >,
9979
9980 value: impl ::fidl_next::Encode<
9981 crate::wire::ExtendedAttributeValue<'static>,
9982 <___T as ::fidl_next::Transport>::SendBuffer,
9983 >,
9984
9985 mode: impl ::fidl_next::Encode<
9986 crate::wire::SetExtendedAttributeMode,
9987 <___T as ::fidl_next::Transport>::SendBuffer,
9988 >,
9989 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
9990 where
9991 <___T as ::fidl_next::Transport>::SendBuffer:
9992 ::fidl_next::encoder::InternalHandleEncoder,
9993 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9994 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9995 {
9996 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
9997 name,
9998
9999 value,
10000
10001 mode,
10002 })
10003 }
10004
10005 #[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"]
10006 pub fn set_extended_attribute_with<___R>(
10007 &self,
10008 request: ___R,
10009 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
10010 where
10011 ___R: ::fidl_next::Encode<
10012 crate::wire::NodeSetExtendedAttributeRequest<'static>,
10013 <___T as ::fidl_next::Transport>::SendBuffer,
10014 >,
10015 {
10016 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10017 5374223046099989052,
10018 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
10019 request,
10020 ))
10021 }
10022
10023 #[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"]
10024 pub fn remove_extended_attribute(
10025 &self,
10026
10027 name: impl ::fidl_next::Encode<
10028 ::fidl_next::wire::Vector<'static, u8>,
10029 <___T as ::fidl_next::Transport>::SendBuffer,
10030 >,
10031 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
10032 where
10033 <___T as ::fidl_next::Transport>::SendBuffer:
10034 ::fidl_next::encoder::InternalHandleEncoder,
10035 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10036 {
10037 self.remove_extended_attribute_with(
10038 crate::generic::NodeRemoveExtendedAttributeRequest { name },
10039 )
10040 }
10041
10042 #[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"]
10043 pub fn remove_extended_attribute_with<___R>(
10044 &self,
10045 request: ___R,
10046 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
10047 where
10048 ___R: ::fidl_next::Encode<
10049 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
10050 <___T as ::fidl_next::Transport>::SendBuffer,
10051 >,
10052 {
10053 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10054 8794297771444732717,
10055 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
10056 request,
10057 ))
10058 }
10059
10060 #[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"]
10061 pub fn open(
10062 &self,
10063
10064 path: impl ::fidl_next::Encode<
10065 ::fidl_next::wire::String<'static>,
10066 <___T as ::fidl_next::Transport>::SendBuffer,
10067 >,
10068
10069 flags: impl ::fidl_next::Encode<
10070 crate::wire::Flags,
10071 <___T as ::fidl_next::Transport>::SendBuffer,
10072 >,
10073
10074 options: impl ::fidl_next::Encode<
10075 crate::wire::Options<'static>,
10076 <___T as ::fidl_next::Transport>::SendBuffer,
10077 >,
10078
10079 object: impl ::fidl_next::Encode<
10080 ::fidl_next::wire::fuchsia::Channel,
10081 <___T as ::fidl_next::Transport>::SendBuffer,
10082 >,
10083 ) -> ::fidl_next::SendFuture<'_, ___T>
10084 where
10085 <___T as ::fidl_next::Transport>::SendBuffer:
10086 ::fidl_next::encoder::InternalHandleEncoder,
10087 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10088 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10089 {
10090 self.open_with(crate::generic::OpenableOpenRequest { path, flags, options, object })
10091 }
10092
10093 #[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"]
10094 pub fn open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
10095 where
10096 ___R: ::fidl_next::Encode<
10097 crate::wire::OpenableOpenRequest<'static>,
10098 <___T as ::fidl_next::Transport>::SendBuffer,
10099 >,
10100 {
10101 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
10102 6236883748953765593,
10103 <super::Open as ::fidl_next::Method>::FLEXIBILITY,
10104 request,
10105 ))
10106 }
10107
10108 #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
10109 pub fn deprecated_open(
10110 &self,
10111
10112 flags: impl ::fidl_next::Encode<
10113 crate::wire::OpenFlags,
10114 <___T as ::fidl_next::Transport>::SendBuffer,
10115 >,
10116
10117 mode: impl ::fidl_next::Encode<
10118 crate::wire::ModeType,
10119 <___T as ::fidl_next::Transport>::SendBuffer,
10120 >,
10121
10122 path: impl ::fidl_next::Encode<
10123 ::fidl_next::wire::String<'static>,
10124 <___T as ::fidl_next::Transport>::SendBuffer,
10125 >,
10126
10127 object: impl ::fidl_next::Encode<
10128 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::wire::fuchsia::Channel>,
10129 <___T as ::fidl_next::Transport>::SendBuffer,
10130 >,
10131 ) -> ::fidl_next::SendFuture<'_, ___T>
10132 where
10133 <___T as ::fidl_next::Transport>::SendBuffer:
10134 ::fidl_next::encoder::InternalHandleEncoder,
10135 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10136 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10137 {
10138 self.deprecated_open_with(crate::generic::DirectoryDeprecatedOpenRequest {
10139 flags,
10140
10141 mode,
10142
10143 path,
10144
10145 object,
10146 })
10147 }
10148
10149 #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
10150 pub fn deprecated_open_with<___R>(
10151 &self,
10152 request: ___R,
10153 ) -> ::fidl_next::SendFuture<'_, ___T>
10154 where
10155 ___R: ::fidl_next::Encode<
10156 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
10157 <___T as ::fidl_next::Transport>::SendBuffer,
10158 >,
10159 {
10160 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
10161 3193127272456937152,
10162 <super::DeprecatedOpen as ::fidl_next::Method>::FLEXIBILITY,
10163 request,
10164 ))
10165 }
10166
10167 #[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"]
10168 pub fn read_dirents(
10169 &self,
10170
10171 max_bytes: impl ::fidl_next::Encode<
10172 ::fidl_next::wire::Uint64,
10173 <___T as ::fidl_next::Transport>::SendBuffer,
10174 >,
10175 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadDirents, ___T>
10176 where
10177 <___T as ::fidl_next::Transport>::SendBuffer:
10178 ::fidl_next::encoder::InternalHandleEncoder,
10179 {
10180 self.read_dirents_with(crate::generic::DirectoryReadDirentsRequest { max_bytes })
10181 }
10182
10183 #[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"]
10184 pub fn read_dirents_with<___R>(
10185 &self,
10186 request: ___R,
10187 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadDirents, ___T>
10188 where
10189 ___R: ::fidl_next::Encode<
10190 crate::wire::DirectoryReadDirentsRequest,
10191 <___T as ::fidl_next::Transport>::SendBuffer,
10192 >,
10193 {
10194 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10195 3855785432100874762,
10196 <super::ReadDirents as ::fidl_next::Method>::FLEXIBILITY,
10197 request,
10198 ))
10199 }
10200
10201 #[doc = " Resets the directory seek offset.\n\n This method does not require any rights, similar to ReadDirents.\n"]
10202 pub fn rewind(&self) -> ::fidl_next::TwoWayFuture<'_, super::Rewind, ___T> {
10203 ::fidl_next::TwoWayFuture::from_untyped(
10204 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10205 1635123508515392625,
10206 <super::Rewind as ::fidl_next::Method>::FLEXIBILITY,
10207 (),
10208 ),
10209 )
10210 }
10211
10212 #[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"]
10213 pub fn get_token(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetToken, ___T> {
10214 ::fidl_next::TwoWayFuture::from_untyped(
10215 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10216 2787337947777369685,
10217 <super::GetToken as ::fidl_next::Method>::FLEXIBILITY,
10218 (),
10219 ),
10220 )
10221 }
10222
10223 #[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"]
10224 pub fn link(
10225 &self,
10226
10227 src: impl ::fidl_next::Encode<
10228 ::fidl_next::wire::String<'static>,
10229 <___T as ::fidl_next::Transport>::SendBuffer,
10230 >,
10231
10232 dst_parent_token: impl ::fidl_next::Encode<
10233 ::fidl_next::wire::fuchsia::NullableHandle,
10234 <___T as ::fidl_next::Transport>::SendBuffer,
10235 >,
10236
10237 dst: impl ::fidl_next::Encode<
10238 ::fidl_next::wire::String<'static>,
10239 <___T as ::fidl_next::Transport>::SendBuffer,
10240 >,
10241 ) -> ::fidl_next::TwoWayFuture<'_, super::Link, ___T>
10242 where
10243 <___T as ::fidl_next::Transport>::SendBuffer:
10244 ::fidl_next::encoder::InternalHandleEncoder,
10245 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10246 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10247 {
10248 self.link_with(crate::generic::DirectoryLinkRequest { src, dst_parent_token, dst })
10249 }
10250
10251 #[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"]
10252 pub fn link_with<___R>(
10253 &self,
10254 request: ___R,
10255 ) -> ::fidl_next::TwoWayFuture<'_, super::Link, ___T>
10256 where
10257 ___R: ::fidl_next::Encode<
10258 crate::wire::DirectoryLinkRequest<'static>,
10259 <___T as ::fidl_next::Transport>::SendBuffer,
10260 >,
10261 {
10262 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10263 8360374984291987687,
10264 <super::Link as ::fidl_next::Method>::FLEXIBILITY,
10265 request,
10266 ))
10267 }
10268
10269 #[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"]
10270 pub fn unlink(
10271 &self,
10272
10273 name: impl ::fidl_next::Encode<
10274 ::fidl_next::wire::String<'static>,
10275 <___T as ::fidl_next::Transport>::SendBuffer,
10276 >,
10277
10278 options: impl ::fidl_next::Encode<
10279 crate::wire::UnlinkOptions<'static>,
10280 <___T as ::fidl_next::Transport>::SendBuffer,
10281 >,
10282 ) -> ::fidl_next::TwoWayFuture<'_, super::Unlink, ___T>
10283 where
10284 <___T as ::fidl_next::Transport>::SendBuffer:
10285 ::fidl_next::encoder::InternalHandleEncoder,
10286 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10287 {
10288 self.unlink_with(crate::generic::DirectoryUnlinkRequest { name, options })
10289 }
10290
10291 #[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"]
10292 pub fn unlink_with<___R>(
10293 &self,
10294 request: ___R,
10295 ) -> ::fidl_next::TwoWayFuture<'_, super::Unlink, ___T>
10296 where
10297 ___R: ::fidl_next::Encode<
10298 crate::wire::DirectoryUnlinkRequest<'static>,
10299 <___T as ::fidl_next::Transport>::SendBuffer,
10300 >,
10301 {
10302 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10303 8433556716759383021,
10304 <super::Unlink as ::fidl_next::Method>::FLEXIBILITY,
10305 request,
10306 ))
10307 }
10308
10309 #[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"]
10310 pub fn rename(
10311 &self,
10312
10313 src: impl ::fidl_next::Encode<
10314 ::fidl_next::wire::String<'static>,
10315 <___T as ::fidl_next::Transport>::SendBuffer,
10316 >,
10317
10318 dst_parent_token: impl ::fidl_next::Encode<
10319 ::fidl_next::wire::fuchsia::Event,
10320 <___T as ::fidl_next::Transport>::SendBuffer,
10321 >,
10322
10323 dst: impl ::fidl_next::Encode<
10324 ::fidl_next::wire::String<'static>,
10325 <___T as ::fidl_next::Transport>::SendBuffer,
10326 >,
10327 ) -> ::fidl_next::TwoWayFuture<'_, super::Rename, ___T>
10328 where
10329 <___T as ::fidl_next::Transport>::SendBuffer:
10330 ::fidl_next::encoder::InternalHandleEncoder,
10331 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10332 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10333 {
10334 self.rename_with(crate::generic::DirectoryRenameRequest {
10335 src,
10336
10337 dst_parent_token,
10338
10339 dst,
10340 })
10341 }
10342
10343 #[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"]
10344 pub fn rename_with<___R>(
10345 &self,
10346 request: ___R,
10347 ) -> ::fidl_next::TwoWayFuture<'_, super::Rename, ___T>
10348 where
10349 ___R: ::fidl_next::Encode<
10350 crate::wire::DirectoryRenameRequest<'static>,
10351 <___T as ::fidl_next::Transport>::SendBuffer,
10352 >,
10353 {
10354 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10355 8097726607824333022,
10356 <super::Rename as ::fidl_next::Method>::FLEXIBILITY,
10357 request,
10358 ))
10359 }
10360
10361 #[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"]
10362 pub fn create_symlink(
10363 &self,
10364
10365 name: impl ::fidl_next::Encode<
10366 ::fidl_next::wire::String<'static>,
10367 <___T as ::fidl_next::Transport>::SendBuffer,
10368 >,
10369
10370 target: impl ::fidl_next::Encode<
10371 ::fidl_next::wire::Vector<'static, u8>,
10372 <___T as ::fidl_next::Transport>::SendBuffer,
10373 >,
10374
10375 connection: impl ::fidl_next::Encode<
10376 ::fidl_next::ServerEnd<
10377 crate::Symlink,
10378 ::fidl_next::wire::fuchsia::OptionalChannel,
10379 >,
10380 <___T as ::fidl_next::Transport>::SendBuffer,
10381 >,
10382 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateSymlink, ___T>
10383 where
10384 <___T as ::fidl_next::Transport>::SendBuffer:
10385 ::fidl_next::encoder::InternalHandleEncoder,
10386 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10387 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10388 {
10389 self.create_symlink_with(crate::generic::DirectoryCreateSymlinkRequest {
10390 name,
10391
10392 target,
10393
10394 connection,
10395 })
10396 }
10397
10398 #[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"]
10399 pub fn create_symlink_with<___R>(
10400 &self,
10401 request: ___R,
10402 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateSymlink, ___T>
10403 where
10404 ___R: ::fidl_next::Encode<
10405 crate::wire::DirectoryCreateSymlinkRequest<'static>,
10406 <___T as ::fidl_next::Transport>::SendBuffer,
10407 >,
10408 {
10409 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10410 2435901052462315657,
10411 <super::CreateSymlink as ::fidl_next::Method>::FLEXIBILITY,
10412 request,
10413 ))
10414 }
10415
10416 #[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"]
10417 pub fn watch(
10418 &self,
10419
10420 mask: impl ::fidl_next::Encode<
10421 crate::wire::WatchMask,
10422 <___T as ::fidl_next::Transport>::SendBuffer,
10423 >,
10424
10425 options: impl ::fidl_next::Encode<
10426 ::fidl_next::wire::Uint32,
10427 <___T as ::fidl_next::Transport>::SendBuffer,
10428 >,
10429
10430 watcher: impl ::fidl_next::Encode<
10431 ::fidl_next::ServerEnd<
10432 crate::DirectoryWatcher,
10433 ::fidl_next::wire::fuchsia::Channel,
10434 >,
10435 <___T as ::fidl_next::Transport>::SendBuffer,
10436 >,
10437 ) -> ::fidl_next::TwoWayFuture<'_, super::Watch, ___T>
10438 where
10439 <___T as ::fidl_next::Transport>::SendBuffer:
10440 ::fidl_next::encoder::InternalHandleEncoder,
10441 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::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::fuchsia::Status,
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: ::fidl_next::fuchsia::HandleEncoder,
10494 {
10495 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
10496 }
10497
10498 #[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"]
10499
10500 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
10501 where
10502 ___R: ::fidl_next::Encode<
10503 <super::OnOpen as ::fidl_next::Method>::Request,
10504 <___T as ::fidl_next::Transport>::SendBuffer,
10505 >,
10506 {
10507 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
10508 9207534335756671346,
10509 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
10510 request,
10511 ))
10512 }
10513
10514 #[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"]
10515
10516 pub fn on_representation_with<___R>(
10517 &self,
10518 request: ___R,
10519 ) -> ::fidl_next::SendFuture<'_, ___T>
10520 where
10521 ___R: ::fidl_next::Encode<
10522 <super::OnRepresentation as ::fidl_next::Method>::Request,
10523 <___T as ::fidl_next::Transport>::SendBuffer,
10524 >,
10525 {
10526 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
10527 6679970090861613324,
10528 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
10529 request,
10530 ))
10531 }
10532 }
10533 }
10534}
10535
10536#[diagnostic::on_unimplemented(
10537 note = "If {Self} implements the non-local DirectoryClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
10538)]
10539
10540pub trait DirectoryLocalClientHandler<
10544 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10545 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10546>
10547{
10548 #[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"]
10549 fn on_open(
10550 &mut self,
10551
10552 request: ::fidl_next::Request<directory::OnOpen, ___T>,
10553 ) -> impl ::core::future::Future<Output = ()>;
10554
10555 #[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"]
10556 fn on_representation(
10557 &mut self,
10558
10559 request: ::fidl_next::Request<directory::OnRepresentation, ___T>,
10560 ) -> impl ::core::future::Future<Output = ()>;
10561
10562 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
10563 ::core::future::ready(())
10564 }
10565}
10566
10567impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Directory
10568where
10569 ___H: DirectoryLocalClientHandler<___T>,
10570 ___T: ::fidl_next::Transport,
10571 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
10572 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10573 Constraint = (),
10574 >,
10575 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
10576 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10577 Constraint = (),
10578 >,
10579{
10580 async fn on_event(
10581 handler: &mut ___H,
10582 mut message: ::fidl_next::Message<___T>,
10583 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10584 match *message.header().ordinal {
10585 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
10586 Ok(decoded) => {
10587 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
10588 Ok(())
10589 }
10590 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10591 ordinal: 9207534335756671346,
10592 error,
10593 }),
10594 },
10595
10596 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
10597 Ok(decoded) => {
10598 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
10599 Ok(())
10600 }
10601 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10602 ordinal: 6679970090861613324,
10603 error,
10604 }),
10605 },
10606
10607 ordinal => {
10608 handler.on_unknown_interaction(ordinal).await;
10609 if ::core::matches!(
10610 message.header().flexibility(),
10611 ::fidl_next::protocol::Flexibility::Strict
10612 ) {
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 = ::fidl_next::fuchsia::zx::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> ::fidl_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 mut message: ::fidl_next::Message<___T>,
10958 ) -> ::core::result::Result<
10959 (),
10960 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10961 > {
10962 match *message.header().ordinal {
10963 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
10964 Ok(decoded) => {
10965 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
10966 Ok(())
10967 }
10968 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10969 ordinal: 2366825959783828089,
10970 error,
10971 }),
10972 },
10973
10974 6512600400724287855 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
10975 Ok(decoded) => {
10976 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
10977 Ok(())
10978 }
10979 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10980 ordinal: 6512600400724287855,
10981 error,
10982 }),
10983 },
10984
10985 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
10986 Ok(decoded) => {
10987 handler
10988 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
10989 .await;
10990 Ok(())
10991 }
10992 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10993 ordinal: 5431626189872037072,
10994 error,
10995 }),
10996 },
10997
10998 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
10999 Ok(decoded) => {
11000 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
11001 Ok(())
11002 }
11003 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11004 ordinal: 6236883748953765593,
11005 error,
11006 }),
11007 },
11008
11009 3193127272456937152 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
11010 Ok(decoded) => {
11011 handler.deprecated_open(::fidl_next::Request::from_decoded(decoded)).await;
11012 Ok(())
11013 }
11014 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11015 ordinal: 3193127272456937152,
11016 error,
11017 }),
11018 },
11019
11020 ordinal => {
11021 handler.on_unknown_interaction(ordinal).await;
11022 if ::core::matches!(
11023 message.header().flexibility(),
11024 ::fidl_next::protocol::Flexibility::Strict
11025 ) {
11026 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11027 } else {
11028 Ok(())
11029 }
11030 }
11031 }
11032 }
11033
11034 async fn on_two_way(
11035 handler: &mut ___H,
11036 mut message: ::fidl_next::Message<___T>,
11037 responder: ::fidl_next::protocol::Responder<___T>,
11038 ) -> ::core::result::Result<
11039 (),
11040 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11041 > {
11042 match *message.header().ordinal {
11043 7992130864415541162 => {
11044 let responder = ::fidl_next::Responder::from_untyped(responder);
11045
11046 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11047 Ok(decoded) => {
11048 handler
11049 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
11050 .await;
11051 Ok(())
11052 }
11053 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11054 ordinal: 7992130864415541162,
11055 error,
11056 }),
11057 }
11058 }
11059
11060 6540867515453498750 => {
11061 let responder = ::fidl_next::Responder::from_untyped(responder);
11062
11063 handler.close(responder).await;
11064 Ok(())
11065 }
11066
11067 2763219980499352582 => {
11068 let responder = ::fidl_next::Responder::from_untyped(responder);
11069
11070 handler.query(responder).await;
11071 Ok(())
11072 }
11073
11074 8689798978500614909 => {
11075 let responder = ::fidl_next::Responder::from_untyped(responder);
11076
11077 handler.deprecated_get_attr(responder).await;
11078 Ok(())
11079 }
11080
11081 4721673413776871238 => {
11082 let responder = ::fidl_next::Responder::from_untyped(responder);
11083
11084 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11085 Ok(decoded) => {
11086 handler
11087 .deprecated_set_attr(
11088 ::fidl_next::Request::from_decoded(decoded),
11089 responder,
11090 )
11091 .await;
11092 Ok(())
11093 }
11094 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11095 ordinal: 4721673413776871238,
11096 error,
11097 }),
11098 }
11099 }
11100
11101 6595803110182632097 => {
11102 let responder = ::fidl_next::Responder::from_untyped(responder);
11103
11104 handler.deprecated_get_flags(responder).await;
11105 Ok(())
11106 }
11107
11108 5950864159036794675 => {
11109 let responder = ::fidl_next::Responder::from_untyped(responder);
11110
11111 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11112 Ok(decoded) => {
11113 handler
11114 .deprecated_set_flags(
11115 ::fidl_next::Request::from_decoded(decoded),
11116 responder,
11117 )
11118 .await;
11119 Ok(())
11120 }
11121 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11122 ordinal: 5950864159036794675,
11123 error,
11124 }),
11125 }
11126 }
11127
11128 105530239381466147 => {
11129 let responder = ::fidl_next::Responder::from_untyped(responder);
11130
11131 handler.get_flags(responder).await;
11132 Ok(())
11133 }
11134
11135 6172186066099445416 => {
11136 let responder = ::fidl_next::Responder::from_untyped(responder);
11137
11138 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11139 Ok(decoded) => {
11140 handler
11141 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
11142 .await;
11143 Ok(())
11144 }
11145 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11146 ordinal: 6172186066099445416,
11147 error,
11148 }),
11149 }
11150 }
11151
11152 8013111122914313744 => {
11153 let responder = ::fidl_next::Responder::from_untyped(responder);
11154
11155 handler.query_filesystem(responder).await;
11156 Ok(())
11157 }
11158
11159 4414537700416816443 => {
11160 let responder = ::fidl_next::Responder::from_untyped(responder);
11161
11162 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11163 Ok(decoded) => {
11164 handler
11165 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
11166 .await;
11167 Ok(())
11168 }
11169 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11170 ordinal: 4414537700416816443,
11171 error,
11172 }),
11173 }
11174 }
11175
11176 3677402239314018056 => {
11177 let responder = ::fidl_next::Responder::from_untyped(responder);
11178
11179 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11180 Ok(decoded) => {
11181 handler
11182 .update_attributes(
11183 ::fidl_next::Request::from_decoded(decoded),
11184 responder,
11185 )
11186 .await;
11187 Ok(())
11188 }
11189 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11190 ordinal: 3677402239314018056,
11191 error,
11192 }),
11193 }
11194 }
11195
11196 3196473584242777161 => {
11197 let responder = ::fidl_next::Responder::from_untyped(responder);
11198
11199 handler.sync(responder).await;
11200 Ok(())
11201 }
11202
11203 5043930208506967771 => {
11204 let responder = ::fidl_next::Responder::from_untyped(responder);
11205
11206 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11207 Ok(decoded) => {
11208 handler
11209 .get_extended_attribute(
11210 ::fidl_next::Request::from_decoded(decoded),
11211 responder,
11212 )
11213 .await;
11214 Ok(())
11215 }
11216 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11217 ordinal: 5043930208506967771,
11218 error,
11219 }),
11220 }
11221 }
11222
11223 5374223046099989052 => {
11224 let responder = ::fidl_next::Responder::from_untyped(responder);
11225
11226 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11227 Ok(decoded) => {
11228 handler
11229 .set_extended_attribute(
11230 ::fidl_next::Request::from_decoded(decoded),
11231 responder,
11232 )
11233 .await;
11234 Ok(())
11235 }
11236 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11237 ordinal: 5374223046099989052,
11238 error,
11239 }),
11240 }
11241 }
11242
11243 8794297771444732717 => {
11244 let responder = ::fidl_next::Responder::from_untyped(responder);
11245
11246 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11247 Ok(decoded) => {
11248 handler
11249 .remove_extended_attribute(
11250 ::fidl_next::Request::from_decoded(decoded),
11251 responder,
11252 )
11253 .await;
11254 Ok(())
11255 }
11256 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11257 ordinal: 8794297771444732717,
11258 error,
11259 }),
11260 }
11261 }
11262
11263 3855785432100874762 => {
11264 let responder = ::fidl_next::Responder::from_untyped(responder);
11265
11266 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11267 Ok(decoded) => {
11268 handler
11269 .read_dirents(::fidl_next::Request::from_decoded(decoded), responder)
11270 .await;
11271 Ok(())
11272 }
11273 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11274 ordinal: 3855785432100874762,
11275 error,
11276 }),
11277 }
11278 }
11279
11280 1635123508515392625 => {
11281 let responder = ::fidl_next::Responder::from_untyped(responder);
11282
11283 handler.rewind(responder).await;
11284 Ok(())
11285 }
11286
11287 2787337947777369685 => {
11288 let responder = ::fidl_next::Responder::from_untyped(responder);
11289
11290 handler.get_token(responder).await;
11291 Ok(())
11292 }
11293
11294 8360374984291987687 => {
11295 let responder = ::fidl_next::Responder::from_untyped(responder);
11296
11297 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11298 Ok(decoded) => {
11299 handler.link(::fidl_next::Request::from_decoded(decoded), responder).await;
11300 Ok(())
11301 }
11302 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11303 ordinal: 8360374984291987687,
11304 error,
11305 }),
11306 }
11307 }
11308
11309 8433556716759383021 => {
11310 let responder = ::fidl_next::Responder::from_untyped(responder);
11311
11312 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11313 Ok(decoded) => {
11314 handler
11315 .unlink(::fidl_next::Request::from_decoded(decoded), responder)
11316 .await;
11317 Ok(())
11318 }
11319 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11320 ordinal: 8433556716759383021,
11321 error,
11322 }),
11323 }
11324 }
11325
11326 8097726607824333022 => {
11327 let responder = ::fidl_next::Responder::from_untyped(responder);
11328
11329 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11330 Ok(decoded) => {
11331 handler
11332 .rename(::fidl_next::Request::from_decoded(decoded), responder)
11333 .await;
11334 Ok(())
11335 }
11336 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11337 ordinal: 8097726607824333022,
11338 error,
11339 }),
11340 }
11341 }
11342
11343 2435901052462315657 => {
11344 let responder = ::fidl_next::Responder::from_untyped(responder);
11345
11346 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11347 Ok(decoded) => {
11348 handler
11349 .create_symlink(::fidl_next::Request::from_decoded(decoded), responder)
11350 .await;
11351 Ok(())
11352 }
11353 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11354 ordinal: 2435901052462315657,
11355 error,
11356 }),
11357 }
11358 }
11359
11360 6275512344170098065 => {
11361 let responder = ::fidl_next::Responder::from_untyped(responder);
11362
11363 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11364 Ok(decoded) => {
11365 handler.watch(::fidl_next::Request::from_decoded(decoded), responder).await;
11366 Ok(())
11367 }
11368 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11369 ordinal: 6275512344170098065,
11370 error,
11371 }),
11372 }
11373 }
11374
11375 ordinal => {
11376 handler.on_unknown_interaction(ordinal).await;
11377 if ::core::matches!(
11378 message.header().flexibility(),
11379 ::fidl_next::protocol::Flexibility::Strict
11380 ) {
11381 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11382 } else {
11383 responder
11384 .respond_framework_error(
11385 ordinal,
11386 ::fidl_next::FrameworkError::UnknownMethod,
11387 )
11388 .expect("encoding a framework error should never fail")
11389 .await?;
11390 Ok(())
11391 }
11392 }
11393 }
11394 }
11395}
11396
11397pub trait DirectoryClientHandler<
11401 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11402 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11403>
11404{
11405 #[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"]
11406 fn on_open(
11407 &mut self,
11408
11409 request: ::fidl_next::Request<directory::OnOpen, ___T>,
11410 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11411
11412 #[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"]
11413 fn on_representation(
11414 &mut self,
11415
11416 request: ::fidl_next::Request<directory::OnRepresentation, ___T>,
11417 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11418
11419 fn on_unknown_interaction(
11420 &mut self,
11421 ordinal: u64,
11422 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11423 ::core::future::ready(())
11424 }
11425}
11426
11427impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Directory
11428where
11429 ___H: DirectoryClientHandler<___T> + ::core::marker::Send,
11430 ___T: ::fidl_next::Transport,
11431 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
11432 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11433 Constraint = (),
11434 >,
11435 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
11436 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11437 Constraint = (),
11438 >,
11439{
11440 async fn on_event(
11441 handler: &mut ___H,
11442 mut message: ::fidl_next::Message<___T>,
11443 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11444 match *message.header().ordinal {
11445 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
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(message) {
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!(
11470 message.header().flexibility(),
11471 ::fidl_next::protocol::Flexibility::Strict
11472 ) {
11473 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11474 } else {
11475 Ok(())
11476 }
11477 }
11478 }
11479 }
11480}
11481
11482pub trait DirectoryServerHandler<
11486 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11487 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11488>
11489{
11490 #[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"]
11491 fn advisory_lock(
11492 &mut self,
11493
11494 request: ::fidl_next::Request<directory::AdvisoryLock, ___T>,
11495
11496 responder: ::fidl_next::Responder<directory::AdvisoryLock, ___T>,
11497 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11498
11499 fn clone(
11500 &mut self,
11501
11502 request: ::fidl_next::Request<directory::Clone, ___T>,
11503 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11504
11505 #[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"]
11506 fn close(
11507 &mut self,
11508
11509 responder: ::fidl_next::Responder<directory::Close, ___T>,
11510 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11511
11512 fn query(
11513 &mut self,
11514
11515 responder: ::fidl_next::Responder<directory::Query, ___T>,
11516 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11517
11518 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
11519 fn deprecated_clone(
11520 &mut self,
11521
11522 request: ::fidl_next::Request<directory::DeprecatedClone, ___T>,
11523 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11524
11525 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
11526 fn deprecated_get_attr(
11527 &mut self,
11528
11529 responder: ::fidl_next::Responder<directory::DeprecatedGetAttr, ___T>,
11530 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11531
11532 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
11533 fn deprecated_set_attr(
11534 &mut self,
11535
11536 request: ::fidl_next::Request<directory::DeprecatedSetAttr, ___T>,
11537
11538 responder: ::fidl_next::Responder<directory::DeprecatedSetAttr, ___T>,
11539 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11540
11541 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
11542 fn deprecated_get_flags(
11543 &mut self,
11544
11545 responder: ::fidl_next::Responder<directory::DeprecatedGetFlags, ___T>,
11546 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11547
11548 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
11549 fn deprecated_set_flags(
11550 &mut self,
11551
11552 request: ::fidl_next::Request<directory::DeprecatedSetFlags, ___T>,
11553
11554 responder: ::fidl_next::Responder<directory::DeprecatedSetFlags, ___T>,
11555 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11556
11557 #[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"]
11558 fn get_flags(
11559 &mut self,
11560
11561 responder: ::fidl_next::Responder<directory::GetFlags, ___T>,
11562 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11563
11564 #[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"]
11565 fn set_flags(
11566 &mut self,
11567
11568 request: ::fidl_next::Request<directory::SetFlags, ___T>,
11569
11570 responder: ::fidl_next::Responder<directory::SetFlags, ___T>,
11571 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11572
11573 #[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"]
11574 fn query_filesystem(
11575 &mut self,
11576
11577 responder: ::fidl_next::Responder<directory::QueryFilesystem, ___T>,
11578 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11579
11580 #[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"]
11581 fn get_attributes(
11582 &mut self,
11583
11584 request: ::fidl_next::Request<directory::GetAttributes, ___T>,
11585
11586 responder: ::fidl_next::Responder<directory::GetAttributes, ___T>,
11587 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11588
11589 #[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"]
11590 fn update_attributes(
11591 &mut self,
11592
11593 request: ::fidl_next::Request<directory::UpdateAttributes, ___T>,
11594
11595 responder: ::fidl_next::Responder<directory::UpdateAttributes, ___T>,
11596 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11597
11598 #[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"]
11599 fn sync(
11600 &mut self,
11601
11602 responder: ::fidl_next::Responder<directory::Sync, ___T>,
11603 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11604
11605 #[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"]
11606 fn list_extended_attributes(
11607 &mut self,
11608
11609 request: ::fidl_next::Request<directory::ListExtendedAttributes, ___T>,
11610 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11611
11612 #[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"]
11613 fn get_extended_attribute(
11614 &mut self,
11615
11616 request: ::fidl_next::Request<directory::GetExtendedAttribute, ___T>,
11617
11618 responder: ::fidl_next::Responder<directory::GetExtendedAttribute, ___T>,
11619 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11620
11621 #[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"]
11622 fn set_extended_attribute(
11623 &mut self,
11624
11625 request: ::fidl_next::Request<directory::SetExtendedAttribute, ___T>,
11626
11627 responder: ::fidl_next::Responder<directory::SetExtendedAttribute, ___T>,
11628 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11629
11630 #[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"]
11631 fn remove_extended_attribute(
11632 &mut self,
11633
11634 request: ::fidl_next::Request<directory::RemoveExtendedAttribute, ___T>,
11635
11636 responder: ::fidl_next::Responder<directory::RemoveExtendedAttribute, ___T>,
11637 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11638
11639 #[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"]
11640 fn open(
11641 &mut self,
11642
11643 request: ::fidl_next::Request<directory::Open, ___T>,
11644 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11645
11646 #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
11647 fn deprecated_open(
11648 &mut self,
11649
11650 request: ::fidl_next::Request<directory::DeprecatedOpen, ___T>,
11651 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11652
11653 #[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"]
11654 fn read_dirents(
11655 &mut self,
11656
11657 request: ::fidl_next::Request<directory::ReadDirents, ___T>,
11658
11659 responder: ::fidl_next::Responder<directory::ReadDirents, ___T>,
11660 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11661
11662 #[doc = " Resets the directory seek offset.\n\n This method does not require any rights, similar to ReadDirents.\n"]
11663 fn rewind(
11664 &mut self,
11665
11666 responder: ::fidl_next::Responder<directory::Rewind, ___T>,
11667 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11668
11669 #[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"]
11670 fn get_token(
11671 &mut self,
11672
11673 responder: ::fidl_next::Responder<directory::GetToken, ___T>,
11674 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11675
11676 #[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"]
11677 fn link(
11678 &mut self,
11679
11680 request: ::fidl_next::Request<directory::Link, ___T>,
11681
11682 responder: ::fidl_next::Responder<directory::Link, ___T>,
11683 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11684
11685 #[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"]
11686 fn unlink(
11687 &mut self,
11688
11689 request: ::fidl_next::Request<directory::Unlink, ___T>,
11690
11691 responder: ::fidl_next::Responder<directory::Unlink, ___T>,
11692 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11693
11694 #[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"]
11695 fn rename(
11696 &mut self,
11697
11698 request: ::fidl_next::Request<directory::Rename, ___T>,
11699
11700 responder: ::fidl_next::Responder<directory::Rename, ___T>,
11701 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11702
11703 #[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"]
11704 fn create_symlink(
11705 &mut self,
11706
11707 request: ::fidl_next::Request<directory::CreateSymlink, ___T>,
11708
11709 responder: ::fidl_next::Responder<directory::CreateSymlink, ___T>,
11710 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11711
11712 #[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"]
11713 fn watch(
11714 &mut self,
11715
11716 request: ::fidl_next::Request<directory::Watch, ___T>,
11717
11718 responder: ::fidl_next::Responder<directory::Watch, ___T>,
11719 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11720
11721 fn on_unknown_interaction(
11722 &mut self,
11723 ordinal: u64,
11724 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11725 ::core::future::ready(())
11726 }
11727}
11728
11729impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Directory
11730where
11731 ___H: DirectoryServerHandler<___T> + ::core::marker::Send,
11732 ___T: ::fidl_next::Transport,
11733 for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
11734 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11735 Constraint = (),
11736 >,
11737 for<'de> ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
11738 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11739 Constraint = (),
11740 >,
11741 for<'de> crate::wire::NodeDeprecatedCloneRequest: ::fidl_next::Decode<
11742 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11743 Constraint = (),
11744 >,
11745 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
11746 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11747 Constraint = (),
11748 >,
11749 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
11750 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11751 Constraint = (),
11752 >,
11753 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
11754 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11755 Constraint = (),
11756 >,
11757 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
11758 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11759 Constraint = (),
11760 >,
11761 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
11762 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11763 Constraint = (),
11764 >,
11765 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
11766 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11767 Constraint = (),
11768 >,
11769 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
11770 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11771 Constraint = (),
11772 >,
11773 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
11774 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11775 Constraint = (),
11776 >,
11777 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
11778 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11779 Constraint = (),
11780 >,
11781 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
11782 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11783 Constraint = (),
11784 >,
11785 for<'de> crate::wire::DirectoryDeprecatedOpenRequest<'de>: ::fidl_next::Decode<
11786 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11787 Constraint = (),
11788 >,
11789 for<'de> crate::wire::DirectoryReadDirentsRequest: ::fidl_next::Decode<
11790 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11791 Constraint = (),
11792 >,
11793 for<'de> crate::wire::DirectoryLinkRequest<'de>: ::fidl_next::Decode<
11794 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11795 Constraint = (),
11796 >,
11797 for<'de> crate::wire::DirectoryUnlinkRequest<'de>: ::fidl_next::Decode<
11798 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11799 Constraint = (),
11800 >,
11801 for<'de> crate::wire::DirectoryRenameRequest<'de>: ::fidl_next::Decode<
11802 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11803 Constraint = (),
11804 >,
11805 for<'de> crate::wire::DirectoryCreateSymlinkRequest<'de>: ::fidl_next::Decode<
11806 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11807 Constraint = (),
11808 >,
11809 for<'de> crate::wire::DirectoryWatchRequest: ::fidl_next::Decode<
11810 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11811 Constraint = (),
11812 >,
11813{
11814 async fn on_one_way(
11815 handler: &mut ___H,
11816 mut message: ::fidl_next::Message<___T>,
11817 ) -> ::core::result::Result<
11818 (),
11819 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11820 > {
11821 match *message.header().ordinal {
11822 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
11823 Ok(decoded) => {
11824 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
11825 Ok(())
11826 }
11827 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11828 ordinal: 2366825959783828089,
11829 error,
11830 }),
11831 },
11832
11833 6512600400724287855 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
11834 Ok(decoded) => {
11835 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
11836 Ok(())
11837 }
11838 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11839 ordinal: 6512600400724287855,
11840 error,
11841 }),
11842 },
11843
11844 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
11845 Ok(decoded) => {
11846 handler
11847 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
11848 .await;
11849 Ok(())
11850 }
11851 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11852 ordinal: 5431626189872037072,
11853 error,
11854 }),
11855 },
11856
11857 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
11858 Ok(decoded) => {
11859 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
11860 Ok(())
11861 }
11862 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11863 ordinal: 6236883748953765593,
11864 error,
11865 }),
11866 },
11867
11868 3193127272456937152 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
11869 Ok(decoded) => {
11870 handler.deprecated_open(::fidl_next::Request::from_decoded(decoded)).await;
11871 Ok(())
11872 }
11873 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11874 ordinal: 3193127272456937152,
11875 error,
11876 }),
11877 },
11878
11879 ordinal => {
11880 handler.on_unknown_interaction(ordinal).await;
11881 if ::core::matches!(
11882 message.header().flexibility(),
11883 ::fidl_next::protocol::Flexibility::Strict
11884 ) {
11885 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11886 } else {
11887 Ok(())
11888 }
11889 }
11890 }
11891 }
11892
11893 async fn on_two_way(
11894 handler: &mut ___H,
11895 mut message: ::fidl_next::Message<___T>,
11896 responder: ::fidl_next::protocol::Responder<___T>,
11897 ) -> ::core::result::Result<
11898 (),
11899 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11900 > {
11901 match *message.header().ordinal {
11902 7992130864415541162 => {
11903 let responder = ::fidl_next::Responder::from_untyped(responder);
11904
11905 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11906 Ok(decoded) => {
11907 handler
11908 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
11909 .await;
11910 Ok(())
11911 }
11912 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11913 ordinal: 7992130864415541162,
11914 error,
11915 }),
11916 }
11917 }
11918
11919 6540867515453498750 => {
11920 let responder = ::fidl_next::Responder::from_untyped(responder);
11921
11922 handler.close(responder).await;
11923 Ok(())
11924 }
11925
11926 2763219980499352582 => {
11927 let responder = ::fidl_next::Responder::from_untyped(responder);
11928
11929 handler.query(responder).await;
11930 Ok(())
11931 }
11932
11933 8689798978500614909 => {
11934 let responder = ::fidl_next::Responder::from_untyped(responder);
11935
11936 handler.deprecated_get_attr(responder).await;
11937 Ok(())
11938 }
11939
11940 4721673413776871238 => {
11941 let responder = ::fidl_next::Responder::from_untyped(responder);
11942
11943 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11944 Ok(decoded) => {
11945 handler
11946 .deprecated_set_attr(
11947 ::fidl_next::Request::from_decoded(decoded),
11948 responder,
11949 )
11950 .await;
11951 Ok(())
11952 }
11953 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11954 ordinal: 4721673413776871238,
11955 error,
11956 }),
11957 }
11958 }
11959
11960 6595803110182632097 => {
11961 let responder = ::fidl_next::Responder::from_untyped(responder);
11962
11963 handler.deprecated_get_flags(responder).await;
11964 Ok(())
11965 }
11966
11967 5950864159036794675 => {
11968 let responder = ::fidl_next::Responder::from_untyped(responder);
11969
11970 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11971 Ok(decoded) => {
11972 handler
11973 .deprecated_set_flags(
11974 ::fidl_next::Request::from_decoded(decoded),
11975 responder,
11976 )
11977 .await;
11978 Ok(())
11979 }
11980 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11981 ordinal: 5950864159036794675,
11982 error,
11983 }),
11984 }
11985 }
11986
11987 105530239381466147 => {
11988 let responder = ::fidl_next::Responder::from_untyped(responder);
11989
11990 handler.get_flags(responder).await;
11991 Ok(())
11992 }
11993
11994 6172186066099445416 => {
11995 let responder = ::fidl_next::Responder::from_untyped(responder);
11996
11997 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11998 Ok(decoded) => {
11999 handler
12000 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
12001 .await;
12002 Ok(())
12003 }
12004 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12005 ordinal: 6172186066099445416,
12006 error,
12007 }),
12008 }
12009 }
12010
12011 8013111122914313744 => {
12012 let responder = ::fidl_next::Responder::from_untyped(responder);
12013
12014 handler.query_filesystem(responder).await;
12015 Ok(())
12016 }
12017
12018 4414537700416816443 => {
12019 let responder = ::fidl_next::Responder::from_untyped(responder);
12020
12021 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12022 Ok(decoded) => {
12023 handler
12024 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
12025 .await;
12026 Ok(())
12027 }
12028 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12029 ordinal: 4414537700416816443,
12030 error,
12031 }),
12032 }
12033 }
12034
12035 3677402239314018056 => {
12036 let responder = ::fidl_next::Responder::from_untyped(responder);
12037
12038 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12039 Ok(decoded) => {
12040 handler
12041 .update_attributes(
12042 ::fidl_next::Request::from_decoded(decoded),
12043 responder,
12044 )
12045 .await;
12046 Ok(())
12047 }
12048 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12049 ordinal: 3677402239314018056,
12050 error,
12051 }),
12052 }
12053 }
12054
12055 3196473584242777161 => {
12056 let responder = ::fidl_next::Responder::from_untyped(responder);
12057
12058 handler.sync(responder).await;
12059 Ok(())
12060 }
12061
12062 5043930208506967771 => {
12063 let responder = ::fidl_next::Responder::from_untyped(responder);
12064
12065 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12066 Ok(decoded) => {
12067 handler
12068 .get_extended_attribute(
12069 ::fidl_next::Request::from_decoded(decoded),
12070 responder,
12071 )
12072 .await;
12073 Ok(())
12074 }
12075 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12076 ordinal: 5043930208506967771,
12077 error,
12078 }),
12079 }
12080 }
12081
12082 5374223046099989052 => {
12083 let responder = ::fidl_next::Responder::from_untyped(responder);
12084
12085 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12086 Ok(decoded) => {
12087 handler
12088 .set_extended_attribute(
12089 ::fidl_next::Request::from_decoded(decoded),
12090 responder,
12091 )
12092 .await;
12093 Ok(())
12094 }
12095 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12096 ordinal: 5374223046099989052,
12097 error,
12098 }),
12099 }
12100 }
12101
12102 8794297771444732717 => {
12103 let responder = ::fidl_next::Responder::from_untyped(responder);
12104
12105 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12106 Ok(decoded) => {
12107 handler
12108 .remove_extended_attribute(
12109 ::fidl_next::Request::from_decoded(decoded),
12110 responder,
12111 )
12112 .await;
12113 Ok(())
12114 }
12115 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12116 ordinal: 8794297771444732717,
12117 error,
12118 }),
12119 }
12120 }
12121
12122 3855785432100874762 => {
12123 let responder = ::fidl_next::Responder::from_untyped(responder);
12124
12125 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12126 Ok(decoded) => {
12127 handler
12128 .read_dirents(::fidl_next::Request::from_decoded(decoded), responder)
12129 .await;
12130 Ok(())
12131 }
12132 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12133 ordinal: 3855785432100874762,
12134 error,
12135 }),
12136 }
12137 }
12138
12139 1635123508515392625 => {
12140 let responder = ::fidl_next::Responder::from_untyped(responder);
12141
12142 handler.rewind(responder).await;
12143 Ok(())
12144 }
12145
12146 2787337947777369685 => {
12147 let responder = ::fidl_next::Responder::from_untyped(responder);
12148
12149 handler.get_token(responder).await;
12150 Ok(())
12151 }
12152
12153 8360374984291987687 => {
12154 let responder = ::fidl_next::Responder::from_untyped(responder);
12155
12156 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12157 Ok(decoded) => {
12158 handler.link(::fidl_next::Request::from_decoded(decoded), responder).await;
12159 Ok(())
12160 }
12161 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12162 ordinal: 8360374984291987687,
12163 error,
12164 }),
12165 }
12166 }
12167
12168 8433556716759383021 => {
12169 let responder = ::fidl_next::Responder::from_untyped(responder);
12170
12171 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12172 Ok(decoded) => {
12173 handler
12174 .unlink(::fidl_next::Request::from_decoded(decoded), responder)
12175 .await;
12176 Ok(())
12177 }
12178 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12179 ordinal: 8433556716759383021,
12180 error,
12181 }),
12182 }
12183 }
12184
12185 8097726607824333022 => {
12186 let responder = ::fidl_next::Responder::from_untyped(responder);
12187
12188 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12189 Ok(decoded) => {
12190 handler
12191 .rename(::fidl_next::Request::from_decoded(decoded), responder)
12192 .await;
12193 Ok(())
12194 }
12195 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12196 ordinal: 8097726607824333022,
12197 error,
12198 }),
12199 }
12200 }
12201
12202 2435901052462315657 => {
12203 let responder = ::fidl_next::Responder::from_untyped(responder);
12204
12205 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12206 Ok(decoded) => {
12207 handler
12208 .create_symlink(::fidl_next::Request::from_decoded(decoded), responder)
12209 .await;
12210 Ok(())
12211 }
12212 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12213 ordinal: 2435901052462315657,
12214 error,
12215 }),
12216 }
12217 }
12218
12219 6275512344170098065 => {
12220 let responder = ::fidl_next::Responder::from_untyped(responder);
12221
12222 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12223 Ok(decoded) => {
12224 handler.watch(::fidl_next::Request::from_decoded(decoded), responder).await;
12225 Ok(())
12226 }
12227 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12228 ordinal: 6275512344170098065,
12229 error,
12230 }),
12231 }
12232 }
12233
12234 ordinal => {
12235 handler.on_unknown_interaction(ordinal).await;
12236 if ::core::matches!(
12237 message.header().flexibility(),
12238 ::fidl_next::protocol::Flexibility::Strict
12239 ) {
12240 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12241 } else {
12242 responder
12243 .respond_framework_error(
12244 ordinal,
12245 ::fidl_next::FrameworkError::UnknownMethod,
12246 )
12247 .expect("encoding a framework error should never fail")
12248 .await?;
12249 Ok(())
12250 }
12251 }
12252 }
12253 }
12254}
12255
12256impl<___T> DirectoryClientHandler<___T> for ::fidl_next::IgnoreEvents
12257where
12258 ___T: ::fidl_next::Transport,
12259{
12260 async fn on_open(&mut self, _: ::fidl_next::Request<directory::OnOpen, ___T>) {}
12261
12262 async fn on_representation(
12263 &mut self,
12264
12265 _: ::fidl_next::Request<directory::OnRepresentation, ___T>,
12266 ) {
12267 }
12268
12269 async fn on_unknown_interaction(&mut self, _: u64) {}
12270}
12271
12272impl<___H, ___T> DirectoryLocalClientHandler<___T> for ::fidl_next::Local<___H>
12273where
12274 ___H: DirectoryClientHandler<___T>,
12275 ___T: ::fidl_next::Transport,
12276{
12277 async fn on_open(&mut self, request: ::fidl_next::Request<directory::OnOpen, ___T>) {
12278 ___H::on_open(&mut self.0, request).await
12279 }
12280
12281 async fn on_representation(
12282 &mut self,
12283
12284 request: ::fidl_next::Request<directory::OnRepresentation, ___T>,
12285 ) {
12286 ___H::on_representation(&mut self.0, request).await
12287 }
12288
12289 async fn on_unknown_interaction(&mut self, ordinal: u64) {
12290 ___H::on_unknown_interaction(&mut self.0, ordinal).await
12291 }
12292}
12293
12294impl<___H, ___T> DirectoryLocalServerHandler<___T> for ::fidl_next::Local<___H>
12295where
12296 ___H: DirectoryServerHandler<___T>,
12297 ___T: ::fidl_next::Transport,
12298{
12299 async fn advisory_lock(
12300 &mut self,
12301
12302 request: ::fidl_next::Request<directory::AdvisoryLock, ___T>,
12303
12304 responder: ::fidl_next::Responder<directory::AdvisoryLock, ___T>,
12305 ) {
12306 ___H::advisory_lock(&mut self.0, request, responder).await
12307 }
12308
12309 async fn clone(&mut self, request: ::fidl_next::Request<directory::Clone, ___T>) {
12310 ___H::clone(&mut self.0, request).await
12311 }
12312
12313 async fn close(&mut self, responder: ::fidl_next::Responder<directory::Close, ___T>) {
12314 ___H::close(&mut self.0, responder).await
12315 }
12316
12317 async fn query(&mut self, responder: ::fidl_next::Responder<directory::Query, ___T>) {
12318 ___H::query(&mut self.0, responder).await
12319 }
12320
12321 async fn deprecated_clone(
12322 &mut self,
12323
12324 request: ::fidl_next::Request<directory::DeprecatedClone, ___T>,
12325 ) {
12326 ___H::deprecated_clone(&mut self.0, request).await
12327 }
12328
12329 async fn deprecated_get_attr(
12330 &mut self,
12331
12332 responder: ::fidl_next::Responder<directory::DeprecatedGetAttr, ___T>,
12333 ) {
12334 ___H::deprecated_get_attr(&mut self.0, responder).await
12335 }
12336
12337 async fn deprecated_set_attr(
12338 &mut self,
12339
12340 request: ::fidl_next::Request<directory::DeprecatedSetAttr, ___T>,
12341
12342 responder: ::fidl_next::Responder<directory::DeprecatedSetAttr, ___T>,
12343 ) {
12344 ___H::deprecated_set_attr(&mut self.0, request, responder).await
12345 }
12346
12347 async fn deprecated_get_flags(
12348 &mut self,
12349
12350 responder: ::fidl_next::Responder<directory::DeprecatedGetFlags, ___T>,
12351 ) {
12352 ___H::deprecated_get_flags(&mut self.0, responder).await
12353 }
12354
12355 async fn deprecated_set_flags(
12356 &mut self,
12357
12358 request: ::fidl_next::Request<directory::DeprecatedSetFlags, ___T>,
12359
12360 responder: ::fidl_next::Responder<directory::DeprecatedSetFlags, ___T>,
12361 ) {
12362 ___H::deprecated_set_flags(&mut self.0, request, responder).await
12363 }
12364
12365 async fn get_flags(&mut self, responder: ::fidl_next::Responder<directory::GetFlags, ___T>) {
12366 ___H::get_flags(&mut self.0, responder).await
12367 }
12368
12369 async fn set_flags(
12370 &mut self,
12371
12372 request: ::fidl_next::Request<directory::SetFlags, ___T>,
12373
12374 responder: ::fidl_next::Responder<directory::SetFlags, ___T>,
12375 ) {
12376 ___H::set_flags(&mut self.0, request, responder).await
12377 }
12378
12379 async fn query_filesystem(
12380 &mut self,
12381
12382 responder: ::fidl_next::Responder<directory::QueryFilesystem, ___T>,
12383 ) {
12384 ___H::query_filesystem(&mut self.0, responder).await
12385 }
12386
12387 async fn get_attributes(
12388 &mut self,
12389
12390 request: ::fidl_next::Request<directory::GetAttributes, ___T>,
12391
12392 responder: ::fidl_next::Responder<directory::GetAttributes, ___T>,
12393 ) {
12394 ___H::get_attributes(&mut self.0, request, responder).await
12395 }
12396
12397 async fn update_attributes(
12398 &mut self,
12399
12400 request: ::fidl_next::Request<directory::UpdateAttributes, ___T>,
12401
12402 responder: ::fidl_next::Responder<directory::UpdateAttributes, ___T>,
12403 ) {
12404 ___H::update_attributes(&mut self.0, request, responder).await
12405 }
12406
12407 async fn sync(&mut self, responder: ::fidl_next::Responder<directory::Sync, ___T>) {
12408 ___H::sync(&mut self.0, responder).await
12409 }
12410
12411 async fn list_extended_attributes(
12412 &mut self,
12413
12414 request: ::fidl_next::Request<directory::ListExtendedAttributes, ___T>,
12415 ) {
12416 ___H::list_extended_attributes(&mut self.0, request).await
12417 }
12418
12419 async fn get_extended_attribute(
12420 &mut self,
12421
12422 request: ::fidl_next::Request<directory::GetExtendedAttribute, ___T>,
12423
12424 responder: ::fidl_next::Responder<directory::GetExtendedAttribute, ___T>,
12425 ) {
12426 ___H::get_extended_attribute(&mut self.0, request, responder).await
12427 }
12428
12429 async fn set_extended_attribute(
12430 &mut self,
12431
12432 request: ::fidl_next::Request<directory::SetExtendedAttribute, ___T>,
12433
12434 responder: ::fidl_next::Responder<directory::SetExtendedAttribute, ___T>,
12435 ) {
12436 ___H::set_extended_attribute(&mut self.0, request, responder).await
12437 }
12438
12439 async fn remove_extended_attribute(
12440 &mut self,
12441
12442 request: ::fidl_next::Request<directory::RemoveExtendedAttribute, ___T>,
12443
12444 responder: ::fidl_next::Responder<directory::RemoveExtendedAttribute, ___T>,
12445 ) {
12446 ___H::remove_extended_attribute(&mut self.0, request, responder).await
12447 }
12448
12449 async fn open(&mut self, request: ::fidl_next::Request<directory::Open, ___T>) {
12450 ___H::open(&mut self.0, request).await
12451 }
12452
12453 async fn deprecated_open(
12454 &mut self,
12455
12456 request: ::fidl_next::Request<directory::DeprecatedOpen, ___T>,
12457 ) {
12458 ___H::deprecated_open(&mut self.0, request).await
12459 }
12460
12461 async fn read_dirents(
12462 &mut self,
12463
12464 request: ::fidl_next::Request<directory::ReadDirents, ___T>,
12465
12466 responder: ::fidl_next::Responder<directory::ReadDirents, ___T>,
12467 ) {
12468 ___H::read_dirents(&mut self.0, request, responder).await
12469 }
12470
12471 async fn rewind(&mut self, responder: ::fidl_next::Responder<directory::Rewind, ___T>) {
12472 ___H::rewind(&mut self.0, responder).await
12473 }
12474
12475 async fn get_token(&mut self, responder: ::fidl_next::Responder<directory::GetToken, ___T>) {
12476 ___H::get_token(&mut self.0, responder).await
12477 }
12478
12479 async fn link(
12480 &mut self,
12481
12482 request: ::fidl_next::Request<directory::Link, ___T>,
12483
12484 responder: ::fidl_next::Responder<directory::Link, ___T>,
12485 ) {
12486 ___H::link(&mut self.0, request, responder).await
12487 }
12488
12489 async fn unlink(
12490 &mut self,
12491
12492 request: ::fidl_next::Request<directory::Unlink, ___T>,
12493
12494 responder: ::fidl_next::Responder<directory::Unlink, ___T>,
12495 ) {
12496 ___H::unlink(&mut self.0, request, responder).await
12497 }
12498
12499 async fn rename(
12500 &mut self,
12501
12502 request: ::fidl_next::Request<directory::Rename, ___T>,
12503
12504 responder: ::fidl_next::Responder<directory::Rename, ___T>,
12505 ) {
12506 ___H::rename(&mut self.0, request, responder).await
12507 }
12508
12509 async fn create_symlink(
12510 &mut self,
12511
12512 request: ::fidl_next::Request<directory::CreateSymlink, ___T>,
12513
12514 responder: ::fidl_next::Responder<directory::CreateSymlink, ___T>,
12515 ) {
12516 ___H::create_symlink(&mut self.0, request, responder).await
12517 }
12518
12519 async fn watch(
12520 &mut self,
12521
12522 request: ::fidl_next::Request<directory::Watch, ___T>,
12523
12524 responder: ::fidl_next::Responder<directory::Watch, ___T>,
12525 ) {
12526 ___H::watch(&mut self.0, request, responder).await
12527 }
12528
12529 async fn on_unknown_interaction(&mut self, ordinal: u64) {
12530 ___H::on_unknown_interaction(&mut self.0, ordinal).await
12531 }
12532}
12533
12534#[derive(PartialEq, Debug)]
12536pub struct Linkable;
12537
12538#[cfg(target_os = "fuchsia")]
12539impl ::fidl_next::HasTransport for Linkable {
12540 type Transport = ::fidl_next::fuchsia::zx::Channel;
12541}
12542
12543pub mod linkable {
12544 pub mod prelude {
12545 pub use crate::{
12546 Linkable, LinkableClientHandler, LinkableLocalClientHandler,
12547 LinkableLocalServerHandler, LinkableServerHandler, linkable,
12548 };
12549
12550 pub use crate::natural::LinkableLinkIntoRequest;
12551
12552 pub use crate::natural::LinkableLinkIntoResponse;
12553 }
12554
12555 pub struct LinkInto;
12556
12557 impl ::fidl_next::Method for LinkInto {
12558 const ORDINAL: u64 = 6121399674497678964;
12559 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12560 ::fidl_next::protocol::Flexibility::Strict;
12561
12562 type Protocol = crate::Linkable;
12563
12564 type Request = crate::wire::LinkableLinkIntoRequest<'static>;
12565 }
12566
12567 impl ::fidl_next::TwoWayMethod for LinkInto {
12568 type Response = ::fidl_next::wire::Result<
12569 'static,
12570 crate::wire::LinkableLinkIntoResponse,
12571 ::fidl_next::wire::fuchsia::Status,
12572 >;
12573 }
12574
12575 impl<___R> ::fidl_next::Respond<___R> for LinkInto {
12576 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
12577
12578 fn respond(response: ___R) -> Self::Output {
12579 ::core::result::Result::Ok(response)
12580 }
12581 }
12582
12583 impl<___R> ::fidl_next::RespondErr<___R> for LinkInto {
12584 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
12585
12586 fn respond_err(response: ___R) -> Self::Output {
12587 ::core::result::Result::Err(response)
12588 }
12589 }
12590
12591 mod ___detail {
12592 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Linkable
12593 where
12594 ___T: ::fidl_next::Transport,
12595 {
12596 type Client = LinkableClient<___T>;
12597 type Server = LinkableServer<___T>;
12598 }
12599
12600 #[repr(transparent)]
12602 pub struct LinkableClient<___T: ::fidl_next::Transport> {
12603 #[allow(dead_code)]
12604 client: ::fidl_next::protocol::Client<___T>,
12605 }
12606
12607 impl<___T> LinkableClient<___T>
12608 where
12609 ___T: ::fidl_next::Transport,
12610 {
12611 #[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"]
12612 pub fn link_into(
12613 &self,
12614
12615 dst_parent_token: impl ::fidl_next::Encode<
12616 ::fidl_next::wire::fuchsia::Event,
12617 <___T as ::fidl_next::Transport>::SendBuffer,
12618 >,
12619
12620 dst: impl ::fidl_next::Encode<
12621 ::fidl_next::wire::String<'static>,
12622 <___T as ::fidl_next::Transport>::SendBuffer,
12623 >,
12624 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
12625 where
12626 <___T as ::fidl_next::Transport>::SendBuffer:
12627 ::fidl_next::encoder::InternalHandleEncoder,
12628 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
12629 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
12630 {
12631 self.link_into_with(crate::generic::LinkableLinkIntoRequest {
12632 dst_parent_token,
12633
12634 dst,
12635 })
12636 }
12637
12638 #[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"]
12639 pub fn link_into_with<___R>(
12640 &self,
12641 request: ___R,
12642 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
12643 where
12644 ___R: ::fidl_next::Encode<
12645 crate::wire::LinkableLinkIntoRequest<'static>,
12646 <___T as ::fidl_next::Transport>::SendBuffer,
12647 >,
12648 {
12649 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12650 6121399674497678964,
12651 <super::LinkInto as ::fidl_next::Method>::FLEXIBILITY,
12652 request,
12653 ))
12654 }
12655 }
12656
12657 #[repr(transparent)]
12659 pub struct LinkableServer<___T: ::fidl_next::Transport> {
12660 server: ::fidl_next::protocol::Server<___T>,
12661 }
12662
12663 impl<___T> LinkableServer<___T> where ___T: ::fidl_next::Transport {}
12664 }
12665}
12666
12667#[diagnostic::on_unimplemented(
12668 note = "If {Self} implements the non-local LinkableClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
12669)]
12670
12671pub trait LinkableLocalClientHandler<
12675 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12676 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12677>
12678{
12679}
12680
12681impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Linkable
12682where
12683 ___H: LinkableLocalClientHandler<___T>,
12684 ___T: ::fidl_next::Transport,
12685{
12686 async fn on_event(
12687 handler: &mut ___H,
12688 mut message: ::fidl_next::Message<___T>,
12689 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12690 match *message.header().ordinal {
12691 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12692 }
12693 }
12694}
12695
12696#[diagnostic::on_unimplemented(
12697 note = "If {Self} implements the non-local LinkableServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
12698)]
12699
12700pub trait LinkableLocalServerHandler<
12704 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12705 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12706>
12707{
12708 #[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"]
12709 fn link_into(
12710 &mut self,
12711
12712 request: ::fidl_next::Request<linkable::LinkInto, ___T>,
12713
12714 responder: ::fidl_next::Responder<linkable::LinkInto, ___T>,
12715 ) -> impl ::core::future::Future<Output = ()>;
12716}
12717
12718impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Linkable
12719where
12720 ___H: LinkableLocalServerHandler<___T>,
12721 ___T: ::fidl_next::Transport,
12722 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
12723 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12724 Constraint = (),
12725 >,
12726{
12727 async fn on_one_way(
12728 handler: &mut ___H,
12729 mut message: ::fidl_next::Message<___T>,
12730 ) -> ::core::result::Result<
12731 (),
12732 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12733 > {
12734 match *message.header().ordinal {
12735 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12736 }
12737 }
12738
12739 async fn on_two_way(
12740 handler: &mut ___H,
12741 mut message: ::fidl_next::Message<___T>,
12742 responder: ::fidl_next::protocol::Responder<___T>,
12743 ) -> ::core::result::Result<
12744 (),
12745 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12746 > {
12747 match *message.header().ordinal {
12748 6121399674497678964 => {
12749 let responder = ::fidl_next::Responder::from_untyped(responder);
12750
12751 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12752 Ok(decoded) => {
12753 handler
12754 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
12755 .await;
12756 Ok(())
12757 }
12758 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12759 ordinal: 6121399674497678964,
12760 error,
12761 }),
12762 }
12763 }
12764
12765 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12766 }
12767 }
12768}
12769
12770pub trait LinkableClientHandler<
12774 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12775 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12776>
12777{
12778}
12779
12780impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Linkable
12781where
12782 ___H: LinkableClientHandler<___T> + ::core::marker::Send,
12783 ___T: ::fidl_next::Transport,
12784{
12785 async fn on_event(
12786 handler: &mut ___H,
12787 mut message: ::fidl_next::Message<___T>,
12788 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12789 match *message.header().ordinal {
12790 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12791 }
12792 }
12793}
12794
12795pub trait LinkableServerHandler<
12799 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12800 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12801>
12802{
12803 #[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"]
12804 fn link_into(
12805 &mut self,
12806
12807 request: ::fidl_next::Request<linkable::LinkInto, ___T>,
12808
12809 responder: ::fidl_next::Responder<linkable::LinkInto, ___T>,
12810 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12811}
12812
12813impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Linkable
12814where
12815 ___H: LinkableServerHandler<___T> + ::core::marker::Send,
12816 ___T: ::fidl_next::Transport,
12817 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
12818 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12819 Constraint = (),
12820 >,
12821{
12822 async fn on_one_way(
12823 handler: &mut ___H,
12824 mut message: ::fidl_next::Message<___T>,
12825 ) -> ::core::result::Result<
12826 (),
12827 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12828 > {
12829 match *message.header().ordinal {
12830 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12831 }
12832 }
12833
12834 async fn on_two_way(
12835 handler: &mut ___H,
12836 mut message: ::fidl_next::Message<___T>,
12837 responder: ::fidl_next::protocol::Responder<___T>,
12838 ) -> ::core::result::Result<
12839 (),
12840 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12841 > {
12842 match *message.header().ordinal {
12843 6121399674497678964 => {
12844 let responder = ::fidl_next::Responder::from_untyped(responder);
12845
12846 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12847 Ok(decoded) => {
12848 handler
12849 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
12850 .await;
12851 Ok(())
12852 }
12853 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12854 ordinal: 6121399674497678964,
12855 error,
12856 }),
12857 }
12858 }
12859
12860 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12861 }
12862 }
12863}
12864
12865impl<___T> LinkableClientHandler<___T> for ::fidl_next::IgnoreEvents where
12866 ___T: ::fidl_next::Transport
12867{
12868}
12869
12870impl<___H, ___T> LinkableLocalClientHandler<___T> for ::fidl_next::Local<___H>
12871where
12872 ___H: LinkableClientHandler<___T>,
12873 ___T: ::fidl_next::Transport,
12874{
12875}
12876
12877impl<___H, ___T> LinkableLocalServerHandler<___T> for ::fidl_next::Local<___H>
12878where
12879 ___H: LinkableServerHandler<___T>,
12880 ___T: ::fidl_next::Transport,
12881{
12882 async fn link_into(
12883 &mut self,
12884
12885 request: ::fidl_next::Request<linkable::LinkInto, ___T>,
12886
12887 responder: ::fidl_next::Responder<linkable::LinkInto, ___T>,
12888 ) {
12889 ___H::link_into(&mut self.0, request, responder).await
12890 }
12891}
12892
12893#[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"]
12895#[derive(PartialEq, Debug)]
12896pub struct File;
12897
12898impl ::fidl_next::Discoverable for File {
12899 const PROTOCOL_NAME: &'static str = "fuchsia.io.File";
12900}
12901
12902#[cfg(target_os = "fuchsia")]
12903impl ::fidl_next::HasTransport for File {
12904 type Transport = ::fidl_next::fuchsia::zx::Channel;
12905}
12906
12907pub mod file {
12908 pub mod prelude {
12909 pub use crate::{
12910 File, FileClientHandler, FileLocalClientHandler, FileLocalServerHandler,
12911 FileServerHandler, file,
12912 };
12913
12914 pub use crate::natural::AdvisoryLockingAdvisoryLockRequest;
12915
12916 pub use crate::natural::AdvisoryLockingAdvisoryLockResponse;
12917
12918 pub use crate::natural::ExtendedAttributeValue;
12919
12920 pub use crate::natural::FileAllocateRequest;
12921
12922 pub use crate::natural::FileEnableVerityRequest;
12923
12924 pub use crate::natural::FileGetBackingMemoryRequest;
12925
12926 pub use crate::natural::FileInfo;
12927
12928 pub use crate::natural::FileReadAtRequest;
12929
12930 pub use crate::natural::FileResizeRequest;
12931
12932 pub use crate::natural::FileSeekRequest;
12933
12934 pub use crate::natural::FileWriteAtRequest;
12935
12936 pub use crate::natural::FileAllocateResponse;
12937
12938 pub use crate::natural::FileEnableVerityResponse;
12939
12940 pub use crate::natural::FileGetBackingMemoryResponse;
12941
12942 pub use crate::natural::FileReadAtResponse;
12943
12944 pub use crate::natural::FileResizeResponse;
12945
12946 pub use crate::natural::FileSeekResponse;
12947
12948 pub use crate::natural::FileWriteAtResponse;
12949
12950 pub use crate::natural::LinkableLinkIntoRequest;
12951
12952 pub use crate::natural::LinkableLinkIntoResponse;
12953
12954 pub use crate::natural::MutableNodeAttributes;
12955
12956 pub use crate::natural::NodeAttributes2;
12957
12958 pub use crate::natural::NodeDeprecatedCloneRequest;
12959
12960 pub use crate::natural::NodeDeprecatedGetAttrResponse;
12961
12962 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
12963
12964 pub use crate::natural::NodeDeprecatedSetAttrRequest;
12965
12966 pub use crate::natural::NodeDeprecatedSetAttrResponse;
12967
12968 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
12969
12970 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
12971
12972 pub use crate::natural::NodeGetAttributesRequest;
12973
12974 pub use crate::natural::NodeGetExtendedAttributeRequest;
12975
12976 pub use crate::natural::NodeListExtendedAttributesRequest;
12977
12978 pub use crate::natural::NodeOnOpenRequest;
12979
12980 pub use crate::natural::NodeQueryFilesystemResponse;
12981
12982 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
12983
12984 pub use crate::natural::NodeSetExtendedAttributeRequest;
12985
12986 pub use crate::natural::NodeSetFlagsRequest;
12987
12988 pub use crate::natural::NodeGetFlagsResponse;
12989
12990 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
12991
12992 pub use crate::natural::NodeSetExtendedAttributeResponse;
12993
12994 pub use crate::natural::NodeSetFlagsResponse;
12995
12996 pub use crate::natural::NodeSyncResponse;
12997
12998 pub use crate::natural::NodeUpdateAttributesResponse;
12999
13000 pub use crate::natural::ReadableReadRequest;
13001
13002 pub use crate::natural::ReadableReadResponse;
13003
13004 pub use crate::natural::Representation;
13005
13006 pub use crate::natural::WritableWriteRequest;
13007
13008 pub use crate::natural::WritableWriteResponse;
13009
13010 pub use ::fidl_next_fuchsia_unknown::natural::CloneableCloneRequest;
13011
13012 pub use ::fidl_next_fuchsia_unknown::natural::CloseableCloseResponse;
13013
13014 pub use ::fidl_next_fuchsia_unknown::natural::QueryableQueryResponse;
13015 }
13016
13017 pub struct AdvisoryLock;
13018
13019 impl ::fidl_next::Method for AdvisoryLock {
13020 const ORDINAL: u64 = 7992130864415541162;
13021 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13022 ::fidl_next::protocol::Flexibility::Strict;
13023
13024 type Protocol = crate::File;
13025
13026 type Request = crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>;
13027 }
13028
13029 impl ::fidl_next::TwoWayMethod for AdvisoryLock {
13030 type Response = ::fidl_next::wire::Result<
13031 'static,
13032 crate::wire::AdvisoryLockingAdvisoryLockResponse,
13033 ::fidl_next::wire::fuchsia::Status,
13034 >;
13035 }
13036
13037 impl<___R> ::fidl_next::Respond<___R> for AdvisoryLock {
13038 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13039
13040 fn respond(response: ___R) -> Self::Output {
13041 ::core::result::Result::Ok(response)
13042 }
13043 }
13044
13045 impl<___R> ::fidl_next::RespondErr<___R> for AdvisoryLock {
13046 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13047
13048 fn respond_err(response: ___R) -> Self::Output {
13049 ::core::result::Result::Err(response)
13050 }
13051 }
13052
13053 pub struct LinkInto;
13054
13055 impl ::fidl_next::Method for LinkInto {
13056 const ORDINAL: u64 = 6121399674497678964;
13057 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13058 ::fidl_next::protocol::Flexibility::Strict;
13059
13060 type Protocol = crate::File;
13061
13062 type Request = crate::wire::LinkableLinkIntoRequest<'static>;
13063 }
13064
13065 impl ::fidl_next::TwoWayMethod for LinkInto {
13066 type Response = ::fidl_next::wire::Result<
13067 'static,
13068 crate::wire::LinkableLinkIntoResponse,
13069 ::fidl_next::wire::fuchsia::Status,
13070 >;
13071 }
13072
13073 impl<___R> ::fidl_next::Respond<___R> for LinkInto {
13074 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13075
13076 fn respond(response: ___R) -> Self::Output {
13077 ::core::result::Result::Ok(response)
13078 }
13079 }
13080
13081 impl<___R> ::fidl_next::RespondErr<___R> for LinkInto {
13082 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13083
13084 fn respond_err(response: ___R) -> Self::Output {
13085 ::core::result::Result::Err(response)
13086 }
13087 }
13088
13089 pub struct Clone;
13090
13091 impl ::fidl_next::Method for Clone {
13092 const ORDINAL: u64 = 2366825959783828089;
13093 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13094 ::fidl_next::protocol::Flexibility::Strict;
13095
13096 type Protocol = crate::File;
13097
13098 type Request = ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest;
13099 }
13100
13101 pub struct Close;
13102
13103 impl ::fidl_next::Method for Close {
13104 const ORDINAL: u64 = 6540867515453498750;
13105 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13106 ::fidl_next::protocol::Flexibility::Strict;
13107
13108 type Protocol = crate::File;
13109
13110 type Request = ::fidl_next::wire::EmptyMessageBody;
13111 }
13112
13113 impl ::fidl_next::TwoWayMethod for Close {
13114 type Response = ::fidl_next::wire::Result<
13115 'static,
13116 ::fidl_next_fuchsia_unknown::wire::CloseableCloseResponse,
13117 ::fidl_next::wire::Int32,
13118 >;
13119 }
13120
13121 impl<___R> ::fidl_next::Respond<___R> for Close {
13122 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13123
13124 fn respond(response: ___R) -> Self::Output {
13125 ::core::result::Result::Ok(response)
13126 }
13127 }
13128
13129 impl<___R> ::fidl_next::RespondErr<___R> for Close {
13130 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13131
13132 fn respond_err(response: ___R) -> Self::Output {
13133 ::core::result::Result::Err(response)
13134 }
13135 }
13136
13137 pub struct Query;
13138
13139 impl ::fidl_next::Method for Query {
13140 const ORDINAL: u64 = 2763219980499352582;
13141 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13142 ::fidl_next::protocol::Flexibility::Strict;
13143
13144 type Protocol = crate::File;
13145
13146 type Request = ::fidl_next::wire::EmptyMessageBody;
13147 }
13148
13149 impl ::fidl_next::TwoWayMethod for Query {
13150 type Response = ::fidl_next::wire::Strict<
13151 ::fidl_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>,
13152 >;
13153 }
13154
13155 impl<___R> ::fidl_next::Respond<___R> for Query {
13156 type Output =
13157 ::fidl_next::Strict<::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>>;
13158
13159 fn respond(response: ___R) -> Self::Output {
13160 ::fidl_next::Strict(::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse {
13161 protocol: response,
13162 })
13163 }
13164 }
13165
13166 pub struct DeprecatedClone;
13167
13168 impl ::fidl_next::Method for DeprecatedClone {
13169 const ORDINAL: u64 = 6512600400724287855;
13170 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13171 ::fidl_next::protocol::Flexibility::Flexible;
13172
13173 type Protocol = crate::File;
13174
13175 type Request = crate::wire::NodeDeprecatedCloneRequest;
13176 }
13177
13178 pub struct OnOpen;
13179
13180 impl ::fidl_next::Method for OnOpen {
13181 const ORDINAL: u64 = 9207534335756671346;
13182 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13183 ::fidl_next::protocol::Flexibility::Flexible;
13184
13185 type Protocol = crate::File;
13186
13187 type Request = crate::wire::NodeOnOpenRequest<'static>;
13188 }
13189
13190 pub struct DeprecatedGetAttr;
13191
13192 impl ::fidl_next::Method for DeprecatedGetAttr {
13193 const ORDINAL: u64 = 8689798978500614909;
13194 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13195 ::fidl_next::protocol::Flexibility::Strict;
13196
13197 type Protocol = crate::File;
13198
13199 type Request = ::fidl_next::wire::EmptyMessageBody;
13200 }
13201
13202 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
13203 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetAttrResponse>;
13204 }
13205
13206 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
13207 type Output = ::fidl_next::Strict<___R>;
13208
13209 fn respond(response: ___R) -> Self::Output {
13210 ::fidl_next::Strict(response)
13211 }
13212 }
13213
13214 pub struct DeprecatedSetAttr;
13215
13216 impl ::fidl_next::Method for DeprecatedSetAttr {
13217 const ORDINAL: u64 = 4721673413776871238;
13218 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13219 ::fidl_next::protocol::Flexibility::Strict;
13220
13221 type Protocol = crate::File;
13222
13223 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
13224 }
13225
13226 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
13227 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetAttrResponse>;
13228 }
13229
13230 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
13231 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetAttrResponse<___R>>;
13232
13233 fn respond(response: ___R) -> Self::Output {
13234 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetAttrResponse { s: response })
13235 }
13236 }
13237
13238 pub struct DeprecatedGetFlags;
13239
13240 impl ::fidl_next::Method for DeprecatedGetFlags {
13241 const ORDINAL: u64 = 6595803110182632097;
13242 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13243 ::fidl_next::protocol::Flexibility::Strict;
13244
13245 type Protocol = crate::File;
13246
13247 type Request = ::fidl_next::wire::EmptyMessageBody;
13248 }
13249
13250 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
13251 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetFlagsResponse>;
13252 }
13253
13254 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
13255 type Output = ::fidl_next::Strict<___R>;
13256
13257 fn respond(response: ___R) -> Self::Output {
13258 ::fidl_next::Strict(response)
13259 }
13260 }
13261
13262 pub struct DeprecatedSetFlags;
13263
13264 impl ::fidl_next::Method for DeprecatedSetFlags {
13265 const ORDINAL: u64 = 5950864159036794675;
13266 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13267 ::fidl_next::protocol::Flexibility::Strict;
13268
13269 type Protocol = crate::File;
13270
13271 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
13272 }
13273
13274 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
13275 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetFlagsResponse>;
13276 }
13277
13278 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
13279 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetFlagsResponse<___R>>;
13280
13281 fn respond(response: ___R) -> Self::Output {
13282 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetFlagsResponse { s: response })
13283 }
13284 }
13285
13286 pub struct GetFlags;
13287
13288 impl ::fidl_next::Method for GetFlags {
13289 const ORDINAL: u64 = 105530239381466147;
13290 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13291 ::fidl_next::protocol::Flexibility::Flexible;
13292
13293 type Protocol = crate::File;
13294
13295 type Request = ::fidl_next::wire::EmptyMessageBody;
13296 }
13297
13298 impl ::fidl_next::TwoWayMethod for GetFlags {
13299 type Response = ::fidl_next::wire::Result<
13300 'static,
13301 crate::wire::NodeGetFlagsResponse,
13302 ::fidl_next::wire::fuchsia::Status,
13303 >;
13304 }
13305
13306 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
13307 type Output = ::core::result::Result<
13308 crate::generic::NodeGetFlagsResponse<___R>,
13309 ::fidl_next::util::Never,
13310 >;
13311
13312 fn respond(response: ___R) -> Self::Output {
13313 ::core::result::Result::Ok(crate::generic::NodeGetFlagsResponse { flags: response })
13314 }
13315 }
13316
13317 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
13318 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13319
13320 fn respond_err(response: ___R) -> Self::Output {
13321 ::core::result::Result::Err(response)
13322 }
13323 }
13324
13325 pub struct SetFlags;
13326
13327 impl ::fidl_next::Method for SetFlags {
13328 const ORDINAL: u64 = 6172186066099445416;
13329 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13330 ::fidl_next::protocol::Flexibility::Flexible;
13331
13332 type Protocol = crate::File;
13333
13334 type Request = crate::wire::NodeSetFlagsRequest;
13335 }
13336
13337 impl ::fidl_next::TwoWayMethod for SetFlags {
13338 type Response = ::fidl_next::wire::Result<
13339 'static,
13340 crate::wire::NodeSetFlagsResponse,
13341 ::fidl_next::wire::fuchsia::Status,
13342 >;
13343 }
13344
13345 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
13346 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13347
13348 fn respond(response: ___R) -> Self::Output {
13349 ::core::result::Result::Ok(response)
13350 }
13351 }
13352
13353 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
13354 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13355
13356 fn respond_err(response: ___R) -> Self::Output {
13357 ::core::result::Result::Err(response)
13358 }
13359 }
13360
13361 pub struct QueryFilesystem;
13362
13363 impl ::fidl_next::Method for QueryFilesystem {
13364 const ORDINAL: u64 = 8013111122914313744;
13365 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13366 ::fidl_next::protocol::Flexibility::Strict;
13367
13368 type Protocol = crate::File;
13369
13370 type Request = ::fidl_next::wire::EmptyMessageBody;
13371 }
13372
13373 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
13374 type Response =
13375 ::fidl_next::wire::Strict<crate::wire::NodeQueryFilesystemResponse<'static>>;
13376 }
13377
13378 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
13379 type Output = ::fidl_next::Strict<___R>;
13380
13381 fn respond(response: ___R) -> Self::Output {
13382 ::fidl_next::Strict(response)
13383 }
13384 }
13385
13386 pub struct OnRepresentation;
13387
13388 impl ::fidl_next::Method for OnRepresentation {
13389 const ORDINAL: u64 = 6679970090861613324;
13390 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13391 ::fidl_next::protocol::Flexibility::Strict;
13392
13393 type Protocol = crate::File;
13394
13395 type Request = crate::wire::Representation<'static>;
13396 }
13397
13398 pub struct GetAttributes;
13399
13400 impl ::fidl_next::Method for GetAttributes {
13401 const ORDINAL: u64 = 4414537700416816443;
13402 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13403 ::fidl_next::protocol::Flexibility::Strict;
13404
13405 type Protocol = crate::File;
13406
13407 type Request = crate::wire::NodeGetAttributesRequest;
13408 }
13409
13410 impl ::fidl_next::TwoWayMethod for GetAttributes {
13411 type Response = ::fidl_next::wire::Result<
13412 'static,
13413 crate::wire::NodeAttributes2<'static>,
13414 ::fidl_next::wire::fuchsia::Status,
13415 >;
13416 }
13417
13418 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
13419 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13420
13421 fn respond(response: ___R) -> Self::Output {
13422 ::core::result::Result::Ok(response)
13423 }
13424 }
13425
13426 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
13427 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13428
13429 fn respond_err(response: ___R) -> Self::Output {
13430 ::core::result::Result::Err(response)
13431 }
13432 }
13433
13434 pub struct UpdateAttributes;
13435
13436 impl ::fidl_next::Method for UpdateAttributes {
13437 const ORDINAL: u64 = 3677402239314018056;
13438 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13439 ::fidl_next::protocol::Flexibility::Strict;
13440
13441 type Protocol = crate::File;
13442
13443 type Request = crate::wire::MutableNodeAttributes<'static>;
13444 }
13445
13446 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
13447 type Response = ::fidl_next::wire::Result<
13448 'static,
13449 crate::wire::NodeUpdateAttributesResponse,
13450 ::fidl_next::wire::fuchsia::Status,
13451 >;
13452 }
13453
13454 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
13455 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13456
13457 fn respond(response: ___R) -> Self::Output {
13458 ::core::result::Result::Ok(response)
13459 }
13460 }
13461
13462 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
13463 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13464
13465 fn respond_err(response: ___R) -> Self::Output {
13466 ::core::result::Result::Err(response)
13467 }
13468 }
13469
13470 pub struct Sync;
13471
13472 impl ::fidl_next::Method for Sync {
13473 const ORDINAL: u64 = 3196473584242777161;
13474 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13475 ::fidl_next::protocol::Flexibility::Strict;
13476
13477 type Protocol = crate::File;
13478
13479 type Request = ::fidl_next::wire::EmptyMessageBody;
13480 }
13481
13482 impl ::fidl_next::TwoWayMethod for Sync {
13483 type Response = ::fidl_next::wire::Result<
13484 'static,
13485 crate::wire::NodeSyncResponse,
13486 ::fidl_next::wire::fuchsia::Status,
13487 >;
13488 }
13489
13490 impl<___R> ::fidl_next::Respond<___R> for Sync {
13491 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13492
13493 fn respond(response: ___R) -> Self::Output {
13494 ::core::result::Result::Ok(response)
13495 }
13496 }
13497
13498 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
13499 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13500
13501 fn respond_err(response: ___R) -> Self::Output {
13502 ::core::result::Result::Err(response)
13503 }
13504 }
13505
13506 pub struct ListExtendedAttributes;
13507
13508 impl ::fidl_next::Method for ListExtendedAttributes {
13509 const ORDINAL: u64 = 5431626189872037072;
13510 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13511 ::fidl_next::protocol::Flexibility::Strict;
13512
13513 type Protocol = crate::File;
13514
13515 type Request = crate::wire::NodeListExtendedAttributesRequest;
13516 }
13517
13518 pub struct GetExtendedAttribute;
13519
13520 impl ::fidl_next::Method for GetExtendedAttribute {
13521 const ORDINAL: u64 = 5043930208506967771;
13522 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13523 ::fidl_next::protocol::Flexibility::Strict;
13524
13525 type Protocol = crate::File;
13526
13527 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
13528 }
13529
13530 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
13531 type Response = ::fidl_next::wire::Result<
13532 'static,
13533 crate::wire::ExtendedAttributeValue<'static>,
13534 ::fidl_next::wire::fuchsia::Status,
13535 >;
13536 }
13537
13538 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
13539 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13540
13541 fn respond(response: ___R) -> Self::Output {
13542 ::core::result::Result::Ok(response)
13543 }
13544 }
13545
13546 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
13547 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13548
13549 fn respond_err(response: ___R) -> Self::Output {
13550 ::core::result::Result::Err(response)
13551 }
13552 }
13553
13554 pub struct SetExtendedAttribute;
13555
13556 impl ::fidl_next::Method for SetExtendedAttribute {
13557 const ORDINAL: u64 = 5374223046099989052;
13558 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13559 ::fidl_next::protocol::Flexibility::Strict;
13560
13561 type Protocol = crate::File;
13562
13563 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
13564 }
13565
13566 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
13567 type Response = ::fidl_next::wire::Result<
13568 'static,
13569 crate::wire::NodeSetExtendedAttributeResponse,
13570 ::fidl_next::wire::fuchsia::Status,
13571 >;
13572 }
13573
13574 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
13575 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13576
13577 fn respond(response: ___R) -> Self::Output {
13578 ::core::result::Result::Ok(response)
13579 }
13580 }
13581
13582 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
13583 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13584
13585 fn respond_err(response: ___R) -> Self::Output {
13586 ::core::result::Result::Err(response)
13587 }
13588 }
13589
13590 pub struct RemoveExtendedAttribute;
13591
13592 impl ::fidl_next::Method for RemoveExtendedAttribute {
13593 const ORDINAL: u64 = 8794297771444732717;
13594 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13595 ::fidl_next::protocol::Flexibility::Strict;
13596
13597 type Protocol = crate::File;
13598
13599 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
13600 }
13601
13602 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
13603 type Response = ::fidl_next::wire::Result<
13604 'static,
13605 crate::wire::NodeRemoveExtendedAttributeResponse,
13606 ::fidl_next::wire::fuchsia::Status,
13607 >;
13608 }
13609
13610 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
13611 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13612
13613 fn respond(response: ___R) -> Self::Output {
13614 ::core::result::Result::Ok(response)
13615 }
13616 }
13617
13618 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
13619 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13620
13621 fn respond_err(response: ___R) -> Self::Output {
13622 ::core::result::Result::Err(response)
13623 }
13624 }
13625
13626 pub struct Read;
13627
13628 impl ::fidl_next::Method for Read {
13629 const ORDINAL: u64 = 395825947633028830;
13630 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13631 ::fidl_next::protocol::Flexibility::Strict;
13632
13633 type Protocol = crate::File;
13634
13635 type Request = crate::wire::ReadableReadRequest;
13636 }
13637
13638 impl ::fidl_next::TwoWayMethod for Read {
13639 type Response = ::fidl_next::wire::Result<
13640 'static,
13641 crate::wire::ReadableReadResponse<'static>,
13642 ::fidl_next::wire::fuchsia::Status,
13643 >;
13644 }
13645
13646 impl<___R> ::fidl_next::Respond<___R> for Read {
13647 type Output = ::core::result::Result<
13648 crate::generic::ReadableReadResponse<___R>,
13649 ::fidl_next::util::Never,
13650 >;
13651
13652 fn respond(response: ___R) -> Self::Output {
13653 ::core::result::Result::Ok(crate::generic::ReadableReadResponse { data: response })
13654 }
13655 }
13656
13657 impl<___R> ::fidl_next::RespondErr<___R> for Read {
13658 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13659
13660 fn respond_err(response: ___R) -> Self::Output {
13661 ::core::result::Result::Err(response)
13662 }
13663 }
13664
13665 pub struct Write;
13666
13667 impl ::fidl_next::Method for Write {
13668 const ORDINAL: u64 = 7651971425397809026;
13669 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13670 ::fidl_next::protocol::Flexibility::Strict;
13671
13672 type Protocol = crate::File;
13673
13674 type Request = crate::wire::WritableWriteRequest<'static>;
13675 }
13676
13677 impl ::fidl_next::TwoWayMethod for Write {
13678 type Response = ::fidl_next::wire::Result<
13679 'static,
13680 crate::wire::WritableWriteResponse,
13681 ::fidl_next::wire::fuchsia::Status,
13682 >;
13683 }
13684
13685 impl<___R> ::fidl_next::Respond<___R> for Write {
13686 type Output = ::core::result::Result<
13687 crate::generic::WritableWriteResponse<___R>,
13688 ::fidl_next::util::Never,
13689 >;
13690
13691 fn respond(response: ___R) -> Self::Output {
13692 ::core::result::Result::Ok(crate::generic::WritableWriteResponse {
13693 actual_count: response,
13694 })
13695 }
13696 }
13697
13698 impl<___R> ::fidl_next::RespondErr<___R> for Write {
13699 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13700
13701 fn respond_err(response: ___R) -> Self::Output {
13702 ::core::result::Result::Err(response)
13703 }
13704 }
13705
13706 pub struct Describe;
13707
13708 impl ::fidl_next::Method for Describe {
13709 const ORDINAL: u64 = 7545125870053689020;
13710 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13711 ::fidl_next::protocol::Flexibility::Strict;
13712
13713 type Protocol = crate::File;
13714
13715 type Request = ::fidl_next::wire::EmptyMessageBody;
13716 }
13717
13718 impl ::fidl_next::TwoWayMethod for Describe {
13719 type Response = ::fidl_next::wire::Strict<crate::wire::FileInfo<'static>>;
13720 }
13721
13722 impl<___R> ::fidl_next::Respond<___R> for Describe {
13723 type Output = ::fidl_next::Strict<___R>;
13724
13725 fn respond(response: ___R) -> Self::Output {
13726 ::fidl_next::Strict(response)
13727 }
13728 }
13729
13730 pub struct Seek;
13731
13732 impl ::fidl_next::Method for Seek {
13733 const ORDINAL: u64 = 8649041485622956551;
13734 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13735 ::fidl_next::protocol::Flexibility::Strict;
13736
13737 type Protocol = crate::File;
13738
13739 type Request = crate::wire::FileSeekRequest;
13740 }
13741
13742 impl ::fidl_next::TwoWayMethod for Seek {
13743 type Response = ::fidl_next::wire::Result<
13744 'static,
13745 crate::wire::FileSeekResponse,
13746 ::fidl_next::wire::fuchsia::Status,
13747 >;
13748 }
13749
13750 impl<___R> ::fidl_next::Respond<___R> for Seek {
13751 type Output = ::core::result::Result<
13752 crate::generic::FileSeekResponse<___R>,
13753 ::fidl_next::util::Never,
13754 >;
13755
13756 fn respond(response: ___R) -> Self::Output {
13757 ::core::result::Result::Ok(crate::generic::FileSeekResponse {
13758 offset_from_start: response,
13759 })
13760 }
13761 }
13762
13763 impl<___R> ::fidl_next::RespondErr<___R> for Seek {
13764 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13765
13766 fn respond_err(response: ___R) -> Self::Output {
13767 ::core::result::Result::Err(response)
13768 }
13769 }
13770
13771 pub struct ReadAt;
13772
13773 impl ::fidl_next::Method for ReadAt {
13774 const ORDINAL: u64 = 1587416148701180478;
13775 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13776 ::fidl_next::protocol::Flexibility::Strict;
13777
13778 type Protocol = crate::File;
13779
13780 type Request = crate::wire::FileReadAtRequest;
13781 }
13782
13783 impl ::fidl_next::TwoWayMethod for ReadAt {
13784 type Response = ::fidl_next::wire::Result<
13785 'static,
13786 crate::wire::FileReadAtResponse<'static>,
13787 ::fidl_next::wire::fuchsia::Status,
13788 >;
13789 }
13790
13791 impl<___R> ::fidl_next::Respond<___R> for ReadAt {
13792 type Output = ::core::result::Result<
13793 crate::generic::FileReadAtResponse<___R>,
13794 ::fidl_next::util::Never,
13795 >;
13796
13797 fn respond(response: ___R) -> Self::Output {
13798 ::core::result::Result::Ok(crate::generic::FileReadAtResponse { data: response })
13799 }
13800 }
13801
13802 impl<___R> ::fidl_next::RespondErr<___R> for ReadAt {
13803 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13804
13805 fn respond_err(response: ___R) -> Self::Output {
13806 ::core::result::Result::Err(response)
13807 }
13808 }
13809
13810 pub struct WriteAt;
13811
13812 impl ::fidl_next::Method for WriteAt {
13813 const ORDINAL: u64 = 8736683935131400491;
13814 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13815 ::fidl_next::protocol::Flexibility::Strict;
13816
13817 type Protocol = crate::File;
13818
13819 type Request = crate::wire::FileWriteAtRequest<'static>;
13820 }
13821
13822 impl ::fidl_next::TwoWayMethod for WriteAt {
13823 type Response = ::fidl_next::wire::Result<
13824 'static,
13825 crate::wire::FileWriteAtResponse,
13826 ::fidl_next::wire::fuchsia::Status,
13827 >;
13828 }
13829
13830 impl<___R> ::fidl_next::Respond<___R> for WriteAt {
13831 type Output = ::core::result::Result<
13832 crate::generic::FileWriteAtResponse<___R>,
13833 ::fidl_next::util::Never,
13834 >;
13835
13836 fn respond(response: ___R) -> Self::Output {
13837 ::core::result::Result::Ok(crate::generic::FileWriteAtResponse {
13838 actual_count: response,
13839 })
13840 }
13841 }
13842
13843 impl<___R> ::fidl_next::RespondErr<___R> for WriteAt {
13844 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13845
13846 fn respond_err(response: ___R) -> Self::Output {
13847 ::core::result::Result::Err(response)
13848 }
13849 }
13850
13851 pub struct Resize;
13852
13853 impl ::fidl_next::Method for Resize {
13854 const ORDINAL: u64 = 3134648685270758458;
13855 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13856 ::fidl_next::protocol::Flexibility::Strict;
13857
13858 type Protocol = crate::File;
13859
13860 type Request = crate::wire::FileResizeRequest;
13861 }
13862
13863 impl ::fidl_next::TwoWayMethod for Resize {
13864 type Response = ::fidl_next::wire::Result<
13865 'static,
13866 crate::wire::FileResizeResponse,
13867 ::fidl_next::wire::fuchsia::Status,
13868 >;
13869 }
13870
13871 impl<___R> ::fidl_next::Respond<___R> for Resize {
13872 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13873
13874 fn respond(response: ___R) -> Self::Output {
13875 ::core::result::Result::Ok(response)
13876 }
13877 }
13878
13879 impl<___R> ::fidl_next::RespondErr<___R> for Resize {
13880 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13881
13882 fn respond_err(response: ___R) -> Self::Output {
13883 ::core::result::Result::Err(response)
13884 }
13885 }
13886
13887 pub struct GetBackingMemory;
13888
13889 impl ::fidl_next::Method for GetBackingMemory {
13890 const ORDINAL: u64 = 46911652864194091;
13891 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13892 ::fidl_next::protocol::Flexibility::Strict;
13893
13894 type Protocol = crate::File;
13895
13896 type Request = crate::wire::FileGetBackingMemoryRequest;
13897 }
13898
13899 impl ::fidl_next::TwoWayMethod for GetBackingMemory {
13900 type Response = ::fidl_next::wire::Result<
13901 'static,
13902 crate::wire::FileGetBackingMemoryResponse,
13903 ::fidl_next::wire::fuchsia::Status,
13904 >;
13905 }
13906
13907 impl<___R> ::fidl_next::Respond<___R> for GetBackingMemory {
13908 type Output = ::core::result::Result<
13909 crate::generic::FileGetBackingMemoryResponse<___R>,
13910 ::fidl_next::util::Never,
13911 >;
13912
13913 fn respond(response: ___R) -> Self::Output {
13914 ::core::result::Result::Ok(crate::generic::FileGetBackingMemoryResponse {
13915 vmo: response,
13916 })
13917 }
13918 }
13919
13920 impl<___R> ::fidl_next::RespondErr<___R> for GetBackingMemory {
13921 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13922
13923 fn respond_err(response: ___R) -> Self::Output {
13924 ::core::result::Result::Err(response)
13925 }
13926 }
13927
13928 pub struct Allocate;
13929
13930 impl ::fidl_next::Method for Allocate {
13931 const ORDINAL: u64 = 8645235848064269614;
13932 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13933 ::fidl_next::protocol::Flexibility::Flexible;
13934
13935 type Protocol = crate::File;
13936
13937 type Request = crate::wire::FileAllocateRequest;
13938 }
13939
13940 impl ::fidl_next::TwoWayMethod for Allocate {
13941 type Response = ::fidl_next::wire::Result<
13942 'static,
13943 crate::wire::FileAllocateResponse,
13944 ::fidl_next::wire::fuchsia::Status,
13945 >;
13946 }
13947
13948 impl<___R> ::fidl_next::Respond<___R> for Allocate {
13949 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13950
13951 fn respond(response: ___R) -> Self::Output {
13952 ::core::result::Result::Ok(response)
13953 }
13954 }
13955
13956 impl<___R> ::fidl_next::RespondErr<___R> for Allocate {
13957 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13958
13959 fn respond_err(response: ___R) -> Self::Output {
13960 ::core::result::Result::Err(response)
13961 }
13962 }
13963
13964 pub struct EnableVerity;
13965
13966 impl ::fidl_next::Method for EnableVerity {
13967 const ORDINAL: u64 = 3189145313204943035;
13968 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13969 ::fidl_next::protocol::Flexibility::Flexible;
13970
13971 type Protocol = crate::File;
13972
13973 type Request = crate::wire::FileEnableVerityRequest<'static>;
13974 }
13975
13976 impl ::fidl_next::TwoWayMethod for EnableVerity {
13977 type Response = ::fidl_next::wire::Result<
13978 'static,
13979 crate::wire::FileEnableVerityResponse,
13980 ::fidl_next::wire::fuchsia::Status,
13981 >;
13982 }
13983
13984 impl<___R> ::fidl_next::Respond<___R> for EnableVerity {
13985 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
13986
13987 fn respond(response: ___R) -> Self::Output {
13988 ::core::result::Result::Ok(response)
13989 }
13990 }
13991
13992 impl<___R> ::fidl_next::RespondErr<___R> for EnableVerity {
13993 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
13994
13995 fn respond_err(response: ___R) -> Self::Output {
13996 ::core::result::Result::Err(response)
13997 }
13998 }
13999
14000 mod ___detail {
14001 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::File
14002 where
14003 ___T: ::fidl_next::Transport,
14004 {
14005 type Client = FileClient<___T>;
14006 type Server = FileServer<___T>;
14007 }
14008
14009 #[repr(transparent)]
14011 pub struct FileClient<___T: ::fidl_next::Transport> {
14012 #[allow(dead_code)]
14013 client: ::fidl_next::protocol::Client<___T>,
14014 }
14015
14016 impl<___T> FileClient<___T>
14017 where
14018 ___T: ::fidl_next::Transport,
14019 {
14020 #[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"]
14021 pub fn advisory_lock(
14022 &self,
14023
14024 request: impl ::fidl_next::Encode<
14025 crate::wire::AdvisoryLockRequest<'static>,
14026 <___T as ::fidl_next::Transport>::SendBuffer,
14027 >,
14028 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
14029 where
14030 <___T as ::fidl_next::Transport>::SendBuffer:
14031 ::fidl_next::encoder::InternalHandleEncoder,
14032 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14033 {
14034 self.advisory_lock_with(crate::generic::AdvisoryLockingAdvisoryLockRequest {
14035 request,
14036 })
14037 }
14038
14039 #[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"]
14040 pub fn advisory_lock_with<___R>(
14041 &self,
14042 request: ___R,
14043 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
14044 where
14045 ___R: ::fidl_next::Encode<
14046 crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
14047 <___T as ::fidl_next::Transport>::SendBuffer,
14048 >,
14049 {
14050 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14051 7992130864415541162,
14052 <super::AdvisoryLock as ::fidl_next::Method>::FLEXIBILITY,
14053 request,
14054 ))
14055 }
14056
14057 #[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"]
14058 pub fn link_into(
14059 &self,
14060
14061 dst_parent_token: impl ::fidl_next::Encode<
14062 ::fidl_next::wire::fuchsia::Event,
14063 <___T as ::fidl_next::Transport>::SendBuffer,
14064 >,
14065
14066 dst: impl ::fidl_next::Encode<
14067 ::fidl_next::wire::String<'static>,
14068 <___T as ::fidl_next::Transport>::SendBuffer,
14069 >,
14070 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
14071 where
14072 <___T as ::fidl_next::Transport>::SendBuffer:
14073 ::fidl_next::encoder::InternalHandleEncoder,
14074 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14075 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
14076 {
14077 self.link_into_with(crate::generic::LinkableLinkIntoRequest {
14078 dst_parent_token,
14079
14080 dst,
14081 })
14082 }
14083
14084 #[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"]
14085 pub fn link_into_with<___R>(
14086 &self,
14087 request: ___R,
14088 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
14089 where
14090 ___R: ::fidl_next::Encode<
14091 crate::wire::LinkableLinkIntoRequest<'static>,
14092 <___T as ::fidl_next::Transport>::SendBuffer,
14093 >,
14094 {
14095 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14096 6121399674497678964,
14097 <super::LinkInto as ::fidl_next::Method>::FLEXIBILITY,
14098 request,
14099 ))
14100 }
14101
14102 pub fn clone(
14103 &self,
14104
14105 request: impl ::fidl_next::Encode<
14106 ::fidl_next::ServerEnd<
14107 ::fidl_next_fuchsia_unknown::Cloneable,
14108 ::fidl_next::wire::fuchsia::Channel,
14109 >,
14110 <___T as ::fidl_next::Transport>::SendBuffer,
14111 >,
14112 ) -> ::fidl_next::SendFuture<'_, ___T>
14113 where
14114 <___T as ::fidl_next::Transport>::SendBuffer:
14115 ::fidl_next::encoder::InternalHandleEncoder,
14116 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
14117 {
14118 self.clone_with(::fidl_next_fuchsia_unknown::generic::CloneableCloneRequest {
14119 request,
14120 })
14121 }
14122
14123 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
14124 where
14125 ___R: ::fidl_next::Encode<
14126 ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest,
14127 <___T as ::fidl_next::Transport>::SendBuffer,
14128 >,
14129 {
14130 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
14131 2366825959783828089,
14132 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
14133 request,
14134 ))
14135 }
14136
14137 #[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"]
14138 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
14139 ::fidl_next::TwoWayFuture::from_untyped(
14140 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14141 6540867515453498750,
14142 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
14143 (),
14144 ),
14145 )
14146 }
14147
14148 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
14149 ::fidl_next::TwoWayFuture::from_untyped(
14150 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14151 2763219980499352582,
14152 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
14153 (),
14154 ),
14155 )
14156 }
14157
14158 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
14159 pub fn deprecated_clone(
14160 &self,
14161
14162 flags: impl ::fidl_next::Encode<
14163 crate::wire::OpenFlags,
14164 <___T as ::fidl_next::Transport>::SendBuffer,
14165 >,
14166
14167 object: impl ::fidl_next::Encode<
14168 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::wire::fuchsia::Channel>,
14169 <___T as ::fidl_next::Transport>::SendBuffer,
14170 >,
14171 ) -> ::fidl_next::SendFuture<'_, ___T>
14172 where
14173 <___T as ::fidl_next::Transport>::SendBuffer:
14174 ::fidl_next::encoder::InternalHandleEncoder,
14175 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
14176 {
14177 self.deprecated_clone_with(crate::generic::NodeDeprecatedCloneRequest {
14178 flags,
14179
14180 object,
14181 })
14182 }
14183
14184 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
14185 pub fn deprecated_clone_with<___R>(
14186 &self,
14187 request: ___R,
14188 ) -> ::fidl_next::SendFuture<'_, ___T>
14189 where
14190 ___R: ::fidl_next::Encode<
14191 crate::wire::NodeDeprecatedCloneRequest,
14192 <___T as ::fidl_next::Transport>::SendBuffer,
14193 >,
14194 {
14195 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
14196 6512600400724287855,
14197 <super::DeprecatedClone as ::fidl_next::Method>::FLEXIBILITY,
14198 request,
14199 ))
14200 }
14201
14202 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
14203 pub fn deprecated_get_attr(
14204 &self,
14205 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
14206 ::fidl_next::TwoWayFuture::from_untyped(
14207 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14208 8689798978500614909,
14209 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
14210 (),
14211 ),
14212 )
14213 }
14214
14215 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
14216 pub fn deprecated_set_attr(
14217 &self,
14218
14219 flags: impl ::fidl_next::Encode<
14220 crate::wire::NodeAttributeFlags,
14221 <___T as ::fidl_next::Transport>::SendBuffer,
14222 >,
14223
14224 attributes: impl ::fidl_next::Encode<
14225 crate::wire::NodeAttributes,
14226 <___T as ::fidl_next::Transport>::SendBuffer,
14227 >,
14228 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
14229 where
14230 <___T as ::fidl_next::Transport>::SendBuffer:
14231 ::fidl_next::encoder::InternalHandleEncoder,
14232 {
14233 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
14234 flags,
14235
14236 attributes,
14237 })
14238 }
14239
14240 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
14241 pub fn deprecated_set_attr_with<___R>(
14242 &self,
14243 request: ___R,
14244 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
14245 where
14246 ___R: ::fidl_next::Encode<
14247 crate::wire::NodeDeprecatedSetAttrRequest,
14248 <___T as ::fidl_next::Transport>::SendBuffer,
14249 >,
14250 {
14251 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14252 4721673413776871238,
14253 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
14254 request,
14255 ))
14256 }
14257
14258 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
14259 pub fn deprecated_get_flags(
14260 &self,
14261 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
14262 ::fidl_next::TwoWayFuture::from_untyped(
14263 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14264 6595803110182632097,
14265 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
14266 (),
14267 ),
14268 )
14269 }
14270
14271 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
14272 pub fn deprecated_set_flags(
14273 &self,
14274
14275 flags: impl ::fidl_next::Encode<
14276 crate::wire::OpenFlags,
14277 <___T as ::fidl_next::Transport>::SendBuffer,
14278 >,
14279 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
14280 where
14281 <___T as ::fidl_next::Transport>::SendBuffer:
14282 ::fidl_next::encoder::InternalHandleEncoder,
14283 {
14284 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
14285 flags,
14286 })
14287 }
14288
14289 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
14290 pub fn deprecated_set_flags_with<___R>(
14291 &self,
14292 request: ___R,
14293 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
14294 where
14295 ___R: ::fidl_next::Encode<
14296 crate::wire::NodeDeprecatedSetFlagsRequest,
14297 <___T as ::fidl_next::Transport>::SendBuffer,
14298 >,
14299 {
14300 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14301 5950864159036794675,
14302 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
14303 request,
14304 ))
14305 }
14306
14307 #[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"]
14308 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
14309 ::fidl_next::TwoWayFuture::from_untyped(
14310 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14311 105530239381466147,
14312 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
14313 (),
14314 ),
14315 )
14316 }
14317
14318 #[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"]
14319 pub fn set_flags(
14320 &self,
14321
14322 flags: impl ::fidl_next::Encode<
14323 crate::wire::Flags,
14324 <___T as ::fidl_next::Transport>::SendBuffer,
14325 >,
14326 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
14327 where
14328 <___T as ::fidl_next::Transport>::SendBuffer:
14329 ::fidl_next::encoder::InternalHandleEncoder,
14330 {
14331 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
14332 }
14333
14334 #[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"]
14335 pub fn set_flags_with<___R>(
14336 &self,
14337 request: ___R,
14338 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
14339 where
14340 ___R: ::fidl_next::Encode<
14341 crate::wire::NodeSetFlagsRequest,
14342 <___T as ::fidl_next::Transport>::SendBuffer,
14343 >,
14344 {
14345 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14346 6172186066099445416,
14347 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
14348 request,
14349 ))
14350 }
14351
14352 #[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"]
14353 pub fn query_filesystem(
14354 &self,
14355 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
14356 ::fidl_next::TwoWayFuture::from_untyped(
14357 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14358 8013111122914313744,
14359 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
14360 (),
14361 ),
14362 )
14363 }
14364
14365 #[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"]
14366 pub fn get_attributes(
14367 &self,
14368
14369 query: impl ::fidl_next::Encode<
14370 crate::wire::NodeAttributesQuery,
14371 <___T as ::fidl_next::Transport>::SendBuffer,
14372 >,
14373 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
14374 where
14375 <___T as ::fidl_next::Transport>::SendBuffer:
14376 ::fidl_next::encoder::InternalHandleEncoder,
14377 {
14378 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
14379 }
14380
14381 #[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"]
14382 pub fn get_attributes_with<___R>(
14383 &self,
14384 request: ___R,
14385 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
14386 where
14387 ___R: ::fidl_next::Encode<
14388 crate::wire::NodeGetAttributesRequest,
14389 <___T as ::fidl_next::Transport>::SendBuffer,
14390 >,
14391 {
14392 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14393 4414537700416816443,
14394 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
14395 request,
14396 ))
14397 }
14398
14399 #[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"]
14400 pub fn update_attributes_with<___R>(
14401 &self,
14402 request: ___R,
14403 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
14404 where
14405 ___R: ::fidl_next::Encode<
14406 crate::wire::MutableNodeAttributes<'static>,
14407 <___T as ::fidl_next::Transport>::SendBuffer,
14408 >,
14409 {
14410 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14411 3677402239314018056,
14412 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
14413 request,
14414 ))
14415 }
14416
14417 #[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"]
14418 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
14419 ::fidl_next::TwoWayFuture::from_untyped(
14420 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14421 3196473584242777161,
14422 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
14423 (),
14424 ),
14425 )
14426 }
14427
14428 #[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"]
14429 pub fn list_extended_attributes(
14430 &self,
14431
14432 iterator: impl ::fidl_next::Encode<
14433 ::fidl_next::ServerEnd<
14434 crate::ExtendedAttributeIterator,
14435 ::fidl_next::wire::fuchsia::Channel,
14436 >,
14437 <___T as ::fidl_next::Transport>::SendBuffer,
14438 >,
14439 ) -> ::fidl_next::SendFuture<'_, ___T>
14440 where
14441 <___T as ::fidl_next::Transport>::SendBuffer:
14442 ::fidl_next::encoder::InternalHandleEncoder,
14443 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
14444 {
14445 self.list_extended_attributes_with(
14446 crate::generic::NodeListExtendedAttributesRequest { iterator },
14447 )
14448 }
14449
14450 #[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"]
14451 pub fn list_extended_attributes_with<___R>(
14452 &self,
14453 request: ___R,
14454 ) -> ::fidl_next::SendFuture<'_, ___T>
14455 where
14456 ___R: ::fidl_next::Encode<
14457 crate::wire::NodeListExtendedAttributesRequest,
14458 <___T as ::fidl_next::Transport>::SendBuffer,
14459 >,
14460 {
14461 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
14462 5431626189872037072,
14463 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
14464 request,
14465 ))
14466 }
14467
14468 #[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"]
14469 pub fn get_extended_attribute(
14470 &self,
14471
14472 name: impl ::fidl_next::Encode<
14473 ::fidl_next::wire::Vector<'static, u8>,
14474 <___T as ::fidl_next::Transport>::SendBuffer,
14475 >,
14476 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
14477 where
14478 <___T as ::fidl_next::Transport>::SendBuffer:
14479 ::fidl_next::encoder::InternalHandleEncoder,
14480 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14481 {
14482 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
14483 name,
14484 })
14485 }
14486
14487 #[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"]
14488 pub fn get_extended_attribute_with<___R>(
14489 &self,
14490 request: ___R,
14491 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
14492 where
14493 ___R: ::fidl_next::Encode<
14494 crate::wire::NodeGetExtendedAttributeRequest<'static>,
14495 <___T as ::fidl_next::Transport>::SendBuffer,
14496 >,
14497 {
14498 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14499 5043930208506967771,
14500 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
14501 request,
14502 ))
14503 }
14504
14505 #[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"]
14506 pub fn set_extended_attribute(
14507 &self,
14508
14509 name: impl ::fidl_next::Encode<
14510 ::fidl_next::wire::Vector<'static, u8>,
14511 <___T as ::fidl_next::Transport>::SendBuffer,
14512 >,
14513
14514 value: impl ::fidl_next::Encode<
14515 crate::wire::ExtendedAttributeValue<'static>,
14516 <___T as ::fidl_next::Transport>::SendBuffer,
14517 >,
14518
14519 mode: impl ::fidl_next::Encode<
14520 crate::wire::SetExtendedAttributeMode,
14521 <___T as ::fidl_next::Transport>::SendBuffer,
14522 >,
14523 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
14524 where
14525 <___T as ::fidl_next::Transport>::SendBuffer:
14526 ::fidl_next::encoder::InternalHandleEncoder,
14527 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14528 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
14529 {
14530 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
14531 name,
14532
14533 value,
14534
14535 mode,
14536 })
14537 }
14538
14539 #[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"]
14540 pub fn set_extended_attribute_with<___R>(
14541 &self,
14542 request: ___R,
14543 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
14544 where
14545 ___R: ::fidl_next::Encode<
14546 crate::wire::NodeSetExtendedAttributeRequest<'static>,
14547 <___T as ::fidl_next::Transport>::SendBuffer,
14548 >,
14549 {
14550 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14551 5374223046099989052,
14552 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
14553 request,
14554 ))
14555 }
14556
14557 #[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"]
14558 pub fn remove_extended_attribute(
14559 &self,
14560
14561 name: impl ::fidl_next::Encode<
14562 ::fidl_next::wire::Vector<'static, u8>,
14563 <___T as ::fidl_next::Transport>::SendBuffer,
14564 >,
14565 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
14566 where
14567 <___T as ::fidl_next::Transport>::SendBuffer:
14568 ::fidl_next::encoder::InternalHandleEncoder,
14569 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14570 {
14571 self.remove_extended_attribute_with(
14572 crate::generic::NodeRemoveExtendedAttributeRequest { name },
14573 )
14574 }
14575
14576 #[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"]
14577 pub fn remove_extended_attribute_with<___R>(
14578 &self,
14579 request: ___R,
14580 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
14581 where
14582 ___R: ::fidl_next::Encode<
14583 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
14584 <___T as ::fidl_next::Transport>::SendBuffer,
14585 >,
14586 {
14587 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14588 8794297771444732717,
14589 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
14590 request,
14591 ))
14592 }
14593
14594 #[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"]
14595 pub fn read(
14596 &self,
14597
14598 count: impl ::fidl_next::Encode<
14599 ::fidl_next::wire::Uint64,
14600 <___T as ::fidl_next::Transport>::SendBuffer,
14601 >,
14602 ) -> ::fidl_next::TwoWayFuture<'_, super::Read, ___T>
14603 where
14604 <___T as ::fidl_next::Transport>::SendBuffer:
14605 ::fidl_next::encoder::InternalHandleEncoder,
14606 {
14607 self.read_with(crate::generic::ReadableReadRequest { count })
14608 }
14609
14610 #[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"]
14611 pub fn read_with<___R>(
14612 &self,
14613 request: ___R,
14614 ) -> ::fidl_next::TwoWayFuture<'_, super::Read, ___T>
14615 where
14616 ___R: ::fidl_next::Encode<
14617 crate::wire::ReadableReadRequest,
14618 <___T as ::fidl_next::Transport>::SendBuffer,
14619 >,
14620 {
14621 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14622 395825947633028830,
14623 <super::Read as ::fidl_next::Method>::FLEXIBILITY,
14624 request,
14625 ))
14626 }
14627
14628 #[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"]
14629 pub fn write(
14630 &self,
14631
14632 data: impl ::fidl_next::Encode<
14633 ::fidl_next::wire::Vector<'static, u8>,
14634 <___T as ::fidl_next::Transport>::SendBuffer,
14635 >,
14636 ) -> ::fidl_next::TwoWayFuture<'_, super::Write, ___T>
14637 where
14638 <___T as ::fidl_next::Transport>::SendBuffer:
14639 ::fidl_next::encoder::InternalHandleEncoder,
14640 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14641 {
14642 self.write_with(crate::generic::WritableWriteRequest { data })
14643 }
14644
14645 #[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"]
14646 pub fn write_with<___R>(
14647 &self,
14648 request: ___R,
14649 ) -> ::fidl_next::TwoWayFuture<'_, super::Write, ___T>
14650 where
14651 ___R: ::fidl_next::Encode<
14652 crate::wire::WritableWriteRequest<'static>,
14653 <___T as ::fidl_next::Transport>::SendBuffer,
14654 >,
14655 {
14656 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14657 7651971425397809026,
14658 <super::Write as ::fidl_next::Method>::FLEXIBILITY,
14659 request,
14660 ))
14661 }
14662
14663 pub fn describe(&self) -> ::fidl_next::TwoWayFuture<'_, super::Describe, ___T> {
14664 ::fidl_next::TwoWayFuture::from_untyped(
14665 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14666 7545125870053689020,
14667 <super::Describe as ::fidl_next::Method>::FLEXIBILITY,
14668 (),
14669 ),
14670 )
14671 }
14672
14673 #[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"]
14674 pub fn seek(
14675 &self,
14676
14677 origin: impl ::fidl_next::Encode<
14678 crate::wire::SeekOrigin,
14679 <___T as ::fidl_next::Transport>::SendBuffer,
14680 >,
14681
14682 offset: impl ::fidl_next::Encode<
14683 ::fidl_next::wire::Int64,
14684 <___T as ::fidl_next::Transport>::SendBuffer,
14685 >,
14686 ) -> ::fidl_next::TwoWayFuture<'_, super::Seek, ___T>
14687 where
14688 <___T as ::fidl_next::Transport>::SendBuffer:
14689 ::fidl_next::encoder::InternalHandleEncoder,
14690 {
14691 self.seek_with(crate::generic::FileSeekRequest { origin, offset })
14692 }
14693
14694 #[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"]
14695 pub fn seek_with<___R>(
14696 &self,
14697 request: ___R,
14698 ) -> ::fidl_next::TwoWayFuture<'_, super::Seek, ___T>
14699 where
14700 ___R: ::fidl_next::Encode<
14701 crate::wire::FileSeekRequest,
14702 <___T as ::fidl_next::Transport>::SendBuffer,
14703 >,
14704 {
14705 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14706 8649041485622956551,
14707 <super::Seek as ::fidl_next::Method>::FLEXIBILITY,
14708 request,
14709 ))
14710 }
14711
14712 #[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"]
14713 pub fn read_at(
14714 &self,
14715
14716 count: impl ::fidl_next::Encode<
14717 ::fidl_next::wire::Uint64,
14718 <___T as ::fidl_next::Transport>::SendBuffer,
14719 >,
14720
14721 offset: impl ::fidl_next::Encode<
14722 ::fidl_next::wire::Uint64,
14723 <___T as ::fidl_next::Transport>::SendBuffer,
14724 >,
14725 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadAt, ___T>
14726 where
14727 <___T as ::fidl_next::Transport>::SendBuffer:
14728 ::fidl_next::encoder::InternalHandleEncoder,
14729 {
14730 self.read_at_with(crate::generic::FileReadAtRequest { count, offset })
14731 }
14732
14733 #[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"]
14734 pub fn read_at_with<___R>(
14735 &self,
14736 request: ___R,
14737 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadAt, ___T>
14738 where
14739 ___R: ::fidl_next::Encode<
14740 crate::wire::FileReadAtRequest,
14741 <___T as ::fidl_next::Transport>::SendBuffer,
14742 >,
14743 {
14744 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14745 1587416148701180478,
14746 <super::ReadAt as ::fidl_next::Method>::FLEXIBILITY,
14747 request,
14748 ))
14749 }
14750
14751 #[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"]
14752 pub fn write_at(
14753 &self,
14754
14755 data: impl ::fidl_next::Encode<
14756 ::fidl_next::wire::Vector<'static, u8>,
14757 <___T as ::fidl_next::Transport>::SendBuffer,
14758 >,
14759
14760 offset: impl ::fidl_next::Encode<
14761 ::fidl_next::wire::Uint64,
14762 <___T as ::fidl_next::Transport>::SendBuffer,
14763 >,
14764 ) -> ::fidl_next::TwoWayFuture<'_, super::WriteAt, ___T>
14765 where
14766 <___T as ::fidl_next::Transport>::SendBuffer:
14767 ::fidl_next::encoder::InternalHandleEncoder,
14768 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14769 {
14770 self.write_at_with(crate::generic::FileWriteAtRequest { data, offset })
14771 }
14772
14773 #[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"]
14774 pub fn write_at_with<___R>(
14775 &self,
14776 request: ___R,
14777 ) -> ::fidl_next::TwoWayFuture<'_, super::WriteAt, ___T>
14778 where
14779 ___R: ::fidl_next::Encode<
14780 crate::wire::FileWriteAtRequest<'static>,
14781 <___T as ::fidl_next::Transport>::SendBuffer,
14782 >,
14783 {
14784 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14785 8736683935131400491,
14786 <super::WriteAt as ::fidl_next::Method>::FLEXIBILITY,
14787 request,
14788 ))
14789 }
14790
14791 #[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"]
14792 pub fn resize(
14793 &self,
14794
14795 length: impl ::fidl_next::Encode<
14796 ::fidl_next::wire::Uint64,
14797 <___T as ::fidl_next::Transport>::SendBuffer,
14798 >,
14799 ) -> ::fidl_next::TwoWayFuture<'_, super::Resize, ___T>
14800 where
14801 <___T as ::fidl_next::Transport>::SendBuffer:
14802 ::fidl_next::encoder::InternalHandleEncoder,
14803 {
14804 self.resize_with(crate::generic::FileResizeRequest { length })
14805 }
14806
14807 #[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"]
14808 pub fn resize_with<___R>(
14809 &self,
14810 request: ___R,
14811 ) -> ::fidl_next::TwoWayFuture<'_, super::Resize, ___T>
14812 where
14813 ___R: ::fidl_next::Encode<
14814 crate::wire::FileResizeRequest,
14815 <___T as ::fidl_next::Transport>::SendBuffer,
14816 >,
14817 {
14818 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14819 3134648685270758458,
14820 <super::Resize as ::fidl_next::Method>::FLEXIBILITY,
14821 request,
14822 ))
14823 }
14824
14825 #[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"]
14826 pub fn get_backing_memory(
14827 &self,
14828
14829 flags: impl ::fidl_next::Encode<
14830 crate::wire::VmoFlags,
14831 <___T as ::fidl_next::Transport>::SendBuffer,
14832 >,
14833 ) -> ::fidl_next::TwoWayFuture<'_, super::GetBackingMemory, ___T>
14834 where
14835 <___T as ::fidl_next::Transport>::SendBuffer:
14836 ::fidl_next::encoder::InternalHandleEncoder,
14837 {
14838 self.get_backing_memory_with(crate::generic::FileGetBackingMemoryRequest { flags })
14839 }
14840
14841 #[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"]
14842 pub fn get_backing_memory_with<___R>(
14843 &self,
14844 request: ___R,
14845 ) -> ::fidl_next::TwoWayFuture<'_, super::GetBackingMemory, ___T>
14846 where
14847 ___R: ::fidl_next::Encode<
14848 crate::wire::FileGetBackingMemoryRequest,
14849 <___T as ::fidl_next::Transport>::SendBuffer,
14850 >,
14851 {
14852 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14853 46911652864194091,
14854 <super::GetBackingMemory as ::fidl_next::Method>::FLEXIBILITY,
14855 request,
14856 ))
14857 }
14858
14859 #[doc = " Pre-allocate on-disk space for this file.\n"]
14860 pub fn allocate(
14861 &self,
14862
14863 offset: impl ::fidl_next::Encode<
14864 ::fidl_next::wire::Uint64,
14865 <___T as ::fidl_next::Transport>::SendBuffer,
14866 >,
14867
14868 length: impl ::fidl_next::Encode<
14869 ::fidl_next::wire::Uint64,
14870 <___T as ::fidl_next::Transport>::SendBuffer,
14871 >,
14872
14873 mode: impl ::fidl_next::Encode<
14874 crate::wire::AllocateMode,
14875 <___T as ::fidl_next::Transport>::SendBuffer,
14876 >,
14877 ) -> ::fidl_next::TwoWayFuture<'_, super::Allocate, ___T>
14878 where
14879 <___T as ::fidl_next::Transport>::SendBuffer:
14880 ::fidl_next::encoder::InternalHandleEncoder,
14881 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
14882 {
14883 self.allocate_with(crate::generic::FileAllocateRequest { offset, length, mode })
14884 }
14885
14886 #[doc = " Pre-allocate on-disk space for this file.\n"]
14887 pub fn allocate_with<___R>(
14888 &self,
14889 request: ___R,
14890 ) -> ::fidl_next::TwoWayFuture<'_, super::Allocate, ___T>
14891 where
14892 ___R: ::fidl_next::Encode<
14893 crate::wire::FileAllocateRequest,
14894 <___T as ::fidl_next::Transport>::SendBuffer,
14895 >,
14896 {
14897 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14898 8645235848064269614,
14899 <super::Allocate as ::fidl_next::Method>::FLEXIBILITY,
14900 request,
14901 ))
14902 }
14903
14904 #[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"]
14905 pub fn enable_verity(
14906 &self,
14907
14908 options: impl ::fidl_next::Encode<
14909 crate::wire::VerificationOptions<'static>,
14910 <___T as ::fidl_next::Transport>::SendBuffer,
14911 >,
14912 ) -> ::fidl_next::TwoWayFuture<'_, super::EnableVerity, ___T>
14913 where
14914 <___T as ::fidl_next::Transport>::SendBuffer:
14915 ::fidl_next::encoder::InternalHandleEncoder,
14916 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14917 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
14918 {
14919 self.enable_verity_with(crate::generic::FileEnableVerityRequest { options })
14920 }
14921
14922 #[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"]
14923 pub fn enable_verity_with<___R>(
14924 &self,
14925 request: ___R,
14926 ) -> ::fidl_next::TwoWayFuture<'_, super::EnableVerity, ___T>
14927 where
14928 ___R: ::fidl_next::Encode<
14929 crate::wire::FileEnableVerityRequest<'static>,
14930 <___T as ::fidl_next::Transport>::SendBuffer,
14931 >,
14932 {
14933 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14934 3189145313204943035,
14935 <super::EnableVerity as ::fidl_next::Method>::FLEXIBILITY,
14936 request,
14937 ))
14938 }
14939 }
14940
14941 #[repr(transparent)]
14943 pub struct FileServer<___T: ::fidl_next::Transport> {
14944 server: ::fidl_next::protocol::Server<___T>,
14945 }
14946
14947 impl<___T> FileServer<___T>
14948 where
14949 ___T: ::fidl_next::Transport,
14950 {
14951 #[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"]
14952 pub fn on_open(
14953 &self,
14954
14955 s: impl ::fidl_next::Encode<
14956 ::fidl_next::wire::fuchsia::Status,
14957 <___T as ::fidl_next::Transport>::SendBuffer,
14958 >,
14959
14960 info: impl ::fidl_next::Encode<
14961 crate::wire_optional::NodeInfoDeprecated<'static>,
14962 <___T as ::fidl_next::Transport>::SendBuffer,
14963 >,
14964 ) -> ::fidl_next::SendFuture<'_, ___T>
14965 where
14966 <___T as ::fidl_next::Transport>::SendBuffer:
14967 ::fidl_next::encoder::InternalHandleEncoder,
14968 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14969 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
14970 {
14971 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
14972 }
14973
14974 #[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"]
14975
14976 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
14977 where
14978 ___R: ::fidl_next::Encode<
14979 <super::OnOpen as ::fidl_next::Method>::Request,
14980 <___T as ::fidl_next::Transport>::SendBuffer,
14981 >,
14982 {
14983 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
14984 9207534335756671346,
14985 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
14986 request,
14987 ))
14988 }
14989
14990 #[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"]
14991
14992 pub fn on_representation_with<___R>(
14993 &self,
14994 request: ___R,
14995 ) -> ::fidl_next::SendFuture<'_, ___T>
14996 where
14997 ___R: ::fidl_next::Encode<
14998 <super::OnRepresentation as ::fidl_next::Method>::Request,
14999 <___T as ::fidl_next::Transport>::SendBuffer,
15000 >,
15001 {
15002 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
15003 6679970090861613324,
15004 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
15005 request,
15006 ))
15007 }
15008 }
15009 }
15010}
15011
15012#[diagnostic::on_unimplemented(
15013 note = "If {Self} implements the non-local FileClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
15014)]
15015
15016pub trait FileLocalClientHandler<
15020 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15021 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15022>
15023{
15024 #[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"]
15025 fn on_open(
15026 &mut self,
15027
15028 request: ::fidl_next::Request<file::OnOpen, ___T>,
15029 ) -> impl ::core::future::Future<Output = ()>;
15030
15031 #[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"]
15032 fn on_representation(
15033 &mut self,
15034
15035 request: ::fidl_next::Request<file::OnRepresentation, ___T>,
15036 ) -> impl ::core::future::Future<Output = ()>;
15037
15038 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
15039 ::core::future::ready(())
15040 }
15041}
15042
15043impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for File
15044where
15045 ___H: FileLocalClientHandler<___T>,
15046 ___T: ::fidl_next::Transport,
15047 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
15048 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15049 Constraint = (),
15050 >,
15051 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
15052 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15053 Constraint = (),
15054 >,
15055{
15056 async fn on_event(
15057 handler: &mut ___H,
15058 mut message: ::fidl_next::Message<___T>,
15059 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
15060 match *message.header().ordinal {
15061 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
15062 Ok(decoded) => {
15063 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
15064 Ok(())
15065 }
15066 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15067 ordinal: 9207534335756671346,
15068 error,
15069 }),
15070 },
15071
15072 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
15073 Ok(decoded) => {
15074 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
15075 Ok(())
15076 }
15077 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15078 ordinal: 6679970090861613324,
15079 error,
15080 }),
15081 },
15082
15083 ordinal => {
15084 handler.on_unknown_interaction(ordinal).await;
15085 if ::core::matches!(
15086 message.header().flexibility(),
15087 ::fidl_next::protocol::Flexibility::Strict
15088 ) {
15089 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15090 } else {
15091 Ok(())
15092 }
15093 }
15094 }
15095 }
15096}
15097
15098#[diagnostic::on_unimplemented(
15099 note = "If {Self} implements the non-local FileServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
15100)]
15101
15102pub trait FileLocalServerHandler<
15106 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15107 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15108>
15109{
15110 #[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"]
15111 fn advisory_lock(
15112 &mut self,
15113
15114 request: ::fidl_next::Request<file::AdvisoryLock, ___T>,
15115
15116 responder: ::fidl_next::Responder<file::AdvisoryLock, ___T>,
15117 ) -> impl ::core::future::Future<Output = ()>;
15118
15119 #[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"]
15120 fn link_into(
15121 &mut self,
15122
15123 request: ::fidl_next::Request<file::LinkInto, ___T>,
15124
15125 responder: ::fidl_next::Responder<file::LinkInto, ___T>,
15126 ) -> impl ::core::future::Future<Output = ()>;
15127
15128 fn clone(
15129 &mut self,
15130
15131 request: ::fidl_next::Request<file::Clone, ___T>,
15132 ) -> impl ::core::future::Future<Output = ()>;
15133
15134 #[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"]
15135 fn close(
15136 &mut self,
15137
15138 responder: ::fidl_next::Responder<file::Close, ___T>,
15139 ) -> impl ::core::future::Future<Output = ()>;
15140
15141 fn query(
15142 &mut self,
15143
15144 responder: ::fidl_next::Responder<file::Query, ___T>,
15145 ) -> impl ::core::future::Future<Output = ()>;
15146
15147 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
15148 fn deprecated_clone(
15149 &mut self,
15150
15151 request: ::fidl_next::Request<file::DeprecatedClone, ___T>,
15152 ) -> impl ::core::future::Future<Output = ()>;
15153
15154 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
15155 fn deprecated_get_attr(
15156 &mut self,
15157
15158 responder: ::fidl_next::Responder<file::DeprecatedGetAttr, ___T>,
15159 ) -> impl ::core::future::Future<Output = ()>;
15160
15161 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
15162 fn deprecated_set_attr(
15163 &mut self,
15164
15165 request: ::fidl_next::Request<file::DeprecatedSetAttr, ___T>,
15166
15167 responder: ::fidl_next::Responder<file::DeprecatedSetAttr, ___T>,
15168 ) -> impl ::core::future::Future<Output = ()>;
15169
15170 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
15171 fn deprecated_get_flags(
15172 &mut self,
15173
15174 responder: ::fidl_next::Responder<file::DeprecatedGetFlags, ___T>,
15175 ) -> impl ::core::future::Future<Output = ()>;
15176
15177 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
15178 fn deprecated_set_flags(
15179 &mut self,
15180
15181 request: ::fidl_next::Request<file::DeprecatedSetFlags, ___T>,
15182
15183 responder: ::fidl_next::Responder<file::DeprecatedSetFlags, ___T>,
15184 ) -> impl ::core::future::Future<Output = ()>;
15185
15186 #[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"]
15187 fn get_flags(
15188 &mut self,
15189
15190 responder: ::fidl_next::Responder<file::GetFlags, ___T>,
15191 ) -> impl ::core::future::Future<Output = ()>;
15192
15193 #[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"]
15194 fn set_flags(
15195 &mut self,
15196
15197 request: ::fidl_next::Request<file::SetFlags, ___T>,
15198
15199 responder: ::fidl_next::Responder<file::SetFlags, ___T>,
15200 ) -> impl ::core::future::Future<Output = ()>;
15201
15202 #[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"]
15203 fn query_filesystem(
15204 &mut self,
15205
15206 responder: ::fidl_next::Responder<file::QueryFilesystem, ___T>,
15207 ) -> impl ::core::future::Future<Output = ()>;
15208
15209 #[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"]
15210 fn get_attributes(
15211 &mut self,
15212
15213 request: ::fidl_next::Request<file::GetAttributes, ___T>,
15214
15215 responder: ::fidl_next::Responder<file::GetAttributes, ___T>,
15216 ) -> impl ::core::future::Future<Output = ()>;
15217
15218 #[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"]
15219 fn update_attributes(
15220 &mut self,
15221
15222 request: ::fidl_next::Request<file::UpdateAttributes, ___T>,
15223
15224 responder: ::fidl_next::Responder<file::UpdateAttributes, ___T>,
15225 ) -> impl ::core::future::Future<Output = ()>;
15226
15227 #[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"]
15228 fn sync(
15229 &mut self,
15230
15231 responder: ::fidl_next::Responder<file::Sync, ___T>,
15232 ) -> impl ::core::future::Future<Output = ()>;
15233
15234 #[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"]
15235 fn list_extended_attributes(
15236 &mut self,
15237
15238 request: ::fidl_next::Request<file::ListExtendedAttributes, ___T>,
15239 ) -> impl ::core::future::Future<Output = ()>;
15240
15241 #[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"]
15242 fn get_extended_attribute(
15243 &mut self,
15244
15245 request: ::fidl_next::Request<file::GetExtendedAttribute, ___T>,
15246
15247 responder: ::fidl_next::Responder<file::GetExtendedAttribute, ___T>,
15248 ) -> impl ::core::future::Future<Output = ()>;
15249
15250 #[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"]
15251 fn set_extended_attribute(
15252 &mut self,
15253
15254 request: ::fidl_next::Request<file::SetExtendedAttribute, ___T>,
15255
15256 responder: ::fidl_next::Responder<file::SetExtendedAttribute, ___T>,
15257 ) -> impl ::core::future::Future<Output = ()>;
15258
15259 #[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"]
15260 fn remove_extended_attribute(
15261 &mut self,
15262
15263 request: ::fidl_next::Request<file::RemoveExtendedAttribute, ___T>,
15264
15265 responder: ::fidl_next::Responder<file::RemoveExtendedAttribute, ___T>,
15266 ) -> impl ::core::future::Future<Output = ()>;
15267
15268 #[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"]
15269 fn read(
15270 &mut self,
15271
15272 request: ::fidl_next::Request<file::Read, ___T>,
15273
15274 responder: ::fidl_next::Responder<file::Read, ___T>,
15275 ) -> impl ::core::future::Future<Output = ()>;
15276
15277 #[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"]
15278 fn write(
15279 &mut self,
15280
15281 request: ::fidl_next::Request<file::Write, ___T>,
15282
15283 responder: ::fidl_next::Responder<file::Write, ___T>,
15284 ) -> impl ::core::future::Future<Output = ()>;
15285
15286 fn describe(
15287 &mut self,
15288
15289 responder: ::fidl_next::Responder<file::Describe, ___T>,
15290 ) -> impl ::core::future::Future<Output = ()>;
15291
15292 #[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"]
15293 fn seek(
15294 &mut self,
15295
15296 request: ::fidl_next::Request<file::Seek, ___T>,
15297
15298 responder: ::fidl_next::Responder<file::Seek, ___T>,
15299 ) -> impl ::core::future::Future<Output = ()>;
15300
15301 #[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"]
15302 fn read_at(
15303 &mut self,
15304
15305 request: ::fidl_next::Request<file::ReadAt, ___T>,
15306
15307 responder: ::fidl_next::Responder<file::ReadAt, ___T>,
15308 ) -> impl ::core::future::Future<Output = ()>;
15309
15310 #[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"]
15311 fn write_at(
15312 &mut self,
15313
15314 request: ::fidl_next::Request<file::WriteAt, ___T>,
15315
15316 responder: ::fidl_next::Responder<file::WriteAt, ___T>,
15317 ) -> impl ::core::future::Future<Output = ()>;
15318
15319 #[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"]
15320 fn resize(
15321 &mut self,
15322
15323 request: ::fidl_next::Request<file::Resize, ___T>,
15324
15325 responder: ::fidl_next::Responder<file::Resize, ___T>,
15326 ) -> impl ::core::future::Future<Output = ()>;
15327
15328 #[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"]
15329 fn get_backing_memory(
15330 &mut self,
15331
15332 request: ::fidl_next::Request<file::GetBackingMemory, ___T>,
15333
15334 responder: ::fidl_next::Responder<file::GetBackingMemory, ___T>,
15335 ) -> impl ::core::future::Future<Output = ()>;
15336
15337 #[doc = " Pre-allocate on-disk space for this file.\n"]
15338 fn allocate(
15339 &mut self,
15340
15341 request: ::fidl_next::Request<file::Allocate, ___T>,
15342
15343 responder: ::fidl_next::Responder<file::Allocate, ___T>,
15344 ) -> impl ::core::future::Future<Output = ()>;
15345
15346 #[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"]
15347 fn enable_verity(
15348 &mut self,
15349
15350 request: ::fidl_next::Request<file::EnableVerity, ___T>,
15351
15352 responder: ::fidl_next::Responder<file::EnableVerity, ___T>,
15353 ) -> impl ::core::future::Future<Output = ()>;
15354
15355 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
15356 ::core::future::ready(())
15357 }
15358}
15359
15360impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for File
15361where
15362 ___H: FileLocalServerHandler<___T>,
15363 ___T: ::fidl_next::Transport,
15364 for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
15365 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15366 Constraint = (),
15367 >,
15368 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
15369 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15370 Constraint = (),
15371 >,
15372 for<'de> ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
15373 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15374 Constraint = (),
15375 >,
15376 for<'de> crate::wire::NodeDeprecatedCloneRequest: ::fidl_next::Decode<
15377 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15378 Constraint = (),
15379 >,
15380 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
15381 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15382 Constraint = (),
15383 >,
15384 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
15385 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15386 Constraint = (),
15387 >,
15388 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
15389 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15390 Constraint = (),
15391 >,
15392 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
15393 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15394 Constraint = (),
15395 >,
15396 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
15397 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15398 Constraint = (),
15399 >,
15400 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
15401 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15402 Constraint = (),
15403 >,
15404 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
15405 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15406 Constraint = (),
15407 >,
15408 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
15409 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15410 Constraint = (),
15411 >,
15412 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
15413 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15414 Constraint = (),
15415 >,
15416 for<'de> crate::wire::ReadableReadRequest: ::fidl_next::Decode<
15417 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15418 Constraint = (),
15419 >,
15420 for<'de> crate::wire::WritableWriteRequest<'de>: ::fidl_next::Decode<
15421 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15422 Constraint = (),
15423 >,
15424 for<'de> crate::wire::FileSeekRequest: ::fidl_next::Decode<
15425 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15426 Constraint = (),
15427 >,
15428 for<'de> crate::wire::FileReadAtRequest: ::fidl_next::Decode<
15429 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15430 Constraint = (),
15431 >,
15432 for<'de> crate::wire::FileWriteAtRequest<'de>: ::fidl_next::Decode<
15433 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15434 Constraint = (),
15435 >,
15436 for<'de> crate::wire::FileResizeRequest: ::fidl_next::Decode<
15437 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15438 Constraint = (),
15439 >,
15440 for<'de> crate::wire::FileGetBackingMemoryRequest: ::fidl_next::Decode<
15441 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15442 Constraint = (),
15443 >,
15444 for<'de> crate::wire::FileAllocateRequest: ::fidl_next::Decode<
15445 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15446 Constraint = (),
15447 >,
15448 for<'de> crate::wire::FileEnableVerityRequest<'de>: ::fidl_next::Decode<
15449 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15450 Constraint = (),
15451 >,
15452{
15453 async fn on_one_way(
15454 handler: &mut ___H,
15455 mut message: ::fidl_next::Message<___T>,
15456 ) -> ::core::result::Result<
15457 (),
15458 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15459 > {
15460 match *message.header().ordinal {
15461 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
15462 Ok(decoded) => {
15463 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
15464 Ok(())
15465 }
15466 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15467 ordinal: 2366825959783828089,
15468 error,
15469 }),
15470 },
15471
15472 6512600400724287855 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
15473 Ok(decoded) => {
15474 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
15475 Ok(())
15476 }
15477 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15478 ordinal: 6512600400724287855,
15479 error,
15480 }),
15481 },
15482
15483 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
15484 Ok(decoded) => {
15485 handler
15486 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
15487 .await;
15488 Ok(())
15489 }
15490 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15491 ordinal: 5431626189872037072,
15492 error,
15493 }),
15494 },
15495
15496 ordinal => {
15497 handler.on_unknown_interaction(ordinal).await;
15498 if ::core::matches!(
15499 message.header().flexibility(),
15500 ::fidl_next::protocol::Flexibility::Strict
15501 ) {
15502 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15503 } else {
15504 Ok(())
15505 }
15506 }
15507 }
15508 }
15509
15510 async fn on_two_way(
15511 handler: &mut ___H,
15512 mut message: ::fidl_next::Message<___T>,
15513 responder: ::fidl_next::protocol::Responder<___T>,
15514 ) -> ::core::result::Result<
15515 (),
15516 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15517 > {
15518 match *message.header().ordinal {
15519 7992130864415541162 => {
15520 let responder = ::fidl_next::Responder::from_untyped(responder);
15521
15522 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15523 Ok(decoded) => {
15524 handler
15525 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
15526 .await;
15527 Ok(())
15528 }
15529 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15530 ordinal: 7992130864415541162,
15531 error,
15532 }),
15533 }
15534 }
15535
15536 6121399674497678964 => {
15537 let responder = ::fidl_next::Responder::from_untyped(responder);
15538
15539 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15540 Ok(decoded) => {
15541 handler
15542 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
15543 .await;
15544 Ok(())
15545 }
15546 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15547 ordinal: 6121399674497678964,
15548 error,
15549 }),
15550 }
15551 }
15552
15553 6540867515453498750 => {
15554 let responder = ::fidl_next::Responder::from_untyped(responder);
15555
15556 handler.close(responder).await;
15557 Ok(())
15558 }
15559
15560 2763219980499352582 => {
15561 let responder = ::fidl_next::Responder::from_untyped(responder);
15562
15563 handler.query(responder).await;
15564 Ok(())
15565 }
15566
15567 8689798978500614909 => {
15568 let responder = ::fidl_next::Responder::from_untyped(responder);
15569
15570 handler.deprecated_get_attr(responder).await;
15571 Ok(())
15572 }
15573
15574 4721673413776871238 => {
15575 let responder = ::fidl_next::Responder::from_untyped(responder);
15576
15577 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15578 Ok(decoded) => {
15579 handler
15580 .deprecated_set_attr(
15581 ::fidl_next::Request::from_decoded(decoded),
15582 responder,
15583 )
15584 .await;
15585 Ok(())
15586 }
15587 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15588 ordinal: 4721673413776871238,
15589 error,
15590 }),
15591 }
15592 }
15593
15594 6595803110182632097 => {
15595 let responder = ::fidl_next::Responder::from_untyped(responder);
15596
15597 handler.deprecated_get_flags(responder).await;
15598 Ok(())
15599 }
15600
15601 5950864159036794675 => {
15602 let responder = ::fidl_next::Responder::from_untyped(responder);
15603
15604 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15605 Ok(decoded) => {
15606 handler
15607 .deprecated_set_flags(
15608 ::fidl_next::Request::from_decoded(decoded),
15609 responder,
15610 )
15611 .await;
15612 Ok(())
15613 }
15614 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15615 ordinal: 5950864159036794675,
15616 error,
15617 }),
15618 }
15619 }
15620
15621 105530239381466147 => {
15622 let responder = ::fidl_next::Responder::from_untyped(responder);
15623
15624 handler.get_flags(responder).await;
15625 Ok(())
15626 }
15627
15628 6172186066099445416 => {
15629 let responder = ::fidl_next::Responder::from_untyped(responder);
15630
15631 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15632 Ok(decoded) => {
15633 handler
15634 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
15635 .await;
15636 Ok(())
15637 }
15638 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15639 ordinal: 6172186066099445416,
15640 error,
15641 }),
15642 }
15643 }
15644
15645 8013111122914313744 => {
15646 let responder = ::fidl_next::Responder::from_untyped(responder);
15647
15648 handler.query_filesystem(responder).await;
15649 Ok(())
15650 }
15651
15652 4414537700416816443 => {
15653 let responder = ::fidl_next::Responder::from_untyped(responder);
15654
15655 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15656 Ok(decoded) => {
15657 handler
15658 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
15659 .await;
15660 Ok(())
15661 }
15662 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15663 ordinal: 4414537700416816443,
15664 error,
15665 }),
15666 }
15667 }
15668
15669 3677402239314018056 => {
15670 let responder = ::fidl_next::Responder::from_untyped(responder);
15671
15672 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15673 Ok(decoded) => {
15674 handler
15675 .update_attributes(
15676 ::fidl_next::Request::from_decoded(decoded),
15677 responder,
15678 )
15679 .await;
15680 Ok(())
15681 }
15682 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15683 ordinal: 3677402239314018056,
15684 error,
15685 }),
15686 }
15687 }
15688
15689 3196473584242777161 => {
15690 let responder = ::fidl_next::Responder::from_untyped(responder);
15691
15692 handler.sync(responder).await;
15693 Ok(())
15694 }
15695
15696 5043930208506967771 => {
15697 let responder = ::fidl_next::Responder::from_untyped(responder);
15698
15699 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15700 Ok(decoded) => {
15701 handler
15702 .get_extended_attribute(
15703 ::fidl_next::Request::from_decoded(decoded),
15704 responder,
15705 )
15706 .await;
15707 Ok(())
15708 }
15709 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15710 ordinal: 5043930208506967771,
15711 error,
15712 }),
15713 }
15714 }
15715
15716 5374223046099989052 => {
15717 let responder = ::fidl_next::Responder::from_untyped(responder);
15718
15719 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15720 Ok(decoded) => {
15721 handler
15722 .set_extended_attribute(
15723 ::fidl_next::Request::from_decoded(decoded),
15724 responder,
15725 )
15726 .await;
15727 Ok(())
15728 }
15729 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15730 ordinal: 5374223046099989052,
15731 error,
15732 }),
15733 }
15734 }
15735
15736 8794297771444732717 => {
15737 let responder = ::fidl_next::Responder::from_untyped(responder);
15738
15739 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15740 Ok(decoded) => {
15741 handler
15742 .remove_extended_attribute(
15743 ::fidl_next::Request::from_decoded(decoded),
15744 responder,
15745 )
15746 .await;
15747 Ok(())
15748 }
15749 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15750 ordinal: 8794297771444732717,
15751 error,
15752 }),
15753 }
15754 }
15755
15756 395825947633028830 => {
15757 let responder = ::fidl_next::Responder::from_untyped(responder);
15758
15759 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15760 Ok(decoded) => {
15761 handler.read(::fidl_next::Request::from_decoded(decoded), responder).await;
15762 Ok(())
15763 }
15764 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15765 ordinal: 395825947633028830,
15766 error,
15767 }),
15768 }
15769 }
15770
15771 7651971425397809026 => {
15772 let responder = ::fidl_next::Responder::from_untyped(responder);
15773
15774 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15775 Ok(decoded) => {
15776 handler.write(::fidl_next::Request::from_decoded(decoded), responder).await;
15777 Ok(())
15778 }
15779 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15780 ordinal: 7651971425397809026,
15781 error,
15782 }),
15783 }
15784 }
15785
15786 7545125870053689020 => {
15787 let responder = ::fidl_next::Responder::from_untyped(responder);
15788
15789 handler.describe(responder).await;
15790 Ok(())
15791 }
15792
15793 8649041485622956551 => {
15794 let responder = ::fidl_next::Responder::from_untyped(responder);
15795
15796 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15797 Ok(decoded) => {
15798 handler.seek(::fidl_next::Request::from_decoded(decoded), responder).await;
15799 Ok(())
15800 }
15801 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15802 ordinal: 8649041485622956551,
15803 error,
15804 }),
15805 }
15806 }
15807
15808 1587416148701180478 => {
15809 let responder = ::fidl_next::Responder::from_untyped(responder);
15810
15811 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15812 Ok(decoded) => {
15813 handler
15814 .read_at(::fidl_next::Request::from_decoded(decoded), responder)
15815 .await;
15816 Ok(())
15817 }
15818 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15819 ordinal: 1587416148701180478,
15820 error,
15821 }),
15822 }
15823 }
15824
15825 8736683935131400491 => {
15826 let responder = ::fidl_next::Responder::from_untyped(responder);
15827
15828 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15829 Ok(decoded) => {
15830 handler
15831 .write_at(::fidl_next::Request::from_decoded(decoded), responder)
15832 .await;
15833 Ok(())
15834 }
15835 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15836 ordinal: 8736683935131400491,
15837 error,
15838 }),
15839 }
15840 }
15841
15842 3134648685270758458 => {
15843 let responder = ::fidl_next::Responder::from_untyped(responder);
15844
15845 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15846 Ok(decoded) => {
15847 handler
15848 .resize(::fidl_next::Request::from_decoded(decoded), responder)
15849 .await;
15850 Ok(())
15851 }
15852 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15853 ordinal: 3134648685270758458,
15854 error,
15855 }),
15856 }
15857 }
15858
15859 46911652864194091 => {
15860 let responder = ::fidl_next::Responder::from_untyped(responder);
15861
15862 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15863 Ok(decoded) => {
15864 handler
15865 .get_backing_memory(
15866 ::fidl_next::Request::from_decoded(decoded),
15867 responder,
15868 )
15869 .await;
15870 Ok(())
15871 }
15872 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15873 ordinal: 46911652864194091,
15874 error,
15875 }),
15876 }
15877 }
15878
15879 8645235848064269614 => {
15880 let responder = ::fidl_next::Responder::from_untyped(responder);
15881
15882 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15883 Ok(decoded) => {
15884 handler
15885 .allocate(::fidl_next::Request::from_decoded(decoded), responder)
15886 .await;
15887 Ok(())
15888 }
15889 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15890 ordinal: 8645235848064269614,
15891 error,
15892 }),
15893 }
15894 }
15895
15896 3189145313204943035 => {
15897 let responder = ::fidl_next::Responder::from_untyped(responder);
15898
15899 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15900 Ok(decoded) => {
15901 handler
15902 .enable_verity(::fidl_next::Request::from_decoded(decoded), responder)
15903 .await;
15904 Ok(())
15905 }
15906 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15907 ordinal: 3189145313204943035,
15908 error,
15909 }),
15910 }
15911 }
15912
15913 ordinal => {
15914 handler.on_unknown_interaction(ordinal).await;
15915 if ::core::matches!(
15916 message.header().flexibility(),
15917 ::fidl_next::protocol::Flexibility::Strict
15918 ) {
15919 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15920 } else {
15921 responder
15922 .respond_framework_error(
15923 ordinal,
15924 ::fidl_next::FrameworkError::UnknownMethod,
15925 )
15926 .expect("encoding a framework error should never fail")
15927 .await?;
15928 Ok(())
15929 }
15930 }
15931 }
15932 }
15933}
15934
15935pub trait FileClientHandler<
15939 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15940 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15941>
15942{
15943 #[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"]
15944 fn on_open(
15945 &mut self,
15946
15947 request: ::fidl_next::Request<file::OnOpen, ___T>,
15948 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
15949
15950 #[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"]
15951 fn on_representation(
15952 &mut self,
15953
15954 request: ::fidl_next::Request<file::OnRepresentation, ___T>,
15955 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
15956
15957 fn on_unknown_interaction(
15958 &mut self,
15959 ordinal: u64,
15960 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
15961 ::core::future::ready(())
15962 }
15963}
15964
15965impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for File
15966where
15967 ___H: FileClientHandler<___T> + ::core::marker::Send,
15968 ___T: ::fidl_next::Transport,
15969 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
15970 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15971 Constraint = (),
15972 >,
15973 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
15974 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15975 Constraint = (),
15976 >,
15977{
15978 async fn on_event(
15979 handler: &mut ___H,
15980 mut message: ::fidl_next::Message<___T>,
15981 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
15982 match *message.header().ordinal {
15983 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
15984 Ok(decoded) => {
15985 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
15986 Ok(())
15987 }
15988 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15989 ordinal: 9207534335756671346,
15990 error,
15991 }),
15992 },
15993
15994 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
15995 Ok(decoded) => {
15996 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
15997 Ok(())
15998 }
15999 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16000 ordinal: 6679970090861613324,
16001 error,
16002 }),
16003 },
16004
16005 ordinal => {
16006 handler.on_unknown_interaction(ordinal).await;
16007 if ::core::matches!(
16008 message.header().flexibility(),
16009 ::fidl_next::protocol::Flexibility::Strict
16010 ) {
16011 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16012 } else {
16013 Ok(())
16014 }
16015 }
16016 }
16017 }
16018}
16019
16020pub trait FileServerHandler<
16024 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
16025 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
16026>
16027{
16028 #[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"]
16029 fn advisory_lock(
16030 &mut self,
16031
16032 request: ::fidl_next::Request<file::AdvisoryLock, ___T>,
16033
16034 responder: ::fidl_next::Responder<file::AdvisoryLock, ___T>,
16035 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16036
16037 #[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"]
16038 fn link_into(
16039 &mut self,
16040
16041 request: ::fidl_next::Request<file::LinkInto, ___T>,
16042
16043 responder: ::fidl_next::Responder<file::LinkInto, ___T>,
16044 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16045
16046 fn clone(
16047 &mut self,
16048
16049 request: ::fidl_next::Request<file::Clone, ___T>,
16050 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16051
16052 #[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"]
16053 fn close(
16054 &mut self,
16055
16056 responder: ::fidl_next::Responder<file::Close, ___T>,
16057 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16058
16059 fn query(
16060 &mut self,
16061
16062 responder: ::fidl_next::Responder<file::Query, ___T>,
16063 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16064
16065 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
16066 fn deprecated_clone(
16067 &mut self,
16068
16069 request: ::fidl_next::Request<file::DeprecatedClone, ___T>,
16070 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16071
16072 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
16073 fn deprecated_get_attr(
16074 &mut self,
16075
16076 responder: ::fidl_next::Responder<file::DeprecatedGetAttr, ___T>,
16077 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16078
16079 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
16080 fn deprecated_set_attr(
16081 &mut self,
16082
16083 request: ::fidl_next::Request<file::DeprecatedSetAttr, ___T>,
16084
16085 responder: ::fidl_next::Responder<file::DeprecatedSetAttr, ___T>,
16086 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16087
16088 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
16089 fn deprecated_get_flags(
16090 &mut self,
16091
16092 responder: ::fidl_next::Responder<file::DeprecatedGetFlags, ___T>,
16093 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16094
16095 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
16096 fn deprecated_set_flags(
16097 &mut self,
16098
16099 request: ::fidl_next::Request<file::DeprecatedSetFlags, ___T>,
16100
16101 responder: ::fidl_next::Responder<file::DeprecatedSetFlags, ___T>,
16102 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16103
16104 #[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"]
16105 fn get_flags(
16106 &mut self,
16107
16108 responder: ::fidl_next::Responder<file::GetFlags, ___T>,
16109 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16110
16111 #[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"]
16112 fn set_flags(
16113 &mut self,
16114
16115 request: ::fidl_next::Request<file::SetFlags, ___T>,
16116
16117 responder: ::fidl_next::Responder<file::SetFlags, ___T>,
16118 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16119
16120 #[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"]
16121 fn query_filesystem(
16122 &mut self,
16123
16124 responder: ::fidl_next::Responder<file::QueryFilesystem, ___T>,
16125 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16126
16127 #[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"]
16128 fn get_attributes(
16129 &mut self,
16130
16131 request: ::fidl_next::Request<file::GetAttributes, ___T>,
16132
16133 responder: ::fidl_next::Responder<file::GetAttributes, ___T>,
16134 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16135
16136 #[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"]
16137 fn update_attributes(
16138 &mut self,
16139
16140 request: ::fidl_next::Request<file::UpdateAttributes, ___T>,
16141
16142 responder: ::fidl_next::Responder<file::UpdateAttributes, ___T>,
16143 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16144
16145 #[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"]
16146 fn sync(
16147 &mut self,
16148
16149 responder: ::fidl_next::Responder<file::Sync, ___T>,
16150 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16151
16152 #[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"]
16153 fn list_extended_attributes(
16154 &mut self,
16155
16156 request: ::fidl_next::Request<file::ListExtendedAttributes, ___T>,
16157 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16158
16159 #[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"]
16160 fn get_extended_attribute(
16161 &mut self,
16162
16163 request: ::fidl_next::Request<file::GetExtendedAttribute, ___T>,
16164
16165 responder: ::fidl_next::Responder<file::GetExtendedAttribute, ___T>,
16166 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16167
16168 #[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"]
16169 fn set_extended_attribute(
16170 &mut self,
16171
16172 request: ::fidl_next::Request<file::SetExtendedAttribute, ___T>,
16173
16174 responder: ::fidl_next::Responder<file::SetExtendedAttribute, ___T>,
16175 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16176
16177 #[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"]
16178 fn remove_extended_attribute(
16179 &mut self,
16180
16181 request: ::fidl_next::Request<file::RemoveExtendedAttribute, ___T>,
16182
16183 responder: ::fidl_next::Responder<file::RemoveExtendedAttribute, ___T>,
16184 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16185
16186 #[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"]
16187 fn read(
16188 &mut self,
16189
16190 request: ::fidl_next::Request<file::Read, ___T>,
16191
16192 responder: ::fidl_next::Responder<file::Read, ___T>,
16193 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16194
16195 #[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"]
16196 fn write(
16197 &mut self,
16198
16199 request: ::fidl_next::Request<file::Write, ___T>,
16200
16201 responder: ::fidl_next::Responder<file::Write, ___T>,
16202 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16203
16204 fn describe(
16205 &mut self,
16206
16207 responder: ::fidl_next::Responder<file::Describe, ___T>,
16208 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16209
16210 #[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"]
16211 fn seek(
16212 &mut self,
16213
16214 request: ::fidl_next::Request<file::Seek, ___T>,
16215
16216 responder: ::fidl_next::Responder<file::Seek, ___T>,
16217 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16218
16219 #[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"]
16220 fn read_at(
16221 &mut self,
16222
16223 request: ::fidl_next::Request<file::ReadAt, ___T>,
16224
16225 responder: ::fidl_next::Responder<file::ReadAt, ___T>,
16226 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16227
16228 #[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"]
16229 fn write_at(
16230 &mut self,
16231
16232 request: ::fidl_next::Request<file::WriteAt, ___T>,
16233
16234 responder: ::fidl_next::Responder<file::WriteAt, ___T>,
16235 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16236
16237 #[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"]
16238 fn resize(
16239 &mut self,
16240
16241 request: ::fidl_next::Request<file::Resize, ___T>,
16242
16243 responder: ::fidl_next::Responder<file::Resize, ___T>,
16244 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16245
16246 #[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"]
16247 fn get_backing_memory(
16248 &mut self,
16249
16250 request: ::fidl_next::Request<file::GetBackingMemory, ___T>,
16251
16252 responder: ::fidl_next::Responder<file::GetBackingMemory, ___T>,
16253 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16254
16255 #[doc = " Pre-allocate on-disk space for this file.\n"]
16256 fn allocate(
16257 &mut self,
16258
16259 request: ::fidl_next::Request<file::Allocate, ___T>,
16260
16261 responder: ::fidl_next::Responder<file::Allocate, ___T>,
16262 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16263
16264 #[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"]
16265 fn enable_verity(
16266 &mut self,
16267
16268 request: ::fidl_next::Request<file::EnableVerity, ___T>,
16269
16270 responder: ::fidl_next::Responder<file::EnableVerity, ___T>,
16271 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16272
16273 fn on_unknown_interaction(
16274 &mut self,
16275 ordinal: u64,
16276 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
16277 ::core::future::ready(())
16278 }
16279}
16280
16281impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for File
16282where
16283 ___H: FileServerHandler<___T> + ::core::marker::Send,
16284 ___T: ::fidl_next::Transport,
16285 for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
16286 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16287 Constraint = (),
16288 >,
16289 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
16290 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16291 Constraint = (),
16292 >,
16293 for<'de> ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
16294 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16295 Constraint = (),
16296 >,
16297 for<'de> crate::wire::NodeDeprecatedCloneRequest: ::fidl_next::Decode<
16298 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16299 Constraint = (),
16300 >,
16301 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
16302 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16303 Constraint = (),
16304 >,
16305 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
16306 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16307 Constraint = (),
16308 >,
16309 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
16310 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16311 Constraint = (),
16312 >,
16313 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
16314 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16315 Constraint = (),
16316 >,
16317 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
16318 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16319 Constraint = (),
16320 >,
16321 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
16322 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16323 Constraint = (),
16324 >,
16325 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'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::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
16330 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16331 Constraint = (),
16332 >,
16333 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'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::ReadableReadRequest: ::fidl_next::Decode<
16338 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16339 Constraint = (),
16340 >,
16341 for<'de> crate::wire::WritableWriteRequest<'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::FileSeekRequest: ::fidl_next::Decode<
16346 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16347 Constraint = (),
16348 >,
16349 for<'de> crate::wire::FileReadAtRequest: ::fidl_next::Decode<
16350 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16351 Constraint = (),
16352 >,
16353 for<'de> crate::wire::FileWriteAtRequest<'de>: ::fidl_next::Decode<
16354 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16355 Constraint = (),
16356 >,
16357 for<'de> crate::wire::FileResizeRequest: ::fidl_next::Decode<
16358 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16359 Constraint = (),
16360 >,
16361 for<'de> crate::wire::FileGetBackingMemoryRequest: ::fidl_next::Decode<
16362 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16363 Constraint = (),
16364 >,
16365 for<'de> crate::wire::FileAllocateRequest: ::fidl_next::Decode<
16366 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16367 Constraint = (),
16368 >,
16369 for<'de> crate::wire::FileEnableVerityRequest<'de>: ::fidl_next::Decode<
16370 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16371 Constraint = (),
16372 >,
16373{
16374 async fn on_one_way(
16375 handler: &mut ___H,
16376 mut message: ::fidl_next::Message<___T>,
16377 ) -> ::core::result::Result<
16378 (),
16379 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16380 > {
16381 match *message.header().ordinal {
16382 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
16383 Ok(decoded) => {
16384 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
16385 Ok(())
16386 }
16387 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16388 ordinal: 2366825959783828089,
16389 error,
16390 }),
16391 },
16392
16393 6512600400724287855 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
16394 Ok(decoded) => {
16395 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
16396 Ok(())
16397 }
16398 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16399 ordinal: 6512600400724287855,
16400 error,
16401 }),
16402 },
16403
16404 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
16405 Ok(decoded) => {
16406 handler
16407 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
16408 .await;
16409 Ok(())
16410 }
16411 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16412 ordinal: 5431626189872037072,
16413 error,
16414 }),
16415 },
16416
16417 ordinal => {
16418 handler.on_unknown_interaction(ordinal).await;
16419 if ::core::matches!(
16420 message.header().flexibility(),
16421 ::fidl_next::protocol::Flexibility::Strict
16422 ) {
16423 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16424 } else {
16425 Ok(())
16426 }
16427 }
16428 }
16429 }
16430
16431 async fn on_two_way(
16432 handler: &mut ___H,
16433 mut message: ::fidl_next::Message<___T>,
16434 responder: ::fidl_next::protocol::Responder<___T>,
16435 ) -> ::core::result::Result<
16436 (),
16437 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16438 > {
16439 match *message.header().ordinal {
16440 7992130864415541162 => {
16441 let responder = ::fidl_next::Responder::from_untyped(responder);
16442
16443 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16444 Ok(decoded) => {
16445 handler
16446 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
16447 .await;
16448 Ok(())
16449 }
16450 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16451 ordinal: 7992130864415541162,
16452 error,
16453 }),
16454 }
16455 }
16456
16457 6121399674497678964 => {
16458 let responder = ::fidl_next::Responder::from_untyped(responder);
16459
16460 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16461 Ok(decoded) => {
16462 handler
16463 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
16464 .await;
16465 Ok(())
16466 }
16467 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16468 ordinal: 6121399674497678964,
16469 error,
16470 }),
16471 }
16472 }
16473
16474 6540867515453498750 => {
16475 let responder = ::fidl_next::Responder::from_untyped(responder);
16476
16477 handler.close(responder).await;
16478 Ok(())
16479 }
16480
16481 2763219980499352582 => {
16482 let responder = ::fidl_next::Responder::from_untyped(responder);
16483
16484 handler.query(responder).await;
16485 Ok(())
16486 }
16487
16488 8689798978500614909 => {
16489 let responder = ::fidl_next::Responder::from_untyped(responder);
16490
16491 handler.deprecated_get_attr(responder).await;
16492 Ok(())
16493 }
16494
16495 4721673413776871238 => {
16496 let responder = ::fidl_next::Responder::from_untyped(responder);
16497
16498 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16499 Ok(decoded) => {
16500 handler
16501 .deprecated_set_attr(
16502 ::fidl_next::Request::from_decoded(decoded),
16503 responder,
16504 )
16505 .await;
16506 Ok(())
16507 }
16508 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16509 ordinal: 4721673413776871238,
16510 error,
16511 }),
16512 }
16513 }
16514
16515 6595803110182632097 => {
16516 let responder = ::fidl_next::Responder::from_untyped(responder);
16517
16518 handler.deprecated_get_flags(responder).await;
16519 Ok(())
16520 }
16521
16522 5950864159036794675 => {
16523 let responder = ::fidl_next::Responder::from_untyped(responder);
16524
16525 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16526 Ok(decoded) => {
16527 handler
16528 .deprecated_set_flags(
16529 ::fidl_next::Request::from_decoded(decoded),
16530 responder,
16531 )
16532 .await;
16533 Ok(())
16534 }
16535 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16536 ordinal: 5950864159036794675,
16537 error,
16538 }),
16539 }
16540 }
16541
16542 105530239381466147 => {
16543 let responder = ::fidl_next::Responder::from_untyped(responder);
16544
16545 handler.get_flags(responder).await;
16546 Ok(())
16547 }
16548
16549 6172186066099445416 => {
16550 let responder = ::fidl_next::Responder::from_untyped(responder);
16551
16552 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16553 Ok(decoded) => {
16554 handler
16555 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
16556 .await;
16557 Ok(())
16558 }
16559 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16560 ordinal: 6172186066099445416,
16561 error,
16562 }),
16563 }
16564 }
16565
16566 8013111122914313744 => {
16567 let responder = ::fidl_next::Responder::from_untyped(responder);
16568
16569 handler.query_filesystem(responder).await;
16570 Ok(())
16571 }
16572
16573 4414537700416816443 => {
16574 let responder = ::fidl_next::Responder::from_untyped(responder);
16575
16576 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16577 Ok(decoded) => {
16578 handler
16579 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
16580 .await;
16581 Ok(())
16582 }
16583 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16584 ordinal: 4414537700416816443,
16585 error,
16586 }),
16587 }
16588 }
16589
16590 3677402239314018056 => {
16591 let responder = ::fidl_next::Responder::from_untyped(responder);
16592
16593 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16594 Ok(decoded) => {
16595 handler
16596 .update_attributes(
16597 ::fidl_next::Request::from_decoded(decoded),
16598 responder,
16599 )
16600 .await;
16601 Ok(())
16602 }
16603 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16604 ordinal: 3677402239314018056,
16605 error,
16606 }),
16607 }
16608 }
16609
16610 3196473584242777161 => {
16611 let responder = ::fidl_next::Responder::from_untyped(responder);
16612
16613 handler.sync(responder).await;
16614 Ok(())
16615 }
16616
16617 5043930208506967771 => {
16618 let responder = ::fidl_next::Responder::from_untyped(responder);
16619
16620 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16621 Ok(decoded) => {
16622 handler
16623 .get_extended_attribute(
16624 ::fidl_next::Request::from_decoded(decoded),
16625 responder,
16626 )
16627 .await;
16628 Ok(())
16629 }
16630 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16631 ordinal: 5043930208506967771,
16632 error,
16633 }),
16634 }
16635 }
16636
16637 5374223046099989052 => {
16638 let responder = ::fidl_next::Responder::from_untyped(responder);
16639
16640 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16641 Ok(decoded) => {
16642 handler
16643 .set_extended_attribute(
16644 ::fidl_next::Request::from_decoded(decoded),
16645 responder,
16646 )
16647 .await;
16648 Ok(())
16649 }
16650 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16651 ordinal: 5374223046099989052,
16652 error,
16653 }),
16654 }
16655 }
16656
16657 8794297771444732717 => {
16658 let responder = ::fidl_next::Responder::from_untyped(responder);
16659
16660 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16661 Ok(decoded) => {
16662 handler
16663 .remove_extended_attribute(
16664 ::fidl_next::Request::from_decoded(decoded),
16665 responder,
16666 )
16667 .await;
16668 Ok(())
16669 }
16670 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16671 ordinal: 8794297771444732717,
16672 error,
16673 }),
16674 }
16675 }
16676
16677 395825947633028830 => {
16678 let responder = ::fidl_next::Responder::from_untyped(responder);
16679
16680 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16681 Ok(decoded) => {
16682 handler.read(::fidl_next::Request::from_decoded(decoded), responder).await;
16683 Ok(())
16684 }
16685 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16686 ordinal: 395825947633028830,
16687 error,
16688 }),
16689 }
16690 }
16691
16692 7651971425397809026 => {
16693 let responder = ::fidl_next::Responder::from_untyped(responder);
16694
16695 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16696 Ok(decoded) => {
16697 handler.write(::fidl_next::Request::from_decoded(decoded), responder).await;
16698 Ok(())
16699 }
16700 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16701 ordinal: 7651971425397809026,
16702 error,
16703 }),
16704 }
16705 }
16706
16707 7545125870053689020 => {
16708 let responder = ::fidl_next::Responder::from_untyped(responder);
16709
16710 handler.describe(responder).await;
16711 Ok(())
16712 }
16713
16714 8649041485622956551 => {
16715 let responder = ::fidl_next::Responder::from_untyped(responder);
16716
16717 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16718 Ok(decoded) => {
16719 handler.seek(::fidl_next::Request::from_decoded(decoded), responder).await;
16720 Ok(())
16721 }
16722 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16723 ordinal: 8649041485622956551,
16724 error,
16725 }),
16726 }
16727 }
16728
16729 1587416148701180478 => {
16730 let responder = ::fidl_next::Responder::from_untyped(responder);
16731
16732 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16733 Ok(decoded) => {
16734 handler
16735 .read_at(::fidl_next::Request::from_decoded(decoded), responder)
16736 .await;
16737 Ok(())
16738 }
16739 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16740 ordinal: 1587416148701180478,
16741 error,
16742 }),
16743 }
16744 }
16745
16746 8736683935131400491 => {
16747 let responder = ::fidl_next::Responder::from_untyped(responder);
16748
16749 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16750 Ok(decoded) => {
16751 handler
16752 .write_at(::fidl_next::Request::from_decoded(decoded), responder)
16753 .await;
16754 Ok(())
16755 }
16756 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16757 ordinal: 8736683935131400491,
16758 error,
16759 }),
16760 }
16761 }
16762
16763 3134648685270758458 => {
16764 let responder = ::fidl_next::Responder::from_untyped(responder);
16765
16766 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16767 Ok(decoded) => {
16768 handler
16769 .resize(::fidl_next::Request::from_decoded(decoded), responder)
16770 .await;
16771 Ok(())
16772 }
16773 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16774 ordinal: 3134648685270758458,
16775 error,
16776 }),
16777 }
16778 }
16779
16780 46911652864194091 => {
16781 let responder = ::fidl_next::Responder::from_untyped(responder);
16782
16783 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16784 Ok(decoded) => {
16785 handler
16786 .get_backing_memory(
16787 ::fidl_next::Request::from_decoded(decoded),
16788 responder,
16789 )
16790 .await;
16791 Ok(())
16792 }
16793 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16794 ordinal: 46911652864194091,
16795 error,
16796 }),
16797 }
16798 }
16799
16800 8645235848064269614 => {
16801 let responder = ::fidl_next::Responder::from_untyped(responder);
16802
16803 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16804 Ok(decoded) => {
16805 handler
16806 .allocate(::fidl_next::Request::from_decoded(decoded), responder)
16807 .await;
16808 Ok(())
16809 }
16810 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16811 ordinal: 8645235848064269614,
16812 error,
16813 }),
16814 }
16815 }
16816
16817 3189145313204943035 => {
16818 let responder = ::fidl_next::Responder::from_untyped(responder);
16819
16820 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16821 Ok(decoded) => {
16822 handler
16823 .enable_verity(::fidl_next::Request::from_decoded(decoded), responder)
16824 .await;
16825 Ok(())
16826 }
16827 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16828 ordinal: 3189145313204943035,
16829 error,
16830 }),
16831 }
16832 }
16833
16834 ordinal => {
16835 handler.on_unknown_interaction(ordinal).await;
16836 if ::core::matches!(
16837 message.header().flexibility(),
16838 ::fidl_next::protocol::Flexibility::Strict
16839 ) {
16840 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16841 } else {
16842 responder
16843 .respond_framework_error(
16844 ordinal,
16845 ::fidl_next::FrameworkError::UnknownMethod,
16846 )
16847 .expect("encoding a framework error should never fail")
16848 .await?;
16849 Ok(())
16850 }
16851 }
16852 }
16853 }
16854}
16855
16856impl<___T> FileClientHandler<___T> for ::fidl_next::IgnoreEvents
16857where
16858 ___T: ::fidl_next::Transport,
16859{
16860 async fn on_open(&mut self, _: ::fidl_next::Request<file::OnOpen, ___T>) {}
16861
16862 async fn on_representation(&mut self, _: ::fidl_next::Request<file::OnRepresentation, ___T>) {}
16863
16864 async fn on_unknown_interaction(&mut self, _: u64) {}
16865}
16866
16867impl<___H, ___T> FileLocalClientHandler<___T> for ::fidl_next::Local<___H>
16868where
16869 ___H: FileClientHandler<___T>,
16870 ___T: ::fidl_next::Transport,
16871{
16872 async fn on_open(&mut self, request: ::fidl_next::Request<file::OnOpen, ___T>) {
16873 ___H::on_open(&mut self.0, request).await
16874 }
16875
16876 async fn on_representation(
16877 &mut self,
16878
16879 request: ::fidl_next::Request<file::OnRepresentation, ___T>,
16880 ) {
16881 ___H::on_representation(&mut self.0, request).await
16882 }
16883
16884 async fn on_unknown_interaction(&mut self, ordinal: u64) {
16885 ___H::on_unknown_interaction(&mut self.0, ordinal).await
16886 }
16887}
16888
16889impl<___H, ___T> FileLocalServerHandler<___T> for ::fidl_next::Local<___H>
16890where
16891 ___H: FileServerHandler<___T>,
16892 ___T: ::fidl_next::Transport,
16893{
16894 async fn advisory_lock(
16895 &mut self,
16896
16897 request: ::fidl_next::Request<file::AdvisoryLock, ___T>,
16898
16899 responder: ::fidl_next::Responder<file::AdvisoryLock, ___T>,
16900 ) {
16901 ___H::advisory_lock(&mut self.0, request, responder).await
16902 }
16903
16904 async fn link_into(
16905 &mut self,
16906
16907 request: ::fidl_next::Request<file::LinkInto, ___T>,
16908
16909 responder: ::fidl_next::Responder<file::LinkInto, ___T>,
16910 ) {
16911 ___H::link_into(&mut self.0, request, responder).await
16912 }
16913
16914 async fn clone(&mut self, request: ::fidl_next::Request<file::Clone, ___T>) {
16915 ___H::clone(&mut self.0, request).await
16916 }
16917
16918 async fn close(&mut self, responder: ::fidl_next::Responder<file::Close, ___T>) {
16919 ___H::close(&mut self.0, responder).await
16920 }
16921
16922 async fn query(&mut self, responder: ::fidl_next::Responder<file::Query, ___T>) {
16923 ___H::query(&mut self.0, responder).await
16924 }
16925
16926 async fn deprecated_clone(
16927 &mut self,
16928
16929 request: ::fidl_next::Request<file::DeprecatedClone, ___T>,
16930 ) {
16931 ___H::deprecated_clone(&mut self.0, request).await
16932 }
16933
16934 async fn deprecated_get_attr(
16935 &mut self,
16936
16937 responder: ::fidl_next::Responder<file::DeprecatedGetAttr, ___T>,
16938 ) {
16939 ___H::deprecated_get_attr(&mut self.0, responder).await
16940 }
16941
16942 async fn deprecated_set_attr(
16943 &mut self,
16944
16945 request: ::fidl_next::Request<file::DeprecatedSetAttr, ___T>,
16946
16947 responder: ::fidl_next::Responder<file::DeprecatedSetAttr, ___T>,
16948 ) {
16949 ___H::deprecated_set_attr(&mut self.0, request, responder).await
16950 }
16951
16952 async fn deprecated_get_flags(
16953 &mut self,
16954
16955 responder: ::fidl_next::Responder<file::DeprecatedGetFlags, ___T>,
16956 ) {
16957 ___H::deprecated_get_flags(&mut self.0, responder).await
16958 }
16959
16960 async fn deprecated_set_flags(
16961 &mut self,
16962
16963 request: ::fidl_next::Request<file::DeprecatedSetFlags, ___T>,
16964
16965 responder: ::fidl_next::Responder<file::DeprecatedSetFlags, ___T>,
16966 ) {
16967 ___H::deprecated_set_flags(&mut self.0, request, responder).await
16968 }
16969
16970 async fn get_flags(&mut self, responder: ::fidl_next::Responder<file::GetFlags, ___T>) {
16971 ___H::get_flags(&mut self.0, responder).await
16972 }
16973
16974 async fn set_flags(
16975 &mut self,
16976
16977 request: ::fidl_next::Request<file::SetFlags, ___T>,
16978
16979 responder: ::fidl_next::Responder<file::SetFlags, ___T>,
16980 ) {
16981 ___H::set_flags(&mut self.0, request, responder).await
16982 }
16983
16984 async fn query_filesystem(
16985 &mut self,
16986
16987 responder: ::fidl_next::Responder<file::QueryFilesystem, ___T>,
16988 ) {
16989 ___H::query_filesystem(&mut self.0, responder).await
16990 }
16991
16992 async fn get_attributes(
16993 &mut self,
16994
16995 request: ::fidl_next::Request<file::GetAttributes, ___T>,
16996
16997 responder: ::fidl_next::Responder<file::GetAttributes, ___T>,
16998 ) {
16999 ___H::get_attributes(&mut self.0, request, responder).await
17000 }
17001
17002 async fn update_attributes(
17003 &mut self,
17004
17005 request: ::fidl_next::Request<file::UpdateAttributes, ___T>,
17006
17007 responder: ::fidl_next::Responder<file::UpdateAttributes, ___T>,
17008 ) {
17009 ___H::update_attributes(&mut self.0, request, responder).await
17010 }
17011
17012 async fn sync(&mut self, responder: ::fidl_next::Responder<file::Sync, ___T>) {
17013 ___H::sync(&mut self.0, responder).await
17014 }
17015
17016 async fn list_extended_attributes(
17017 &mut self,
17018
17019 request: ::fidl_next::Request<file::ListExtendedAttributes, ___T>,
17020 ) {
17021 ___H::list_extended_attributes(&mut self.0, request).await
17022 }
17023
17024 async fn get_extended_attribute(
17025 &mut self,
17026
17027 request: ::fidl_next::Request<file::GetExtendedAttribute, ___T>,
17028
17029 responder: ::fidl_next::Responder<file::GetExtendedAttribute, ___T>,
17030 ) {
17031 ___H::get_extended_attribute(&mut self.0, request, responder).await
17032 }
17033
17034 async fn set_extended_attribute(
17035 &mut self,
17036
17037 request: ::fidl_next::Request<file::SetExtendedAttribute, ___T>,
17038
17039 responder: ::fidl_next::Responder<file::SetExtendedAttribute, ___T>,
17040 ) {
17041 ___H::set_extended_attribute(&mut self.0, request, responder).await
17042 }
17043
17044 async fn remove_extended_attribute(
17045 &mut self,
17046
17047 request: ::fidl_next::Request<file::RemoveExtendedAttribute, ___T>,
17048
17049 responder: ::fidl_next::Responder<file::RemoveExtendedAttribute, ___T>,
17050 ) {
17051 ___H::remove_extended_attribute(&mut self.0, request, responder).await
17052 }
17053
17054 async fn read(
17055 &mut self,
17056
17057 request: ::fidl_next::Request<file::Read, ___T>,
17058
17059 responder: ::fidl_next::Responder<file::Read, ___T>,
17060 ) {
17061 ___H::read(&mut self.0, request, responder).await
17062 }
17063
17064 async fn write(
17065 &mut self,
17066
17067 request: ::fidl_next::Request<file::Write, ___T>,
17068
17069 responder: ::fidl_next::Responder<file::Write, ___T>,
17070 ) {
17071 ___H::write(&mut self.0, request, responder).await
17072 }
17073
17074 async fn describe(&mut self, responder: ::fidl_next::Responder<file::Describe, ___T>) {
17075 ___H::describe(&mut self.0, responder).await
17076 }
17077
17078 async fn seek(
17079 &mut self,
17080
17081 request: ::fidl_next::Request<file::Seek, ___T>,
17082
17083 responder: ::fidl_next::Responder<file::Seek, ___T>,
17084 ) {
17085 ___H::seek(&mut self.0, request, responder).await
17086 }
17087
17088 async fn read_at(
17089 &mut self,
17090
17091 request: ::fidl_next::Request<file::ReadAt, ___T>,
17092
17093 responder: ::fidl_next::Responder<file::ReadAt, ___T>,
17094 ) {
17095 ___H::read_at(&mut self.0, request, responder).await
17096 }
17097
17098 async fn write_at(
17099 &mut self,
17100
17101 request: ::fidl_next::Request<file::WriteAt, ___T>,
17102
17103 responder: ::fidl_next::Responder<file::WriteAt, ___T>,
17104 ) {
17105 ___H::write_at(&mut self.0, request, responder).await
17106 }
17107
17108 async fn resize(
17109 &mut self,
17110
17111 request: ::fidl_next::Request<file::Resize, ___T>,
17112
17113 responder: ::fidl_next::Responder<file::Resize, ___T>,
17114 ) {
17115 ___H::resize(&mut self.0, request, responder).await
17116 }
17117
17118 async fn get_backing_memory(
17119 &mut self,
17120
17121 request: ::fidl_next::Request<file::GetBackingMemory, ___T>,
17122
17123 responder: ::fidl_next::Responder<file::GetBackingMemory, ___T>,
17124 ) {
17125 ___H::get_backing_memory(&mut self.0, request, responder).await
17126 }
17127
17128 async fn allocate(
17129 &mut self,
17130
17131 request: ::fidl_next::Request<file::Allocate, ___T>,
17132
17133 responder: ::fidl_next::Responder<file::Allocate, ___T>,
17134 ) {
17135 ___H::allocate(&mut self.0, request, responder).await
17136 }
17137
17138 async fn enable_verity(
17139 &mut self,
17140
17141 request: ::fidl_next::Request<file::EnableVerity, ___T>,
17142
17143 responder: ::fidl_next::Responder<file::EnableVerity, ___T>,
17144 ) {
17145 ___H::enable_verity(&mut self.0, request, responder).await
17146 }
17147
17148 async fn on_unknown_interaction(&mut self, ordinal: u64) {
17149 ___H::on_unknown_interaction(&mut self.0, ordinal).await
17150 }
17151}
17152
17153#[doc = " A [\'Node\'] which contains a symbolic link.\n"]
17155#[derive(PartialEq, Debug)]
17156pub struct Symlink;
17157
17158impl ::fidl_next::Discoverable for Symlink {
17159 const PROTOCOL_NAME: &'static str = "fuchsia.io.Symlink";
17160}
17161
17162#[cfg(target_os = "fuchsia")]
17163impl ::fidl_next::HasTransport for Symlink {
17164 type Transport = ::fidl_next::fuchsia::zx::Channel;
17165}
17166
17167pub mod symlink {
17168 pub mod prelude {
17169 pub use crate::{
17170 Symlink, SymlinkClientHandler, SymlinkLocalClientHandler, SymlinkLocalServerHandler,
17171 SymlinkServerHandler, symlink,
17172 };
17173
17174 pub use crate::natural::ExtendedAttributeValue;
17175
17176 pub use crate::natural::LinkableLinkIntoRequest;
17177
17178 pub use crate::natural::LinkableLinkIntoResponse;
17179
17180 pub use crate::natural::MutableNodeAttributes;
17181
17182 pub use crate::natural::NodeAttributes2;
17183
17184 pub use crate::natural::NodeDeprecatedCloneRequest;
17185
17186 pub use crate::natural::NodeDeprecatedGetAttrResponse;
17187
17188 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
17189
17190 pub use crate::natural::NodeDeprecatedSetAttrRequest;
17191
17192 pub use crate::natural::NodeDeprecatedSetAttrResponse;
17193
17194 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
17195
17196 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
17197
17198 pub use crate::natural::NodeGetAttributesRequest;
17199
17200 pub use crate::natural::NodeGetExtendedAttributeRequest;
17201
17202 pub use crate::natural::NodeListExtendedAttributesRequest;
17203
17204 pub use crate::natural::NodeOnOpenRequest;
17205
17206 pub use crate::natural::NodeQueryFilesystemResponse;
17207
17208 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
17209
17210 pub use crate::natural::NodeSetExtendedAttributeRequest;
17211
17212 pub use crate::natural::NodeSetFlagsRequest;
17213
17214 pub use crate::natural::NodeGetFlagsResponse;
17215
17216 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
17217
17218 pub use crate::natural::NodeSetExtendedAttributeResponse;
17219
17220 pub use crate::natural::NodeSetFlagsResponse;
17221
17222 pub use crate::natural::NodeSyncResponse;
17223
17224 pub use crate::natural::NodeUpdateAttributesResponse;
17225
17226 pub use crate::natural::OpenableOpenRequest;
17227
17228 pub use crate::natural::Representation;
17229
17230 pub use crate::natural::SymlinkInfo;
17231
17232 pub use ::fidl_next_fuchsia_unknown::natural::CloneableCloneRequest;
17233
17234 pub use ::fidl_next_fuchsia_unknown::natural::CloseableCloseResponse;
17235
17236 pub use ::fidl_next_fuchsia_unknown::natural::QueryableQueryResponse;
17237 }
17238
17239 pub struct LinkInto;
17240
17241 impl ::fidl_next::Method for LinkInto {
17242 const ORDINAL: u64 = 6121399674497678964;
17243 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17244 ::fidl_next::protocol::Flexibility::Strict;
17245
17246 type Protocol = crate::Symlink;
17247
17248 type Request = crate::wire::LinkableLinkIntoRequest<'static>;
17249 }
17250
17251 impl ::fidl_next::TwoWayMethod for LinkInto {
17252 type Response = ::fidl_next::wire::Result<
17253 'static,
17254 crate::wire::LinkableLinkIntoResponse,
17255 ::fidl_next::wire::fuchsia::Status,
17256 >;
17257 }
17258
17259 impl<___R> ::fidl_next::Respond<___R> for LinkInto {
17260 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
17261
17262 fn respond(response: ___R) -> Self::Output {
17263 ::core::result::Result::Ok(response)
17264 }
17265 }
17266
17267 impl<___R> ::fidl_next::RespondErr<___R> for LinkInto {
17268 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
17269
17270 fn respond_err(response: ___R) -> Self::Output {
17271 ::core::result::Result::Err(response)
17272 }
17273 }
17274
17275 pub struct Clone;
17276
17277 impl ::fidl_next::Method for Clone {
17278 const ORDINAL: u64 = 2366825959783828089;
17279 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17280 ::fidl_next::protocol::Flexibility::Strict;
17281
17282 type Protocol = crate::Symlink;
17283
17284 type Request = ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest;
17285 }
17286
17287 pub struct Close;
17288
17289 impl ::fidl_next::Method for Close {
17290 const ORDINAL: u64 = 6540867515453498750;
17291 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17292 ::fidl_next::protocol::Flexibility::Strict;
17293
17294 type Protocol = crate::Symlink;
17295
17296 type Request = ::fidl_next::wire::EmptyMessageBody;
17297 }
17298
17299 impl ::fidl_next::TwoWayMethod for Close {
17300 type Response = ::fidl_next::wire::Result<
17301 'static,
17302 ::fidl_next_fuchsia_unknown::wire::CloseableCloseResponse,
17303 ::fidl_next::wire::Int32,
17304 >;
17305 }
17306
17307 impl<___R> ::fidl_next::Respond<___R> for Close {
17308 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
17309
17310 fn respond(response: ___R) -> Self::Output {
17311 ::core::result::Result::Ok(response)
17312 }
17313 }
17314
17315 impl<___R> ::fidl_next::RespondErr<___R> for Close {
17316 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
17317
17318 fn respond_err(response: ___R) -> Self::Output {
17319 ::core::result::Result::Err(response)
17320 }
17321 }
17322
17323 pub struct Query;
17324
17325 impl ::fidl_next::Method for Query {
17326 const ORDINAL: u64 = 2763219980499352582;
17327 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17328 ::fidl_next::protocol::Flexibility::Strict;
17329
17330 type Protocol = crate::Symlink;
17331
17332 type Request = ::fidl_next::wire::EmptyMessageBody;
17333 }
17334
17335 impl ::fidl_next::TwoWayMethod for Query {
17336 type Response = ::fidl_next::wire::Strict<
17337 ::fidl_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>,
17338 >;
17339 }
17340
17341 impl<___R> ::fidl_next::Respond<___R> for Query {
17342 type Output =
17343 ::fidl_next::Strict<::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>>;
17344
17345 fn respond(response: ___R) -> Self::Output {
17346 ::fidl_next::Strict(::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse {
17347 protocol: response,
17348 })
17349 }
17350 }
17351
17352 pub struct DeprecatedClone;
17353
17354 impl ::fidl_next::Method for DeprecatedClone {
17355 const ORDINAL: u64 = 6512600400724287855;
17356 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17357 ::fidl_next::protocol::Flexibility::Flexible;
17358
17359 type Protocol = crate::Symlink;
17360
17361 type Request = crate::wire::NodeDeprecatedCloneRequest;
17362 }
17363
17364 pub struct OnOpen;
17365
17366 impl ::fidl_next::Method for OnOpen {
17367 const ORDINAL: u64 = 9207534335756671346;
17368 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17369 ::fidl_next::protocol::Flexibility::Flexible;
17370
17371 type Protocol = crate::Symlink;
17372
17373 type Request = crate::wire::NodeOnOpenRequest<'static>;
17374 }
17375
17376 pub struct DeprecatedGetAttr;
17377
17378 impl ::fidl_next::Method for DeprecatedGetAttr {
17379 const ORDINAL: u64 = 8689798978500614909;
17380 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17381 ::fidl_next::protocol::Flexibility::Strict;
17382
17383 type Protocol = crate::Symlink;
17384
17385 type Request = ::fidl_next::wire::EmptyMessageBody;
17386 }
17387
17388 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
17389 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetAttrResponse>;
17390 }
17391
17392 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
17393 type Output = ::fidl_next::Strict<___R>;
17394
17395 fn respond(response: ___R) -> Self::Output {
17396 ::fidl_next::Strict(response)
17397 }
17398 }
17399
17400 pub struct DeprecatedSetAttr;
17401
17402 impl ::fidl_next::Method for DeprecatedSetAttr {
17403 const ORDINAL: u64 = 4721673413776871238;
17404 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17405 ::fidl_next::protocol::Flexibility::Strict;
17406
17407 type Protocol = crate::Symlink;
17408
17409 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
17410 }
17411
17412 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
17413 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetAttrResponse>;
17414 }
17415
17416 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
17417 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetAttrResponse<___R>>;
17418
17419 fn respond(response: ___R) -> Self::Output {
17420 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetAttrResponse { s: response })
17421 }
17422 }
17423
17424 pub struct DeprecatedGetFlags;
17425
17426 impl ::fidl_next::Method for DeprecatedGetFlags {
17427 const ORDINAL: u64 = 6595803110182632097;
17428 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17429 ::fidl_next::protocol::Flexibility::Strict;
17430
17431 type Protocol = crate::Symlink;
17432
17433 type Request = ::fidl_next::wire::EmptyMessageBody;
17434 }
17435
17436 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
17437 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetFlagsResponse>;
17438 }
17439
17440 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
17441 type Output = ::fidl_next::Strict<___R>;
17442
17443 fn respond(response: ___R) -> Self::Output {
17444 ::fidl_next::Strict(response)
17445 }
17446 }
17447
17448 pub struct DeprecatedSetFlags;
17449
17450 impl ::fidl_next::Method for DeprecatedSetFlags {
17451 const ORDINAL: u64 = 5950864159036794675;
17452 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17453 ::fidl_next::protocol::Flexibility::Strict;
17454
17455 type Protocol = crate::Symlink;
17456
17457 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
17458 }
17459
17460 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
17461 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetFlagsResponse>;
17462 }
17463
17464 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
17465 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetFlagsResponse<___R>>;
17466
17467 fn respond(response: ___R) -> Self::Output {
17468 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetFlagsResponse { s: response })
17469 }
17470 }
17471
17472 pub struct GetFlags;
17473
17474 impl ::fidl_next::Method for GetFlags {
17475 const ORDINAL: u64 = 105530239381466147;
17476 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17477 ::fidl_next::protocol::Flexibility::Flexible;
17478
17479 type Protocol = crate::Symlink;
17480
17481 type Request = ::fidl_next::wire::EmptyMessageBody;
17482 }
17483
17484 impl ::fidl_next::TwoWayMethod for GetFlags {
17485 type Response = ::fidl_next::wire::Result<
17486 'static,
17487 crate::wire::NodeGetFlagsResponse,
17488 ::fidl_next::wire::fuchsia::Status,
17489 >;
17490 }
17491
17492 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
17493 type Output = ::core::result::Result<
17494 crate::generic::NodeGetFlagsResponse<___R>,
17495 ::fidl_next::util::Never,
17496 >;
17497
17498 fn respond(response: ___R) -> Self::Output {
17499 ::core::result::Result::Ok(crate::generic::NodeGetFlagsResponse { flags: response })
17500 }
17501 }
17502
17503 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
17504 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
17505
17506 fn respond_err(response: ___R) -> Self::Output {
17507 ::core::result::Result::Err(response)
17508 }
17509 }
17510
17511 pub struct SetFlags;
17512
17513 impl ::fidl_next::Method for SetFlags {
17514 const ORDINAL: u64 = 6172186066099445416;
17515 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17516 ::fidl_next::protocol::Flexibility::Flexible;
17517
17518 type Protocol = crate::Symlink;
17519
17520 type Request = crate::wire::NodeSetFlagsRequest;
17521 }
17522
17523 impl ::fidl_next::TwoWayMethod for SetFlags {
17524 type Response = ::fidl_next::wire::Result<
17525 'static,
17526 crate::wire::NodeSetFlagsResponse,
17527 ::fidl_next::wire::fuchsia::Status,
17528 >;
17529 }
17530
17531 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
17532 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
17533
17534 fn respond(response: ___R) -> Self::Output {
17535 ::core::result::Result::Ok(response)
17536 }
17537 }
17538
17539 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
17540 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
17541
17542 fn respond_err(response: ___R) -> Self::Output {
17543 ::core::result::Result::Err(response)
17544 }
17545 }
17546
17547 pub struct QueryFilesystem;
17548
17549 impl ::fidl_next::Method for QueryFilesystem {
17550 const ORDINAL: u64 = 8013111122914313744;
17551 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17552 ::fidl_next::protocol::Flexibility::Strict;
17553
17554 type Protocol = crate::Symlink;
17555
17556 type Request = ::fidl_next::wire::EmptyMessageBody;
17557 }
17558
17559 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
17560 type Response =
17561 ::fidl_next::wire::Strict<crate::wire::NodeQueryFilesystemResponse<'static>>;
17562 }
17563
17564 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
17565 type Output = ::fidl_next::Strict<___R>;
17566
17567 fn respond(response: ___R) -> Self::Output {
17568 ::fidl_next::Strict(response)
17569 }
17570 }
17571
17572 pub struct OnRepresentation;
17573
17574 impl ::fidl_next::Method for OnRepresentation {
17575 const ORDINAL: u64 = 6679970090861613324;
17576 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17577 ::fidl_next::protocol::Flexibility::Strict;
17578
17579 type Protocol = crate::Symlink;
17580
17581 type Request = crate::wire::Representation<'static>;
17582 }
17583
17584 pub struct GetAttributes;
17585
17586 impl ::fidl_next::Method for GetAttributes {
17587 const ORDINAL: u64 = 4414537700416816443;
17588 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17589 ::fidl_next::protocol::Flexibility::Strict;
17590
17591 type Protocol = crate::Symlink;
17592
17593 type Request = crate::wire::NodeGetAttributesRequest;
17594 }
17595
17596 impl ::fidl_next::TwoWayMethod for GetAttributes {
17597 type Response = ::fidl_next::wire::Result<
17598 'static,
17599 crate::wire::NodeAttributes2<'static>,
17600 ::fidl_next::wire::fuchsia::Status,
17601 >;
17602 }
17603
17604 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
17605 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
17606
17607 fn respond(response: ___R) -> Self::Output {
17608 ::core::result::Result::Ok(response)
17609 }
17610 }
17611
17612 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
17613 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
17614
17615 fn respond_err(response: ___R) -> Self::Output {
17616 ::core::result::Result::Err(response)
17617 }
17618 }
17619
17620 pub struct UpdateAttributes;
17621
17622 impl ::fidl_next::Method for UpdateAttributes {
17623 const ORDINAL: u64 = 3677402239314018056;
17624 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17625 ::fidl_next::protocol::Flexibility::Strict;
17626
17627 type Protocol = crate::Symlink;
17628
17629 type Request = crate::wire::MutableNodeAttributes<'static>;
17630 }
17631
17632 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
17633 type Response = ::fidl_next::wire::Result<
17634 'static,
17635 crate::wire::NodeUpdateAttributesResponse,
17636 ::fidl_next::wire::fuchsia::Status,
17637 >;
17638 }
17639
17640 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
17641 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
17642
17643 fn respond(response: ___R) -> Self::Output {
17644 ::core::result::Result::Ok(response)
17645 }
17646 }
17647
17648 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
17649 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
17650
17651 fn respond_err(response: ___R) -> Self::Output {
17652 ::core::result::Result::Err(response)
17653 }
17654 }
17655
17656 pub struct Sync;
17657
17658 impl ::fidl_next::Method for Sync {
17659 const ORDINAL: u64 = 3196473584242777161;
17660 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17661 ::fidl_next::protocol::Flexibility::Strict;
17662
17663 type Protocol = crate::Symlink;
17664
17665 type Request = ::fidl_next::wire::EmptyMessageBody;
17666 }
17667
17668 impl ::fidl_next::TwoWayMethod for Sync {
17669 type Response = ::fidl_next::wire::Result<
17670 'static,
17671 crate::wire::NodeSyncResponse,
17672 ::fidl_next::wire::fuchsia::Status,
17673 >;
17674 }
17675
17676 impl<___R> ::fidl_next::Respond<___R> for Sync {
17677 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
17678
17679 fn respond(response: ___R) -> Self::Output {
17680 ::core::result::Result::Ok(response)
17681 }
17682 }
17683
17684 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
17685 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
17686
17687 fn respond_err(response: ___R) -> Self::Output {
17688 ::core::result::Result::Err(response)
17689 }
17690 }
17691
17692 pub struct ListExtendedAttributes;
17693
17694 impl ::fidl_next::Method for ListExtendedAttributes {
17695 const ORDINAL: u64 = 5431626189872037072;
17696 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17697 ::fidl_next::protocol::Flexibility::Strict;
17698
17699 type Protocol = crate::Symlink;
17700
17701 type Request = crate::wire::NodeListExtendedAttributesRequest;
17702 }
17703
17704 pub struct GetExtendedAttribute;
17705
17706 impl ::fidl_next::Method for GetExtendedAttribute {
17707 const ORDINAL: u64 = 5043930208506967771;
17708 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17709 ::fidl_next::protocol::Flexibility::Strict;
17710
17711 type Protocol = crate::Symlink;
17712
17713 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
17714 }
17715
17716 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
17717 type Response = ::fidl_next::wire::Result<
17718 'static,
17719 crate::wire::ExtendedAttributeValue<'static>,
17720 ::fidl_next::wire::fuchsia::Status,
17721 >;
17722 }
17723
17724 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
17725 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
17726
17727 fn respond(response: ___R) -> Self::Output {
17728 ::core::result::Result::Ok(response)
17729 }
17730 }
17731
17732 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
17733 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
17734
17735 fn respond_err(response: ___R) -> Self::Output {
17736 ::core::result::Result::Err(response)
17737 }
17738 }
17739
17740 pub struct SetExtendedAttribute;
17741
17742 impl ::fidl_next::Method for SetExtendedAttribute {
17743 const ORDINAL: u64 = 5374223046099989052;
17744 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17745 ::fidl_next::protocol::Flexibility::Strict;
17746
17747 type Protocol = crate::Symlink;
17748
17749 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
17750 }
17751
17752 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
17753 type Response = ::fidl_next::wire::Result<
17754 'static,
17755 crate::wire::NodeSetExtendedAttributeResponse,
17756 ::fidl_next::wire::fuchsia::Status,
17757 >;
17758 }
17759
17760 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
17761 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
17762
17763 fn respond(response: ___R) -> Self::Output {
17764 ::core::result::Result::Ok(response)
17765 }
17766 }
17767
17768 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
17769 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
17770
17771 fn respond_err(response: ___R) -> Self::Output {
17772 ::core::result::Result::Err(response)
17773 }
17774 }
17775
17776 pub struct RemoveExtendedAttribute;
17777
17778 impl ::fidl_next::Method for RemoveExtendedAttribute {
17779 const ORDINAL: u64 = 8794297771444732717;
17780 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17781 ::fidl_next::protocol::Flexibility::Strict;
17782
17783 type Protocol = crate::Symlink;
17784
17785 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
17786 }
17787
17788 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
17789 type Response = ::fidl_next::wire::Result<
17790 'static,
17791 crate::wire::NodeRemoveExtendedAttributeResponse,
17792 ::fidl_next::wire::fuchsia::Status,
17793 >;
17794 }
17795
17796 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
17797 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
17798
17799 fn respond(response: ___R) -> Self::Output {
17800 ::core::result::Result::Ok(response)
17801 }
17802 }
17803
17804 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
17805 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
17806
17807 fn respond_err(response: ___R) -> Self::Output {
17808 ::core::result::Result::Err(response)
17809 }
17810 }
17811
17812 pub struct Open;
17813
17814 impl ::fidl_next::Method for Open {
17815 const ORDINAL: u64 = 6236883748953765593;
17816 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17817 ::fidl_next::protocol::Flexibility::Flexible;
17818
17819 type Protocol = crate::Symlink;
17820
17821 type Request = crate::wire::OpenableOpenRequest<'static>;
17822 }
17823
17824 pub struct Describe;
17825
17826 impl ::fidl_next::Method for Describe {
17827 const ORDINAL: u64 = 8371117097481679347;
17828 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17829 ::fidl_next::protocol::Flexibility::Flexible;
17830
17831 type Protocol = crate::Symlink;
17832
17833 type Request = ::fidl_next::wire::EmptyMessageBody;
17834 }
17835
17836 impl ::fidl_next::TwoWayMethod for Describe {
17837 type Response = ::fidl_next::wire::Flexible<'static, crate::wire::SymlinkInfo<'static>>;
17838 }
17839
17840 impl<___R> ::fidl_next::Respond<___R> for Describe {
17841 type Output = ::fidl_next::Flexible<___R>;
17842
17843 fn respond(response: ___R) -> Self::Output {
17844 ::fidl_next::Flexible(response)
17845 }
17846 }
17847
17848 mod ___detail {
17849 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Symlink
17850 where
17851 ___T: ::fidl_next::Transport,
17852 {
17853 type Client = SymlinkClient<___T>;
17854 type Server = SymlinkServer<___T>;
17855 }
17856
17857 #[repr(transparent)]
17859 pub struct SymlinkClient<___T: ::fidl_next::Transport> {
17860 #[allow(dead_code)]
17861 client: ::fidl_next::protocol::Client<___T>,
17862 }
17863
17864 impl<___T> SymlinkClient<___T>
17865 where
17866 ___T: ::fidl_next::Transport,
17867 {
17868 #[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"]
17869 pub fn link_into(
17870 &self,
17871
17872 dst_parent_token: impl ::fidl_next::Encode<
17873 ::fidl_next::wire::fuchsia::Event,
17874 <___T as ::fidl_next::Transport>::SendBuffer,
17875 >,
17876
17877 dst: impl ::fidl_next::Encode<
17878 ::fidl_next::wire::String<'static>,
17879 <___T as ::fidl_next::Transport>::SendBuffer,
17880 >,
17881 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
17882 where
17883 <___T as ::fidl_next::Transport>::SendBuffer:
17884 ::fidl_next::encoder::InternalHandleEncoder,
17885 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
17886 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17887 {
17888 self.link_into_with(crate::generic::LinkableLinkIntoRequest {
17889 dst_parent_token,
17890
17891 dst,
17892 })
17893 }
17894
17895 #[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"]
17896 pub fn link_into_with<___R>(
17897 &self,
17898 request: ___R,
17899 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
17900 where
17901 ___R: ::fidl_next::Encode<
17902 crate::wire::LinkableLinkIntoRequest<'static>,
17903 <___T as ::fidl_next::Transport>::SendBuffer,
17904 >,
17905 {
17906 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17907 6121399674497678964,
17908 <super::LinkInto as ::fidl_next::Method>::FLEXIBILITY,
17909 request,
17910 ))
17911 }
17912
17913 pub fn clone(
17914 &self,
17915
17916 request: impl ::fidl_next::Encode<
17917 ::fidl_next::ServerEnd<
17918 ::fidl_next_fuchsia_unknown::Cloneable,
17919 ::fidl_next::wire::fuchsia::Channel,
17920 >,
17921 <___T as ::fidl_next::Transport>::SendBuffer,
17922 >,
17923 ) -> ::fidl_next::SendFuture<'_, ___T>
17924 where
17925 <___T as ::fidl_next::Transport>::SendBuffer:
17926 ::fidl_next::encoder::InternalHandleEncoder,
17927 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17928 {
17929 self.clone_with(::fidl_next_fuchsia_unknown::generic::CloneableCloneRequest {
17930 request,
17931 })
17932 }
17933
17934 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
17935 where
17936 ___R: ::fidl_next::Encode<
17937 ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest,
17938 <___T as ::fidl_next::Transport>::SendBuffer,
17939 >,
17940 {
17941 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
17942 2366825959783828089,
17943 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
17944 request,
17945 ))
17946 }
17947
17948 #[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"]
17949 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
17950 ::fidl_next::TwoWayFuture::from_untyped(
17951 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
17952 6540867515453498750,
17953 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
17954 (),
17955 ),
17956 )
17957 }
17958
17959 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
17960 ::fidl_next::TwoWayFuture::from_untyped(
17961 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
17962 2763219980499352582,
17963 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
17964 (),
17965 ),
17966 )
17967 }
17968
17969 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
17970 pub fn deprecated_clone(
17971 &self,
17972
17973 flags: impl ::fidl_next::Encode<
17974 crate::wire::OpenFlags,
17975 <___T as ::fidl_next::Transport>::SendBuffer,
17976 >,
17977
17978 object: impl ::fidl_next::Encode<
17979 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::wire::fuchsia::Channel>,
17980 <___T as ::fidl_next::Transport>::SendBuffer,
17981 >,
17982 ) -> ::fidl_next::SendFuture<'_, ___T>
17983 where
17984 <___T as ::fidl_next::Transport>::SendBuffer:
17985 ::fidl_next::encoder::InternalHandleEncoder,
17986 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17987 {
17988 self.deprecated_clone_with(crate::generic::NodeDeprecatedCloneRequest {
17989 flags,
17990
17991 object,
17992 })
17993 }
17994
17995 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
17996 pub fn deprecated_clone_with<___R>(
17997 &self,
17998 request: ___R,
17999 ) -> ::fidl_next::SendFuture<'_, ___T>
18000 where
18001 ___R: ::fidl_next::Encode<
18002 crate::wire::NodeDeprecatedCloneRequest,
18003 <___T as ::fidl_next::Transport>::SendBuffer,
18004 >,
18005 {
18006 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
18007 6512600400724287855,
18008 <super::DeprecatedClone as ::fidl_next::Method>::FLEXIBILITY,
18009 request,
18010 ))
18011 }
18012
18013 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
18014 pub fn deprecated_get_attr(
18015 &self,
18016 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
18017 ::fidl_next::TwoWayFuture::from_untyped(
18018 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18019 8689798978500614909,
18020 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
18021 (),
18022 ),
18023 )
18024 }
18025
18026 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
18027 pub fn deprecated_set_attr(
18028 &self,
18029
18030 flags: impl ::fidl_next::Encode<
18031 crate::wire::NodeAttributeFlags,
18032 <___T as ::fidl_next::Transport>::SendBuffer,
18033 >,
18034
18035 attributes: impl ::fidl_next::Encode<
18036 crate::wire::NodeAttributes,
18037 <___T as ::fidl_next::Transport>::SendBuffer,
18038 >,
18039 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
18040 where
18041 <___T as ::fidl_next::Transport>::SendBuffer:
18042 ::fidl_next::encoder::InternalHandleEncoder,
18043 {
18044 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
18045 flags,
18046
18047 attributes,
18048 })
18049 }
18050
18051 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
18052 pub fn deprecated_set_attr_with<___R>(
18053 &self,
18054 request: ___R,
18055 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
18056 where
18057 ___R: ::fidl_next::Encode<
18058 crate::wire::NodeDeprecatedSetAttrRequest,
18059 <___T as ::fidl_next::Transport>::SendBuffer,
18060 >,
18061 {
18062 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18063 4721673413776871238,
18064 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
18065 request,
18066 ))
18067 }
18068
18069 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
18070 pub fn deprecated_get_flags(
18071 &self,
18072 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
18073 ::fidl_next::TwoWayFuture::from_untyped(
18074 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18075 6595803110182632097,
18076 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
18077 (),
18078 ),
18079 )
18080 }
18081
18082 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
18083 pub fn deprecated_set_flags(
18084 &self,
18085
18086 flags: impl ::fidl_next::Encode<
18087 crate::wire::OpenFlags,
18088 <___T as ::fidl_next::Transport>::SendBuffer,
18089 >,
18090 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
18091 where
18092 <___T as ::fidl_next::Transport>::SendBuffer:
18093 ::fidl_next::encoder::InternalHandleEncoder,
18094 {
18095 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
18096 flags,
18097 })
18098 }
18099
18100 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
18101 pub fn deprecated_set_flags_with<___R>(
18102 &self,
18103 request: ___R,
18104 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
18105 where
18106 ___R: ::fidl_next::Encode<
18107 crate::wire::NodeDeprecatedSetFlagsRequest,
18108 <___T as ::fidl_next::Transport>::SendBuffer,
18109 >,
18110 {
18111 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18112 5950864159036794675,
18113 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
18114 request,
18115 ))
18116 }
18117
18118 #[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"]
18119 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
18120 ::fidl_next::TwoWayFuture::from_untyped(
18121 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18122 105530239381466147,
18123 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
18124 (),
18125 ),
18126 )
18127 }
18128
18129 #[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"]
18130 pub fn set_flags(
18131 &self,
18132
18133 flags: impl ::fidl_next::Encode<
18134 crate::wire::Flags,
18135 <___T as ::fidl_next::Transport>::SendBuffer,
18136 >,
18137 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
18138 where
18139 <___T as ::fidl_next::Transport>::SendBuffer:
18140 ::fidl_next::encoder::InternalHandleEncoder,
18141 {
18142 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
18143 }
18144
18145 #[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"]
18146 pub fn set_flags_with<___R>(
18147 &self,
18148 request: ___R,
18149 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
18150 where
18151 ___R: ::fidl_next::Encode<
18152 crate::wire::NodeSetFlagsRequest,
18153 <___T as ::fidl_next::Transport>::SendBuffer,
18154 >,
18155 {
18156 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18157 6172186066099445416,
18158 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
18159 request,
18160 ))
18161 }
18162
18163 #[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"]
18164 pub fn query_filesystem(
18165 &self,
18166 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
18167 ::fidl_next::TwoWayFuture::from_untyped(
18168 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18169 8013111122914313744,
18170 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
18171 (),
18172 ),
18173 )
18174 }
18175
18176 #[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"]
18177 pub fn get_attributes(
18178 &self,
18179
18180 query: impl ::fidl_next::Encode<
18181 crate::wire::NodeAttributesQuery,
18182 <___T as ::fidl_next::Transport>::SendBuffer,
18183 >,
18184 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
18185 where
18186 <___T as ::fidl_next::Transport>::SendBuffer:
18187 ::fidl_next::encoder::InternalHandleEncoder,
18188 {
18189 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
18190 }
18191
18192 #[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"]
18193 pub fn get_attributes_with<___R>(
18194 &self,
18195 request: ___R,
18196 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
18197 where
18198 ___R: ::fidl_next::Encode<
18199 crate::wire::NodeGetAttributesRequest,
18200 <___T as ::fidl_next::Transport>::SendBuffer,
18201 >,
18202 {
18203 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18204 4414537700416816443,
18205 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
18206 request,
18207 ))
18208 }
18209
18210 #[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"]
18211 pub fn update_attributes_with<___R>(
18212 &self,
18213 request: ___R,
18214 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
18215 where
18216 ___R: ::fidl_next::Encode<
18217 crate::wire::MutableNodeAttributes<'static>,
18218 <___T as ::fidl_next::Transport>::SendBuffer,
18219 >,
18220 {
18221 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18222 3677402239314018056,
18223 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
18224 request,
18225 ))
18226 }
18227
18228 #[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"]
18229 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
18230 ::fidl_next::TwoWayFuture::from_untyped(
18231 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18232 3196473584242777161,
18233 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
18234 (),
18235 ),
18236 )
18237 }
18238
18239 #[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"]
18240 pub fn list_extended_attributes(
18241 &self,
18242
18243 iterator: impl ::fidl_next::Encode<
18244 ::fidl_next::ServerEnd<
18245 crate::ExtendedAttributeIterator,
18246 ::fidl_next::wire::fuchsia::Channel,
18247 >,
18248 <___T as ::fidl_next::Transport>::SendBuffer,
18249 >,
18250 ) -> ::fidl_next::SendFuture<'_, ___T>
18251 where
18252 <___T as ::fidl_next::Transport>::SendBuffer:
18253 ::fidl_next::encoder::InternalHandleEncoder,
18254 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
18255 {
18256 self.list_extended_attributes_with(
18257 crate::generic::NodeListExtendedAttributesRequest { iterator },
18258 )
18259 }
18260
18261 #[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"]
18262 pub fn list_extended_attributes_with<___R>(
18263 &self,
18264 request: ___R,
18265 ) -> ::fidl_next::SendFuture<'_, ___T>
18266 where
18267 ___R: ::fidl_next::Encode<
18268 crate::wire::NodeListExtendedAttributesRequest,
18269 <___T as ::fidl_next::Transport>::SendBuffer,
18270 >,
18271 {
18272 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
18273 5431626189872037072,
18274 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
18275 request,
18276 ))
18277 }
18278
18279 #[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"]
18280 pub fn get_extended_attribute(
18281 &self,
18282
18283 name: impl ::fidl_next::Encode<
18284 ::fidl_next::wire::Vector<'static, u8>,
18285 <___T as ::fidl_next::Transport>::SendBuffer,
18286 >,
18287 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
18288 where
18289 <___T as ::fidl_next::Transport>::SendBuffer:
18290 ::fidl_next::encoder::InternalHandleEncoder,
18291 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18292 {
18293 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
18294 name,
18295 })
18296 }
18297
18298 #[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"]
18299 pub fn get_extended_attribute_with<___R>(
18300 &self,
18301 request: ___R,
18302 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
18303 where
18304 ___R: ::fidl_next::Encode<
18305 crate::wire::NodeGetExtendedAttributeRequest<'static>,
18306 <___T as ::fidl_next::Transport>::SendBuffer,
18307 >,
18308 {
18309 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18310 5043930208506967771,
18311 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
18312 request,
18313 ))
18314 }
18315
18316 #[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"]
18317 pub fn set_extended_attribute(
18318 &self,
18319
18320 name: impl ::fidl_next::Encode<
18321 ::fidl_next::wire::Vector<'static, u8>,
18322 <___T as ::fidl_next::Transport>::SendBuffer,
18323 >,
18324
18325 value: impl ::fidl_next::Encode<
18326 crate::wire::ExtendedAttributeValue<'static>,
18327 <___T as ::fidl_next::Transport>::SendBuffer,
18328 >,
18329
18330 mode: impl ::fidl_next::Encode<
18331 crate::wire::SetExtendedAttributeMode,
18332 <___T as ::fidl_next::Transport>::SendBuffer,
18333 >,
18334 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
18335 where
18336 <___T as ::fidl_next::Transport>::SendBuffer:
18337 ::fidl_next::encoder::InternalHandleEncoder,
18338 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18339 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
18340 {
18341 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
18342 name,
18343
18344 value,
18345
18346 mode,
18347 })
18348 }
18349
18350 #[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"]
18351 pub fn set_extended_attribute_with<___R>(
18352 &self,
18353 request: ___R,
18354 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
18355 where
18356 ___R: ::fidl_next::Encode<
18357 crate::wire::NodeSetExtendedAttributeRequest<'static>,
18358 <___T as ::fidl_next::Transport>::SendBuffer,
18359 >,
18360 {
18361 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18362 5374223046099989052,
18363 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
18364 request,
18365 ))
18366 }
18367
18368 #[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"]
18369 pub fn remove_extended_attribute(
18370 &self,
18371
18372 name: impl ::fidl_next::Encode<
18373 ::fidl_next::wire::Vector<'static, u8>,
18374 <___T as ::fidl_next::Transport>::SendBuffer,
18375 >,
18376 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
18377 where
18378 <___T as ::fidl_next::Transport>::SendBuffer:
18379 ::fidl_next::encoder::InternalHandleEncoder,
18380 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18381 {
18382 self.remove_extended_attribute_with(
18383 crate::generic::NodeRemoveExtendedAttributeRequest { name },
18384 )
18385 }
18386
18387 #[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"]
18388 pub fn remove_extended_attribute_with<___R>(
18389 &self,
18390 request: ___R,
18391 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
18392 where
18393 ___R: ::fidl_next::Encode<
18394 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
18395 <___T as ::fidl_next::Transport>::SendBuffer,
18396 >,
18397 {
18398 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18399 8794297771444732717,
18400 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
18401 request,
18402 ))
18403 }
18404
18405 #[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"]
18406 pub fn open(
18407 &self,
18408
18409 path: impl ::fidl_next::Encode<
18410 ::fidl_next::wire::String<'static>,
18411 <___T as ::fidl_next::Transport>::SendBuffer,
18412 >,
18413
18414 flags: impl ::fidl_next::Encode<
18415 crate::wire::Flags,
18416 <___T as ::fidl_next::Transport>::SendBuffer,
18417 >,
18418
18419 options: impl ::fidl_next::Encode<
18420 crate::wire::Options<'static>,
18421 <___T as ::fidl_next::Transport>::SendBuffer,
18422 >,
18423
18424 object: impl ::fidl_next::Encode<
18425 ::fidl_next::wire::fuchsia::Channel,
18426 <___T as ::fidl_next::Transport>::SendBuffer,
18427 >,
18428 ) -> ::fidl_next::SendFuture<'_, ___T>
18429 where
18430 <___T as ::fidl_next::Transport>::SendBuffer:
18431 ::fidl_next::encoder::InternalHandleEncoder,
18432 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18433 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
18434 {
18435 self.open_with(crate::generic::OpenableOpenRequest { path, flags, options, object })
18436 }
18437
18438 #[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"]
18439 pub fn open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
18440 where
18441 ___R: ::fidl_next::Encode<
18442 crate::wire::OpenableOpenRequest<'static>,
18443 <___T as ::fidl_next::Transport>::SendBuffer,
18444 >,
18445 {
18446 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
18447 6236883748953765593,
18448 <super::Open as ::fidl_next::Method>::FLEXIBILITY,
18449 request,
18450 ))
18451 }
18452
18453 pub fn describe(&self) -> ::fidl_next::TwoWayFuture<'_, super::Describe, ___T> {
18454 ::fidl_next::TwoWayFuture::from_untyped(
18455 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18456 8371117097481679347,
18457 <super::Describe as ::fidl_next::Method>::FLEXIBILITY,
18458 (),
18459 ),
18460 )
18461 }
18462 }
18463
18464 #[repr(transparent)]
18466 pub struct SymlinkServer<___T: ::fidl_next::Transport> {
18467 server: ::fidl_next::protocol::Server<___T>,
18468 }
18469
18470 impl<___T> SymlinkServer<___T>
18471 where
18472 ___T: ::fidl_next::Transport,
18473 {
18474 #[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"]
18475 pub fn on_open(
18476 &self,
18477
18478 s: impl ::fidl_next::Encode<
18479 ::fidl_next::wire::fuchsia::Status,
18480 <___T as ::fidl_next::Transport>::SendBuffer,
18481 >,
18482
18483 info: impl ::fidl_next::Encode<
18484 crate::wire_optional::NodeInfoDeprecated<'static>,
18485 <___T as ::fidl_next::Transport>::SendBuffer,
18486 >,
18487 ) -> ::fidl_next::SendFuture<'_, ___T>
18488 where
18489 <___T as ::fidl_next::Transport>::SendBuffer:
18490 ::fidl_next::encoder::InternalHandleEncoder,
18491 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18492 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
18493 {
18494 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
18495 }
18496
18497 #[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"]
18498
18499 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
18500 where
18501 ___R: ::fidl_next::Encode<
18502 <super::OnOpen as ::fidl_next::Method>::Request,
18503 <___T as ::fidl_next::Transport>::SendBuffer,
18504 >,
18505 {
18506 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
18507 9207534335756671346,
18508 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
18509 request,
18510 ))
18511 }
18512
18513 #[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"]
18514
18515 pub fn on_representation_with<___R>(
18516 &self,
18517 request: ___R,
18518 ) -> ::fidl_next::SendFuture<'_, ___T>
18519 where
18520 ___R: ::fidl_next::Encode<
18521 <super::OnRepresentation as ::fidl_next::Method>::Request,
18522 <___T as ::fidl_next::Transport>::SendBuffer,
18523 >,
18524 {
18525 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
18526 6679970090861613324,
18527 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
18528 request,
18529 ))
18530 }
18531 }
18532 }
18533}
18534
18535#[diagnostic::on_unimplemented(
18536 note = "If {Self} implements the non-local SymlinkClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
18537)]
18538
18539pub trait SymlinkLocalClientHandler<
18543 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18544 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18545>
18546{
18547 #[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"]
18548 fn on_open(
18549 &mut self,
18550
18551 request: ::fidl_next::Request<symlink::OnOpen, ___T>,
18552 ) -> impl ::core::future::Future<Output = ()>;
18553
18554 #[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"]
18555 fn on_representation(
18556 &mut self,
18557
18558 request: ::fidl_next::Request<symlink::OnRepresentation, ___T>,
18559 ) -> impl ::core::future::Future<Output = ()>;
18560
18561 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
18562 ::core::future::ready(())
18563 }
18564}
18565
18566impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Symlink
18567where
18568 ___H: SymlinkLocalClientHandler<___T>,
18569 ___T: ::fidl_next::Transport,
18570 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
18571 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18572 Constraint = (),
18573 >,
18574 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
18575 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18576 Constraint = (),
18577 >,
18578{
18579 async fn on_event(
18580 handler: &mut ___H,
18581 mut message: ::fidl_next::Message<___T>,
18582 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18583 match *message.header().ordinal {
18584 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
18585 Ok(decoded) => {
18586 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
18587 Ok(())
18588 }
18589 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18590 ordinal: 9207534335756671346,
18591 error,
18592 }),
18593 },
18594
18595 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
18596 Ok(decoded) => {
18597 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
18598 Ok(())
18599 }
18600 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18601 ordinal: 6679970090861613324,
18602 error,
18603 }),
18604 },
18605
18606 ordinal => {
18607 handler.on_unknown_interaction(ordinal).await;
18608 if ::core::matches!(
18609 message.header().flexibility(),
18610 ::fidl_next::protocol::Flexibility::Strict
18611 ) {
18612 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18613 } else {
18614 Ok(())
18615 }
18616 }
18617 }
18618 }
18619}
18620
18621#[diagnostic::on_unimplemented(
18622 note = "If {Self} implements the non-local SymlinkServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
18623)]
18624
18625pub trait SymlinkLocalServerHandler<
18629 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18630 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18631>
18632{
18633 #[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"]
18634 fn link_into(
18635 &mut self,
18636
18637 request: ::fidl_next::Request<symlink::LinkInto, ___T>,
18638
18639 responder: ::fidl_next::Responder<symlink::LinkInto, ___T>,
18640 ) -> impl ::core::future::Future<Output = ()>;
18641
18642 fn clone(
18643 &mut self,
18644
18645 request: ::fidl_next::Request<symlink::Clone, ___T>,
18646 ) -> impl ::core::future::Future<Output = ()>;
18647
18648 #[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"]
18649 fn close(
18650 &mut self,
18651
18652 responder: ::fidl_next::Responder<symlink::Close, ___T>,
18653 ) -> impl ::core::future::Future<Output = ()>;
18654
18655 fn query(
18656 &mut self,
18657
18658 responder: ::fidl_next::Responder<symlink::Query, ___T>,
18659 ) -> impl ::core::future::Future<Output = ()>;
18660
18661 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
18662 fn deprecated_clone(
18663 &mut self,
18664
18665 request: ::fidl_next::Request<symlink::DeprecatedClone, ___T>,
18666 ) -> impl ::core::future::Future<Output = ()>;
18667
18668 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
18669 fn deprecated_get_attr(
18670 &mut self,
18671
18672 responder: ::fidl_next::Responder<symlink::DeprecatedGetAttr, ___T>,
18673 ) -> impl ::core::future::Future<Output = ()>;
18674
18675 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
18676 fn deprecated_set_attr(
18677 &mut self,
18678
18679 request: ::fidl_next::Request<symlink::DeprecatedSetAttr, ___T>,
18680
18681 responder: ::fidl_next::Responder<symlink::DeprecatedSetAttr, ___T>,
18682 ) -> impl ::core::future::Future<Output = ()>;
18683
18684 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
18685 fn deprecated_get_flags(
18686 &mut self,
18687
18688 responder: ::fidl_next::Responder<symlink::DeprecatedGetFlags, ___T>,
18689 ) -> impl ::core::future::Future<Output = ()>;
18690
18691 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
18692 fn deprecated_set_flags(
18693 &mut self,
18694
18695 request: ::fidl_next::Request<symlink::DeprecatedSetFlags, ___T>,
18696
18697 responder: ::fidl_next::Responder<symlink::DeprecatedSetFlags, ___T>,
18698 ) -> impl ::core::future::Future<Output = ()>;
18699
18700 #[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"]
18701 fn get_flags(
18702 &mut self,
18703
18704 responder: ::fidl_next::Responder<symlink::GetFlags, ___T>,
18705 ) -> impl ::core::future::Future<Output = ()>;
18706
18707 #[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"]
18708 fn set_flags(
18709 &mut self,
18710
18711 request: ::fidl_next::Request<symlink::SetFlags, ___T>,
18712
18713 responder: ::fidl_next::Responder<symlink::SetFlags, ___T>,
18714 ) -> impl ::core::future::Future<Output = ()>;
18715
18716 #[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"]
18717 fn query_filesystem(
18718 &mut self,
18719
18720 responder: ::fidl_next::Responder<symlink::QueryFilesystem, ___T>,
18721 ) -> impl ::core::future::Future<Output = ()>;
18722
18723 #[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"]
18724 fn get_attributes(
18725 &mut self,
18726
18727 request: ::fidl_next::Request<symlink::GetAttributes, ___T>,
18728
18729 responder: ::fidl_next::Responder<symlink::GetAttributes, ___T>,
18730 ) -> impl ::core::future::Future<Output = ()>;
18731
18732 #[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"]
18733 fn update_attributes(
18734 &mut self,
18735
18736 request: ::fidl_next::Request<symlink::UpdateAttributes, ___T>,
18737
18738 responder: ::fidl_next::Responder<symlink::UpdateAttributes, ___T>,
18739 ) -> impl ::core::future::Future<Output = ()>;
18740
18741 #[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"]
18742 fn sync(
18743 &mut self,
18744
18745 responder: ::fidl_next::Responder<symlink::Sync, ___T>,
18746 ) -> impl ::core::future::Future<Output = ()>;
18747
18748 #[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"]
18749 fn list_extended_attributes(
18750 &mut self,
18751
18752 request: ::fidl_next::Request<symlink::ListExtendedAttributes, ___T>,
18753 ) -> impl ::core::future::Future<Output = ()>;
18754
18755 #[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"]
18756 fn get_extended_attribute(
18757 &mut self,
18758
18759 request: ::fidl_next::Request<symlink::GetExtendedAttribute, ___T>,
18760
18761 responder: ::fidl_next::Responder<symlink::GetExtendedAttribute, ___T>,
18762 ) -> impl ::core::future::Future<Output = ()>;
18763
18764 #[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"]
18765 fn set_extended_attribute(
18766 &mut self,
18767
18768 request: ::fidl_next::Request<symlink::SetExtendedAttribute, ___T>,
18769
18770 responder: ::fidl_next::Responder<symlink::SetExtendedAttribute, ___T>,
18771 ) -> impl ::core::future::Future<Output = ()>;
18772
18773 #[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"]
18774 fn remove_extended_attribute(
18775 &mut self,
18776
18777 request: ::fidl_next::Request<symlink::RemoveExtendedAttribute, ___T>,
18778
18779 responder: ::fidl_next::Responder<symlink::RemoveExtendedAttribute, ___T>,
18780 ) -> impl ::core::future::Future<Output = ()>;
18781
18782 #[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"]
18783 fn open(
18784 &mut self,
18785
18786 request: ::fidl_next::Request<symlink::Open, ___T>,
18787 ) -> impl ::core::future::Future<Output = ()>;
18788
18789 fn describe(
18790 &mut self,
18791
18792 responder: ::fidl_next::Responder<symlink::Describe, ___T>,
18793 ) -> impl ::core::future::Future<Output = ()>;
18794
18795 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
18796 ::core::future::ready(())
18797 }
18798}
18799
18800impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Symlink
18801where
18802 ___H: SymlinkLocalServerHandler<___T>,
18803 ___T: ::fidl_next::Transport,
18804 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
18805 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18806 Constraint = (),
18807 >,
18808 for<'de> ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
18809 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18810 Constraint = (),
18811 >,
18812 for<'de> crate::wire::NodeDeprecatedCloneRequest: ::fidl_next::Decode<
18813 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18814 Constraint = (),
18815 >,
18816 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
18817 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18818 Constraint = (),
18819 >,
18820 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
18821 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18822 Constraint = (),
18823 >,
18824 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
18825 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18826 Constraint = (),
18827 >,
18828 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
18829 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18830 Constraint = (),
18831 >,
18832 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
18833 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18834 Constraint = (),
18835 >,
18836 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
18837 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18838 Constraint = (),
18839 >,
18840 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'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::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
18845 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18846 Constraint = (),
18847 >,
18848 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'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::OpenableOpenRequest<'de>: ::fidl_next::Decode<
18853 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18854 Constraint = (),
18855 >,
18856{
18857 async fn on_one_way(
18858 handler: &mut ___H,
18859 mut message: ::fidl_next::Message<___T>,
18860 ) -> ::core::result::Result<
18861 (),
18862 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18863 > {
18864 match *message.header().ordinal {
18865 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
18866 Ok(decoded) => {
18867 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
18868 Ok(())
18869 }
18870 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18871 ordinal: 2366825959783828089,
18872 error,
18873 }),
18874 },
18875
18876 6512600400724287855 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
18877 Ok(decoded) => {
18878 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
18879 Ok(())
18880 }
18881 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18882 ordinal: 6512600400724287855,
18883 error,
18884 }),
18885 },
18886
18887 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
18888 Ok(decoded) => {
18889 handler
18890 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
18891 .await;
18892 Ok(())
18893 }
18894 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18895 ordinal: 5431626189872037072,
18896 error,
18897 }),
18898 },
18899
18900 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
18901 Ok(decoded) => {
18902 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
18903 Ok(())
18904 }
18905 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18906 ordinal: 6236883748953765593,
18907 error,
18908 }),
18909 },
18910
18911 ordinal => {
18912 handler.on_unknown_interaction(ordinal).await;
18913 if ::core::matches!(
18914 message.header().flexibility(),
18915 ::fidl_next::protocol::Flexibility::Strict
18916 ) {
18917 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18918 } else {
18919 Ok(())
18920 }
18921 }
18922 }
18923 }
18924
18925 async fn on_two_way(
18926 handler: &mut ___H,
18927 mut message: ::fidl_next::Message<___T>,
18928 responder: ::fidl_next::protocol::Responder<___T>,
18929 ) -> ::core::result::Result<
18930 (),
18931 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18932 > {
18933 match *message.header().ordinal {
18934 6121399674497678964 => {
18935 let responder = ::fidl_next::Responder::from_untyped(responder);
18936
18937 match ::fidl_next::AsDecoderExt::into_decoded(message) {
18938 Ok(decoded) => {
18939 handler
18940 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
18941 .await;
18942 Ok(())
18943 }
18944 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18945 ordinal: 6121399674497678964,
18946 error,
18947 }),
18948 }
18949 }
18950
18951 6540867515453498750 => {
18952 let responder = ::fidl_next::Responder::from_untyped(responder);
18953
18954 handler.close(responder).await;
18955 Ok(())
18956 }
18957
18958 2763219980499352582 => {
18959 let responder = ::fidl_next::Responder::from_untyped(responder);
18960
18961 handler.query(responder).await;
18962 Ok(())
18963 }
18964
18965 8689798978500614909 => {
18966 let responder = ::fidl_next::Responder::from_untyped(responder);
18967
18968 handler.deprecated_get_attr(responder).await;
18969 Ok(())
18970 }
18971
18972 4721673413776871238 => {
18973 let responder = ::fidl_next::Responder::from_untyped(responder);
18974
18975 match ::fidl_next::AsDecoderExt::into_decoded(message) {
18976 Ok(decoded) => {
18977 handler
18978 .deprecated_set_attr(
18979 ::fidl_next::Request::from_decoded(decoded),
18980 responder,
18981 )
18982 .await;
18983 Ok(())
18984 }
18985 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18986 ordinal: 4721673413776871238,
18987 error,
18988 }),
18989 }
18990 }
18991
18992 6595803110182632097 => {
18993 let responder = ::fidl_next::Responder::from_untyped(responder);
18994
18995 handler.deprecated_get_flags(responder).await;
18996 Ok(())
18997 }
18998
18999 5950864159036794675 => {
19000 let responder = ::fidl_next::Responder::from_untyped(responder);
19001
19002 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19003 Ok(decoded) => {
19004 handler
19005 .deprecated_set_flags(
19006 ::fidl_next::Request::from_decoded(decoded),
19007 responder,
19008 )
19009 .await;
19010 Ok(())
19011 }
19012 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19013 ordinal: 5950864159036794675,
19014 error,
19015 }),
19016 }
19017 }
19018
19019 105530239381466147 => {
19020 let responder = ::fidl_next::Responder::from_untyped(responder);
19021
19022 handler.get_flags(responder).await;
19023 Ok(())
19024 }
19025
19026 6172186066099445416 => {
19027 let responder = ::fidl_next::Responder::from_untyped(responder);
19028
19029 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19030 Ok(decoded) => {
19031 handler
19032 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
19033 .await;
19034 Ok(())
19035 }
19036 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19037 ordinal: 6172186066099445416,
19038 error,
19039 }),
19040 }
19041 }
19042
19043 8013111122914313744 => {
19044 let responder = ::fidl_next::Responder::from_untyped(responder);
19045
19046 handler.query_filesystem(responder).await;
19047 Ok(())
19048 }
19049
19050 4414537700416816443 => {
19051 let responder = ::fidl_next::Responder::from_untyped(responder);
19052
19053 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19054 Ok(decoded) => {
19055 handler
19056 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
19057 .await;
19058 Ok(())
19059 }
19060 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19061 ordinal: 4414537700416816443,
19062 error,
19063 }),
19064 }
19065 }
19066
19067 3677402239314018056 => {
19068 let responder = ::fidl_next::Responder::from_untyped(responder);
19069
19070 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19071 Ok(decoded) => {
19072 handler
19073 .update_attributes(
19074 ::fidl_next::Request::from_decoded(decoded),
19075 responder,
19076 )
19077 .await;
19078 Ok(())
19079 }
19080 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19081 ordinal: 3677402239314018056,
19082 error,
19083 }),
19084 }
19085 }
19086
19087 3196473584242777161 => {
19088 let responder = ::fidl_next::Responder::from_untyped(responder);
19089
19090 handler.sync(responder).await;
19091 Ok(())
19092 }
19093
19094 5043930208506967771 => {
19095 let responder = ::fidl_next::Responder::from_untyped(responder);
19096
19097 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19098 Ok(decoded) => {
19099 handler
19100 .get_extended_attribute(
19101 ::fidl_next::Request::from_decoded(decoded),
19102 responder,
19103 )
19104 .await;
19105 Ok(())
19106 }
19107 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19108 ordinal: 5043930208506967771,
19109 error,
19110 }),
19111 }
19112 }
19113
19114 5374223046099989052 => {
19115 let responder = ::fidl_next::Responder::from_untyped(responder);
19116
19117 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19118 Ok(decoded) => {
19119 handler
19120 .set_extended_attribute(
19121 ::fidl_next::Request::from_decoded(decoded),
19122 responder,
19123 )
19124 .await;
19125 Ok(())
19126 }
19127 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19128 ordinal: 5374223046099989052,
19129 error,
19130 }),
19131 }
19132 }
19133
19134 8794297771444732717 => {
19135 let responder = ::fidl_next::Responder::from_untyped(responder);
19136
19137 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19138 Ok(decoded) => {
19139 handler
19140 .remove_extended_attribute(
19141 ::fidl_next::Request::from_decoded(decoded),
19142 responder,
19143 )
19144 .await;
19145 Ok(())
19146 }
19147 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19148 ordinal: 8794297771444732717,
19149 error,
19150 }),
19151 }
19152 }
19153
19154 8371117097481679347 => {
19155 let responder = ::fidl_next::Responder::from_untyped(responder);
19156
19157 handler.describe(responder).await;
19158 Ok(())
19159 }
19160
19161 ordinal => {
19162 handler.on_unknown_interaction(ordinal).await;
19163 if ::core::matches!(
19164 message.header().flexibility(),
19165 ::fidl_next::protocol::Flexibility::Strict
19166 ) {
19167 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19168 } else {
19169 responder
19170 .respond_framework_error(
19171 ordinal,
19172 ::fidl_next::FrameworkError::UnknownMethod,
19173 )
19174 .expect("encoding a framework error should never fail")
19175 .await?;
19176 Ok(())
19177 }
19178 }
19179 }
19180 }
19181}
19182
19183pub trait SymlinkClientHandler<
19187 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19188 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19189>
19190{
19191 #[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"]
19192 fn on_open(
19193 &mut self,
19194
19195 request: ::fidl_next::Request<symlink::OnOpen, ___T>,
19196 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19197
19198 #[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"]
19199 fn on_representation(
19200 &mut self,
19201
19202 request: ::fidl_next::Request<symlink::OnRepresentation, ___T>,
19203 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19204
19205 fn on_unknown_interaction(
19206 &mut self,
19207 ordinal: u64,
19208 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19209 ::core::future::ready(())
19210 }
19211}
19212
19213impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Symlink
19214where
19215 ___H: SymlinkClientHandler<___T> + ::core::marker::Send,
19216 ___T: ::fidl_next::Transport,
19217 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
19218 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19219 Constraint = (),
19220 >,
19221 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
19222 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19223 Constraint = (),
19224 >,
19225{
19226 async fn on_event(
19227 handler: &mut ___H,
19228 mut message: ::fidl_next::Message<___T>,
19229 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
19230 match *message.header().ordinal {
19231 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19232 Ok(decoded) => {
19233 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
19234 Ok(())
19235 }
19236 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19237 ordinal: 9207534335756671346,
19238 error,
19239 }),
19240 },
19241
19242 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19243 Ok(decoded) => {
19244 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
19245 Ok(())
19246 }
19247 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19248 ordinal: 6679970090861613324,
19249 error,
19250 }),
19251 },
19252
19253 ordinal => {
19254 handler.on_unknown_interaction(ordinal).await;
19255 if ::core::matches!(
19256 message.header().flexibility(),
19257 ::fidl_next::protocol::Flexibility::Strict
19258 ) {
19259 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19260 } else {
19261 Ok(())
19262 }
19263 }
19264 }
19265 }
19266}
19267
19268pub trait SymlinkServerHandler<
19272 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19273 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19274>
19275{
19276 #[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"]
19277 fn link_into(
19278 &mut self,
19279
19280 request: ::fidl_next::Request<symlink::LinkInto, ___T>,
19281
19282 responder: ::fidl_next::Responder<symlink::LinkInto, ___T>,
19283 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19284
19285 fn clone(
19286 &mut self,
19287
19288 request: ::fidl_next::Request<symlink::Clone, ___T>,
19289 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19290
19291 #[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"]
19292 fn close(
19293 &mut self,
19294
19295 responder: ::fidl_next::Responder<symlink::Close, ___T>,
19296 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19297
19298 fn query(
19299 &mut self,
19300
19301 responder: ::fidl_next::Responder<symlink::Query, ___T>,
19302 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19303
19304 #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
19305 fn deprecated_clone(
19306 &mut self,
19307
19308 request: ::fidl_next::Request<symlink::DeprecatedClone, ___T>,
19309 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19310
19311 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
19312 fn deprecated_get_attr(
19313 &mut self,
19314
19315 responder: ::fidl_next::Responder<symlink::DeprecatedGetAttr, ___T>,
19316 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19317
19318 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
19319 fn deprecated_set_attr(
19320 &mut self,
19321
19322 request: ::fidl_next::Request<symlink::DeprecatedSetAttr, ___T>,
19323
19324 responder: ::fidl_next::Responder<symlink::DeprecatedSetAttr, ___T>,
19325 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19326
19327 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
19328 fn deprecated_get_flags(
19329 &mut self,
19330
19331 responder: ::fidl_next::Responder<symlink::DeprecatedGetFlags, ___T>,
19332 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19333
19334 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
19335 fn deprecated_set_flags(
19336 &mut self,
19337
19338 request: ::fidl_next::Request<symlink::DeprecatedSetFlags, ___T>,
19339
19340 responder: ::fidl_next::Responder<symlink::DeprecatedSetFlags, ___T>,
19341 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19342
19343 #[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"]
19344 fn get_flags(
19345 &mut self,
19346
19347 responder: ::fidl_next::Responder<symlink::GetFlags, ___T>,
19348 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19349
19350 #[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"]
19351 fn set_flags(
19352 &mut self,
19353
19354 request: ::fidl_next::Request<symlink::SetFlags, ___T>,
19355
19356 responder: ::fidl_next::Responder<symlink::SetFlags, ___T>,
19357 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19358
19359 #[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"]
19360 fn query_filesystem(
19361 &mut self,
19362
19363 responder: ::fidl_next::Responder<symlink::QueryFilesystem, ___T>,
19364 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19365
19366 #[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"]
19367 fn get_attributes(
19368 &mut self,
19369
19370 request: ::fidl_next::Request<symlink::GetAttributes, ___T>,
19371
19372 responder: ::fidl_next::Responder<symlink::GetAttributes, ___T>,
19373 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19374
19375 #[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"]
19376 fn update_attributes(
19377 &mut self,
19378
19379 request: ::fidl_next::Request<symlink::UpdateAttributes, ___T>,
19380
19381 responder: ::fidl_next::Responder<symlink::UpdateAttributes, ___T>,
19382 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19383
19384 #[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"]
19385 fn sync(
19386 &mut self,
19387
19388 responder: ::fidl_next::Responder<symlink::Sync, ___T>,
19389 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19390
19391 #[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"]
19392 fn list_extended_attributes(
19393 &mut self,
19394
19395 request: ::fidl_next::Request<symlink::ListExtendedAttributes, ___T>,
19396 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19397
19398 #[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"]
19399 fn get_extended_attribute(
19400 &mut self,
19401
19402 request: ::fidl_next::Request<symlink::GetExtendedAttribute, ___T>,
19403
19404 responder: ::fidl_next::Responder<symlink::GetExtendedAttribute, ___T>,
19405 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19406
19407 #[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"]
19408 fn set_extended_attribute(
19409 &mut self,
19410
19411 request: ::fidl_next::Request<symlink::SetExtendedAttribute, ___T>,
19412
19413 responder: ::fidl_next::Responder<symlink::SetExtendedAttribute, ___T>,
19414 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19415
19416 #[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"]
19417 fn remove_extended_attribute(
19418 &mut self,
19419
19420 request: ::fidl_next::Request<symlink::RemoveExtendedAttribute, ___T>,
19421
19422 responder: ::fidl_next::Responder<symlink::RemoveExtendedAttribute, ___T>,
19423 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19424
19425 #[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"]
19426 fn open(
19427 &mut self,
19428
19429 request: ::fidl_next::Request<symlink::Open, ___T>,
19430 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19431
19432 fn describe(
19433 &mut self,
19434
19435 responder: ::fidl_next::Responder<symlink::Describe, ___T>,
19436 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19437
19438 fn on_unknown_interaction(
19439 &mut self,
19440 ordinal: u64,
19441 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19442 ::core::future::ready(())
19443 }
19444}
19445
19446impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Symlink
19447where
19448 ___H: SymlinkServerHandler<___T> + ::core::marker::Send,
19449 ___T: ::fidl_next::Transport,
19450 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
19451 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19452 Constraint = (),
19453 >,
19454 for<'de> ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
19455 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19456 Constraint = (),
19457 >,
19458 for<'de> crate::wire::NodeDeprecatedCloneRequest: ::fidl_next::Decode<
19459 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19460 Constraint = (),
19461 >,
19462 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
19463 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19464 Constraint = (),
19465 >,
19466 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
19467 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19468 Constraint = (),
19469 >,
19470 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
19471 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19472 Constraint = (),
19473 >,
19474 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
19475 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19476 Constraint = (),
19477 >,
19478 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
19479 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19480 Constraint = (),
19481 >,
19482 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
19483 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19484 Constraint = (),
19485 >,
19486 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
19487 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19488 Constraint = (),
19489 >,
19490 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
19491 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19492 Constraint = (),
19493 >,
19494 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
19495 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19496 Constraint = (),
19497 >,
19498 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
19499 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19500 Constraint = (),
19501 >,
19502{
19503 async fn on_one_way(
19504 handler: &mut ___H,
19505 mut message: ::fidl_next::Message<___T>,
19506 ) -> ::core::result::Result<
19507 (),
19508 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19509 > {
19510 match *message.header().ordinal {
19511 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19512 Ok(decoded) => {
19513 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
19514 Ok(())
19515 }
19516 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19517 ordinal: 2366825959783828089,
19518 error,
19519 }),
19520 },
19521
19522 6512600400724287855 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19523 Ok(decoded) => {
19524 handler.deprecated_clone(::fidl_next::Request::from_decoded(decoded)).await;
19525 Ok(())
19526 }
19527 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19528 ordinal: 6512600400724287855,
19529 error,
19530 }),
19531 },
19532
19533 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19534 Ok(decoded) => {
19535 handler
19536 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
19537 .await;
19538 Ok(())
19539 }
19540 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19541 ordinal: 5431626189872037072,
19542 error,
19543 }),
19544 },
19545
19546 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19547 Ok(decoded) => {
19548 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
19549 Ok(())
19550 }
19551 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19552 ordinal: 6236883748953765593,
19553 error,
19554 }),
19555 },
19556
19557 ordinal => {
19558 handler.on_unknown_interaction(ordinal).await;
19559 if ::core::matches!(
19560 message.header().flexibility(),
19561 ::fidl_next::protocol::Flexibility::Strict
19562 ) {
19563 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19564 } else {
19565 Ok(())
19566 }
19567 }
19568 }
19569 }
19570
19571 async fn on_two_way(
19572 handler: &mut ___H,
19573 mut message: ::fidl_next::Message<___T>,
19574 responder: ::fidl_next::protocol::Responder<___T>,
19575 ) -> ::core::result::Result<
19576 (),
19577 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19578 > {
19579 match *message.header().ordinal {
19580 6121399674497678964 => {
19581 let responder = ::fidl_next::Responder::from_untyped(responder);
19582
19583 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19584 Ok(decoded) => {
19585 handler
19586 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
19587 .await;
19588 Ok(())
19589 }
19590 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19591 ordinal: 6121399674497678964,
19592 error,
19593 }),
19594 }
19595 }
19596
19597 6540867515453498750 => {
19598 let responder = ::fidl_next::Responder::from_untyped(responder);
19599
19600 handler.close(responder).await;
19601 Ok(())
19602 }
19603
19604 2763219980499352582 => {
19605 let responder = ::fidl_next::Responder::from_untyped(responder);
19606
19607 handler.query(responder).await;
19608 Ok(())
19609 }
19610
19611 8689798978500614909 => {
19612 let responder = ::fidl_next::Responder::from_untyped(responder);
19613
19614 handler.deprecated_get_attr(responder).await;
19615 Ok(())
19616 }
19617
19618 4721673413776871238 => {
19619 let responder = ::fidl_next::Responder::from_untyped(responder);
19620
19621 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19622 Ok(decoded) => {
19623 handler
19624 .deprecated_set_attr(
19625 ::fidl_next::Request::from_decoded(decoded),
19626 responder,
19627 )
19628 .await;
19629 Ok(())
19630 }
19631 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19632 ordinal: 4721673413776871238,
19633 error,
19634 }),
19635 }
19636 }
19637
19638 6595803110182632097 => {
19639 let responder = ::fidl_next::Responder::from_untyped(responder);
19640
19641 handler.deprecated_get_flags(responder).await;
19642 Ok(())
19643 }
19644
19645 5950864159036794675 => {
19646 let responder = ::fidl_next::Responder::from_untyped(responder);
19647
19648 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19649 Ok(decoded) => {
19650 handler
19651 .deprecated_set_flags(
19652 ::fidl_next::Request::from_decoded(decoded),
19653 responder,
19654 )
19655 .await;
19656 Ok(())
19657 }
19658 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19659 ordinal: 5950864159036794675,
19660 error,
19661 }),
19662 }
19663 }
19664
19665 105530239381466147 => {
19666 let responder = ::fidl_next::Responder::from_untyped(responder);
19667
19668 handler.get_flags(responder).await;
19669 Ok(())
19670 }
19671
19672 6172186066099445416 => {
19673 let responder = ::fidl_next::Responder::from_untyped(responder);
19674
19675 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19676 Ok(decoded) => {
19677 handler
19678 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
19679 .await;
19680 Ok(())
19681 }
19682 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19683 ordinal: 6172186066099445416,
19684 error,
19685 }),
19686 }
19687 }
19688
19689 8013111122914313744 => {
19690 let responder = ::fidl_next::Responder::from_untyped(responder);
19691
19692 handler.query_filesystem(responder).await;
19693 Ok(())
19694 }
19695
19696 4414537700416816443 => {
19697 let responder = ::fidl_next::Responder::from_untyped(responder);
19698
19699 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19700 Ok(decoded) => {
19701 handler
19702 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
19703 .await;
19704 Ok(())
19705 }
19706 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19707 ordinal: 4414537700416816443,
19708 error,
19709 }),
19710 }
19711 }
19712
19713 3677402239314018056 => {
19714 let responder = ::fidl_next::Responder::from_untyped(responder);
19715
19716 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19717 Ok(decoded) => {
19718 handler
19719 .update_attributes(
19720 ::fidl_next::Request::from_decoded(decoded),
19721 responder,
19722 )
19723 .await;
19724 Ok(())
19725 }
19726 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19727 ordinal: 3677402239314018056,
19728 error,
19729 }),
19730 }
19731 }
19732
19733 3196473584242777161 => {
19734 let responder = ::fidl_next::Responder::from_untyped(responder);
19735
19736 handler.sync(responder).await;
19737 Ok(())
19738 }
19739
19740 5043930208506967771 => {
19741 let responder = ::fidl_next::Responder::from_untyped(responder);
19742
19743 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19744 Ok(decoded) => {
19745 handler
19746 .get_extended_attribute(
19747 ::fidl_next::Request::from_decoded(decoded),
19748 responder,
19749 )
19750 .await;
19751 Ok(())
19752 }
19753 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19754 ordinal: 5043930208506967771,
19755 error,
19756 }),
19757 }
19758 }
19759
19760 5374223046099989052 => {
19761 let responder = ::fidl_next::Responder::from_untyped(responder);
19762
19763 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19764 Ok(decoded) => {
19765 handler
19766 .set_extended_attribute(
19767 ::fidl_next::Request::from_decoded(decoded),
19768 responder,
19769 )
19770 .await;
19771 Ok(())
19772 }
19773 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19774 ordinal: 5374223046099989052,
19775 error,
19776 }),
19777 }
19778 }
19779
19780 8794297771444732717 => {
19781 let responder = ::fidl_next::Responder::from_untyped(responder);
19782
19783 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19784 Ok(decoded) => {
19785 handler
19786 .remove_extended_attribute(
19787 ::fidl_next::Request::from_decoded(decoded),
19788 responder,
19789 )
19790 .await;
19791 Ok(())
19792 }
19793 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19794 ordinal: 8794297771444732717,
19795 error,
19796 }),
19797 }
19798 }
19799
19800 8371117097481679347 => {
19801 let responder = ::fidl_next::Responder::from_untyped(responder);
19802
19803 handler.describe(responder).await;
19804 Ok(())
19805 }
19806
19807 ordinal => {
19808 handler.on_unknown_interaction(ordinal).await;
19809 if ::core::matches!(
19810 message.header().flexibility(),
19811 ::fidl_next::protocol::Flexibility::Strict
19812 ) {
19813 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19814 } else {
19815 responder
19816 .respond_framework_error(
19817 ordinal,
19818 ::fidl_next::FrameworkError::UnknownMethod,
19819 )
19820 .expect("encoding a framework error should never fail")
19821 .await?;
19822 Ok(())
19823 }
19824 }
19825 }
19826 }
19827}
19828
19829impl<___T> SymlinkClientHandler<___T> for ::fidl_next::IgnoreEvents
19830where
19831 ___T: ::fidl_next::Transport,
19832{
19833 async fn on_open(&mut self, _: ::fidl_next::Request<symlink::OnOpen, ___T>) {}
19834
19835 async fn on_representation(
19836 &mut self,
19837
19838 _: ::fidl_next::Request<symlink::OnRepresentation, ___T>,
19839 ) {
19840 }
19841
19842 async fn on_unknown_interaction(&mut self, _: u64) {}
19843}
19844
19845impl<___H, ___T> SymlinkLocalClientHandler<___T> for ::fidl_next::Local<___H>
19846where
19847 ___H: SymlinkClientHandler<___T>,
19848 ___T: ::fidl_next::Transport,
19849{
19850 async fn on_open(&mut self, request: ::fidl_next::Request<symlink::OnOpen, ___T>) {
19851 ___H::on_open(&mut self.0, request).await
19852 }
19853
19854 async fn on_representation(
19855 &mut self,
19856
19857 request: ::fidl_next::Request<symlink::OnRepresentation, ___T>,
19858 ) {
19859 ___H::on_representation(&mut self.0, request).await
19860 }
19861
19862 async fn on_unknown_interaction(&mut self, ordinal: u64) {
19863 ___H::on_unknown_interaction(&mut self.0, ordinal).await
19864 }
19865}
19866
19867impl<___H, ___T> SymlinkLocalServerHandler<___T> for ::fidl_next::Local<___H>
19868where
19869 ___H: SymlinkServerHandler<___T>,
19870 ___T: ::fidl_next::Transport,
19871{
19872 async fn link_into(
19873 &mut self,
19874
19875 request: ::fidl_next::Request<symlink::LinkInto, ___T>,
19876
19877 responder: ::fidl_next::Responder<symlink::LinkInto, ___T>,
19878 ) {
19879 ___H::link_into(&mut self.0, request, responder).await
19880 }
19881
19882 async fn clone(&mut self, request: ::fidl_next::Request<symlink::Clone, ___T>) {
19883 ___H::clone(&mut self.0, request).await
19884 }
19885
19886 async fn close(&mut self, responder: ::fidl_next::Responder<symlink::Close, ___T>) {
19887 ___H::close(&mut self.0, responder).await
19888 }
19889
19890 async fn query(&mut self, responder: ::fidl_next::Responder<symlink::Query, ___T>) {
19891 ___H::query(&mut self.0, responder).await
19892 }
19893
19894 async fn deprecated_clone(
19895 &mut self,
19896
19897 request: ::fidl_next::Request<symlink::DeprecatedClone, ___T>,
19898 ) {
19899 ___H::deprecated_clone(&mut self.0, request).await
19900 }
19901
19902 async fn deprecated_get_attr(
19903 &mut self,
19904
19905 responder: ::fidl_next::Responder<symlink::DeprecatedGetAttr, ___T>,
19906 ) {
19907 ___H::deprecated_get_attr(&mut self.0, responder).await
19908 }
19909
19910 async fn deprecated_set_attr(
19911 &mut self,
19912
19913 request: ::fidl_next::Request<symlink::DeprecatedSetAttr, ___T>,
19914
19915 responder: ::fidl_next::Responder<symlink::DeprecatedSetAttr, ___T>,
19916 ) {
19917 ___H::deprecated_set_attr(&mut self.0, request, responder).await
19918 }
19919
19920 async fn deprecated_get_flags(
19921 &mut self,
19922
19923 responder: ::fidl_next::Responder<symlink::DeprecatedGetFlags, ___T>,
19924 ) {
19925 ___H::deprecated_get_flags(&mut self.0, responder).await
19926 }
19927
19928 async fn deprecated_set_flags(
19929 &mut self,
19930
19931 request: ::fidl_next::Request<symlink::DeprecatedSetFlags, ___T>,
19932
19933 responder: ::fidl_next::Responder<symlink::DeprecatedSetFlags, ___T>,
19934 ) {
19935 ___H::deprecated_set_flags(&mut self.0, request, responder).await
19936 }
19937
19938 async fn get_flags(&mut self, responder: ::fidl_next::Responder<symlink::GetFlags, ___T>) {
19939 ___H::get_flags(&mut self.0, responder).await
19940 }
19941
19942 async fn set_flags(
19943 &mut self,
19944
19945 request: ::fidl_next::Request<symlink::SetFlags, ___T>,
19946
19947 responder: ::fidl_next::Responder<symlink::SetFlags, ___T>,
19948 ) {
19949 ___H::set_flags(&mut self.0, request, responder).await
19950 }
19951
19952 async fn query_filesystem(
19953 &mut self,
19954
19955 responder: ::fidl_next::Responder<symlink::QueryFilesystem, ___T>,
19956 ) {
19957 ___H::query_filesystem(&mut self.0, responder).await
19958 }
19959
19960 async fn get_attributes(
19961 &mut self,
19962
19963 request: ::fidl_next::Request<symlink::GetAttributes, ___T>,
19964
19965 responder: ::fidl_next::Responder<symlink::GetAttributes, ___T>,
19966 ) {
19967 ___H::get_attributes(&mut self.0, request, responder).await
19968 }
19969
19970 async fn update_attributes(
19971 &mut self,
19972
19973 request: ::fidl_next::Request<symlink::UpdateAttributes, ___T>,
19974
19975 responder: ::fidl_next::Responder<symlink::UpdateAttributes, ___T>,
19976 ) {
19977 ___H::update_attributes(&mut self.0, request, responder).await
19978 }
19979
19980 async fn sync(&mut self, responder: ::fidl_next::Responder<symlink::Sync, ___T>) {
19981 ___H::sync(&mut self.0, responder).await
19982 }
19983
19984 async fn list_extended_attributes(
19985 &mut self,
19986
19987 request: ::fidl_next::Request<symlink::ListExtendedAttributes, ___T>,
19988 ) {
19989 ___H::list_extended_attributes(&mut self.0, request).await
19990 }
19991
19992 async fn get_extended_attribute(
19993 &mut self,
19994
19995 request: ::fidl_next::Request<symlink::GetExtendedAttribute, ___T>,
19996
19997 responder: ::fidl_next::Responder<symlink::GetExtendedAttribute, ___T>,
19998 ) {
19999 ___H::get_extended_attribute(&mut self.0, request, responder).await
20000 }
20001
20002 async fn set_extended_attribute(
20003 &mut self,
20004
20005 request: ::fidl_next::Request<symlink::SetExtendedAttribute, ___T>,
20006
20007 responder: ::fidl_next::Responder<symlink::SetExtendedAttribute, ___T>,
20008 ) {
20009 ___H::set_extended_attribute(&mut self.0, request, responder).await
20010 }
20011
20012 async fn remove_extended_attribute(
20013 &mut self,
20014
20015 request: ::fidl_next::Request<symlink::RemoveExtendedAttribute, ___T>,
20016
20017 responder: ::fidl_next::Responder<symlink::RemoveExtendedAttribute, ___T>,
20018 ) {
20019 ___H::remove_extended_attribute(&mut self.0, request, responder).await
20020 }
20021
20022 async fn open(&mut self, request: ::fidl_next::Request<symlink::Open, ___T>) {
20023 ___H::open(&mut self.0, request).await
20024 }
20025
20026 async fn describe(&mut self, responder: ::fidl_next::Responder<symlink::Describe, ___T>) {
20027 ___H::describe(&mut self.0, responder).await
20028 }
20029
20030 async fn on_unknown_interaction(&mut self, ordinal: u64) {
20031 ___H::on_unknown_interaction(&mut self.0, ordinal).await
20032 }
20033}
20034
20035pub use fidl_next_common_fuchsia_io::*;