1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 pub use fidl_next_common_fuchsia_io::natural::*;
8
9 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
10 pub struct ConnectionInfo {
11 pub rights: ::core::option::Option<crate::natural::Operations>,
12 }
13
14 impl ConnectionInfo {
15 fn __max_ordinal(&self) -> usize {
16 if self.rights.is_some() {
17 return 1;
18 }
19
20 0
21 }
22 }
23
24 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConnectionInfo<'static>, ___E> for ConnectionInfo
25 where
26 ___E: ::fidl_next::Encoder + ?Sized,
27 ___E: ::fdomain_client::fidl_next::HandleEncoder,
28 {
29 #[inline]
30 fn encode(
31 mut self,
32 encoder: &mut ___E,
33 out: &mut ::core::mem::MaybeUninit<crate::wire::ConnectionInfo<'static>>,
34 _: (),
35 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
36 ::fidl_next::munge!(let crate::wire::ConnectionInfo { table } = out);
37
38 let max_ord = self.__max_ordinal();
39
40 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
41 ::fidl_next::Wire::zero_padding(&mut out);
42
43 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
44 ::fidl_next::wire::Envelope,
45 >(encoder, max_ord);
46
47 for i in 1..=max_ord {
48 match i {
49 1 => {
50 if let Some(value) = self.rights.take() {
51 ::fidl_next::wire::Envelope::encode_value::<
52 crate::wire::Operations,
53 ___E,
54 >(
55 value, preallocated.encoder, &mut out, ()
56 )?;
57 } else {
58 ::fidl_next::wire::Envelope::encode_zero(&mut out)
59 }
60 }
61
62 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
63 }
64 unsafe {
65 preallocated.write_next(out.assume_init_ref());
66 }
67 }
68
69 ::fidl_next::wire::Table::encode_len(table, max_ord);
70
71 Ok(())
72 }
73 }
74
75 impl<'de> ::fidl_next::FromWire<crate::wire::ConnectionInfo<'de>> for ConnectionInfo {
76 #[inline]
77 fn from_wire(wire_: crate::wire::ConnectionInfo<'de>) -> Self {
78 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
79
80 let rights = wire_.table.get(1);
81
82 Self {
83 rights: rights.map(|envelope| {
84 ::fidl_next::FromWire::from_wire(unsafe {
85 envelope.read_unchecked::<crate::wire::Operations>()
86 })
87 }),
88 }
89 }
90 }
91
92 #[derive(Debug, PartialEq)]
93 pub struct DirectoryLinkRequest {
94 pub src: ::std::string::String,
95
96 pub dst_parent_token: ::fdomain_client::NullableHandle,
97
98 pub dst: ::std::string::String,
99 }
100
101 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryLinkRequest<'static>, ___E>
102 for DirectoryLinkRequest
103 where
104 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
105 ___E: ::fidl_next::Encoder,
106 ___E: ::fdomain_client::fidl_next::HandleEncoder,
107 {
108 #[inline]
109 fn encode(
110 self,
111 encoder_: &mut ___E,
112 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkRequest<'static>>,
113 _: (),
114 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
115 ::fidl_next::munge! {
116 let crate::wire::DirectoryLinkRequest {
117 src,
118 dst_parent_token,
119 dst,
120
121 } = out_;
122 }
123
124 ::fidl_next::Encode::encode(self.src, encoder_, src, 255)?;
125
126 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(src.as_mut_ptr()) };
127 ::fidl_next::Constrained::validate(_field, 255)?;
128
129 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
130
131 let mut _field =
132 unsafe { ::fidl_next::Slot::new_unchecked(dst_parent_token.as_mut_ptr()) };
133
134 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
135
136 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dst.as_mut_ptr()) };
137 ::fidl_next::Constrained::validate(_field, 255)?;
138
139 Ok(())
140 }
141 }
142
143 unsafe impl<___E>
144 ::fidl_next::EncodeOption<
145 ::fidl_next::wire::Box<'static, crate::wire::DirectoryLinkRequest<'static>>,
146 ___E,
147 > for DirectoryLinkRequest
148 where
149 ___E: ::fidl_next::Encoder + ?Sized,
150 DirectoryLinkRequest: ::fidl_next::Encode<crate::wire::DirectoryLinkRequest<'static>, ___E>,
151 {
152 #[inline]
153 fn encode_option(
154 this: ::core::option::Option<Self>,
155 encoder: &mut ___E,
156 out: &mut ::core::mem::MaybeUninit<
157 ::fidl_next::wire::Box<'static, crate::wire::DirectoryLinkRequest<'static>>,
158 >,
159 _: (),
160 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
161 if let Some(inner) = this {
162 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
163 ::fidl_next::wire::Box::encode_present(out);
164 } else {
165 ::fidl_next::wire::Box::encode_absent(out);
166 }
167
168 Ok(())
169 }
170 }
171
172 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryLinkRequest<'de>> for DirectoryLinkRequest {
173 #[inline]
174 fn from_wire(wire: crate::wire::DirectoryLinkRequest<'de>) -> Self {
175 Self {
176 src: ::fidl_next::FromWire::from_wire(wire.src),
177
178 dst_parent_token: ::fidl_next::FromWire::from_wire(wire.dst_parent_token),
179
180 dst: ::fidl_next::FromWire::from_wire(wire.dst),
181 }
182 }
183 }
184
185 #[doc = " The type to identify a connection to a node.\n It represents a capability: a reference to a node with associated rights.\n"]
186 pub type Token = ::fdomain_client::Event;
187
188 #[derive(Debug, PartialEq)]
189 pub struct DirectoryRenameRequest {
190 pub src: ::std::string::String,
191
192 pub dst_parent_token: ::fdomain_client::Event,
193
194 pub dst: ::std::string::String,
195 }
196
197 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryRenameRequest<'static>, ___E>
198 for DirectoryRenameRequest
199 where
200 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
201 ___E: ::fidl_next::Encoder,
202 ___E: ::fdomain_client::fidl_next::HandleEncoder,
203 {
204 #[inline]
205 fn encode(
206 self,
207 encoder_: &mut ___E,
208 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRenameRequest<'static>>,
209 _: (),
210 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
211 ::fidl_next::munge! {
212 let crate::wire::DirectoryRenameRequest {
213 src,
214 dst_parent_token,
215 dst,
216
217 } = out_;
218 }
219
220 ::fidl_next::Encode::encode(self.src, encoder_, src, 255)?;
221
222 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(src.as_mut_ptr()) };
223 ::fidl_next::Constrained::validate(_field, 255)?;
224
225 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
226
227 let mut _field =
228 unsafe { ::fidl_next::Slot::new_unchecked(dst_parent_token.as_mut_ptr()) };
229
230 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
231
232 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dst.as_mut_ptr()) };
233 ::fidl_next::Constrained::validate(_field, 255)?;
234
235 Ok(())
236 }
237 }
238
239 unsafe impl<___E>
240 ::fidl_next::EncodeOption<
241 ::fidl_next::wire::Box<'static, crate::wire::DirectoryRenameRequest<'static>>,
242 ___E,
243 > for DirectoryRenameRequest
244 where
245 ___E: ::fidl_next::Encoder + ?Sized,
246 DirectoryRenameRequest:
247 ::fidl_next::Encode<crate::wire::DirectoryRenameRequest<'static>, ___E>,
248 {
249 #[inline]
250 fn encode_option(
251 this: ::core::option::Option<Self>,
252 encoder: &mut ___E,
253 out: &mut ::core::mem::MaybeUninit<
254 ::fidl_next::wire::Box<'static, crate::wire::DirectoryRenameRequest<'static>>,
255 >,
256 _: (),
257 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
258 if let Some(inner) = this {
259 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
260 ::fidl_next::wire::Box::encode_present(out);
261 } else {
262 ::fidl_next::wire::Box::encode_absent(out);
263 }
264
265 Ok(())
266 }
267 }
268
269 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryRenameRequest<'de>>
270 for DirectoryRenameRequest
271 {
272 #[inline]
273 fn from_wire(wire: crate::wire::DirectoryRenameRequest<'de>) -> Self {
274 Self {
275 src: ::fidl_next::FromWire::from_wire(wire.src),
276
277 dst_parent_token: ::fidl_next::FromWire::from_wire(wire.dst_parent_token),
278
279 dst: ::fidl_next::FromWire::from_wire(wire.dst),
280 }
281 }
282 }
283
284 #[derive(Debug, PartialEq)]
285 #[repr(C)]
286 pub struct DirectoryWatchRequest {
287 pub mask: crate::natural::WatchMask,
288
289 pub options: u32,
290
291 pub watcher: ::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fdomain_client::Channel>,
292 }
293
294 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryWatchRequest, ___E>
295 for DirectoryWatchRequest
296 where
297 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
298 ___E: ::fdomain_client::fidl_next::HandleEncoder,
299 {
300 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
301 Self,
302 crate::wire::DirectoryWatchRequest,
303 > = unsafe {
304 ::fidl_next::CopyOptimization::enable_if(
305 true
306
307 && <
308 crate::natural::WatchMask as ::fidl_next::Encode<crate::wire::WatchMask, ___E>
309 >::COPY_OPTIMIZATION.is_enabled()
310
311 && <
312 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
313 >::COPY_OPTIMIZATION.is_enabled()
314
315 && <
316 ::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fdomain_client::Channel> as ::fidl_next::Encode<::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fdomain_client::fidl_next::wire::Handle>, ___E>
317 >::COPY_OPTIMIZATION.is_enabled()
318
319 )
320 };
321
322 #[inline]
323 fn encode(
324 self,
325 encoder_: &mut ___E,
326 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchRequest>,
327 _: (),
328 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
329 ::fidl_next::munge! {
330 let crate::wire::DirectoryWatchRequest {
331 mask,
332 options,
333 watcher,
334
335 } = out_;
336 }
337
338 ::fidl_next::Encode::encode(self.mask, encoder_, mask, ())?;
339
340 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mask.as_mut_ptr()) };
341
342 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
343
344 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
345
346 ::fidl_next::Encode::encode(self.watcher, encoder_, watcher, ())?;
347
348 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(watcher.as_mut_ptr()) };
349
350 Ok(())
351 }
352 }
353
354 unsafe impl<___E>
355 ::fidl_next::EncodeOption<
356 ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchRequest>,
357 ___E,
358 > for DirectoryWatchRequest
359 where
360 ___E: ::fidl_next::Encoder + ?Sized,
361 DirectoryWatchRequest: ::fidl_next::Encode<crate::wire::DirectoryWatchRequest, ___E>,
362 {
363 #[inline]
364 fn encode_option(
365 this: ::core::option::Option<Self>,
366 encoder: &mut ___E,
367 out: &mut ::core::mem::MaybeUninit<
368 ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchRequest>,
369 >,
370 _: (),
371 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
372 if let Some(inner) = this {
373 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
374 ::fidl_next::wire::Box::encode_present(out);
375 } else {
376 ::fidl_next::wire::Box::encode_absent(out);
377 }
378
379 Ok(())
380 }
381 }
382
383 impl ::fidl_next::FromWire<crate::wire::DirectoryWatchRequest> for DirectoryWatchRequest {
384 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
385 crate::wire::DirectoryWatchRequest,
386 Self,
387 > = unsafe {
388 ::fidl_next::CopyOptimization::enable_if(
389 true
390
391 && <
392 crate::natural::WatchMask as ::fidl_next::FromWire<crate::wire::WatchMask>
393 >::COPY_OPTIMIZATION.is_enabled()
394
395 && <
396 u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>
397 >::COPY_OPTIMIZATION.is_enabled()
398
399 && <
400 ::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fdomain_client::Channel> as ::fidl_next::FromWire<::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fdomain_client::fidl_next::wire::Handle>>
401 >::COPY_OPTIMIZATION.is_enabled()
402
403 )
404 };
405
406 #[inline]
407 fn from_wire(wire: crate::wire::DirectoryWatchRequest) -> Self {
408 Self {
409 mask: ::fidl_next::FromWire::from_wire(wire.mask),
410
411 options: ::fidl_next::FromWire::from_wire(wire.options),
412
413 watcher: ::fidl_next::FromWire::from_wire(wire.watcher),
414 }
415 }
416 }
417
418 #[derive(Debug, PartialEq)]
419 #[repr(C)]
420 pub struct NodeListExtendedAttributesRequest {
421 pub iterator:
422 ::fidl_next::ServerEnd<crate::ExtendedAttributeIterator, ::fdomain_client::Channel>,
423 }
424
425 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeListExtendedAttributesRequest, ___E>
426 for NodeListExtendedAttributesRequest
427 where
428 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
429 ___E: ::fdomain_client::fidl_next::HandleEncoder,
430 {
431 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
432 Self,
433 crate::wire::NodeListExtendedAttributesRequest,
434 > = unsafe {
435 ::fidl_next::CopyOptimization::enable_if(
436 true && <::fidl_next::ServerEnd<
437 crate::ExtendedAttributeIterator,
438 ::fdomain_client::Channel,
439 > as ::fidl_next::Encode<
440 ::fidl_next::ServerEnd<
441 crate::ExtendedAttributeIterator,
442 ::fdomain_client::fidl_next::wire::Handle,
443 >,
444 ___E,
445 >>::COPY_OPTIMIZATION
446 .is_enabled(),
447 )
448 };
449
450 #[inline]
451 fn encode(
452 self,
453 encoder_: &mut ___E,
454 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeListExtendedAttributesRequest>,
455 _: (),
456 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
457 ::fidl_next::munge! {
458 let crate::wire::NodeListExtendedAttributesRequest {
459 iterator,
460
461 } = out_;
462 }
463
464 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
465
466 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
467
468 Ok(())
469 }
470 }
471
472 unsafe impl<___E>
473 ::fidl_next::EncodeOption<
474 ::fidl_next::wire::Box<'static, crate::wire::NodeListExtendedAttributesRequest>,
475 ___E,
476 > for NodeListExtendedAttributesRequest
477 where
478 ___E: ::fidl_next::Encoder + ?Sized,
479 NodeListExtendedAttributesRequest:
480 ::fidl_next::Encode<crate::wire::NodeListExtendedAttributesRequest, ___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::NodeListExtendedAttributesRequest>,
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::NodeListExtendedAttributesRequest>
503 for NodeListExtendedAttributesRequest
504 {
505 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
506 crate::wire::NodeListExtendedAttributesRequest,
507 Self,
508 > = unsafe {
509 ::fidl_next::CopyOptimization::enable_if(
510 true && <::fidl_next::ServerEnd<
511 crate::ExtendedAttributeIterator,
512 ::fdomain_client::Channel,
513 > as ::fidl_next::FromWire<
514 ::fidl_next::ServerEnd<
515 crate::ExtendedAttributeIterator,
516 ::fdomain_client::fidl_next::wire::Handle,
517 >,
518 >>::COPY_OPTIMIZATION
519 .is_enabled(),
520 )
521 };
522
523 #[inline]
524 fn from_wire(wire: crate::wire::NodeListExtendedAttributesRequest) -> Self {
525 Self { iterator: ::fidl_next::FromWire::from_wire(wire.iterator) }
526 }
527 }
528
529 #[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"]
530 #[derive(Debug, PartialEq)]
531 pub enum ExtendedAttributeValue {
532 Bytes(::std::vec::Vec<u8>),
533
534 Buffer(::fdomain_client::Vmo),
535
536 UnknownOrdinal_(u64),
537 }
538
539 impl ExtendedAttributeValue {
540 pub fn is_unknown(&self) -> bool {
541 #[allow(unreachable_patterns)]
542 match self {
543 Self::UnknownOrdinal_(_) => true,
544 _ => false,
545 }
546 }
547 }
548
549 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExtendedAttributeValue<'static>, ___E>
550 for ExtendedAttributeValue
551 where
552 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
553 ___E: ::fidl_next::Encoder,
554 ___E: ::fdomain_client::fidl_next::HandleEncoder,
555 {
556 #[inline]
557 fn encode(
558 self,
559 encoder: &mut ___E,
560 out: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedAttributeValue<'static>>,
561 _: (),
562 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
563 ::fidl_next::munge!(let crate::wire::ExtendedAttributeValue { raw, _phantom: _ } = out);
564
565 match self {
566 Self::Bytes(value) => ::fidl_next::wire::Union::encode_as::<
567 ___E,
568 ::fidl_next::wire::Vector<'static, u8>,
569 >(value, 1, encoder, raw, (32768, ()))?,
570
571 Self::Buffer(value) => ::fidl_next::wire::Union::encode_as::<
572 ___E,
573 ::fdomain_client::fidl_next::wire::Handle,
574 >(value, 2, encoder, raw, ())?,
575
576 Self::UnknownOrdinal_(ordinal) => {
577 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
578 }
579 }
580
581 Ok(())
582 }
583 }
584
585 unsafe impl<___E>
586 ::fidl_next::EncodeOption<crate::wire_optional::ExtendedAttributeValue<'static>, ___E>
587 for ExtendedAttributeValue
588 where
589 ___E: ?Sized,
590 ExtendedAttributeValue:
591 ::fidl_next::Encode<crate::wire::ExtendedAttributeValue<'static>, ___E>,
592 {
593 #[inline]
594 fn encode_option(
595 this: ::core::option::Option<Self>,
596 encoder: &mut ___E,
597 out: &mut ::core::mem::MaybeUninit<
598 crate::wire_optional::ExtendedAttributeValue<'static>,
599 >,
600 _: (),
601 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
602 ::fidl_next::munge!(let crate::wire_optional::ExtendedAttributeValue { raw, _phantom: _ } = &mut *out);
603
604 if let Some(inner) = this {
605 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
606 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
607 } else {
608 ::fidl_next::wire::Union::encode_absent(raw);
609 }
610
611 Ok(())
612 }
613 }
614
615 impl<'de> ::fidl_next::FromWire<crate::wire::ExtendedAttributeValue<'de>>
616 for ExtendedAttributeValue
617 {
618 #[inline]
619 fn from_wire(wire: crate::wire::ExtendedAttributeValue<'de>) -> Self {
620 let wire = ::core::mem::ManuallyDrop::new(wire);
621 match wire.raw.ordinal() {
622 1 => Self::Bytes(::fidl_next::FromWire::from_wire(unsafe {
623 wire.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
624 })),
625
626 2 => Self::Buffer(::fidl_next::FromWire::from_wire(unsafe {
627 wire.raw.get().read_unchecked::<::fdomain_client::fidl_next::wire::Handle>()
628 })),
629
630 ord => return Self::UnknownOrdinal_(ord as u64),
631 }
632 }
633 }
634
635 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ExtendedAttributeValue<'de>>
636 for ExtendedAttributeValue
637 {
638 #[inline]
639 fn from_wire_option(
640 wire: crate::wire_optional::ExtendedAttributeValue<'de>,
641 ) -> ::core::option::Option<Self> {
642 if let Some(inner) = wire.into_option() {
643 Some(::fidl_next::FromWire::from_wire(inner))
644 } else {
645 None
646 }
647 }
648 }
649
650 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ExtendedAttributeValue<'de>>
651 for Box<ExtendedAttributeValue>
652 {
653 #[inline]
654 fn from_wire_option(
655 wire: crate::wire_optional::ExtendedAttributeValue<'de>,
656 ) -> ::core::option::Option<Self> {
657 <ExtendedAttributeValue as ::fidl_next::FromWireOption<
658 crate::wire_optional::ExtendedAttributeValue<'de>,
659 >>::from_wire_option(wire)
660 .map(Box::new)
661 }
662 }
663
664 #[derive(Debug, PartialEq)]
665 pub struct NodeSetExtendedAttributeRequest {
666 pub name: ::std::vec::Vec<u8>,
667
668 pub value: crate::natural::ExtendedAttributeValue,
669
670 pub mode: crate::natural::SetExtendedAttributeMode,
671 }
672
673 unsafe impl<___E>
674 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeRequest<'static>, ___E>
675 for NodeSetExtendedAttributeRequest
676 where
677 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
678 ___E: ::fidl_next::Encoder,
679 ___E: ::fdomain_client::fidl_next::HandleEncoder,
680 {
681 #[inline]
682 fn encode(
683 self,
684 encoder_: &mut ___E,
685 out_: &mut ::core::mem::MaybeUninit<
686 crate::wire::NodeSetExtendedAttributeRequest<'static>,
687 >,
688 _: (),
689 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
690 ::fidl_next::munge! {
691 let crate::wire::NodeSetExtendedAttributeRequest {
692 name,
693 value,
694 mode,
695
696 } = out_;
697 }
698
699 ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
700
701 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
702 ::fidl_next::Constrained::validate(_field, (255, ()))?;
703
704 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
705
706 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
707
708 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
709
710 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
711
712 Ok(())
713 }
714 }
715
716 unsafe impl<___E>
717 ::fidl_next::EncodeOption<
718 ::fidl_next::wire::Box<'static, crate::wire::NodeSetExtendedAttributeRequest<'static>>,
719 ___E,
720 > for NodeSetExtendedAttributeRequest
721 where
722 ___E: ::fidl_next::Encoder + ?Sized,
723 NodeSetExtendedAttributeRequest:
724 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeRequest<'static>, ___E>,
725 {
726 #[inline]
727 fn encode_option(
728 this: ::core::option::Option<Self>,
729 encoder: &mut ___E,
730 out: &mut ::core::mem::MaybeUninit<
731 ::fidl_next::wire::Box<
732 'static,
733 crate::wire::NodeSetExtendedAttributeRequest<'static>,
734 >,
735 >,
736 _: (),
737 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
738 if let Some(inner) = this {
739 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
740 ::fidl_next::wire::Box::encode_present(out);
741 } else {
742 ::fidl_next::wire::Box::encode_absent(out);
743 }
744
745 Ok(())
746 }
747 }
748
749 impl<'de> ::fidl_next::FromWire<crate::wire::NodeSetExtendedAttributeRequest<'de>>
750 for NodeSetExtendedAttributeRequest
751 {
752 #[inline]
753 fn from_wire(wire: crate::wire::NodeSetExtendedAttributeRequest<'de>) -> Self {
754 Self {
755 name: ::fidl_next::FromWire::from_wire(wire.name),
756
757 value: ::fidl_next::FromWire::from_wire(wire.value),
758
759 mode: ::fidl_next::FromWire::from_wire(wire.mode),
760 }
761 }
762 }
763
764 #[derive(Debug, PartialEq)]
765 #[repr(C)]
766 pub struct NodeGetTokenResponse {
767 pub token: ::fdomain_client::Event,
768 }
769
770 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeGetTokenResponse, ___E>
771 for NodeGetTokenResponse
772 where
773 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
774 ___E: ::fdomain_client::fidl_next::HandleEncoder,
775 {
776 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
777 Self,
778 crate::wire::NodeGetTokenResponse,
779 > = unsafe {
780 ::fidl_next::CopyOptimization::enable_if(
781 true && <::fdomain_client::Event as ::fidl_next::Encode<
782 ::fdomain_client::fidl_next::wire::Handle,
783 ___E,
784 >>::COPY_OPTIMIZATION
785 .is_enabled(),
786 )
787 };
788
789 #[inline]
790 fn encode(
791 self,
792 encoder_: &mut ___E,
793 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetTokenResponse>,
794 _: (),
795 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
796 ::fidl_next::munge! {
797 let crate::wire::NodeGetTokenResponse {
798 token,
799
800 } = out_;
801 }
802
803 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
804
805 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
806
807 Ok(())
808 }
809 }
810
811 unsafe impl<___E>
812 ::fidl_next::EncodeOption<
813 ::fidl_next::wire::Box<'static, crate::wire::NodeGetTokenResponse>,
814 ___E,
815 > for NodeGetTokenResponse
816 where
817 ___E: ::fidl_next::Encoder + ?Sized,
818 NodeGetTokenResponse: ::fidl_next::Encode<crate::wire::NodeGetTokenResponse, ___E>,
819 {
820 #[inline]
821 fn encode_option(
822 this: ::core::option::Option<Self>,
823 encoder: &mut ___E,
824 out: &mut ::core::mem::MaybeUninit<
825 ::fidl_next::wire::Box<'static, crate::wire::NodeGetTokenResponse>,
826 >,
827 _: (),
828 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
829 if let Some(inner) = this {
830 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
831 ::fidl_next::wire::Box::encode_present(out);
832 } else {
833 ::fidl_next::wire::Box::encode_absent(out);
834 }
835
836 Ok(())
837 }
838 }
839
840 impl ::fidl_next::FromWire<crate::wire::NodeGetTokenResponse> for NodeGetTokenResponse {
841 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
842 crate::wire::NodeGetTokenResponse,
843 Self,
844 > = unsafe {
845 ::fidl_next::CopyOptimization::enable_if(
846 true && <::fdomain_client::Event as ::fidl_next::FromWire<
847 ::fdomain_client::fidl_next::wire::Handle,
848 >>::COPY_OPTIMIZATION
849 .is_enabled(),
850 )
851 };
852
853 #[inline]
854 fn from_wire(wire: crate::wire::NodeGetTokenResponse) -> Self {
855 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
856 }
857 }
858
859 #[derive(Debug, PartialEq)]
860 #[repr(C)]
861 pub struct DirectoryDeprecatedGetTokenResponse {
862 pub s: ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status>,
863
864 pub token: ::core::option::Option<::fdomain_client::NullableHandle>,
865 }
866
867 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryDeprecatedGetTokenResponse, ___E>
868 for DirectoryDeprecatedGetTokenResponse
869 where
870 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
871 ___E: ::fdomain_client::fidl_next::HandleEncoder,
872 {
873 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
874 Self,
875 crate::wire::DirectoryDeprecatedGetTokenResponse,
876 > = unsafe {
877 ::fidl_next::CopyOptimization::enable_if(
878 true
879
880 && <
881 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>
882 >::COPY_OPTIMIZATION.is_enabled()
883
884 && <
885 ::core::option::Option<::fdomain_client::NullableHandle> as ::fidl_next::Encode<::fdomain_client::fidl_next::wire::OptionalHandle, ___E>
886 >::COPY_OPTIMIZATION.is_enabled()
887
888 )
889 };
890
891 #[inline]
892 fn encode(
893 self,
894 encoder_: &mut ___E,
895 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryDeprecatedGetTokenResponse>,
896 _: (),
897 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
898 ::fidl_next::munge! {
899 let crate::wire::DirectoryDeprecatedGetTokenResponse {
900 s,
901 token,
902
903 } = out_;
904 }
905
906 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
907
908 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
909
910 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
911
912 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
913
914 Ok(())
915 }
916 }
917
918 unsafe impl<___E>
919 ::fidl_next::EncodeOption<
920 ::fidl_next::wire::Box<'static, crate::wire::DirectoryDeprecatedGetTokenResponse>,
921 ___E,
922 > for DirectoryDeprecatedGetTokenResponse
923 where
924 ___E: ::fidl_next::Encoder + ?Sized,
925 DirectoryDeprecatedGetTokenResponse:
926 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedGetTokenResponse, ___E>,
927 {
928 #[inline]
929 fn encode_option(
930 this: ::core::option::Option<Self>,
931 encoder: &mut ___E,
932 out: &mut ::core::mem::MaybeUninit<
933 ::fidl_next::wire::Box<'static, crate::wire::DirectoryDeprecatedGetTokenResponse>,
934 >,
935 _: (),
936 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
937 if let Some(inner) = this {
938 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
939 ::fidl_next::wire::Box::encode_present(out);
940 } else {
941 ::fidl_next::wire::Box::encode_absent(out);
942 }
943
944 Ok(())
945 }
946 }
947
948 impl ::fidl_next::FromWire<crate::wire::DirectoryDeprecatedGetTokenResponse>
949 for DirectoryDeprecatedGetTokenResponse
950 {
951 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
952 crate::wire::DirectoryDeprecatedGetTokenResponse,
953 Self,
954 > = unsafe {
955 ::fidl_next::CopyOptimization::enable_if(
956 true
957
958 && <
959 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::StatusResult>
960 >::COPY_OPTIMIZATION.is_enabled()
961
962 && <
963 ::core::option::Option<::fdomain_client::NullableHandle> as ::fidl_next::FromWire<::fdomain_client::fidl_next::wire::OptionalHandle>
964 >::COPY_OPTIMIZATION.is_enabled()
965
966 )
967 };
968
969 #[inline]
970 fn from_wire(wire: crate::wire::DirectoryDeprecatedGetTokenResponse) -> Self {
971 Self {
972 s: ::fidl_next::FromWire::from_wire(wire.s),
973
974 token: ::fidl_next::FromWire::from_wire(wire.token),
975 }
976 }
977 }
978
979 #[doc = " Auxiliary data for the file representation of a node.\n"]
980 #[derive(Debug, Default, PartialEq)]
981 pub struct FileInfo {
982 pub is_append: ::core::option::Option<bool>,
983
984 pub observer: ::core::option::Option<::fdomain_client::Event>,
985
986 pub stream: ::core::option::Option<::fdomain_client::Stream>,
987
988 pub attributes: ::core::option::Option<crate::natural::NodeAttributes2>,
989 }
990
991 impl FileInfo {
992 fn __max_ordinal(&self) -> usize {
993 if self.attributes.is_some() {
994 return 4;
995 }
996
997 if self.stream.is_some() {
998 return 3;
999 }
1000
1001 if self.observer.is_some() {
1002 return 2;
1003 }
1004
1005 if self.is_append.is_some() {
1006 return 1;
1007 }
1008
1009 0
1010 }
1011 }
1012
1013 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileInfo<'static>, ___E> for FileInfo
1014 where
1015 ___E: ::fidl_next::Encoder + ?Sized,
1016 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1017 {
1018 #[inline]
1019 fn encode(
1020 mut self,
1021 encoder: &mut ___E,
1022 out: &mut ::core::mem::MaybeUninit<crate::wire::FileInfo<'static>>,
1023 _: (),
1024 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1025 ::fidl_next::munge!(let crate::wire::FileInfo { table } = out);
1026
1027 let max_ord = self.__max_ordinal();
1028
1029 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1030 ::fidl_next::Wire::zero_padding(&mut out);
1031
1032 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1033 ::fidl_next::wire::Envelope,
1034 >(encoder, max_ord);
1035
1036 for i in 1..=max_ord {
1037 match i {
1038 4 => {
1039 if let Some(value) = self.attributes.take() {
1040 ::fidl_next::wire::Envelope::encode_value::<
1041 crate::wire::NodeAttributes2<'static>,
1042 ___E,
1043 >(
1044 value, preallocated.encoder, &mut out, ()
1045 )?;
1046 } else {
1047 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1048 }
1049 }
1050
1051 3 => {
1052 if let Some(value) = self.stream.take() {
1053 ::fidl_next::wire::Envelope::encode_value::<
1054 ::fdomain_client::fidl_next::wire::Handle,
1055 ___E,
1056 >(
1057 value, preallocated.encoder, &mut out, ()
1058 )?;
1059 } else {
1060 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1061 }
1062 }
1063
1064 2 => {
1065 if let Some(value) = self.observer.take() {
1066 ::fidl_next::wire::Envelope::encode_value::<
1067 ::fdomain_client::fidl_next::wire::Handle,
1068 ___E,
1069 >(
1070 value, preallocated.encoder, &mut out, ()
1071 )?;
1072 } else {
1073 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1074 }
1075 }
1076
1077 1 => {
1078 if let Some(value) = self.is_append.take() {
1079 ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
1080 value,
1081 preallocated.encoder,
1082 &mut out,
1083 (),
1084 )?;
1085 } else {
1086 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1087 }
1088 }
1089
1090 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1091 }
1092 unsafe {
1093 preallocated.write_next(out.assume_init_ref());
1094 }
1095 }
1096
1097 ::fidl_next::wire::Table::encode_len(table, max_ord);
1098
1099 Ok(())
1100 }
1101 }
1102
1103 impl<'de> ::fidl_next::FromWire<crate::wire::FileInfo<'de>> for FileInfo {
1104 #[inline]
1105 fn from_wire(wire_: crate::wire::FileInfo<'de>) -> Self {
1106 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1107
1108 let is_append = wire_.table.get(1);
1109
1110 let observer = wire_.table.get(2);
1111
1112 let stream = wire_.table.get(3);
1113
1114 let attributes = wire_.table.get(4);
1115
1116 Self {
1117 is_append: is_append.map(|envelope| {
1118 ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
1119 }),
1120
1121 observer: observer.map(|envelope| {
1122 ::fidl_next::FromWire::from_wire(unsafe {
1123 envelope.read_unchecked::<::fdomain_client::fidl_next::wire::Handle>()
1124 })
1125 }),
1126
1127 stream: stream.map(|envelope| {
1128 ::fidl_next::FromWire::from_wire(unsafe {
1129 envelope.read_unchecked::<::fdomain_client::fidl_next::wire::Handle>()
1130 })
1131 }),
1132
1133 attributes: attributes.map(|envelope| {
1134 ::fidl_next::FromWire::from_wire(unsafe {
1135 envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
1136 })
1137 }),
1138 }
1139 }
1140 }
1141
1142 #[derive(Debug, PartialEq)]
1143 pub enum Representation {
1144 Node(crate::natural::NodeInfo),
1145
1146 Directory(crate::natural::DirectoryInfo),
1147
1148 File(crate::natural::FileInfo),
1149
1150 Symlink(crate::natural::SymlinkInfo),
1151
1152 UnknownOrdinal_(u64),
1153 }
1154
1155 impl Representation {
1156 pub fn is_unknown(&self) -> bool {
1157 #[allow(unreachable_patterns)]
1158 match self {
1159 Self::UnknownOrdinal_(_) => true,
1160 _ => false,
1161 }
1162 }
1163 }
1164
1165 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Representation<'static>, ___E> for Representation
1166 where
1167 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1168 ___E: ::fidl_next::Encoder,
1169 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1170 {
1171 #[inline]
1172 fn encode(
1173 self,
1174 encoder: &mut ___E,
1175 out: &mut ::core::mem::MaybeUninit<crate::wire::Representation<'static>>,
1176 _: (),
1177 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1178 ::fidl_next::munge!(let crate::wire::Representation { raw, _phantom: _ } = out);
1179
1180 match self {
1181 Self::Node(value) => ::fidl_next::wire::Union::encode_as::<
1182 ___E,
1183 crate::wire::NodeInfo<'static>,
1184 >(value, 1, encoder, raw, ())?,
1185
1186 Self::Directory(value) => ::fidl_next::wire::Union::encode_as::<
1187 ___E,
1188 crate::wire::DirectoryInfo<'static>,
1189 >(value, 2, encoder, raw, ())?,
1190
1191 Self::File(value) => ::fidl_next::wire::Union::encode_as::<
1192 ___E,
1193 crate::wire::FileInfo<'static>,
1194 >(value, 3, encoder, raw, ())?,
1195
1196 Self::Symlink(value) => ::fidl_next::wire::Union::encode_as::<
1197 ___E,
1198 crate::wire::SymlinkInfo<'static>,
1199 >(value, 4, encoder, raw, ())?,
1200
1201 Self::UnknownOrdinal_(ordinal) => {
1202 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
1203 }
1204 }
1205
1206 Ok(())
1207 }
1208 }
1209
1210 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::Representation<'static>, ___E>
1211 for Representation
1212 where
1213 ___E: ?Sized,
1214 Representation: ::fidl_next::Encode<crate::wire::Representation<'static>, ___E>,
1215 {
1216 #[inline]
1217 fn encode_option(
1218 this: ::core::option::Option<Self>,
1219 encoder: &mut ___E,
1220 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::Representation<'static>>,
1221 _: (),
1222 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1223 ::fidl_next::munge!(let crate::wire_optional::Representation { raw, _phantom: _ } = &mut *out);
1224
1225 if let Some(inner) = this {
1226 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
1227 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
1228 } else {
1229 ::fidl_next::wire::Union::encode_absent(raw);
1230 }
1231
1232 Ok(())
1233 }
1234 }
1235
1236 impl<'de> ::fidl_next::FromWire<crate::wire::Representation<'de>> for Representation {
1237 #[inline]
1238 fn from_wire(wire: crate::wire::Representation<'de>) -> Self {
1239 let wire = ::core::mem::ManuallyDrop::new(wire);
1240 match wire.raw.ordinal() {
1241 1 => Self::Node(::fidl_next::FromWire::from_wire(unsafe {
1242 wire.raw.get().read_unchecked::<crate::wire::NodeInfo<'de>>()
1243 })),
1244
1245 2 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
1246 wire.raw.get().read_unchecked::<crate::wire::DirectoryInfo<'de>>()
1247 })),
1248
1249 3 => Self::File(::fidl_next::FromWire::from_wire(unsafe {
1250 wire.raw.get().read_unchecked::<crate::wire::FileInfo<'de>>()
1251 })),
1252
1253 4 => Self::Symlink(::fidl_next::FromWire::from_wire(unsafe {
1254 wire.raw.get().read_unchecked::<crate::wire::SymlinkInfo<'de>>()
1255 })),
1256
1257 ord => return Self::UnknownOrdinal_(ord as u64),
1258 }
1259 }
1260 }
1261
1262 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Representation<'de>>
1263 for Representation
1264 {
1265 #[inline]
1266 fn from_wire_option(
1267 wire: crate::wire_optional::Representation<'de>,
1268 ) -> ::core::option::Option<Self> {
1269 if let Some(inner) = wire.into_option() {
1270 Some(::fidl_next::FromWire::from_wire(inner))
1271 } else {
1272 None
1273 }
1274 }
1275 }
1276
1277 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Representation<'de>>
1278 for Box<Representation>
1279 {
1280 #[inline]
1281 fn from_wire_option(
1282 wire: crate::wire_optional::Representation<'de>,
1283 ) -> ::core::option::Option<Self> {
1284 <Representation as ::fidl_next::FromWireOption<
1285 crate::wire_optional::Representation<'de>,
1286 >>::from_wire_option(wire)
1287 .map(Box::new)
1288 }
1289 }
1290
1291 #[derive(Debug, PartialEq)]
1292 pub struct OpenableOpenRequest {
1293 pub path: ::std::string::String,
1294
1295 pub flags: crate::natural::Flags,
1296
1297 pub options: crate::natural::Options,
1298
1299 pub object: ::fdomain_client::Channel,
1300 }
1301
1302 unsafe impl<___E> ::fidl_next::Encode<crate::wire::OpenableOpenRequest<'static>, ___E>
1303 for OpenableOpenRequest
1304 where
1305 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1306 ___E: ::fidl_next::Encoder,
1307 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1308 {
1309 #[inline]
1310 fn encode(
1311 self,
1312 encoder_: &mut ___E,
1313 out_: &mut ::core::mem::MaybeUninit<crate::wire::OpenableOpenRequest<'static>>,
1314 _: (),
1315 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1316 ::fidl_next::munge! {
1317 let crate::wire::OpenableOpenRequest {
1318 path,
1319 flags,
1320 options,
1321 object,
1322
1323 } = out_;
1324 }
1325
1326 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
1327
1328 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
1329 ::fidl_next::Constrained::validate(_field, 4095)?;
1330
1331 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
1332
1333 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
1334
1335 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
1336
1337 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
1338
1339 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
1340
1341 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
1342
1343 Ok(())
1344 }
1345 }
1346
1347 unsafe impl<___E>
1348 ::fidl_next::EncodeOption<
1349 ::fidl_next::wire::Box<'static, crate::wire::OpenableOpenRequest<'static>>,
1350 ___E,
1351 > for OpenableOpenRequest
1352 where
1353 ___E: ::fidl_next::Encoder + ?Sized,
1354 OpenableOpenRequest: ::fidl_next::Encode<crate::wire::OpenableOpenRequest<'static>, ___E>,
1355 {
1356 #[inline]
1357 fn encode_option(
1358 this: ::core::option::Option<Self>,
1359 encoder: &mut ___E,
1360 out: &mut ::core::mem::MaybeUninit<
1361 ::fidl_next::wire::Box<'static, crate::wire::OpenableOpenRequest<'static>>,
1362 >,
1363 _: (),
1364 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1365 if let Some(inner) = this {
1366 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1367 ::fidl_next::wire::Box::encode_present(out);
1368 } else {
1369 ::fidl_next::wire::Box::encode_absent(out);
1370 }
1371
1372 Ok(())
1373 }
1374 }
1375
1376 impl<'de> ::fidl_next::FromWire<crate::wire::OpenableOpenRequest<'de>> for OpenableOpenRequest {
1377 #[inline]
1378 fn from_wire(wire: crate::wire::OpenableOpenRequest<'de>) -> Self {
1379 Self {
1380 path: ::fidl_next::FromWire::from_wire(wire.path),
1381
1382 flags: ::fidl_next::FromWire::from_wire(wire.flags),
1383
1384 options: ::fidl_next::FromWire::from_wire(wire.options),
1385
1386 object: ::fidl_next::FromWire::from_wire(wire.object),
1387 }
1388 }
1389 }
1390
1391 #[derive(Debug, PartialEq)]
1392 pub struct NodeOnOpenRequest {
1393 pub s: ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status>,
1394
1395 pub info: ::core::option::Option<::std::boxed::Box<crate::natural::NodeInfoDeprecated>>,
1396 }
1397
1398 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeOnOpenRequest<'static>, ___E>
1399 for NodeOnOpenRequest
1400 where
1401 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1402 ___E: ::fidl_next::Encoder,
1403 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1404 {
1405 #[inline]
1406 fn encode(
1407 self,
1408 encoder_: &mut ___E,
1409 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeOnOpenRequest<'static>>,
1410 _: (),
1411 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1412 ::fidl_next::munge! {
1413 let crate::wire::NodeOnOpenRequest {
1414 s,
1415 info,
1416
1417 } = out_;
1418 }
1419
1420 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
1421
1422 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
1423
1424 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
1425
1426 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
1427
1428 Ok(())
1429 }
1430 }
1431
1432 unsafe impl<___E>
1433 ::fidl_next::EncodeOption<
1434 ::fidl_next::wire::Box<'static, crate::wire::NodeOnOpenRequest<'static>>,
1435 ___E,
1436 > for NodeOnOpenRequest
1437 where
1438 ___E: ::fidl_next::Encoder + ?Sized,
1439 NodeOnOpenRequest: ::fidl_next::Encode<crate::wire::NodeOnOpenRequest<'static>, ___E>,
1440 {
1441 #[inline]
1442 fn encode_option(
1443 this: ::core::option::Option<Self>,
1444 encoder: &mut ___E,
1445 out: &mut ::core::mem::MaybeUninit<
1446 ::fidl_next::wire::Box<'static, crate::wire::NodeOnOpenRequest<'static>>,
1447 >,
1448 _: (),
1449 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1450 if let Some(inner) = this {
1451 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1452 ::fidl_next::wire::Box::encode_present(out);
1453 } else {
1454 ::fidl_next::wire::Box::encode_absent(out);
1455 }
1456
1457 Ok(())
1458 }
1459 }
1460
1461 impl<'de> ::fidl_next::FromWire<crate::wire::NodeOnOpenRequest<'de>> for NodeOnOpenRequest {
1462 #[inline]
1463 fn from_wire(wire: crate::wire::NodeOnOpenRequest<'de>) -> Self {
1464 Self {
1465 s: ::fidl_next::FromWire::from_wire(wire.s),
1466
1467 info: ::fidl_next::FromWire::from_wire(wire.info),
1468 }
1469 }
1470 }
1471
1472 #[derive(Debug, PartialEq)]
1473 pub struct DirectoryDeprecatedOpenRequest {
1474 pub flags: crate::natural::OpenFlags,
1475
1476 pub mode: crate::natural::ModeType,
1477
1478 pub path: ::std::string::String,
1479
1480 pub object: ::fidl_next::ServerEnd<crate::Node, ::fdomain_client::Channel>,
1481 }
1482
1483 unsafe impl<___E>
1484 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedOpenRequest<'static>, ___E>
1485 for DirectoryDeprecatedOpenRequest
1486 where
1487 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1488 ___E: ::fidl_next::Encoder,
1489 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1490 {
1491 #[inline]
1492 fn encode(
1493 self,
1494 encoder_: &mut ___E,
1495 out_: &mut ::core::mem::MaybeUninit<
1496 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
1497 >,
1498 _: (),
1499 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1500 ::fidl_next::munge! {
1501 let crate::wire::DirectoryDeprecatedOpenRequest {
1502 flags,
1503 mode,
1504 path,
1505 object,
1506
1507 } = out_;
1508 }
1509
1510 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
1511
1512 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
1513
1514 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
1515
1516 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
1517
1518 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
1519
1520 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
1521 ::fidl_next::Constrained::validate(_field, 4095)?;
1522
1523 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
1524
1525 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
1526
1527 Ok(())
1528 }
1529 }
1530
1531 unsafe impl<___E>
1532 ::fidl_next::EncodeOption<
1533 ::fidl_next::wire::Box<'static, crate::wire::DirectoryDeprecatedOpenRequest<'static>>,
1534 ___E,
1535 > for DirectoryDeprecatedOpenRequest
1536 where
1537 ___E: ::fidl_next::Encoder + ?Sized,
1538 DirectoryDeprecatedOpenRequest:
1539 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedOpenRequest<'static>, ___E>,
1540 {
1541 #[inline]
1542 fn encode_option(
1543 this: ::core::option::Option<Self>,
1544 encoder: &mut ___E,
1545 out: &mut ::core::mem::MaybeUninit<
1546 ::fidl_next::wire::Box<
1547 'static,
1548 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
1549 >,
1550 >,
1551 _: (),
1552 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1553 if let Some(inner) = this {
1554 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1555 ::fidl_next::wire::Box::encode_present(out);
1556 } else {
1557 ::fidl_next::wire::Box::encode_absent(out);
1558 }
1559
1560 Ok(())
1561 }
1562 }
1563
1564 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryDeprecatedOpenRequest<'de>>
1565 for DirectoryDeprecatedOpenRequest
1566 {
1567 #[inline]
1568 fn from_wire(wire: crate::wire::DirectoryDeprecatedOpenRequest<'de>) -> Self {
1569 Self {
1570 flags: ::fidl_next::FromWire::from_wire(wire.flags),
1571
1572 mode: ::fidl_next::FromWire::from_wire(wire.mode),
1573
1574 path: ::fidl_next::FromWire::from_wire(wire.path),
1575
1576 object: ::fidl_next::FromWire::from_wire(wire.object),
1577 }
1578 }
1579 }
1580
1581 #[derive(Debug, PartialEq)]
1582 pub struct DirectoryCreateSymlinkRequest {
1583 pub name: ::std::string::String,
1584
1585 pub target: ::std::vec::Vec<u8>,
1586
1587 pub connection: ::core::option::Option<
1588 ::fidl_next::ServerEnd<crate::Symlink, ::fdomain_client::Channel>,
1589 >,
1590 }
1591
1592 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkRequest<'static>, ___E>
1593 for DirectoryCreateSymlinkRequest
1594 where
1595 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1596 ___E: ::fidl_next::Encoder,
1597 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1598 {
1599 #[inline]
1600 fn encode(
1601 self,
1602 encoder_: &mut ___E,
1603 out_: &mut ::core::mem::MaybeUninit<
1604 crate::wire::DirectoryCreateSymlinkRequest<'static>,
1605 >,
1606 _: (),
1607 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1608 ::fidl_next::munge! {
1609 let crate::wire::DirectoryCreateSymlinkRequest {
1610 name,
1611 target,
1612 connection,
1613
1614 } = out_;
1615 }
1616
1617 ::fidl_next::Encode::encode(self.name, encoder_, name, 255)?;
1618
1619 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
1620 ::fidl_next::Constrained::validate(_field, 255)?;
1621
1622 ::fidl_next::Encode::encode(self.target, encoder_, target, (4095, ()))?;
1623
1624 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(target.as_mut_ptr()) };
1625 ::fidl_next::Constrained::validate(_field, (4095, ()))?;
1626
1627 ::fidl_next::Encode::encode(self.connection, encoder_, connection, ())?;
1628
1629 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(connection.as_mut_ptr()) };
1630
1631 Ok(())
1632 }
1633 }
1634
1635 unsafe impl<___E>
1636 ::fidl_next::EncodeOption<
1637 ::fidl_next::wire::Box<'static, crate::wire::DirectoryCreateSymlinkRequest<'static>>,
1638 ___E,
1639 > for DirectoryCreateSymlinkRequest
1640 where
1641 ___E: ::fidl_next::Encoder + ?Sized,
1642 DirectoryCreateSymlinkRequest:
1643 ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkRequest<'static>, ___E>,
1644 {
1645 #[inline]
1646 fn encode_option(
1647 this: ::core::option::Option<Self>,
1648 encoder: &mut ___E,
1649 out: &mut ::core::mem::MaybeUninit<
1650 ::fidl_next::wire::Box<
1651 'static,
1652 crate::wire::DirectoryCreateSymlinkRequest<'static>,
1653 >,
1654 >,
1655 _: (),
1656 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1657 if let Some(inner) = this {
1658 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1659 ::fidl_next::wire::Box::encode_present(out);
1660 } else {
1661 ::fidl_next::wire::Box::encode_absent(out);
1662 }
1663
1664 Ok(())
1665 }
1666 }
1667
1668 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryCreateSymlinkRequest<'de>>
1669 for DirectoryCreateSymlinkRequest
1670 {
1671 #[inline]
1672 fn from_wire(wire: crate::wire::DirectoryCreateSymlinkRequest<'de>) -> Self {
1673 Self {
1674 name: ::fidl_next::FromWire::from_wire(wire.name),
1675
1676 target: ::fidl_next::FromWire::from_wire(wire.target),
1677
1678 connection: ::fidl_next::FromWire::from_wire(wire.connection),
1679 }
1680 }
1681 }
1682
1683 #[derive(Debug, PartialEq)]
1684 #[repr(C)]
1685 pub struct FileGetBackingMemoryResponse {
1686 pub vmo: ::fdomain_client::Vmo,
1687 }
1688
1689 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryResponse, ___E>
1690 for FileGetBackingMemoryResponse
1691 where
1692 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1693 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1694 {
1695 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1696 Self,
1697 crate::wire::FileGetBackingMemoryResponse,
1698 > = unsafe {
1699 ::fidl_next::CopyOptimization::enable_if(
1700 true && <::fdomain_client::Vmo as ::fidl_next::Encode<
1701 ::fdomain_client::fidl_next::wire::Handle,
1702 ___E,
1703 >>::COPY_OPTIMIZATION
1704 .is_enabled(),
1705 )
1706 };
1707
1708 #[inline]
1709 fn encode(
1710 self,
1711 encoder_: &mut ___E,
1712 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryResponse>,
1713 _: (),
1714 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1715 ::fidl_next::munge! {
1716 let crate::wire::FileGetBackingMemoryResponse {
1717 vmo,
1718
1719 } = out_;
1720 }
1721
1722 ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
1723
1724 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vmo.as_mut_ptr()) };
1725
1726 Ok(())
1727 }
1728 }
1729
1730 unsafe impl<___E>
1731 ::fidl_next::EncodeOption<
1732 ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryResponse>,
1733 ___E,
1734 > for FileGetBackingMemoryResponse
1735 where
1736 ___E: ::fidl_next::Encoder + ?Sized,
1737 FileGetBackingMemoryResponse:
1738 ::fidl_next::Encode<crate::wire::FileGetBackingMemoryResponse, ___E>,
1739 {
1740 #[inline]
1741 fn encode_option(
1742 this: ::core::option::Option<Self>,
1743 encoder: &mut ___E,
1744 out: &mut ::core::mem::MaybeUninit<
1745 ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryResponse>,
1746 >,
1747 _: (),
1748 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1749 if let Some(inner) = this {
1750 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1751 ::fidl_next::wire::Box::encode_present(out);
1752 } else {
1753 ::fidl_next::wire::Box::encode_absent(out);
1754 }
1755
1756 Ok(())
1757 }
1758 }
1759
1760 impl ::fidl_next::FromWire<crate::wire::FileGetBackingMemoryResponse>
1761 for FileGetBackingMemoryResponse
1762 {
1763 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1764 crate::wire::FileGetBackingMemoryResponse,
1765 Self,
1766 > = unsafe {
1767 ::fidl_next::CopyOptimization::enable_if(
1768 true && <::fdomain_client::Vmo as ::fidl_next::FromWire<
1769 ::fdomain_client::fidl_next::wire::Handle,
1770 >>::COPY_OPTIMIZATION
1771 .is_enabled(),
1772 )
1773 };
1774
1775 #[inline]
1776 fn from_wire(wire: crate::wire::FileGetBackingMemoryResponse) -> Self {
1777 Self { vmo: ::fidl_next::FromWire::from_wire(wire.vmo) }
1778 }
1779 }
1780
1781 #[derive(Debug, PartialEq)]
1782 pub struct LinkableLinkIntoRequest {
1783 pub dst_parent_token: ::fdomain_client::Event,
1784
1785 pub dst: ::std::string::String,
1786 }
1787
1788 unsafe impl<___E> ::fidl_next::Encode<crate::wire::LinkableLinkIntoRequest<'static>, ___E>
1789 for LinkableLinkIntoRequest
1790 where
1791 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1792 ___E: ::fidl_next::Encoder,
1793 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1794 {
1795 #[inline]
1796 fn encode(
1797 self,
1798 encoder_: &mut ___E,
1799 out_: &mut ::core::mem::MaybeUninit<crate::wire::LinkableLinkIntoRequest<'static>>,
1800 _: (),
1801 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1802 ::fidl_next::munge! {
1803 let crate::wire::LinkableLinkIntoRequest {
1804 dst_parent_token,
1805 dst,
1806
1807 } = out_;
1808 }
1809
1810 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
1811
1812 let mut _field =
1813 unsafe { ::fidl_next::Slot::new_unchecked(dst_parent_token.as_mut_ptr()) };
1814
1815 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
1816
1817 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dst.as_mut_ptr()) };
1818 ::fidl_next::Constrained::validate(_field, 255)?;
1819
1820 Ok(())
1821 }
1822 }
1823
1824 unsafe impl<___E>
1825 ::fidl_next::EncodeOption<
1826 ::fidl_next::wire::Box<'static, crate::wire::LinkableLinkIntoRequest<'static>>,
1827 ___E,
1828 > for LinkableLinkIntoRequest
1829 where
1830 ___E: ::fidl_next::Encoder + ?Sized,
1831 LinkableLinkIntoRequest:
1832 ::fidl_next::Encode<crate::wire::LinkableLinkIntoRequest<'static>, ___E>,
1833 {
1834 #[inline]
1835 fn encode_option(
1836 this: ::core::option::Option<Self>,
1837 encoder: &mut ___E,
1838 out: &mut ::core::mem::MaybeUninit<
1839 ::fidl_next::wire::Box<'static, crate::wire::LinkableLinkIntoRequest<'static>>,
1840 >,
1841 _: (),
1842 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1843 if let Some(inner) = this {
1844 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1845 ::fidl_next::wire::Box::encode_present(out);
1846 } else {
1847 ::fidl_next::wire::Box::encode_absent(out);
1848 }
1849
1850 Ok(())
1851 }
1852 }
1853
1854 impl<'de> ::fidl_next::FromWire<crate::wire::LinkableLinkIntoRequest<'de>>
1855 for LinkableLinkIntoRequest
1856 {
1857 #[inline]
1858 fn from_wire(wire: crate::wire::LinkableLinkIntoRequest<'de>) -> Self {
1859 Self {
1860 dst_parent_token: ::fidl_next::FromWire::from_wire(wire.dst_parent_token),
1861
1862 dst: ::fidl_next::FromWire::from_wire(wire.dst),
1863 }
1864 }
1865 }
1866
1867 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1868 pub struct FileAllocateRequest {
1869 pub offset: u64,
1870
1871 pub length: u64,
1872
1873 pub mode: crate::natural::AllocateMode,
1874 }
1875
1876 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileAllocateRequest, ___E>
1877 for FileAllocateRequest
1878 where
1879 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1880 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1881 {
1882 #[inline]
1883 fn encode(
1884 self,
1885 encoder_: &mut ___E,
1886 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileAllocateRequest>,
1887 _: (),
1888 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1889 ::fidl_next::munge! {
1890 let crate::wire::FileAllocateRequest {
1891 offset,
1892 length,
1893 mode,
1894
1895 } = out_;
1896 }
1897
1898 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
1899
1900 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
1901
1902 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
1903
1904 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
1905
1906 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
1907
1908 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
1909
1910 Ok(())
1911 }
1912 }
1913
1914 unsafe impl<___E>
1915 ::fidl_next::EncodeOption<
1916 ::fidl_next::wire::Box<'static, crate::wire::FileAllocateRequest>,
1917 ___E,
1918 > for FileAllocateRequest
1919 where
1920 ___E: ::fidl_next::Encoder + ?Sized,
1921 FileAllocateRequest: ::fidl_next::Encode<crate::wire::FileAllocateRequest, ___E>,
1922 {
1923 #[inline]
1924 fn encode_option(
1925 this: ::core::option::Option<Self>,
1926 encoder: &mut ___E,
1927 out: &mut ::core::mem::MaybeUninit<
1928 ::fidl_next::wire::Box<'static, crate::wire::FileAllocateRequest>,
1929 >,
1930 _: (),
1931 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1932 if let Some(inner) = this {
1933 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1934 ::fidl_next::wire::Box::encode_present(out);
1935 } else {
1936 ::fidl_next::wire::Box::encode_absent(out);
1937 }
1938
1939 Ok(())
1940 }
1941 }
1942
1943 impl ::fidl_next::FromWire<crate::wire::FileAllocateRequest> for FileAllocateRequest {
1944 #[inline]
1945 fn from_wire(wire: crate::wire::FileAllocateRequest) -> Self {
1946 Self {
1947 offset: ::fidl_next::FromWire::from_wire(wire.offset),
1948
1949 length: ::fidl_next::FromWire::from_wire(wire.length),
1950
1951 mode: ::fidl_next::FromWire::from_wire(wire.mode),
1952 }
1953 }
1954 }
1955
1956 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1957 pub struct FileEnableVerityRequest {
1958 pub options: crate::natural::VerificationOptions,
1959 }
1960
1961 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileEnableVerityRequest<'static>, ___E>
1962 for FileEnableVerityRequest
1963 where
1964 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1965 ___E: ::fidl_next::Encoder,
1966 ___E: ::fdomain_client::fidl_next::HandleEncoder,
1967 {
1968 #[inline]
1969 fn encode(
1970 self,
1971 encoder_: &mut ___E,
1972 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileEnableVerityRequest<'static>>,
1973 _: (),
1974 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1975 ::fidl_next::munge! {
1976 let crate::wire::FileEnableVerityRequest {
1977 options,
1978
1979 } = out_;
1980 }
1981
1982 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
1983
1984 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
1985
1986 Ok(())
1987 }
1988 }
1989
1990 unsafe impl<___E>
1991 ::fidl_next::EncodeOption<
1992 ::fidl_next::wire::Box<'static, crate::wire::FileEnableVerityRequest<'static>>,
1993 ___E,
1994 > for FileEnableVerityRequest
1995 where
1996 ___E: ::fidl_next::Encoder + ?Sized,
1997 FileEnableVerityRequest:
1998 ::fidl_next::Encode<crate::wire::FileEnableVerityRequest<'static>, ___E>,
1999 {
2000 #[inline]
2001 fn encode_option(
2002 this: ::core::option::Option<Self>,
2003 encoder: &mut ___E,
2004 out: &mut ::core::mem::MaybeUninit<
2005 ::fidl_next::wire::Box<'static, crate::wire::FileEnableVerityRequest<'static>>,
2006 >,
2007 _: (),
2008 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2009 if let Some(inner) = this {
2010 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2011 ::fidl_next::wire::Box::encode_present(out);
2012 } else {
2013 ::fidl_next::wire::Box::encode_absent(out);
2014 }
2015
2016 Ok(())
2017 }
2018 }
2019
2020 impl<'de> ::fidl_next::FromWire<crate::wire::FileEnableVerityRequest<'de>>
2021 for FileEnableVerityRequest
2022 {
2023 #[inline]
2024 fn from_wire(wire: crate::wire::FileEnableVerityRequest<'de>) -> Self {
2025 Self { options: ::fidl_next::FromWire::from_wire(wire.options) }
2026 }
2027 }
2028
2029 #[derive(Debug, PartialEq)]
2030 #[repr(C)]
2031 pub struct FileObject {
2032 pub event: ::core::option::Option<::fdomain_client::Event>,
2033
2034 pub stream: ::core::option::Option<::fdomain_client::Stream>,
2035 }
2036
2037 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileObject, ___E> for FileObject
2038 where
2039 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2040 ___E: ::fdomain_client::fidl_next::HandleEncoder,
2041 {
2042 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::FileObject> = unsafe {
2043 ::fidl_next::CopyOptimization::enable_if(
2044 true && <::core::option::Option<::fdomain_client::Event> as ::fidl_next::Encode<
2045 ::fdomain_client::fidl_next::wire::OptionalHandle,
2046 ___E,
2047 >>::COPY_OPTIMIZATION
2048 .is_enabled()
2049 && <::core::option::Option<::fdomain_client::Stream> as ::fidl_next::Encode<
2050 ::fdomain_client::fidl_next::wire::OptionalHandle,
2051 ___E,
2052 >>::COPY_OPTIMIZATION
2053 .is_enabled(),
2054 )
2055 };
2056
2057 #[inline]
2058 fn encode(
2059 self,
2060 encoder_: &mut ___E,
2061 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileObject>,
2062 _: (),
2063 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2064 ::fidl_next::munge! {
2065 let crate::wire::FileObject {
2066 event,
2067 stream,
2068
2069 } = out_;
2070 }
2071
2072 ::fidl_next::Encode::encode(self.event, encoder_, event, ())?;
2073
2074 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(event.as_mut_ptr()) };
2075
2076 ::fidl_next::Encode::encode(self.stream, encoder_, stream, ())?;
2077
2078 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(stream.as_mut_ptr()) };
2079
2080 Ok(())
2081 }
2082 }
2083
2084 unsafe impl<___E>
2085 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::FileObject>, ___E>
2086 for FileObject
2087 where
2088 ___E: ::fidl_next::Encoder + ?Sized,
2089 FileObject: ::fidl_next::Encode<crate::wire::FileObject, ___E>,
2090 {
2091 #[inline]
2092 fn encode_option(
2093 this: ::core::option::Option<Self>,
2094 encoder: &mut ___E,
2095 out: &mut ::core::mem::MaybeUninit<
2096 ::fidl_next::wire::Box<'static, crate::wire::FileObject>,
2097 >,
2098 _: (),
2099 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2100 if let Some(inner) = this {
2101 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2102 ::fidl_next::wire::Box::encode_present(out);
2103 } else {
2104 ::fidl_next::wire::Box::encode_absent(out);
2105 }
2106
2107 Ok(())
2108 }
2109 }
2110
2111 impl ::fidl_next::FromWire<crate::wire::FileObject> for FileObject {
2112 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::FileObject, Self> = unsafe {
2113 ::fidl_next::CopyOptimization::enable_if(
2114 true
2115
2116 && <
2117 ::core::option::Option<::fdomain_client::Event> as ::fidl_next::FromWire<::fdomain_client::fidl_next::wire::OptionalHandle>
2118 >::COPY_OPTIMIZATION.is_enabled()
2119
2120 && <
2121 ::core::option::Option<::fdomain_client::Stream> as ::fidl_next::FromWire<::fdomain_client::fidl_next::wire::OptionalHandle>
2122 >::COPY_OPTIMIZATION.is_enabled()
2123
2124 )
2125 };
2126
2127 #[inline]
2128 fn from_wire(wire: crate::wire::FileObject) -> Self {
2129 Self {
2130 event: ::fidl_next::FromWire::from_wire(wire.event),
2131
2132 stream: ::fidl_next::FromWire::from_wire(wire.stream),
2133 }
2134 }
2135 }
2136
2137 #[derive(Debug, PartialEq)]
2138 pub enum NodeInfoDeprecated {
2139 Service(crate::natural::Service),
2140
2141 File(crate::natural::FileObject),
2142
2143 Directory(crate::natural::DirectoryObject),
2144
2145 Symlink(crate::natural::SymlinkObject),
2146 }
2147
2148 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeInfoDeprecated<'static>, ___E>
2149 for NodeInfoDeprecated
2150 where
2151 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2152 ___E: ::fidl_next::Encoder,
2153 ___E: ::fdomain_client::fidl_next::HandleEncoder,
2154 {
2155 #[inline]
2156 fn encode(
2157 self,
2158 encoder: &mut ___E,
2159 out: &mut ::core::mem::MaybeUninit<crate::wire::NodeInfoDeprecated<'static>>,
2160 _: (),
2161 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2162 ::fidl_next::munge!(let crate::wire::NodeInfoDeprecated { raw, _phantom: _ } = out);
2163
2164 match self {
2165 Self::Service(value) => ::fidl_next::wire::Union::encode_as::<
2166 ___E,
2167 crate::wire::Service,
2168 >(value, 1, encoder, raw, ())?,
2169
2170 Self::File(value) => ::fidl_next::wire::Union::encode_as::<
2171 ___E,
2172 crate::wire::FileObject,
2173 >(value, 2, encoder, raw, ())?,
2174
2175 Self::Directory(value) => ::fidl_next::wire::Union::encode_as::<
2176 ___E,
2177 crate::wire::DirectoryObject,
2178 >(value, 3, encoder, raw, ())?,
2179
2180 Self::Symlink(value) => ::fidl_next::wire::Union::encode_as::<
2181 ___E,
2182 crate::wire::SymlinkObject<'static>,
2183 >(value, 4, encoder, raw, ())?,
2184 }
2185
2186 Ok(())
2187 }
2188 }
2189
2190 unsafe impl<___E>
2191 ::fidl_next::EncodeOption<crate::wire_optional::NodeInfoDeprecated<'static>, ___E>
2192 for NodeInfoDeprecated
2193 where
2194 ___E: ?Sized,
2195 NodeInfoDeprecated: ::fidl_next::Encode<crate::wire::NodeInfoDeprecated<'static>, ___E>,
2196 {
2197 #[inline]
2198 fn encode_option(
2199 this: ::core::option::Option<Self>,
2200 encoder: &mut ___E,
2201 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::NodeInfoDeprecated<'static>>,
2202 _: (),
2203 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2204 ::fidl_next::munge!(let crate::wire_optional::NodeInfoDeprecated { raw, _phantom: _ } = &mut *out);
2205
2206 if let Some(inner) = this {
2207 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2208 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2209 } else {
2210 ::fidl_next::wire::Union::encode_absent(raw);
2211 }
2212
2213 Ok(())
2214 }
2215 }
2216
2217 impl<'de> ::fidl_next::FromWire<crate::wire::NodeInfoDeprecated<'de>> for NodeInfoDeprecated {
2218 #[inline]
2219 fn from_wire(wire: crate::wire::NodeInfoDeprecated<'de>) -> Self {
2220 let wire = ::core::mem::ManuallyDrop::new(wire);
2221 match wire.raw.ordinal() {
2222 1 => Self::Service(::fidl_next::FromWire::from_wire(unsafe {
2223 wire.raw.get().read_unchecked::<crate::wire::Service>()
2224 })),
2225
2226 2 => Self::File(::fidl_next::FromWire::from_wire(unsafe {
2227 wire.raw.get().read_unchecked::<crate::wire::FileObject>()
2228 })),
2229
2230 3 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
2231 wire.raw.get().read_unchecked::<crate::wire::DirectoryObject>()
2232 })),
2233
2234 4 => Self::Symlink(::fidl_next::FromWire::from_wire(unsafe {
2235 wire.raw.get().read_unchecked::<crate::wire::SymlinkObject<'de>>()
2236 })),
2237
2238 _ => unsafe { ::core::hint::unreachable_unchecked() },
2239 }
2240 }
2241 }
2242
2243 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::NodeInfoDeprecated<'de>>
2244 for NodeInfoDeprecated
2245 {
2246 #[inline]
2247 fn from_wire_option(
2248 wire: crate::wire_optional::NodeInfoDeprecated<'de>,
2249 ) -> ::core::option::Option<Self> {
2250 if let Some(inner) = wire.into_option() {
2251 Some(::fidl_next::FromWire::from_wire(inner))
2252 } else {
2253 None
2254 }
2255 }
2256 }
2257
2258 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::NodeInfoDeprecated<'de>>
2259 for Box<NodeInfoDeprecated>
2260 {
2261 #[inline]
2262 fn from_wire_option(
2263 wire: crate::wire_optional::NodeInfoDeprecated<'de>,
2264 ) -> ::core::option::Option<Self> {
2265 <NodeInfoDeprecated as ::fidl_next::FromWireOption<
2266 crate::wire_optional::NodeInfoDeprecated<'de>,
2267 >>::from_wire_option(wire)
2268 .map(Box::new)
2269 }
2270 }
2271}
2272
2273pub mod wire {
2274
2275 pub use fidl_next_common_fuchsia_io::wire::*;
2276
2277 #[repr(C)]
2279 pub struct ConnectionInfo<'de> {
2280 pub(crate) table: ::fidl_next::wire::Table<'de>,
2281 }
2282
2283 impl<'de> Drop for ConnectionInfo<'de> {
2284 fn drop(&mut self) {
2285 let _ = self
2286 .table
2287 .get(1)
2288 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Operations>() });
2289 }
2290 }
2291
2292 impl ::fidl_next::Constrained for ConnectionInfo<'_> {
2293 type Constraint = ();
2294
2295 fn validate(
2296 _: ::fidl_next::Slot<'_, Self>,
2297 _: Self::Constraint,
2298 ) -> Result<(), ::fidl_next::ValidationError> {
2299 Ok(())
2300 }
2301 }
2302
2303 unsafe impl ::fidl_next::Wire for ConnectionInfo<'static> {
2304 type Narrowed<'de> = ConnectionInfo<'de>;
2305
2306 #[inline]
2307 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
2308 ::fidl_next::munge!(let Self { table } = out);
2309 ::fidl_next::wire::Table::zero_padding(table);
2310 }
2311 }
2312
2313 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConnectionInfo<'de>
2314 where
2315 ___D: ::fidl_next::Decoder<'de> + ?Sized,
2316 ___D: ::fdomain_client::fidl_next::HandleDecoder,
2317 {
2318 fn decode(
2319 slot: ::fidl_next::Slot<'_, Self>,
2320 decoder: &mut ___D,
2321 _: (),
2322 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2323 ::fidl_next::munge!(let Self { table } = slot);
2324
2325 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
2326 match ordinal {
2327 0 => unsafe { ::core::hint::unreachable_unchecked() },
2328
2329 1 => {
2330 ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Operations>(
2331 slot.as_mut(),
2332 decoder,
2333 (),
2334 )?;
2335
2336 Ok(())
2337 }
2338
2339 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
2340 }
2341 })
2342 }
2343 }
2344
2345 impl<'de> ConnectionInfo<'de> {
2346 pub fn rights(&self) -> ::core::option::Option<&crate::wire::Operations> {
2347 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
2348 }
2349
2350 pub fn take_rights(&mut self) -> ::core::option::Option<crate::wire::Operations> {
2351 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
2352 }
2353 }
2354
2355 impl<'de> ::core::fmt::Debug for ConnectionInfo<'de> {
2356 fn fmt(
2357 &self,
2358 f: &mut ::core::fmt::Formatter<'_>,
2359 ) -> ::core::result::Result<(), ::core::fmt::Error> {
2360 f.debug_struct("ConnectionInfo").field("rights", &self.rights()).finish()
2361 }
2362 }
2363
2364 impl<'de> ::fidl_next::IntoNatural for ConnectionInfo<'de> {
2365 type Natural = crate::natural::ConnectionInfo;
2366 }
2367
2368 #[derive(Debug)]
2370 #[repr(C)]
2371 pub struct DirectoryLinkRequest<'de> {
2372 pub src: ::fidl_next::wire::String<'de>,
2373
2374 pub dst_parent_token: ::fdomain_client::fidl_next::wire::Handle,
2375
2376 pub dst: ::fidl_next::wire::String<'de>,
2377 }
2378
2379 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryLinkRequest<'_>>(), 40);
2380 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryLinkRequest<'_>>(), 8);
2381
2382 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryLinkRequest<'_>, src), 0);
2383
2384 static_assertions::const_assert_eq!(
2385 std::mem::offset_of!(DirectoryLinkRequest<'_>, dst_parent_token),
2386 16
2387 );
2388
2389 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryLinkRequest<'_>, dst), 24);
2390
2391 impl ::fidl_next::Constrained for DirectoryLinkRequest<'_> {
2392 type Constraint = ();
2393
2394 fn validate(
2395 _: ::fidl_next::Slot<'_, Self>,
2396 _: Self::Constraint,
2397 ) -> Result<(), ::fidl_next::ValidationError> {
2398 Ok(())
2399 }
2400 }
2401
2402 unsafe impl ::fidl_next::Wire for DirectoryLinkRequest<'static> {
2403 type Narrowed<'de> = DirectoryLinkRequest<'de>;
2404
2405 #[inline]
2406 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2407 ::fidl_next::munge! {
2408 let Self {
2409 src,
2410 dst_parent_token,
2411 dst,
2412
2413 } = &mut *out_;
2414 }
2415
2416 ::fidl_next::Wire::zero_padding(src);
2417
2418 ::fidl_next::Wire::zero_padding(dst_parent_token);
2419
2420 ::fidl_next::Wire::zero_padding(dst);
2421
2422 unsafe {
2423 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
2424 }
2425 }
2426 }
2427
2428 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryLinkRequest<'de>
2429 where
2430 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2431 ___D: ::fidl_next::Decoder<'de>,
2432 ___D: ::fdomain_client::fidl_next::HandleDecoder,
2433 {
2434 fn decode(
2435 slot_: ::fidl_next::Slot<'_, Self>,
2436 decoder_: &mut ___D,
2437 _: (),
2438 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2439 if slot_.as_bytes()[20..24] != [0u8; 4] {
2440 return Err(::fidl_next::DecodeError::InvalidPadding);
2441 }
2442
2443 ::fidl_next::munge! {
2444 let Self {
2445 mut src,
2446 mut dst_parent_token,
2447 mut dst,
2448
2449 } = slot_;
2450 }
2451
2452 let _field = src.as_mut();
2453 ::fidl_next::Constrained::validate(_field, 255)?;
2454 ::fidl_next::Decode::decode(src.as_mut(), decoder_, 255)?;
2455
2456 let src = unsafe { src.deref_unchecked() };
2457
2458 if src.len() > 255 {
2459 return Err(::fidl_next::DecodeError::VectorTooLong {
2460 size: src.len() as u64,
2461 limit: 255,
2462 });
2463 }
2464
2465 let _field = dst_parent_token.as_mut();
2466
2467 ::fidl_next::Decode::decode(dst_parent_token.as_mut(), decoder_, ())?;
2468
2469 let _field = dst.as_mut();
2470 ::fidl_next::Constrained::validate(_field, 255)?;
2471 ::fidl_next::Decode::decode(dst.as_mut(), decoder_, 255)?;
2472
2473 let dst = unsafe { dst.deref_unchecked() };
2474
2475 if dst.len() > 255 {
2476 return Err(::fidl_next::DecodeError::VectorTooLong {
2477 size: dst.len() as u64,
2478 limit: 255,
2479 });
2480 }
2481
2482 Ok(())
2483 }
2484 }
2485
2486 impl<'de> ::fidl_next::IntoNatural for DirectoryLinkRequest<'de> {
2487 type Natural = crate::natural::DirectoryLinkRequest;
2488 }
2489
2490 pub type Token = ::fdomain_client::fidl_next::wire::Handle;
2492
2493 #[derive(Debug)]
2495 #[repr(C)]
2496 pub struct DirectoryRenameRequest<'de> {
2497 pub src: ::fidl_next::wire::String<'de>,
2498
2499 pub dst_parent_token: ::fdomain_client::fidl_next::wire::Handle,
2500
2501 pub dst: ::fidl_next::wire::String<'de>,
2502 }
2503
2504 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryRenameRequest<'_>>(), 40);
2505 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryRenameRequest<'_>>(), 8);
2506
2507 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryRenameRequest<'_>, src), 0);
2508
2509 static_assertions::const_assert_eq!(
2510 std::mem::offset_of!(DirectoryRenameRequest<'_>, dst_parent_token),
2511 16
2512 );
2513
2514 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryRenameRequest<'_>, dst), 24);
2515
2516 impl ::fidl_next::Constrained for DirectoryRenameRequest<'_> {
2517 type Constraint = ();
2518
2519 fn validate(
2520 _: ::fidl_next::Slot<'_, Self>,
2521 _: Self::Constraint,
2522 ) -> Result<(), ::fidl_next::ValidationError> {
2523 Ok(())
2524 }
2525 }
2526
2527 unsafe impl ::fidl_next::Wire for DirectoryRenameRequest<'static> {
2528 type Narrowed<'de> = DirectoryRenameRequest<'de>;
2529
2530 #[inline]
2531 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2532 ::fidl_next::munge! {
2533 let Self {
2534 src,
2535 dst_parent_token,
2536 dst,
2537
2538 } = &mut *out_;
2539 }
2540
2541 ::fidl_next::Wire::zero_padding(src);
2542
2543 ::fidl_next::Wire::zero_padding(dst_parent_token);
2544
2545 ::fidl_next::Wire::zero_padding(dst);
2546
2547 unsafe {
2548 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
2549 }
2550 }
2551 }
2552
2553 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryRenameRequest<'de>
2554 where
2555 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2556 ___D: ::fidl_next::Decoder<'de>,
2557 ___D: ::fdomain_client::fidl_next::HandleDecoder,
2558 {
2559 fn decode(
2560 slot_: ::fidl_next::Slot<'_, Self>,
2561 decoder_: &mut ___D,
2562 _: (),
2563 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2564 if slot_.as_bytes()[20..24] != [0u8; 4] {
2565 return Err(::fidl_next::DecodeError::InvalidPadding);
2566 }
2567
2568 ::fidl_next::munge! {
2569 let Self {
2570 mut src,
2571 mut dst_parent_token,
2572 mut dst,
2573
2574 } = slot_;
2575 }
2576
2577 let _field = src.as_mut();
2578 ::fidl_next::Constrained::validate(_field, 255)?;
2579 ::fidl_next::Decode::decode(src.as_mut(), decoder_, 255)?;
2580
2581 let src = unsafe { src.deref_unchecked() };
2582
2583 if src.len() > 255 {
2584 return Err(::fidl_next::DecodeError::VectorTooLong {
2585 size: src.len() as u64,
2586 limit: 255,
2587 });
2588 }
2589
2590 let _field = dst_parent_token.as_mut();
2591
2592 ::fidl_next::Decode::decode(dst_parent_token.as_mut(), decoder_, ())?;
2593
2594 let _field = dst.as_mut();
2595 ::fidl_next::Constrained::validate(_field, 255)?;
2596 ::fidl_next::Decode::decode(dst.as_mut(), decoder_, 255)?;
2597
2598 let dst = unsafe { dst.deref_unchecked() };
2599
2600 if dst.len() > 255 {
2601 return Err(::fidl_next::DecodeError::VectorTooLong {
2602 size: dst.len() as u64,
2603 limit: 255,
2604 });
2605 }
2606
2607 Ok(())
2608 }
2609 }
2610
2611 impl<'de> ::fidl_next::IntoNatural for DirectoryRenameRequest<'de> {
2612 type Natural = crate::natural::DirectoryRenameRequest;
2613 }
2614
2615 #[derive(Debug)]
2617 #[repr(C)]
2618 pub struct DirectoryWatchRequest {
2619 pub mask: crate::wire::WatchMask,
2620
2621 pub options: ::fidl_next::wire::Uint32,
2622
2623 pub watcher: ::fidl_next::ServerEnd<
2624 crate::DirectoryWatcher,
2625 ::fdomain_client::fidl_next::wire::Handle,
2626 >,
2627 }
2628
2629 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryWatchRequest>(), 12);
2630 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryWatchRequest>(), 4);
2631
2632 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryWatchRequest, mask), 0);
2633
2634 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryWatchRequest, options), 4);
2635
2636 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryWatchRequest, watcher), 8);
2637
2638 impl ::fidl_next::Constrained for DirectoryWatchRequest {
2639 type Constraint = ();
2640
2641 fn validate(
2642 _: ::fidl_next::Slot<'_, Self>,
2643 _: Self::Constraint,
2644 ) -> Result<(), ::fidl_next::ValidationError> {
2645 Ok(())
2646 }
2647 }
2648
2649 unsafe impl ::fidl_next::Wire for DirectoryWatchRequest {
2650 type Narrowed<'de> = DirectoryWatchRequest;
2651
2652 #[inline]
2653 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2654 ::fidl_next::munge! {
2655 let Self {
2656 mask,
2657 options,
2658 watcher,
2659
2660 } = &mut *out_;
2661 }
2662
2663 ::fidl_next::Wire::zero_padding(mask);
2664
2665 ::fidl_next::Wire::zero_padding(options);
2666
2667 ::fidl_next::Wire::zero_padding(watcher);
2668 }
2669 }
2670
2671 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryWatchRequest
2672 where
2673 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2674 ___D: ::fdomain_client::fidl_next::HandleDecoder,
2675 {
2676 fn decode(
2677 slot_: ::fidl_next::Slot<'_, Self>,
2678 decoder_: &mut ___D,
2679 _: (),
2680 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2681 ::fidl_next::munge! {
2682 let Self {
2683 mut mask,
2684 mut options,
2685 mut watcher,
2686
2687 } = slot_;
2688 }
2689
2690 let _field = mask.as_mut();
2691
2692 ::fidl_next::Decode::decode(mask.as_mut(), decoder_, ())?;
2693
2694 let _field = options.as_mut();
2695
2696 ::fidl_next::Decode::decode(options.as_mut(), decoder_, ())?;
2697
2698 let _field = watcher.as_mut();
2699
2700 ::fidl_next::Decode::decode(watcher.as_mut(), decoder_, ())?;
2701
2702 Ok(())
2703 }
2704 }
2705
2706 impl ::fidl_next::IntoNatural for DirectoryWatchRequest {
2707 type Natural = crate::natural::DirectoryWatchRequest;
2708 }
2709
2710 #[derive(Debug)]
2712 #[repr(C)]
2713 pub struct NodeListExtendedAttributesRequest {
2714 pub iterator: ::fidl_next::ServerEnd<
2715 crate::ExtendedAttributeIterator,
2716 ::fdomain_client::fidl_next::wire::Handle,
2717 >,
2718 }
2719
2720 static_assertions::const_assert_eq!(
2721 std::mem::size_of::<NodeListExtendedAttributesRequest>(),
2722 4
2723 );
2724 static_assertions::const_assert_eq!(
2725 std::mem::align_of::<NodeListExtendedAttributesRequest>(),
2726 4
2727 );
2728
2729 static_assertions::const_assert_eq!(
2730 std::mem::offset_of!(NodeListExtendedAttributesRequest, iterator),
2731 0
2732 );
2733
2734 impl ::fidl_next::Constrained for NodeListExtendedAttributesRequest {
2735 type Constraint = ();
2736
2737 fn validate(
2738 _: ::fidl_next::Slot<'_, Self>,
2739 _: Self::Constraint,
2740 ) -> Result<(), ::fidl_next::ValidationError> {
2741 Ok(())
2742 }
2743 }
2744
2745 unsafe impl ::fidl_next::Wire for NodeListExtendedAttributesRequest {
2746 type Narrowed<'de> = NodeListExtendedAttributesRequest;
2747
2748 #[inline]
2749 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2750 ::fidl_next::munge! {
2751 let Self {
2752 iterator,
2753
2754 } = &mut *out_;
2755 }
2756
2757 ::fidl_next::Wire::zero_padding(iterator);
2758 }
2759 }
2760
2761 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeListExtendedAttributesRequest
2762 where
2763 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2764 ___D: ::fdomain_client::fidl_next::HandleDecoder,
2765 {
2766 fn decode(
2767 slot_: ::fidl_next::Slot<'_, Self>,
2768 decoder_: &mut ___D,
2769 _: (),
2770 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2771 ::fidl_next::munge! {
2772 let Self {
2773 mut iterator,
2774
2775 } = slot_;
2776 }
2777
2778 let _field = iterator.as_mut();
2779
2780 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
2781
2782 Ok(())
2783 }
2784 }
2785
2786 impl ::fidl_next::IntoNatural for NodeListExtendedAttributesRequest {
2787 type Natural = crate::natural::NodeListExtendedAttributesRequest;
2788 }
2789
2790 #[repr(transparent)]
2792 pub struct ExtendedAttributeValue<'de> {
2793 pub(crate) raw: ::fidl_next::wire::Union,
2794 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
2795 }
2796
2797 impl<'de> Drop for ExtendedAttributeValue<'de> {
2798 fn drop(&mut self) {
2799 match self.raw.ordinal() {
2800 1 => {
2801 let _ = unsafe {
2802 self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
2803 };
2804 }
2805
2806 2 => {
2807 let _ = unsafe {
2808 self.raw.get().read_unchecked::<::fdomain_client::fidl_next::wire::Handle>()
2809 };
2810 }
2811
2812 _ => (),
2813 }
2814 }
2815 }
2816
2817 impl ::fidl_next::Constrained for ExtendedAttributeValue<'_> {
2818 type Constraint = ();
2819
2820 fn validate(
2821 _: ::fidl_next::Slot<'_, Self>,
2822 _: Self::Constraint,
2823 ) -> Result<(), ::fidl_next::ValidationError> {
2824 Ok(())
2825 }
2826 }
2827
2828 unsafe impl ::fidl_next::Wire for ExtendedAttributeValue<'static> {
2829 type Narrowed<'de> = ExtendedAttributeValue<'de>;
2830
2831 #[inline]
2832 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
2833 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
2834 ::fidl_next::wire::Union::zero_padding(raw);
2835 }
2836 }
2837
2838 pub mod extended_attribute_value {
2839 pub enum Ref<'de> {
2840 Bytes(&'de ::fidl_next::wire::Vector<'de, u8>),
2841
2842 Buffer(&'de ::fdomain_client::fidl_next::wire::Handle),
2843
2844 UnknownOrdinal_(u64),
2845 }
2846
2847 pub enum Value<'de> {
2848 Bytes(::fidl_next::wire::Vector<'de, u8>),
2849
2850 Buffer(::fdomain_client::fidl_next::wire::Handle),
2851
2852 UnknownOrdinal_(u64),
2853 }
2854 }
2855
2856 impl<'de> ExtendedAttributeValue<'de> {
2857 pub fn as_ref(&self) -> crate::wire::extended_attribute_value::Ref<'_> {
2858 match self.raw.ordinal() {
2859 1 => crate::wire::extended_attribute_value::Ref::Bytes(unsafe {
2860 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
2861 }),
2862
2863 2 => crate::wire::extended_attribute_value::Ref::Buffer(unsafe {
2864 self.raw.get().deref_unchecked::<::fdomain_client::fidl_next::wire::Handle>()
2865 }),
2866
2867 unknown => crate::wire::extended_attribute_value::Ref::UnknownOrdinal_(unknown),
2868 }
2869 }
2870
2871 pub fn into_inner(self) -> crate::wire::extended_attribute_value::Value<'de> {
2872 let this = ::core::mem::ManuallyDrop::new(self);
2873
2874 match this.raw.ordinal() {
2875 1 => crate::wire::extended_attribute_value::Value::Bytes(unsafe {
2876 this.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
2877 }),
2878
2879 2 => crate::wire::extended_attribute_value::Value::Buffer(unsafe {
2880 this.raw.get().read_unchecked::<::fdomain_client::fidl_next::wire::Handle>()
2881 }),
2882
2883 unknown => crate::wire::extended_attribute_value::Value::UnknownOrdinal_(unknown),
2884 }
2885 }
2886 }
2887
2888 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExtendedAttributeValue<'de>
2889 where
2890 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2891 ___D: ::fidl_next::Decoder<'de>,
2892 ___D: ::fdomain_client::fidl_next::HandleDecoder,
2893 {
2894 fn decode(
2895 mut slot: ::fidl_next::Slot<'_, Self>,
2896 decoder: &mut ___D,
2897 _: (),
2898 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2899 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
2900 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
2901 1 => {
2902 ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
2903 raw,
2904 decoder,
2905 (32768, ()),
2906 )?
2907 }
2908
2909 2 => ::fidl_next::wire::Union::decode_as::<
2910 ___D,
2911 ::fdomain_client::fidl_next::wire::Handle,
2912 >(raw, decoder, ())?,
2913
2914 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
2915 }
2916
2917 Ok(())
2918 }
2919 }
2920
2921 impl<'de> ::core::fmt::Debug for ExtendedAttributeValue<'de> {
2922 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2923 match self.raw.ordinal() {
2924 1 => unsafe {
2925 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>().fmt(f)
2926 },
2927 2 => unsafe {
2928 self.raw
2929 .get()
2930 .deref_unchecked::<::fdomain_client::fidl_next::wire::Handle>()
2931 .fmt(f)
2932 },
2933 _ => unsafe { ::core::hint::unreachable_unchecked() },
2934 }
2935 }
2936 }
2937
2938 impl<'de> ::fidl_next::IntoNatural for ExtendedAttributeValue<'de> {
2939 type Natural = crate::natural::ExtendedAttributeValue;
2940 }
2941
2942 #[derive(Debug)]
2944 #[repr(C)]
2945 pub struct NodeSetExtendedAttributeRequest<'de> {
2946 pub name: ::fidl_next::wire::Vector<'de, u8>,
2947
2948 pub value: crate::wire::ExtendedAttributeValue<'de>,
2949
2950 pub mode: crate::wire::SetExtendedAttributeMode,
2951 }
2952
2953 static_assertions::const_assert_eq!(
2954 std::mem::size_of::<NodeSetExtendedAttributeRequest<'_>>(),
2955 40
2956 );
2957 static_assertions::const_assert_eq!(
2958 std::mem::align_of::<NodeSetExtendedAttributeRequest<'_>>(),
2959 8
2960 );
2961
2962 static_assertions::const_assert_eq!(
2963 std::mem::offset_of!(NodeSetExtendedAttributeRequest<'_>, name),
2964 0
2965 );
2966
2967 static_assertions::const_assert_eq!(
2968 std::mem::offset_of!(NodeSetExtendedAttributeRequest<'_>, value),
2969 16
2970 );
2971
2972 static_assertions::const_assert_eq!(
2973 std::mem::offset_of!(NodeSetExtendedAttributeRequest<'_>, mode),
2974 32
2975 );
2976
2977 impl ::fidl_next::Constrained for NodeSetExtendedAttributeRequest<'_> {
2978 type Constraint = ();
2979
2980 fn validate(
2981 _: ::fidl_next::Slot<'_, Self>,
2982 _: Self::Constraint,
2983 ) -> Result<(), ::fidl_next::ValidationError> {
2984 Ok(())
2985 }
2986 }
2987
2988 unsafe impl ::fidl_next::Wire for NodeSetExtendedAttributeRequest<'static> {
2989 type Narrowed<'de> = NodeSetExtendedAttributeRequest<'de>;
2990
2991 #[inline]
2992 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2993 ::fidl_next::munge! {
2994 let Self {
2995 name,
2996 value,
2997 mode,
2998
2999 } = &mut *out_;
3000 }
3001
3002 ::fidl_next::Wire::zero_padding(name);
3003
3004 ::fidl_next::Wire::zero_padding(value);
3005
3006 ::fidl_next::Wire::zero_padding(mode);
3007
3008 unsafe {
3009 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
3010 }
3011 }
3012 }
3013
3014 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeSetExtendedAttributeRequest<'de>
3015 where
3016 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3017 ___D: ::fidl_next::Decoder<'de>,
3018 ___D: ::fdomain_client::fidl_next::HandleDecoder,
3019 {
3020 fn decode(
3021 slot_: ::fidl_next::Slot<'_, Self>,
3022 decoder_: &mut ___D,
3023 _: (),
3024 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3025 if slot_.as_bytes()[36..40] != [0u8; 4] {
3026 return Err(::fidl_next::DecodeError::InvalidPadding);
3027 }
3028
3029 ::fidl_next::munge! {
3030 let Self {
3031 mut name,
3032 mut value,
3033 mut mode,
3034
3035 } = slot_;
3036 }
3037
3038 let _field = name.as_mut();
3039 ::fidl_next::Constrained::validate(_field, (255, ()))?;
3040 ::fidl_next::Decode::decode(name.as_mut(), decoder_, (255, ()))?;
3041
3042 let name = unsafe { name.deref_unchecked() };
3043
3044 if name.len() > 255 {
3045 return Err(::fidl_next::DecodeError::VectorTooLong {
3046 size: name.len() as u64,
3047 limit: 255,
3048 });
3049 }
3050
3051 let _field = value.as_mut();
3052
3053 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
3054
3055 let _field = mode.as_mut();
3056
3057 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
3058
3059 Ok(())
3060 }
3061 }
3062
3063 impl<'de> ::fidl_next::IntoNatural for NodeSetExtendedAttributeRequest<'de> {
3064 type Natural = crate::natural::NodeSetExtendedAttributeRequest;
3065 }
3066
3067 #[derive(Debug)]
3069 #[repr(C)]
3070 pub struct NodeGetTokenResponse {
3071 pub token: ::fdomain_client::fidl_next::wire::Handle,
3072 }
3073
3074 static_assertions::const_assert_eq!(std::mem::size_of::<NodeGetTokenResponse>(), 4);
3075 static_assertions::const_assert_eq!(std::mem::align_of::<NodeGetTokenResponse>(), 4);
3076
3077 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeGetTokenResponse, token), 0);
3078
3079 impl ::fidl_next::Constrained for NodeGetTokenResponse {
3080 type Constraint = ();
3081
3082 fn validate(
3083 _: ::fidl_next::Slot<'_, Self>,
3084 _: Self::Constraint,
3085 ) -> Result<(), ::fidl_next::ValidationError> {
3086 Ok(())
3087 }
3088 }
3089
3090 unsafe impl ::fidl_next::Wire for NodeGetTokenResponse {
3091 type Narrowed<'de> = NodeGetTokenResponse;
3092
3093 #[inline]
3094 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3095 ::fidl_next::munge! {
3096 let Self {
3097 token,
3098
3099 } = &mut *out_;
3100 }
3101
3102 ::fidl_next::Wire::zero_padding(token);
3103 }
3104 }
3105
3106 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeGetTokenResponse
3107 where
3108 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3109 ___D: ::fdomain_client::fidl_next::HandleDecoder,
3110 {
3111 fn decode(
3112 slot_: ::fidl_next::Slot<'_, Self>,
3113 decoder_: &mut ___D,
3114 _: (),
3115 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3116 ::fidl_next::munge! {
3117 let Self {
3118 mut token,
3119
3120 } = slot_;
3121 }
3122
3123 let _field = token.as_mut();
3124
3125 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3126
3127 Ok(())
3128 }
3129 }
3130
3131 impl ::fidl_next::IntoNatural for NodeGetTokenResponse {
3132 type Natural = crate::natural::NodeGetTokenResponse;
3133 }
3134
3135 #[derive(Debug)]
3137 #[repr(C)]
3138 pub struct DirectoryDeprecatedGetTokenResponse {
3139 pub s: ::fidl_next::wire::fuchsia::StatusResult,
3140
3141 pub token: ::fdomain_client::fidl_next::wire::OptionalHandle,
3142 }
3143
3144 static_assertions::const_assert_eq!(
3145 std::mem::size_of::<DirectoryDeprecatedGetTokenResponse>(),
3146 8
3147 );
3148 static_assertions::const_assert_eq!(
3149 std::mem::align_of::<DirectoryDeprecatedGetTokenResponse>(),
3150 4
3151 );
3152
3153 static_assertions::const_assert_eq!(
3154 std::mem::offset_of!(DirectoryDeprecatedGetTokenResponse, s),
3155 0
3156 );
3157
3158 static_assertions::const_assert_eq!(
3159 std::mem::offset_of!(DirectoryDeprecatedGetTokenResponse, token),
3160 4
3161 );
3162
3163 impl ::fidl_next::Constrained for DirectoryDeprecatedGetTokenResponse {
3164 type Constraint = ();
3165
3166 fn validate(
3167 _: ::fidl_next::Slot<'_, Self>,
3168 _: Self::Constraint,
3169 ) -> Result<(), ::fidl_next::ValidationError> {
3170 Ok(())
3171 }
3172 }
3173
3174 unsafe impl ::fidl_next::Wire for DirectoryDeprecatedGetTokenResponse {
3175 type Narrowed<'de> = DirectoryDeprecatedGetTokenResponse;
3176
3177 #[inline]
3178 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3179 ::fidl_next::munge! {
3180 let Self {
3181 s,
3182 token,
3183
3184 } = &mut *out_;
3185 }
3186
3187 ::fidl_next::Wire::zero_padding(s);
3188
3189 ::fidl_next::Wire::zero_padding(token);
3190 }
3191 }
3192
3193 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryDeprecatedGetTokenResponse
3194 where
3195 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3196 ___D: ::fdomain_client::fidl_next::HandleDecoder,
3197 {
3198 fn decode(
3199 slot_: ::fidl_next::Slot<'_, Self>,
3200 decoder_: &mut ___D,
3201 _: (),
3202 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3203 ::fidl_next::munge! {
3204 let Self {
3205 mut s,
3206 mut token,
3207
3208 } = slot_;
3209 }
3210
3211 let _field = s.as_mut();
3212
3213 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
3214
3215 let _field = token.as_mut();
3216
3217 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3218
3219 Ok(())
3220 }
3221 }
3222
3223 impl ::fidl_next::IntoNatural for DirectoryDeprecatedGetTokenResponse {
3224 type Natural = crate::natural::DirectoryDeprecatedGetTokenResponse;
3225 }
3226
3227 #[repr(C)]
3229 pub struct FileInfo<'de> {
3230 pub(crate) table: ::fidl_next::wire::Table<'de>,
3231 }
3232
3233 impl<'de> Drop for FileInfo<'de> {
3234 fn drop(&mut self) {
3235 let _ = self.table.get(1).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });
3236
3237 let _ = self.table.get(2).map(|envelope| unsafe {
3238 envelope.read_unchecked::<::fdomain_client::fidl_next::wire::Handle>()
3239 });
3240
3241 let _ = self.table.get(3).map(|envelope| unsafe {
3242 envelope.read_unchecked::<::fdomain_client::fidl_next::wire::Handle>()
3243 });
3244
3245 let _ = self.table.get(4).map(|envelope| unsafe {
3246 envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
3247 });
3248 }
3249 }
3250
3251 impl ::fidl_next::Constrained for FileInfo<'_> {
3252 type Constraint = ();
3253
3254 fn validate(
3255 _: ::fidl_next::Slot<'_, Self>,
3256 _: Self::Constraint,
3257 ) -> Result<(), ::fidl_next::ValidationError> {
3258 Ok(())
3259 }
3260 }
3261
3262 unsafe impl ::fidl_next::Wire for FileInfo<'static> {
3263 type Narrowed<'de> = FileInfo<'de>;
3264
3265 #[inline]
3266 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3267 ::fidl_next::munge!(let Self { table } = out);
3268 ::fidl_next::wire::Table::zero_padding(table);
3269 }
3270 }
3271
3272 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for FileInfo<'de>
3273 where
3274 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3275 ___D: ::fdomain_client::fidl_next::HandleDecoder,
3276 {
3277 fn decode(
3278 slot: ::fidl_next::Slot<'_, Self>,
3279 decoder: &mut ___D,
3280 _: (),
3281 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3282 ::fidl_next::munge!(let Self { table } = slot);
3283
3284 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3285 match ordinal {
3286 0 => unsafe { ::core::hint::unreachable_unchecked() },
3287
3288 1 => {
3289 ::fidl_next::wire::Envelope::decode_as::<___D, bool>(
3290 slot.as_mut(),
3291 decoder,
3292 (),
3293 )?;
3294
3295 Ok(())
3296 }
3297
3298 2 => {
3299 ::fidl_next::wire::Envelope::decode_as::<
3300 ___D,
3301 ::fdomain_client::fidl_next::wire::Handle,
3302 >(slot.as_mut(), decoder, ())?;
3303
3304 Ok(())
3305 }
3306
3307 3 => {
3308 ::fidl_next::wire::Envelope::decode_as::<
3309 ___D,
3310 ::fdomain_client::fidl_next::wire::Handle,
3311 >(slot.as_mut(), decoder, ())?;
3312
3313 Ok(())
3314 }
3315
3316 4 => {
3317 ::fidl_next::wire::Envelope::decode_as::<
3318 ___D,
3319 crate::wire::NodeAttributes2<'de>,
3320 >(slot.as_mut(), decoder, ())?;
3321
3322 Ok(())
3323 }
3324
3325 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3326 }
3327 })
3328 }
3329 }
3330
3331 impl<'de> FileInfo<'de> {
3332 pub fn is_append(&self) -> ::core::option::Option<&bool> {
3333 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3334 }
3335
3336 pub fn take_is_append(&mut self) -> ::core::option::Option<bool> {
3337 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
3338 }
3339
3340 pub fn observer(
3341 &self,
3342 ) -> ::core::option::Option<&::fdomain_client::fidl_next::wire::Handle> {
3343 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3344 }
3345
3346 pub fn take_observer(
3347 &mut self,
3348 ) -> ::core::option::Option<::fdomain_client::fidl_next::wire::Handle> {
3349 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
3350 }
3351
3352 pub fn stream(&self) -> ::core::option::Option<&::fdomain_client::fidl_next::wire::Handle> {
3353 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
3354 }
3355
3356 pub fn take_stream(
3357 &mut self,
3358 ) -> ::core::option::Option<::fdomain_client::fidl_next::wire::Handle> {
3359 unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
3360 }
3361
3362 pub fn attributes(&self) -> ::core::option::Option<&crate::wire::NodeAttributes2<'de>> {
3363 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
3364 }
3365
3366 pub fn take_attributes(
3367 &mut self,
3368 ) -> ::core::option::Option<crate::wire::NodeAttributes2<'de>> {
3369 unsafe { Some(self.table.get_mut(4)?.take_unchecked()) }
3370 }
3371 }
3372
3373 impl<'de> ::core::fmt::Debug for FileInfo<'de> {
3374 fn fmt(
3375 &self,
3376 f: &mut ::core::fmt::Formatter<'_>,
3377 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3378 f.debug_struct("FileInfo")
3379 .field("is_append", &self.is_append())
3380 .field("observer", &self.observer())
3381 .field("stream", &self.stream())
3382 .field("attributes", &self.attributes())
3383 .finish()
3384 }
3385 }
3386
3387 impl<'de> ::fidl_next::IntoNatural for FileInfo<'de> {
3388 type Natural = crate::natural::FileInfo;
3389 }
3390
3391 #[repr(transparent)]
3393 pub struct Representation<'de> {
3394 pub(crate) raw: ::fidl_next::wire::Union,
3395 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
3396 }
3397
3398 impl<'de> Drop for Representation<'de> {
3399 fn drop(&mut self) {
3400 match self.raw.ordinal() {
3401 1 => {
3402 let _ =
3403 unsafe { self.raw.get().read_unchecked::<crate::wire::NodeInfo<'de>>() };
3404 }
3405
3406 2 => {
3407 let _ = unsafe {
3408 self.raw.get().read_unchecked::<crate::wire::DirectoryInfo<'de>>()
3409 };
3410 }
3411
3412 3 => {
3413 let _ =
3414 unsafe { self.raw.get().read_unchecked::<crate::wire::FileInfo<'de>>() };
3415 }
3416
3417 4 => {
3418 let _ =
3419 unsafe { self.raw.get().read_unchecked::<crate::wire::SymlinkInfo<'de>>() };
3420 }
3421
3422 _ => (),
3423 }
3424 }
3425 }
3426
3427 impl ::fidl_next::Constrained for Representation<'_> {
3428 type Constraint = ();
3429
3430 fn validate(
3431 _: ::fidl_next::Slot<'_, Self>,
3432 _: Self::Constraint,
3433 ) -> Result<(), ::fidl_next::ValidationError> {
3434 Ok(())
3435 }
3436 }
3437
3438 unsafe impl ::fidl_next::Wire for Representation<'static> {
3439 type Narrowed<'de> = Representation<'de>;
3440
3441 #[inline]
3442 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3443 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
3444 ::fidl_next::wire::Union::zero_padding(raw);
3445 }
3446 }
3447
3448 pub mod representation {
3449 pub enum Ref<'de> {
3450 Node(&'de crate::wire::NodeInfo<'de>),
3451
3452 Directory(&'de crate::wire::DirectoryInfo<'de>),
3453
3454 File(&'de crate::wire::FileInfo<'de>),
3455
3456 Symlink(&'de crate::wire::SymlinkInfo<'de>),
3457
3458 UnknownOrdinal_(u64),
3459 }
3460
3461 pub enum Value<'de> {
3462 Node(crate::wire::NodeInfo<'de>),
3463
3464 Directory(crate::wire::DirectoryInfo<'de>),
3465
3466 File(crate::wire::FileInfo<'de>),
3467
3468 Symlink(crate::wire::SymlinkInfo<'de>),
3469
3470 UnknownOrdinal_(u64),
3471 }
3472 }
3473
3474 impl<'de> Representation<'de> {
3475 pub fn as_ref(&self) -> crate::wire::representation::Ref<'_> {
3476 match self.raw.ordinal() {
3477 1 => crate::wire::representation::Ref::Node(unsafe {
3478 self.raw.get().deref_unchecked::<crate::wire::NodeInfo<'_>>()
3479 }),
3480
3481 2 => crate::wire::representation::Ref::Directory(unsafe {
3482 self.raw.get().deref_unchecked::<crate::wire::DirectoryInfo<'_>>()
3483 }),
3484
3485 3 => crate::wire::representation::Ref::File(unsafe {
3486 self.raw.get().deref_unchecked::<crate::wire::FileInfo<'_>>()
3487 }),
3488
3489 4 => crate::wire::representation::Ref::Symlink(unsafe {
3490 self.raw.get().deref_unchecked::<crate::wire::SymlinkInfo<'_>>()
3491 }),
3492
3493 unknown => crate::wire::representation::Ref::UnknownOrdinal_(unknown),
3494 }
3495 }
3496
3497 pub fn into_inner(self) -> crate::wire::representation::Value<'de> {
3498 let this = ::core::mem::ManuallyDrop::new(self);
3499
3500 match this.raw.ordinal() {
3501 1 => crate::wire::representation::Value::Node(unsafe {
3502 this.raw.get().read_unchecked::<crate::wire::NodeInfo<'de>>()
3503 }),
3504
3505 2 => crate::wire::representation::Value::Directory(unsafe {
3506 this.raw.get().read_unchecked::<crate::wire::DirectoryInfo<'de>>()
3507 }),
3508
3509 3 => crate::wire::representation::Value::File(unsafe {
3510 this.raw.get().read_unchecked::<crate::wire::FileInfo<'de>>()
3511 }),
3512
3513 4 => crate::wire::representation::Value::Symlink(unsafe {
3514 this.raw.get().read_unchecked::<crate::wire::SymlinkInfo<'de>>()
3515 }),
3516
3517 unknown => crate::wire::representation::Value::UnknownOrdinal_(unknown),
3518 }
3519 }
3520 }
3521
3522 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Representation<'de>
3523 where
3524 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3525 ___D: ::fidl_next::Decoder<'de>,
3526 ___D: ::fdomain_client::fidl_next::HandleDecoder,
3527 {
3528 fn decode(
3529 mut slot: ::fidl_next::Slot<'_, Self>,
3530 decoder: &mut ___D,
3531 _: (),
3532 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3533 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
3534 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
3535 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::NodeInfo<'de>>(
3536 raw,
3537 decoder,
3538 (),
3539 )?,
3540
3541 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirectoryInfo<'de>>(
3542 raw,
3543 decoder,
3544 (),
3545 )?,
3546
3547 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::FileInfo<'de>>(
3548 raw,
3549 decoder,
3550 (),
3551 )?,
3552
3553 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SymlinkInfo<'de>>(
3554 raw,
3555 decoder,
3556 (),
3557 )?,
3558
3559 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
3560 }
3561
3562 Ok(())
3563 }
3564 }
3565
3566 impl<'de> ::core::fmt::Debug for Representation<'de> {
3567 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3568 match self.raw.ordinal() {
3569 1 => unsafe {
3570 self.raw.get().deref_unchecked::<crate::wire::NodeInfo<'_>>().fmt(f)
3571 },
3572 2 => unsafe {
3573 self.raw.get().deref_unchecked::<crate::wire::DirectoryInfo<'_>>().fmt(f)
3574 },
3575 3 => unsafe {
3576 self.raw.get().deref_unchecked::<crate::wire::FileInfo<'_>>().fmt(f)
3577 },
3578 4 => unsafe {
3579 self.raw.get().deref_unchecked::<crate::wire::SymlinkInfo<'_>>().fmt(f)
3580 },
3581 _ => unsafe { ::core::hint::unreachable_unchecked() },
3582 }
3583 }
3584 }
3585
3586 impl<'de> ::fidl_next::IntoNatural for Representation<'de> {
3587 type Natural = crate::natural::Representation;
3588 }
3589
3590 #[derive(Debug)]
3592 #[repr(C)]
3593 pub struct OpenableOpenRequest<'de> {
3594 pub path: ::fidl_next::wire::String<'de>,
3595
3596 pub flags: crate::wire::Flags,
3597
3598 pub options: crate::wire::Options<'de>,
3599
3600 pub object: ::fdomain_client::fidl_next::wire::Handle,
3601 }
3602
3603 static_assertions::const_assert_eq!(std::mem::size_of::<OpenableOpenRequest<'_>>(), 48);
3604 static_assertions::const_assert_eq!(std::mem::align_of::<OpenableOpenRequest<'_>>(), 8);
3605
3606 static_assertions::const_assert_eq!(std::mem::offset_of!(OpenableOpenRequest<'_>, path), 0);
3607
3608 static_assertions::const_assert_eq!(std::mem::offset_of!(OpenableOpenRequest<'_>, flags), 16);
3609
3610 static_assertions::const_assert_eq!(std::mem::offset_of!(OpenableOpenRequest<'_>, options), 24);
3611
3612 static_assertions::const_assert_eq!(std::mem::offset_of!(OpenableOpenRequest<'_>, object), 40);
3613
3614 impl ::fidl_next::Constrained for OpenableOpenRequest<'_> {
3615 type Constraint = ();
3616
3617 fn validate(
3618 _: ::fidl_next::Slot<'_, Self>,
3619 _: Self::Constraint,
3620 ) -> Result<(), ::fidl_next::ValidationError> {
3621 Ok(())
3622 }
3623 }
3624
3625 unsafe impl ::fidl_next::Wire for OpenableOpenRequest<'static> {
3626 type Narrowed<'de> = OpenableOpenRequest<'de>;
3627
3628 #[inline]
3629 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3630 ::fidl_next::munge! {
3631 let Self {
3632 path,
3633 flags,
3634 options,
3635 object,
3636
3637 } = &mut *out_;
3638 }
3639
3640 ::fidl_next::Wire::zero_padding(path);
3641
3642 ::fidl_next::Wire::zero_padding(flags);
3643
3644 ::fidl_next::Wire::zero_padding(options);
3645
3646 ::fidl_next::Wire::zero_padding(object);
3647
3648 unsafe {
3649 out_.as_mut_ptr().cast::<u8>().add(44).write_bytes(0, 4);
3650 }
3651 }
3652 }
3653
3654 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for OpenableOpenRequest<'de>
3655 where
3656 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3657 ___D: ::fidl_next::Decoder<'de>,
3658 ___D: ::fdomain_client::fidl_next::HandleDecoder,
3659 {
3660 fn decode(
3661 slot_: ::fidl_next::Slot<'_, Self>,
3662 decoder_: &mut ___D,
3663 _: (),
3664 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3665 if slot_.as_bytes()[44..48] != [0u8; 4] {
3666 return Err(::fidl_next::DecodeError::InvalidPadding);
3667 }
3668
3669 ::fidl_next::munge! {
3670 let Self {
3671 mut path,
3672 mut flags,
3673 mut options,
3674 mut object,
3675
3676 } = slot_;
3677 }
3678
3679 let _field = path.as_mut();
3680 ::fidl_next::Constrained::validate(_field, 4095)?;
3681 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
3682
3683 let path = unsafe { path.deref_unchecked() };
3684
3685 if path.len() > 4095 {
3686 return Err(::fidl_next::DecodeError::VectorTooLong {
3687 size: path.len() as u64,
3688 limit: 4095,
3689 });
3690 }
3691
3692 let _field = flags.as_mut();
3693
3694 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
3695
3696 let _field = options.as_mut();
3697
3698 ::fidl_next::Decode::decode(options.as_mut(), decoder_, ())?;
3699
3700 let _field = object.as_mut();
3701
3702 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
3703
3704 Ok(())
3705 }
3706 }
3707
3708 impl<'de> ::fidl_next::IntoNatural for OpenableOpenRequest<'de> {
3709 type Natural = crate::natural::OpenableOpenRequest;
3710 }
3711
3712 #[derive(Debug)]
3714 #[repr(C)]
3715 pub struct NodeOnOpenRequest<'de> {
3716 pub s: ::fidl_next::wire::fuchsia::StatusResult,
3717
3718 pub info: crate::wire_optional::NodeInfoDeprecated<'de>,
3719 }
3720
3721 static_assertions::const_assert_eq!(std::mem::size_of::<NodeOnOpenRequest<'_>>(), 24);
3722 static_assertions::const_assert_eq!(std::mem::align_of::<NodeOnOpenRequest<'_>>(), 8);
3723
3724 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeOnOpenRequest<'_>, s), 0);
3725
3726 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeOnOpenRequest<'_>, info), 8);
3727
3728 impl ::fidl_next::Constrained for NodeOnOpenRequest<'_> {
3729 type Constraint = ();
3730
3731 fn validate(
3732 _: ::fidl_next::Slot<'_, Self>,
3733 _: Self::Constraint,
3734 ) -> Result<(), ::fidl_next::ValidationError> {
3735 Ok(())
3736 }
3737 }
3738
3739 unsafe impl ::fidl_next::Wire for NodeOnOpenRequest<'static> {
3740 type Narrowed<'de> = NodeOnOpenRequest<'de>;
3741
3742 #[inline]
3743 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3744 ::fidl_next::munge! {
3745 let Self {
3746 s,
3747 info,
3748
3749 } = &mut *out_;
3750 }
3751
3752 ::fidl_next::Wire::zero_padding(s);
3753
3754 ::fidl_next::Wire::zero_padding(info);
3755
3756 unsafe {
3757 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
3758 }
3759 }
3760 }
3761
3762 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeOnOpenRequest<'de>
3763 where
3764 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3765 ___D: ::fidl_next::Decoder<'de>,
3766 ___D: ::fdomain_client::fidl_next::HandleDecoder,
3767 {
3768 fn decode(
3769 slot_: ::fidl_next::Slot<'_, Self>,
3770 decoder_: &mut ___D,
3771 _: (),
3772 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3773 if slot_.as_bytes()[4..8] != [0u8; 4] {
3774 return Err(::fidl_next::DecodeError::InvalidPadding);
3775 }
3776
3777 ::fidl_next::munge! {
3778 let Self {
3779 mut s,
3780 mut info,
3781
3782 } = slot_;
3783 }
3784
3785 let _field = s.as_mut();
3786
3787 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
3788
3789 let _field = info.as_mut();
3790
3791 ::fidl_next::Decode::decode(info.as_mut(), decoder_, ())?;
3792
3793 Ok(())
3794 }
3795 }
3796
3797 impl<'de> ::fidl_next::IntoNatural for NodeOnOpenRequest<'de> {
3798 type Natural = crate::natural::NodeOnOpenRequest;
3799 }
3800
3801 #[derive(Debug)]
3803 #[repr(C)]
3804 pub struct DirectoryDeprecatedOpenRequest<'de> {
3805 pub flags: crate::wire::OpenFlags,
3806
3807 pub mode: crate::wire::ModeType,
3808
3809 pub path: ::fidl_next::wire::String<'de>,
3810
3811 pub object: ::fidl_next::ServerEnd<crate::Node, ::fdomain_client::fidl_next::wire::Handle>,
3812 }
3813
3814 static_assertions::const_assert_eq!(
3815 std::mem::size_of::<DirectoryDeprecatedOpenRequest<'_>>(),
3816 32
3817 );
3818 static_assertions::const_assert_eq!(
3819 std::mem::align_of::<DirectoryDeprecatedOpenRequest<'_>>(),
3820 8
3821 );
3822
3823 static_assertions::const_assert_eq!(
3824 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, flags),
3825 0
3826 );
3827
3828 static_assertions::const_assert_eq!(
3829 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, mode),
3830 4
3831 );
3832
3833 static_assertions::const_assert_eq!(
3834 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, path),
3835 8
3836 );
3837
3838 static_assertions::const_assert_eq!(
3839 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, object),
3840 24
3841 );
3842
3843 impl ::fidl_next::Constrained for DirectoryDeprecatedOpenRequest<'_> {
3844 type Constraint = ();
3845
3846 fn validate(
3847 _: ::fidl_next::Slot<'_, Self>,
3848 _: Self::Constraint,
3849 ) -> Result<(), ::fidl_next::ValidationError> {
3850 Ok(())
3851 }
3852 }
3853
3854 unsafe impl ::fidl_next::Wire for DirectoryDeprecatedOpenRequest<'static> {
3855 type Narrowed<'de> = DirectoryDeprecatedOpenRequest<'de>;
3856
3857 #[inline]
3858 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3859 ::fidl_next::munge! {
3860 let Self {
3861 flags,
3862 mode,
3863 path,
3864 object,
3865
3866 } = &mut *out_;
3867 }
3868
3869 ::fidl_next::Wire::zero_padding(flags);
3870
3871 ::fidl_next::Wire::zero_padding(mode);
3872
3873 ::fidl_next::Wire::zero_padding(path);
3874
3875 ::fidl_next::Wire::zero_padding(object);
3876
3877 unsafe {
3878 out_.as_mut_ptr().cast::<u8>().add(28).write_bytes(0, 4);
3879 }
3880 }
3881 }
3882
3883 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryDeprecatedOpenRequest<'de>
3884 where
3885 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3886 ___D: ::fidl_next::Decoder<'de>,
3887 ___D: ::fdomain_client::fidl_next::HandleDecoder,
3888 {
3889 fn decode(
3890 slot_: ::fidl_next::Slot<'_, Self>,
3891 decoder_: &mut ___D,
3892 _: (),
3893 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3894 if slot_.as_bytes()[28..32] != [0u8; 4] {
3895 return Err(::fidl_next::DecodeError::InvalidPadding);
3896 }
3897
3898 ::fidl_next::munge! {
3899 let Self {
3900 mut flags,
3901 mut mode,
3902 mut path,
3903 mut object,
3904
3905 } = slot_;
3906 }
3907
3908 let _field = flags.as_mut();
3909
3910 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
3911
3912 let _field = mode.as_mut();
3913
3914 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
3915
3916 let _field = path.as_mut();
3917 ::fidl_next::Constrained::validate(_field, 4095)?;
3918 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
3919
3920 let path = unsafe { path.deref_unchecked() };
3921
3922 if path.len() > 4095 {
3923 return Err(::fidl_next::DecodeError::VectorTooLong {
3924 size: path.len() as u64,
3925 limit: 4095,
3926 });
3927 }
3928
3929 let _field = object.as_mut();
3930
3931 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
3932
3933 Ok(())
3934 }
3935 }
3936
3937 impl<'de> ::fidl_next::IntoNatural for DirectoryDeprecatedOpenRequest<'de> {
3938 type Natural = crate::natural::DirectoryDeprecatedOpenRequest;
3939 }
3940
3941 #[derive(Debug)]
3943 #[repr(C)]
3944 pub struct DirectoryCreateSymlinkRequest<'de> {
3945 pub name: ::fidl_next::wire::String<'de>,
3946
3947 pub target: ::fidl_next::wire::Vector<'de, u8>,
3948
3949 pub connection: ::fidl_next::ServerEnd<
3950 crate::Symlink,
3951 ::fdomain_client::fidl_next::wire::OptionalHandle,
3952 >,
3953 }
3954
3955 static_assertions::const_assert_eq!(
3956 std::mem::size_of::<DirectoryCreateSymlinkRequest<'_>>(),
3957 40
3958 );
3959 static_assertions::const_assert_eq!(
3960 std::mem::align_of::<DirectoryCreateSymlinkRequest<'_>>(),
3961 8
3962 );
3963
3964 static_assertions::const_assert_eq!(
3965 std::mem::offset_of!(DirectoryCreateSymlinkRequest<'_>, name),
3966 0
3967 );
3968
3969 static_assertions::const_assert_eq!(
3970 std::mem::offset_of!(DirectoryCreateSymlinkRequest<'_>, target),
3971 16
3972 );
3973
3974 static_assertions::const_assert_eq!(
3975 std::mem::offset_of!(DirectoryCreateSymlinkRequest<'_>, connection),
3976 32
3977 );
3978
3979 impl ::fidl_next::Constrained for DirectoryCreateSymlinkRequest<'_> {
3980 type Constraint = ();
3981
3982 fn validate(
3983 _: ::fidl_next::Slot<'_, Self>,
3984 _: Self::Constraint,
3985 ) -> Result<(), ::fidl_next::ValidationError> {
3986 Ok(())
3987 }
3988 }
3989
3990 unsafe impl ::fidl_next::Wire for DirectoryCreateSymlinkRequest<'static> {
3991 type Narrowed<'de> = DirectoryCreateSymlinkRequest<'de>;
3992
3993 #[inline]
3994 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3995 ::fidl_next::munge! {
3996 let Self {
3997 name,
3998 target,
3999 connection,
4000
4001 } = &mut *out_;
4002 }
4003
4004 ::fidl_next::Wire::zero_padding(name);
4005
4006 ::fidl_next::Wire::zero_padding(target);
4007
4008 ::fidl_next::Wire::zero_padding(connection);
4009
4010 unsafe {
4011 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
4012 }
4013 }
4014 }
4015
4016 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryCreateSymlinkRequest<'de>
4017 where
4018 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4019 ___D: ::fidl_next::Decoder<'de>,
4020 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4021 {
4022 fn decode(
4023 slot_: ::fidl_next::Slot<'_, Self>,
4024 decoder_: &mut ___D,
4025 _: (),
4026 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4027 if slot_.as_bytes()[36..40] != [0u8; 4] {
4028 return Err(::fidl_next::DecodeError::InvalidPadding);
4029 }
4030
4031 ::fidl_next::munge! {
4032 let Self {
4033 mut name,
4034 mut target,
4035 mut connection,
4036
4037 } = slot_;
4038 }
4039
4040 let _field = name.as_mut();
4041 ::fidl_next::Constrained::validate(_field, 255)?;
4042 ::fidl_next::Decode::decode(name.as_mut(), decoder_, 255)?;
4043
4044 let name = unsafe { name.deref_unchecked() };
4045
4046 if name.len() > 255 {
4047 return Err(::fidl_next::DecodeError::VectorTooLong {
4048 size: name.len() as u64,
4049 limit: 255,
4050 });
4051 }
4052
4053 let _field = target.as_mut();
4054 ::fidl_next::Constrained::validate(_field, (4095, ()))?;
4055 ::fidl_next::Decode::decode(target.as_mut(), decoder_, (4095, ()))?;
4056
4057 let target = unsafe { target.deref_unchecked() };
4058
4059 if target.len() > 4095 {
4060 return Err(::fidl_next::DecodeError::VectorTooLong {
4061 size: target.len() as u64,
4062 limit: 4095,
4063 });
4064 }
4065
4066 let _field = connection.as_mut();
4067
4068 ::fidl_next::Decode::decode(connection.as_mut(), decoder_, ())?;
4069
4070 Ok(())
4071 }
4072 }
4073
4074 impl<'de> ::fidl_next::IntoNatural for DirectoryCreateSymlinkRequest<'de> {
4075 type Natural = crate::natural::DirectoryCreateSymlinkRequest;
4076 }
4077
4078 #[derive(Debug)]
4080 #[repr(C)]
4081 pub struct FileGetBackingMemoryResponse {
4082 pub vmo: ::fdomain_client::fidl_next::wire::Handle,
4083 }
4084
4085 static_assertions::const_assert_eq!(std::mem::size_of::<FileGetBackingMemoryResponse>(), 4);
4086 static_assertions::const_assert_eq!(std::mem::align_of::<FileGetBackingMemoryResponse>(), 4);
4087
4088 static_assertions::const_assert_eq!(std::mem::offset_of!(FileGetBackingMemoryResponse, vmo), 0);
4089
4090 impl ::fidl_next::Constrained for FileGetBackingMemoryResponse {
4091 type Constraint = ();
4092
4093 fn validate(
4094 _: ::fidl_next::Slot<'_, Self>,
4095 _: Self::Constraint,
4096 ) -> Result<(), ::fidl_next::ValidationError> {
4097 Ok(())
4098 }
4099 }
4100
4101 unsafe impl ::fidl_next::Wire for FileGetBackingMemoryResponse {
4102 type Narrowed<'de> = FileGetBackingMemoryResponse;
4103
4104 #[inline]
4105 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4106 ::fidl_next::munge! {
4107 let Self {
4108 vmo,
4109
4110 } = &mut *out_;
4111 }
4112
4113 ::fidl_next::Wire::zero_padding(vmo);
4114 }
4115 }
4116
4117 unsafe impl<___D> ::fidl_next::Decode<___D> for FileGetBackingMemoryResponse
4118 where
4119 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4120 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4121 {
4122 fn decode(
4123 slot_: ::fidl_next::Slot<'_, Self>,
4124 decoder_: &mut ___D,
4125 _: (),
4126 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4127 ::fidl_next::munge! {
4128 let Self {
4129 mut vmo,
4130
4131 } = slot_;
4132 }
4133
4134 let _field = vmo.as_mut();
4135
4136 ::fidl_next::Decode::decode(vmo.as_mut(), decoder_, ())?;
4137
4138 Ok(())
4139 }
4140 }
4141
4142 impl ::fidl_next::IntoNatural for FileGetBackingMemoryResponse {
4143 type Natural = crate::natural::FileGetBackingMemoryResponse;
4144 }
4145
4146 #[derive(Debug)]
4148 #[repr(C)]
4149 pub struct LinkableLinkIntoRequest<'de> {
4150 pub dst_parent_token: ::fdomain_client::fidl_next::wire::Handle,
4151
4152 pub dst: ::fidl_next::wire::String<'de>,
4153 }
4154
4155 static_assertions::const_assert_eq!(std::mem::size_of::<LinkableLinkIntoRequest<'_>>(), 24);
4156 static_assertions::const_assert_eq!(std::mem::align_of::<LinkableLinkIntoRequest<'_>>(), 8);
4157
4158 static_assertions::const_assert_eq!(
4159 std::mem::offset_of!(LinkableLinkIntoRequest<'_>, dst_parent_token),
4160 0
4161 );
4162
4163 static_assertions::const_assert_eq!(std::mem::offset_of!(LinkableLinkIntoRequest<'_>, dst), 8);
4164
4165 impl ::fidl_next::Constrained for LinkableLinkIntoRequest<'_> {
4166 type Constraint = ();
4167
4168 fn validate(
4169 _: ::fidl_next::Slot<'_, Self>,
4170 _: Self::Constraint,
4171 ) -> Result<(), ::fidl_next::ValidationError> {
4172 Ok(())
4173 }
4174 }
4175
4176 unsafe impl ::fidl_next::Wire for LinkableLinkIntoRequest<'static> {
4177 type Narrowed<'de> = LinkableLinkIntoRequest<'de>;
4178
4179 #[inline]
4180 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4181 ::fidl_next::munge! {
4182 let Self {
4183 dst_parent_token,
4184 dst,
4185
4186 } = &mut *out_;
4187 }
4188
4189 ::fidl_next::Wire::zero_padding(dst_parent_token);
4190
4191 ::fidl_next::Wire::zero_padding(dst);
4192
4193 unsafe {
4194 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
4195 }
4196 }
4197 }
4198
4199 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for LinkableLinkIntoRequest<'de>
4200 where
4201 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4202 ___D: ::fidl_next::Decoder<'de>,
4203 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4204 {
4205 fn decode(
4206 slot_: ::fidl_next::Slot<'_, Self>,
4207 decoder_: &mut ___D,
4208 _: (),
4209 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4210 if slot_.as_bytes()[4..8] != [0u8; 4] {
4211 return Err(::fidl_next::DecodeError::InvalidPadding);
4212 }
4213
4214 ::fidl_next::munge! {
4215 let Self {
4216 mut dst_parent_token,
4217 mut dst,
4218
4219 } = slot_;
4220 }
4221
4222 let _field = dst_parent_token.as_mut();
4223
4224 ::fidl_next::Decode::decode(dst_parent_token.as_mut(), decoder_, ())?;
4225
4226 let _field = dst.as_mut();
4227 ::fidl_next::Constrained::validate(_field, 255)?;
4228 ::fidl_next::Decode::decode(dst.as_mut(), decoder_, 255)?;
4229
4230 let dst = unsafe { dst.deref_unchecked() };
4231
4232 if dst.len() > 255 {
4233 return Err(::fidl_next::DecodeError::VectorTooLong {
4234 size: dst.len() as u64,
4235 limit: 255,
4236 });
4237 }
4238
4239 Ok(())
4240 }
4241 }
4242
4243 impl<'de> ::fidl_next::IntoNatural for LinkableLinkIntoRequest<'de> {
4244 type Natural = crate::natural::LinkableLinkIntoRequest;
4245 }
4246
4247 #[derive(Debug)]
4249 #[repr(C)]
4250 pub struct FileAllocateRequest {
4251 pub offset: ::fidl_next::wire::Uint64,
4252
4253 pub length: ::fidl_next::wire::Uint64,
4254
4255 pub mode: crate::wire::AllocateMode,
4256 }
4257
4258 static_assertions::const_assert_eq!(std::mem::size_of::<FileAllocateRequest>(), 24);
4259 static_assertions::const_assert_eq!(std::mem::align_of::<FileAllocateRequest>(), 8);
4260
4261 static_assertions::const_assert_eq!(std::mem::offset_of!(FileAllocateRequest, offset), 0);
4262
4263 static_assertions::const_assert_eq!(std::mem::offset_of!(FileAllocateRequest, length), 8);
4264
4265 static_assertions::const_assert_eq!(std::mem::offset_of!(FileAllocateRequest, mode), 16);
4266
4267 impl ::fidl_next::Constrained for FileAllocateRequest {
4268 type Constraint = ();
4269
4270 fn validate(
4271 _: ::fidl_next::Slot<'_, Self>,
4272 _: Self::Constraint,
4273 ) -> Result<(), ::fidl_next::ValidationError> {
4274 Ok(())
4275 }
4276 }
4277
4278 unsafe impl ::fidl_next::Wire for FileAllocateRequest {
4279 type Narrowed<'de> = FileAllocateRequest;
4280
4281 #[inline]
4282 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4283 ::fidl_next::munge! {
4284 let Self {
4285 offset,
4286 length,
4287 mode,
4288
4289 } = &mut *out_;
4290 }
4291
4292 ::fidl_next::Wire::zero_padding(offset);
4293
4294 ::fidl_next::Wire::zero_padding(length);
4295
4296 ::fidl_next::Wire::zero_padding(mode);
4297
4298 unsafe {
4299 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
4300 }
4301 }
4302 }
4303
4304 unsafe impl<___D> ::fidl_next::Decode<___D> for FileAllocateRequest
4305 where
4306 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4307 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4308 {
4309 fn decode(
4310 slot_: ::fidl_next::Slot<'_, Self>,
4311 decoder_: &mut ___D,
4312 _: (),
4313 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4314 if slot_.as_bytes()[20..24] != [0u8; 4] {
4315 return Err(::fidl_next::DecodeError::InvalidPadding);
4316 }
4317
4318 ::fidl_next::munge! {
4319 let Self {
4320 mut offset,
4321 mut length,
4322 mut mode,
4323
4324 } = slot_;
4325 }
4326
4327 let _field = offset.as_mut();
4328
4329 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
4330
4331 let _field = length.as_mut();
4332
4333 ::fidl_next::Decode::decode(length.as_mut(), decoder_, ())?;
4334
4335 let _field = mode.as_mut();
4336
4337 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
4338
4339 Ok(())
4340 }
4341 }
4342
4343 impl ::fidl_next::IntoNatural for FileAllocateRequest {
4344 type Natural = crate::natural::FileAllocateRequest;
4345 }
4346
4347 #[derive(Debug)]
4349 #[repr(C)]
4350 pub struct FileEnableVerityRequest<'de> {
4351 pub options: crate::wire::VerificationOptions<'de>,
4352 }
4353
4354 static_assertions::const_assert_eq!(std::mem::size_of::<FileEnableVerityRequest<'_>>(), 16);
4355 static_assertions::const_assert_eq!(std::mem::align_of::<FileEnableVerityRequest<'_>>(), 8);
4356
4357 static_assertions::const_assert_eq!(
4358 std::mem::offset_of!(FileEnableVerityRequest<'_>, options),
4359 0
4360 );
4361
4362 impl ::fidl_next::Constrained for FileEnableVerityRequest<'_> {
4363 type Constraint = ();
4364
4365 fn validate(
4366 _: ::fidl_next::Slot<'_, Self>,
4367 _: Self::Constraint,
4368 ) -> Result<(), ::fidl_next::ValidationError> {
4369 Ok(())
4370 }
4371 }
4372
4373 unsafe impl ::fidl_next::Wire for FileEnableVerityRequest<'static> {
4374 type Narrowed<'de> = FileEnableVerityRequest<'de>;
4375
4376 #[inline]
4377 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4378 ::fidl_next::munge! {
4379 let Self {
4380 options,
4381
4382 } = &mut *out_;
4383 }
4384
4385 ::fidl_next::Wire::zero_padding(options);
4386 }
4387 }
4388
4389 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for FileEnableVerityRequest<'de>
4390 where
4391 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4392 ___D: ::fidl_next::Decoder<'de>,
4393 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4394 {
4395 fn decode(
4396 slot_: ::fidl_next::Slot<'_, Self>,
4397 decoder_: &mut ___D,
4398 _: (),
4399 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4400 ::fidl_next::munge! {
4401 let Self {
4402 mut options,
4403
4404 } = slot_;
4405 }
4406
4407 let _field = options.as_mut();
4408
4409 ::fidl_next::Decode::decode(options.as_mut(), decoder_, ())?;
4410
4411 Ok(())
4412 }
4413 }
4414
4415 impl<'de> ::fidl_next::IntoNatural for FileEnableVerityRequest<'de> {
4416 type Natural = crate::natural::FileEnableVerityRequest;
4417 }
4418
4419 #[derive(Debug)]
4421 #[repr(C)]
4422 pub struct FileObject {
4423 pub event: ::fdomain_client::fidl_next::wire::OptionalHandle,
4424
4425 pub stream: ::fdomain_client::fidl_next::wire::OptionalHandle,
4426 }
4427
4428 static_assertions::const_assert_eq!(std::mem::size_of::<FileObject>(), 8);
4429 static_assertions::const_assert_eq!(std::mem::align_of::<FileObject>(), 4);
4430
4431 static_assertions::const_assert_eq!(std::mem::offset_of!(FileObject, event), 0);
4432
4433 static_assertions::const_assert_eq!(std::mem::offset_of!(FileObject, stream), 4);
4434
4435 impl ::fidl_next::Constrained for FileObject {
4436 type Constraint = ();
4437
4438 fn validate(
4439 _: ::fidl_next::Slot<'_, Self>,
4440 _: Self::Constraint,
4441 ) -> Result<(), ::fidl_next::ValidationError> {
4442 Ok(())
4443 }
4444 }
4445
4446 unsafe impl ::fidl_next::Wire for FileObject {
4447 type Narrowed<'de> = FileObject;
4448
4449 #[inline]
4450 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4451 ::fidl_next::munge! {
4452 let Self {
4453 event,
4454 stream,
4455
4456 } = &mut *out_;
4457 }
4458
4459 ::fidl_next::Wire::zero_padding(event);
4460
4461 ::fidl_next::Wire::zero_padding(stream);
4462 }
4463 }
4464
4465 unsafe impl<___D> ::fidl_next::Decode<___D> for FileObject
4466 where
4467 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4468 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4469 {
4470 fn decode(
4471 slot_: ::fidl_next::Slot<'_, Self>,
4472 decoder_: &mut ___D,
4473 _: (),
4474 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4475 ::fidl_next::munge! {
4476 let Self {
4477 mut event,
4478 mut stream,
4479
4480 } = slot_;
4481 }
4482
4483 let _field = event.as_mut();
4484
4485 ::fidl_next::Decode::decode(event.as_mut(), decoder_, ())?;
4486
4487 let _field = stream.as_mut();
4488
4489 ::fidl_next::Decode::decode(stream.as_mut(), decoder_, ())?;
4490
4491 Ok(())
4492 }
4493 }
4494
4495 impl ::fidl_next::IntoNatural for FileObject {
4496 type Natural = crate::natural::FileObject;
4497 }
4498
4499 #[repr(transparent)]
4501 pub struct NodeInfoDeprecated<'de> {
4502 pub(crate) raw: ::fidl_next::wire::Union,
4503 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4504 }
4505
4506 impl<'de> Drop for NodeInfoDeprecated<'de> {
4507 fn drop(&mut self) {
4508 match self.raw.ordinal() {
4509 1 => {
4510 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Service>() };
4511 }
4512
4513 2 => {
4514 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::FileObject>() };
4515 }
4516
4517 3 => {
4518 let _ =
4519 unsafe { self.raw.get().read_unchecked::<crate::wire::DirectoryObject>() };
4520 }
4521
4522 4 => {
4523 let _ = unsafe {
4524 self.raw.get().read_unchecked::<crate::wire::SymlinkObject<'de>>()
4525 };
4526 }
4527
4528 _ => unsafe { ::core::hint::unreachable_unchecked() },
4529 }
4530 }
4531 }
4532
4533 impl ::fidl_next::Constrained for NodeInfoDeprecated<'_> {
4534 type Constraint = ();
4535
4536 fn validate(
4537 _: ::fidl_next::Slot<'_, Self>,
4538 _: Self::Constraint,
4539 ) -> Result<(), ::fidl_next::ValidationError> {
4540 Ok(())
4541 }
4542 }
4543
4544 unsafe impl ::fidl_next::Wire for NodeInfoDeprecated<'static> {
4545 type Narrowed<'de> = NodeInfoDeprecated<'de>;
4546
4547 #[inline]
4548 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4549 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4550 ::fidl_next::wire::Union::zero_padding(raw);
4551 }
4552 }
4553
4554 pub mod node_info_deprecated {
4555 pub enum Ref<'de> {
4556 Service(&'de crate::wire::Service),
4557
4558 File(&'de crate::wire::FileObject),
4559
4560 Directory(&'de crate::wire::DirectoryObject),
4561
4562 Symlink(&'de crate::wire::SymlinkObject<'de>),
4563 }
4564
4565 pub enum Value<'de> {
4566 Service(crate::wire::Service),
4567
4568 File(crate::wire::FileObject),
4569
4570 Directory(crate::wire::DirectoryObject),
4571
4572 Symlink(crate::wire::SymlinkObject<'de>),
4573 }
4574 }
4575
4576 impl<'de> NodeInfoDeprecated<'de> {
4577 pub fn as_ref(&self) -> crate::wire::node_info_deprecated::Ref<'_> {
4578 match self.raw.ordinal() {
4579 1 => crate::wire::node_info_deprecated::Ref::Service(unsafe {
4580 self.raw.get().deref_unchecked::<crate::wire::Service>()
4581 }),
4582
4583 2 => crate::wire::node_info_deprecated::Ref::File(unsafe {
4584 self.raw.get().deref_unchecked::<crate::wire::FileObject>()
4585 }),
4586
4587 3 => crate::wire::node_info_deprecated::Ref::Directory(unsafe {
4588 self.raw.get().deref_unchecked::<crate::wire::DirectoryObject>()
4589 }),
4590
4591 4 => crate::wire::node_info_deprecated::Ref::Symlink(unsafe {
4592 self.raw.get().deref_unchecked::<crate::wire::SymlinkObject<'_>>()
4593 }),
4594
4595 _ => unsafe { ::core::hint::unreachable_unchecked() },
4596 }
4597 }
4598
4599 pub fn into_inner(self) -> crate::wire::node_info_deprecated::Value<'de> {
4600 let this = ::core::mem::ManuallyDrop::new(self);
4601
4602 match this.raw.ordinal() {
4603 1 => crate::wire::node_info_deprecated::Value::Service(unsafe {
4604 this.raw.get().read_unchecked::<crate::wire::Service>()
4605 }),
4606
4607 2 => crate::wire::node_info_deprecated::Value::File(unsafe {
4608 this.raw.get().read_unchecked::<crate::wire::FileObject>()
4609 }),
4610
4611 3 => crate::wire::node_info_deprecated::Value::Directory(unsafe {
4612 this.raw.get().read_unchecked::<crate::wire::DirectoryObject>()
4613 }),
4614
4615 4 => crate::wire::node_info_deprecated::Value::Symlink(unsafe {
4616 this.raw.get().read_unchecked::<crate::wire::SymlinkObject<'de>>()
4617 }),
4618
4619 _ => unsafe { ::core::hint::unreachable_unchecked() },
4620 }
4621 }
4622 }
4623
4624 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeInfoDeprecated<'de>
4625 where
4626 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4627 ___D: ::fidl_next::Decoder<'de>,
4628 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4629 {
4630 fn decode(
4631 mut slot: ::fidl_next::Slot<'_, Self>,
4632 decoder: &mut ___D,
4633 _: (),
4634 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4635 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4636 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4637 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Service>(
4638 raw,
4639 decoder,
4640 (),
4641 )?,
4642
4643 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::FileObject>(
4644 raw,
4645 decoder,
4646 (),
4647 )?,
4648
4649 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirectoryObject>(
4650 raw,
4651 decoder,
4652 (),
4653 )?,
4654
4655 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SymlinkObject<'de>>(
4656 raw,
4657 decoder,
4658 (),
4659 )?,
4660
4661 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
4662 }
4663
4664 Ok(())
4665 }
4666 }
4667
4668 impl<'de> ::core::fmt::Debug for NodeInfoDeprecated<'de> {
4669 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4670 match self.raw.ordinal() {
4671 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Service>().fmt(f) },
4672 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::FileObject>().fmt(f) },
4673 3 => unsafe {
4674 self.raw.get().deref_unchecked::<crate::wire::DirectoryObject>().fmt(f)
4675 },
4676 4 => unsafe {
4677 self.raw.get().deref_unchecked::<crate::wire::SymlinkObject<'_>>().fmt(f)
4678 },
4679 _ => unsafe { ::core::hint::unreachable_unchecked() },
4680 }
4681 }
4682 }
4683
4684 impl<'de> ::fidl_next::IntoNatural for NodeInfoDeprecated<'de> {
4685 type Natural = crate::natural::NodeInfoDeprecated;
4686 }
4687}
4688
4689pub mod wire_optional {
4690
4691 pub use fidl_next_common_fuchsia_io::wire_optional::*;
4692
4693 #[repr(transparent)]
4694 pub struct ExtendedAttributeValue<'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 ExtendedAttributeValue<'_> {
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 ExtendedAttributeValue<'static> {
4711 type Narrowed<'de> = ExtendedAttributeValue<'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> ExtendedAttributeValue<'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::ExtendedAttributeValue<'de>> {
4730 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
4731 }
4732
4733 pub fn into_option(
4734 self,
4735 ) -> ::core::option::Option<crate::wire::ExtendedAttributeValue<'de>> {
4736 if self.is_some() {
4737 Some(crate::wire::ExtendedAttributeValue {
4738 raw: self.raw,
4739 _phantom: ::core::marker::PhantomData,
4740 })
4741 } else {
4742 None
4743 }
4744 }
4745 }
4746
4747 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExtendedAttributeValue<'de>
4748 where
4749 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4750 ___D: ::fidl_next::Decoder<'de>,
4751 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4752 {
4753 fn decode(
4754 mut slot: ::fidl_next::Slot<'_, Self>,
4755 decoder: &mut ___D,
4756 _: (),
4757 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4758 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4759 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4760 1 => {
4761 ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
4762 raw,
4763 decoder,
4764 (32768, ()),
4765 )?
4766 }
4767
4768 2 => ::fidl_next::wire::Union::decode_as::<
4769 ___D,
4770 ::fdomain_client::fidl_next::wire::Handle,
4771 >(raw, decoder, ())?,
4772
4773 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
4774 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4775 }
4776
4777 Ok(())
4778 }
4779 }
4780
4781 impl<'de> ::core::fmt::Debug for ExtendedAttributeValue<'de> {
4782 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4783 self.as_ref().fmt(f)
4784 }
4785 }
4786
4787 impl<'de> ::fidl_next::IntoNatural for ExtendedAttributeValue<'de> {
4788 type Natural = ::core::option::Option<crate::natural::ExtendedAttributeValue>;
4789 }
4790
4791 #[repr(transparent)]
4792 pub struct Representation<'de> {
4793 pub(crate) raw: ::fidl_next::wire::Union,
4794 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4795 }
4796
4797 impl ::fidl_next::Constrained for Representation<'_> {
4798 type Constraint = ();
4799
4800 fn validate(
4801 _: ::fidl_next::Slot<'_, Self>,
4802 _: Self::Constraint,
4803 ) -> Result<(), ::fidl_next::ValidationError> {
4804 Ok(())
4805 }
4806 }
4807
4808 unsafe impl ::fidl_next::Wire for Representation<'static> {
4809 type Narrowed<'de> = Representation<'de>;
4810
4811 #[inline]
4812 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4813 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4814 ::fidl_next::wire::Union::zero_padding(raw);
4815 }
4816 }
4817
4818 impl<'de> Representation<'de> {
4819 pub fn is_some(&self) -> bool {
4820 self.raw.is_some()
4821 }
4822
4823 pub fn is_none(&self) -> bool {
4824 self.raw.is_none()
4825 }
4826
4827 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Representation<'de>> {
4828 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
4829 }
4830
4831 pub fn into_option(self) -> ::core::option::Option<crate::wire::Representation<'de>> {
4832 if self.is_some() {
4833 Some(crate::wire::Representation {
4834 raw: self.raw,
4835 _phantom: ::core::marker::PhantomData,
4836 })
4837 } else {
4838 None
4839 }
4840 }
4841 }
4842
4843 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Representation<'de>
4844 where
4845 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4846 ___D: ::fidl_next::Decoder<'de>,
4847 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4848 {
4849 fn decode(
4850 mut slot: ::fidl_next::Slot<'_, Self>,
4851 decoder: &mut ___D,
4852 _: (),
4853 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4854 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4855 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4856 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::NodeInfo<'de>>(
4857 raw,
4858 decoder,
4859 (),
4860 )?,
4861
4862 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirectoryInfo<'de>>(
4863 raw,
4864 decoder,
4865 (),
4866 )?,
4867
4868 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::FileInfo<'de>>(
4869 raw,
4870 decoder,
4871 (),
4872 )?,
4873
4874 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SymlinkInfo<'de>>(
4875 raw,
4876 decoder,
4877 (),
4878 )?,
4879
4880 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
4881 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4882 }
4883
4884 Ok(())
4885 }
4886 }
4887
4888 impl<'de> ::core::fmt::Debug for Representation<'de> {
4889 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4890 self.as_ref().fmt(f)
4891 }
4892 }
4893
4894 impl<'de> ::fidl_next::IntoNatural for Representation<'de> {
4895 type Natural = ::core::option::Option<crate::natural::Representation>;
4896 }
4897
4898 #[repr(transparent)]
4899 pub struct NodeInfoDeprecated<'de> {
4900 pub(crate) raw: ::fidl_next::wire::Union,
4901 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4902 }
4903
4904 impl ::fidl_next::Constrained for NodeInfoDeprecated<'_> {
4905 type Constraint = ();
4906
4907 fn validate(
4908 _: ::fidl_next::Slot<'_, Self>,
4909 _: Self::Constraint,
4910 ) -> Result<(), ::fidl_next::ValidationError> {
4911 Ok(())
4912 }
4913 }
4914
4915 unsafe impl ::fidl_next::Wire for NodeInfoDeprecated<'static> {
4916 type Narrowed<'de> = NodeInfoDeprecated<'de>;
4917
4918 #[inline]
4919 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4920 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4921 ::fidl_next::wire::Union::zero_padding(raw);
4922 }
4923 }
4924
4925 impl<'de> NodeInfoDeprecated<'de> {
4926 pub fn is_some(&self) -> bool {
4927 self.raw.is_some()
4928 }
4929
4930 pub fn is_none(&self) -> bool {
4931 self.raw.is_none()
4932 }
4933
4934 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::NodeInfoDeprecated<'de>> {
4935 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
4936 }
4937
4938 pub fn into_option(self) -> ::core::option::Option<crate::wire::NodeInfoDeprecated<'de>> {
4939 if self.is_some() {
4940 Some(crate::wire::NodeInfoDeprecated {
4941 raw: self.raw,
4942 _phantom: ::core::marker::PhantomData,
4943 })
4944 } else {
4945 None
4946 }
4947 }
4948 }
4949
4950 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeInfoDeprecated<'de>
4951 where
4952 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4953 ___D: ::fidl_next::Decoder<'de>,
4954 ___D: ::fdomain_client::fidl_next::HandleDecoder,
4955 {
4956 fn decode(
4957 mut slot: ::fidl_next::Slot<'_, Self>,
4958 decoder: &mut ___D,
4959 _: (),
4960 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4961 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4962 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4963 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Service>(
4964 raw,
4965 decoder,
4966 (),
4967 )?,
4968
4969 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::FileObject>(
4970 raw,
4971 decoder,
4972 (),
4973 )?,
4974
4975 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirectoryObject>(
4976 raw,
4977 decoder,
4978 (),
4979 )?,
4980
4981 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SymlinkObject<'de>>(
4982 raw,
4983 decoder,
4984 (),
4985 )?,
4986
4987 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
4988 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4989 }
4990
4991 Ok(())
4992 }
4993 }
4994
4995 impl<'de> ::core::fmt::Debug for NodeInfoDeprecated<'de> {
4996 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4997 self.as_ref().fmt(f)
4998 }
4999 }
5000
5001 impl<'de> ::fidl_next::IntoNatural for NodeInfoDeprecated<'de> {
5002 type Natural = ::core::option::Option<crate::natural::NodeInfoDeprecated>;
5003 }
5004}
5005
5006pub mod generic {
5007
5008 pub use fidl_next_common_fuchsia_io::generic::*;
5009
5010 pub struct DirectoryLinkRequest<T0, T1, T2> {
5012 pub src: T0,
5013
5014 pub dst_parent_token: T1,
5015
5016 pub dst: T2,
5017 }
5018
5019 unsafe impl<___E, T0, T1, T2>
5020 ::fidl_next::Encode<crate::wire::DirectoryLinkRequest<'static>, ___E>
5021 for DirectoryLinkRequest<T0, T1, T2>
5022 where
5023 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5024 ___E: ::fidl_next::Encoder,
5025 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5026 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5027 T1: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::Handle, ___E>,
5028 T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5029 {
5030 #[inline]
5031 fn encode(
5032 self,
5033 encoder_: &mut ___E,
5034 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkRequest<'static>>,
5035 _: (),
5036 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5037 ::fidl_next::munge! {
5038 let crate::wire::DirectoryLinkRequest {
5039 src,
5040 dst_parent_token,
5041 dst,
5042
5043 } = out_;
5044 }
5045
5046 ::fidl_next::Encode::encode(self.src, encoder_, src, 255)?;
5047
5048 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
5049
5050 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
5051
5052 Ok(())
5053 }
5054 }
5055
5056 unsafe impl<'a, ___E, T0, T1, T2>
5057 ::fidl_next::Encode<crate::wire::DirectoryLinkRequest<'static>, ___E>
5058 for &'a DirectoryLinkRequest<T0, T1, T2>
5059 where
5060 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5061 ___E: ::fidl_next::Encoder,
5062 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5063 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5064 &'a T1: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::Handle, ___E>,
5065 &'a T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5066 {
5067 #[inline]
5068 fn encode(
5069 self,
5070 encoder_: &mut ___E,
5071 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkRequest<'static>>,
5072 _: (),
5073 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5074 ::fidl_next::munge! {
5075 let crate::wire::DirectoryLinkRequest {
5076 src,
5077 dst_parent_token,
5078 dst,
5079
5080 } = out_;
5081 }
5082
5083 ::fidl_next::Encode::encode(&self.src, encoder_, src, 255)?;
5084
5085 ::fidl_next::Encode::encode(&self.dst_parent_token, encoder_, dst_parent_token, ())?;
5086
5087 ::fidl_next::Encode::encode(&self.dst, encoder_, dst, 255)?;
5088
5089 Ok(())
5090 }
5091 }
5092
5093 pub struct DirectoryRenameRequest<T0, T1, T2> {
5095 pub src: T0,
5096
5097 pub dst_parent_token: T1,
5098
5099 pub dst: T2,
5100 }
5101
5102 unsafe impl<___E, T0, T1, T2>
5103 ::fidl_next::Encode<crate::wire::DirectoryRenameRequest<'static>, ___E>
5104 for DirectoryRenameRequest<T0, T1, T2>
5105 where
5106 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5107 ___E: ::fidl_next::Encoder,
5108 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5109 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5110 T1: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::Handle, ___E>,
5111 T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5112 {
5113 #[inline]
5114 fn encode(
5115 self,
5116 encoder_: &mut ___E,
5117 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRenameRequest<'static>>,
5118 _: (),
5119 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5120 ::fidl_next::munge! {
5121 let crate::wire::DirectoryRenameRequest {
5122 src,
5123 dst_parent_token,
5124 dst,
5125
5126 } = out_;
5127 }
5128
5129 ::fidl_next::Encode::encode(self.src, encoder_, src, 255)?;
5130
5131 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
5132
5133 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
5134
5135 Ok(())
5136 }
5137 }
5138
5139 unsafe impl<'a, ___E, T0, T1, T2>
5140 ::fidl_next::Encode<crate::wire::DirectoryRenameRequest<'static>, ___E>
5141 for &'a DirectoryRenameRequest<T0, T1, T2>
5142 where
5143 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5144 ___E: ::fidl_next::Encoder,
5145 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5146 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5147 &'a T1: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::Handle, ___E>,
5148 &'a T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5149 {
5150 #[inline]
5151 fn encode(
5152 self,
5153 encoder_: &mut ___E,
5154 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRenameRequest<'static>>,
5155 _: (),
5156 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5157 ::fidl_next::munge! {
5158 let crate::wire::DirectoryRenameRequest {
5159 src,
5160 dst_parent_token,
5161 dst,
5162
5163 } = out_;
5164 }
5165
5166 ::fidl_next::Encode::encode(&self.src, encoder_, src, 255)?;
5167
5168 ::fidl_next::Encode::encode(&self.dst_parent_token, encoder_, dst_parent_token, ())?;
5169
5170 ::fidl_next::Encode::encode(&self.dst, encoder_, dst, 255)?;
5171
5172 Ok(())
5173 }
5174 }
5175
5176 pub struct DirectoryWatchRequest<T0, T1, T2> {
5178 pub mask: T0,
5179
5180 pub options: T1,
5181
5182 pub watcher: T2,
5183 }
5184
5185 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::DirectoryWatchRequest, ___E>
5186 for DirectoryWatchRequest<T0, T1, T2>
5187 where
5188 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5189 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5190 T0: ::fidl_next::Encode<crate::wire::WatchMask, ___E>,
5191 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
5192 T2: ::fidl_next::Encode<
5193 ::fidl_next::ServerEnd<
5194 crate::DirectoryWatcher,
5195 ::fdomain_client::fidl_next::wire::Handle,
5196 >,
5197 ___E,
5198 >,
5199 {
5200 #[inline]
5201 fn encode(
5202 self,
5203 encoder_: &mut ___E,
5204 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchRequest>,
5205 _: (),
5206 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5207 ::fidl_next::munge! {
5208 let crate::wire::DirectoryWatchRequest {
5209 mask,
5210 options,
5211 watcher,
5212
5213 } = out_;
5214 }
5215
5216 ::fidl_next::Encode::encode(self.mask, encoder_, mask, ())?;
5217
5218 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
5219
5220 ::fidl_next::Encode::encode(self.watcher, encoder_, watcher, ())?;
5221
5222 Ok(())
5223 }
5224 }
5225
5226 unsafe impl<'a, ___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::DirectoryWatchRequest, ___E>
5227 for &'a DirectoryWatchRequest<T0, T1, T2>
5228 where
5229 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5230 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5231 &'a T0: ::fidl_next::Encode<crate::wire::WatchMask, ___E>,
5232 &'a T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
5233 &'a T2: ::fidl_next::Encode<
5234 ::fidl_next::ServerEnd<
5235 crate::DirectoryWatcher,
5236 ::fdomain_client::fidl_next::wire::Handle,
5237 >,
5238 ___E,
5239 >,
5240 {
5241 #[inline]
5242 fn encode(
5243 self,
5244 encoder_: &mut ___E,
5245 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchRequest>,
5246 _: (),
5247 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5248 ::fidl_next::munge! {
5249 let crate::wire::DirectoryWatchRequest {
5250 mask,
5251 options,
5252 watcher,
5253
5254 } = out_;
5255 }
5256
5257 ::fidl_next::Encode::encode(&self.mask, encoder_, mask, ())?;
5258
5259 ::fidl_next::Encode::encode(&self.options, encoder_, options, ())?;
5260
5261 ::fidl_next::Encode::encode(&self.watcher, encoder_, watcher, ())?;
5262
5263 Ok(())
5264 }
5265 }
5266
5267 pub struct NodeListExtendedAttributesRequest<T0> {
5269 pub iterator: T0,
5270 }
5271
5272 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeListExtendedAttributesRequest, ___E>
5273 for NodeListExtendedAttributesRequest<T0>
5274 where
5275 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5276 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5277 T0: ::fidl_next::Encode<
5278 ::fidl_next::ServerEnd<
5279 crate::ExtendedAttributeIterator,
5280 ::fdomain_client::fidl_next::wire::Handle,
5281 >,
5282 ___E,
5283 >,
5284 {
5285 #[inline]
5286 fn encode(
5287 self,
5288 encoder_: &mut ___E,
5289 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeListExtendedAttributesRequest>,
5290 _: (),
5291 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5292 ::fidl_next::munge! {
5293 let crate::wire::NodeListExtendedAttributesRequest {
5294 iterator,
5295
5296 } = out_;
5297 }
5298
5299 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
5300
5301 Ok(())
5302 }
5303 }
5304
5305 unsafe impl<'a, ___E, T0>
5306 ::fidl_next::Encode<crate::wire::NodeListExtendedAttributesRequest, ___E>
5307 for &'a NodeListExtendedAttributesRequest<T0>
5308 where
5309 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5310 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5311 &'a T0: ::fidl_next::Encode<
5312 ::fidl_next::ServerEnd<
5313 crate::ExtendedAttributeIterator,
5314 ::fdomain_client::fidl_next::wire::Handle,
5315 >,
5316 ___E,
5317 >,
5318 {
5319 #[inline]
5320 fn encode(
5321 self,
5322 encoder_: &mut ___E,
5323 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeListExtendedAttributesRequest>,
5324 _: (),
5325 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5326 ::fidl_next::munge! {
5327 let crate::wire::NodeListExtendedAttributesRequest {
5328 iterator,
5329
5330 } = out_;
5331 }
5332
5333 ::fidl_next::Encode::encode(&self.iterator, encoder_, iterator, ())?;
5334
5335 Ok(())
5336 }
5337 }
5338
5339 pub struct NodeSetExtendedAttributeRequest<T0, T1, T2> {
5341 pub name: T0,
5342
5343 pub value: T1,
5344
5345 pub mode: T2,
5346 }
5347
5348 unsafe impl<___E, T0, T1, T2>
5349 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeRequest<'static>, ___E>
5350 for NodeSetExtendedAttributeRequest<T0, T1, T2>
5351 where
5352 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5353 ___E: ::fidl_next::Encoder,
5354 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5355 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
5356 T1: ::fidl_next::Encode<crate::wire::ExtendedAttributeValue<'static>, ___E>,
5357 T2: ::fidl_next::Encode<crate::wire::SetExtendedAttributeMode, ___E>,
5358 {
5359 #[inline]
5360 fn encode(
5361 self,
5362 encoder_: &mut ___E,
5363 out_: &mut ::core::mem::MaybeUninit<
5364 crate::wire::NodeSetExtendedAttributeRequest<'static>,
5365 >,
5366 _: (),
5367 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5368 ::fidl_next::munge! {
5369 let crate::wire::NodeSetExtendedAttributeRequest {
5370 name,
5371 value,
5372 mode,
5373
5374 } = out_;
5375 }
5376
5377 ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
5378
5379 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
5380
5381 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
5382
5383 Ok(())
5384 }
5385 }
5386
5387 unsafe impl<'a, ___E, T0, T1, T2>
5388 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeRequest<'static>, ___E>
5389 for &'a NodeSetExtendedAttributeRequest<T0, T1, T2>
5390 where
5391 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5392 ___E: ::fidl_next::Encoder,
5393 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5394 &'a T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
5395 &'a T1: ::fidl_next::Encode<crate::wire::ExtendedAttributeValue<'static>, ___E>,
5396 &'a T2: ::fidl_next::Encode<crate::wire::SetExtendedAttributeMode, ___E>,
5397 {
5398 #[inline]
5399 fn encode(
5400 self,
5401 encoder_: &mut ___E,
5402 out_: &mut ::core::mem::MaybeUninit<
5403 crate::wire::NodeSetExtendedAttributeRequest<'static>,
5404 >,
5405 _: (),
5406 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5407 ::fidl_next::munge! {
5408 let crate::wire::NodeSetExtendedAttributeRequest {
5409 name,
5410 value,
5411 mode,
5412
5413 } = out_;
5414 }
5415
5416 ::fidl_next::Encode::encode(&self.name, encoder_, name, (255, ()))?;
5417
5418 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
5419
5420 ::fidl_next::Encode::encode(&self.mode, encoder_, mode, ())?;
5421
5422 Ok(())
5423 }
5424 }
5425
5426 pub struct NodeGetTokenResponse<T0> {
5428 pub token: T0,
5429 }
5430
5431 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeGetTokenResponse, ___E>
5432 for NodeGetTokenResponse<T0>
5433 where
5434 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5435 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5436 T0: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::Handle, ___E>,
5437 {
5438 #[inline]
5439 fn encode(
5440 self,
5441 encoder_: &mut ___E,
5442 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetTokenResponse>,
5443 _: (),
5444 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5445 ::fidl_next::munge! {
5446 let crate::wire::NodeGetTokenResponse {
5447 token,
5448
5449 } = out_;
5450 }
5451
5452 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
5453
5454 Ok(())
5455 }
5456 }
5457
5458 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::NodeGetTokenResponse, ___E>
5459 for &'a NodeGetTokenResponse<T0>
5460 where
5461 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5462 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5463 &'a T0: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::Handle, ___E>,
5464 {
5465 #[inline]
5466 fn encode(
5467 self,
5468 encoder_: &mut ___E,
5469 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetTokenResponse>,
5470 _: (),
5471 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5472 ::fidl_next::munge! {
5473 let crate::wire::NodeGetTokenResponse {
5474 token,
5475
5476 } = out_;
5477 }
5478
5479 ::fidl_next::Encode::encode(&self.token, encoder_, token, ())?;
5480
5481 Ok(())
5482 }
5483 }
5484
5485 pub struct DirectoryDeprecatedGetTokenResponse<T0, T1> {
5487 pub s: T0,
5488
5489 pub token: T1,
5490 }
5491
5492 unsafe impl<___E, T0, T1>
5493 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedGetTokenResponse, ___E>
5494 for DirectoryDeprecatedGetTokenResponse<T0, T1>
5495 where
5496 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5497 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5498 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
5499 T1: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::OptionalHandle, ___E>,
5500 {
5501 #[inline]
5502 fn encode(
5503 self,
5504 encoder_: &mut ___E,
5505 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryDeprecatedGetTokenResponse>,
5506 _: (),
5507 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5508 ::fidl_next::munge! {
5509 let crate::wire::DirectoryDeprecatedGetTokenResponse {
5510 s,
5511 token,
5512
5513 } = out_;
5514 }
5515
5516 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
5517
5518 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
5519
5520 Ok(())
5521 }
5522 }
5523
5524 unsafe impl<'a, ___E, T0, T1>
5525 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedGetTokenResponse, ___E>
5526 for &'a DirectoryDeprecatedGetTokenResponse<T0, T1>
5527 where
5528 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5529 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5530 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
5531 &'a T1: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::OptionalHandle, ___E>,
5532 {
5533 #[inline]
5534 fn encode(
5535 self,
5536 encoder_: &mut ___E,
5537 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryDeprecatedGetTokenResponse>,
5538 _: (),
5539 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5540 ::fidl_next::munge! {
5541 let crate::wire::DirectoryDeprecatedGetTokenResponse {
5542 s,
5543 token,
5544
5545 } = out_;
5546 }
5547
5548 ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
5549
5550 ::fidl_next::Encode::encode(&self.token, encoder_, token, ())?;
5551
5552 Ok(())
5553 }
5554 }
5555
5556 pub struct OpenableOpenRequest<T0, T1, T2, T3> {
5558 pub path: T0,
5559
5560 pub flags: T1,
5561
5562 pub options: T2,
5563
5564 pub object: T3,
5565 }
5566
5567 unsafe impl<___E, T0, T1, T2, T3>
5568 ::fidl_next::Encode<crate::wire::OpenableOpenRequest<'static>, ___E>
5569 for OpenableOpenRequest<T0, T1, T2, T3>
5570 where
5571 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5572 ___E: ::fidl_next::Encoder,
5573 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5574 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5575 T1: ::fidl_next::Encode<crate::wire::Flags, ___E>,
5576 T2: ::fidl_next::Encode<crate::wire::Options<'static>, ___E>,
5577 T3: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::Handle, ___E>,
5578 {
5579 #[inline]
5580 fn encode(
5581 self,
5582 encoder_: &mut ___E,
5583 out_: &mut ::core::mem::MaybeUninit<crate::wire::OpenableOpenRequest<'static>>,
5584 _: (),
5585 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5586 ::fidl_next::munge! {
5587 let crate::wire::OpenableOpenRequest {
5588 path,
5589 flags,
5590 options,
5591 object,
5592
5593 } = out_;
5594 }
5595
5596 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
5597
5598 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
5599
5600 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
5601
5602 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
5603
5604 Ok(())
5605 }
5606 }
5607
5608 unsafe impl<'a, ___E, T0, T1, T2, T3>
5609 ::fidl_next::Encode<crate::wire::OpenableOpenRequest<'static>, ___E>
5610 for &'a OpenableOpenRequest<T0, T1, T2, T3>
5611 where
5612 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5613 ___E: ::fidl_next::Encoder,
5614 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5615 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5616 &'a T1: ::fidl_next::Encode<crate::wire::Flags, ___E>,
5617 &'a T2: ::fidl_next::Encode<crate::wire::Options<'static>, ___E>,
5618 &'a T3: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::Handle, ___E>,
5619 {
5620 #[inline]
5621 fn encode(
5622 self,
5623 encoder_: &mut ___E,
5624 out_: &mut ::core::mem::MaybeUninit<crate::wire::OpenableOpenRequest<'static>>,
5625 _: (),
5626 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5627 ::fidl_next::munge! {
5628 let crate::wire::OpenableOpenRequest {
5629 path,
5630 flags,
5631 options,
5632 object,
5633
5634 } = out_;
5635 }
5636
5637 ::fidl_next::Encode::encode(&self.path, encoder_, path, 4095)?;
5638
5639 ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
5640
5641 ::fidl_next::Encode::encode(&self.options, encoder_, options, ())?;
5642
5643 ::fidl_next::Encode::encode(&self.object, encoder_, object, ())?;
5644
5645 Ok(())
5646 }
5647 }
5648
5649 pub struct NodeOnOpenRequest<T0, T1> {
5651 pub s: T0,
5652
5653 pub info: T1,
5654 }
5655
5656 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeOnOpenRequest<'static>, ___E>
5657 for NodeOnOpenRequest<T0, T1>
5658 where
5659 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5660 ___E: ::fidl_next::Encoder,
5661 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5662 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
5663 T1: ::fidl_next::Encode<crate::wire_optional::NodeInfoDeprecated<'static>, ___E>,
5664 {
5665 #[inline]
5666 fn encode(
5667 self,
5668 encoder_: &mut ___E,
5669 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeOnOpenRequest<'static>>,
5670 _: (),
5671 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5672 ::fidl_next::munge! {
5673 let crate::wire::NodeOnOpenRequest {
5674 s,
5675 info,
5676
5677 } = out_;
5678 }
5679
5680 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
5681
5682 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
5683
5684 Ok(())
5685 }
5686 }
5687
5688 unsafe impl<'a, ___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeOnOpenRequest<'static>, ___E>
5689 for &'a NodeOnOpenRequest<T0, T1>
5690 where
5691 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5692 ___E: ::fidl_next::Encoder,
5693 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5694 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
5695 &'a T1: ::fidl_next::Encode<crate::wire_optional::NodeInfoDeprecated<'static>, ___E>,
5696 {
5697 #[inline]
5698 fn encode(
5699 self,
5700 encoder_: &mut ___E,
5701 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeOnOpenRequest<'static>>,
5702 _: (),
5703 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5704 ::fidl_next::munge! {
5705 let crate::wire::NodeOnOpenRequest {
5706 s,
5707 info,
5708
5709 } = out_;
5710 }
5711
5712 ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
5713
5714 ::fidl_next::Encode::encode(&self.info, encoder_, info, ())?;
5715
5716 Ok(())
5717 }
5718 }
5719
5720 pub struct DirectoryDeprecatedOpenRequest<T0, T1, T2, T3> {
5722 pub flags: T0,
5723
5724 pub mode: T1,
5725
5726 pub path: T2,
5727
5728 pub object: T3,
5729 }
5730
5731 unsafe impl<___E, T0, T1, T2, T3>
5732 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedOpenRequest<'static>, ___E>
5733 for DirectoryDeprecatedOpenRequest<T0, T1, T2, T3>
5734 where
5735 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5736 ___E: ::fidl_next::Encoder,
5737 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5738 T0: ::fidl_next::Encode<crate::wire::OpenFlags, ___E>,
5739 T1: ::fidl_next::Encode<crate::wire::ModeType, ___E>,
5740 T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5741 T3: ::fidl_next::Encode<
5742 ::fidl_next::ServerEnd<crate::Node, ::fdomain_client::fidl_next::wire::Handle>,
5743 ___E,
5744 >,
5745 {
5746 #[inline]
5747 fn encode(
5748 self,
5749 encoder_: &mut ___E,
5750 out_: &mut ::core::mem::MaybeUninit<
5751 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
5752 >,
5753 _: (),
5754 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5755 ::fidl_next::munge! {
5756 let crate::wire::DirectoryDeprecatedOpenRequest {
5757 flags,
5758 mode,
5759 path,
5760 object,
5761
5762 } = out_;
5763 }
5764
5765 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
5766
5767 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
5768
5769 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
5770
5771 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
5772
5773 Ok(())
5774 }
5775 }
5776
5777 unsafe impl<'a, ___E, T0, T1, T2, T3>
5778 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedOpenRequest<'static>, ___E>
5779 for &'a DirectoryDeprecatedOpenRequest<T0, T1, T2, T3>
5780 where
5781 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5782 ___E: ::fidl_next::Encoder,
5783 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5784 &'a T0: ::fidl_next::Encode<crate::wire::OpenFlags, ___E>,
5785 &'a T1: ::fidl_next::Encode<crate::wire::ModeType, ___E>,
5786 &'a T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5787 &'a T3: ::fidl_next::Encode<
5788 ::fidl_next::ServerEnd<crate::Node, ::fdomain_client::fidl_next::wire::Handle>,
5789 ___E,
5790 >,
5791 {
5792 #[inline]
5793 fn encode(
5794 self,
5795 encoder_: &mut ___E,
5796 out_: &mut ::core::mem::MaybeUninit<
5797 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
5798 >,
5799 _: (),
5800 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5801 ::fidl_next::munge! {
5802 let crate::wire::DirectoryDeprecatedOpenRequest {
5803 flags,
5804 mode,
5805 path,
5806 object,
5807
5808 } = out_;
5809 }
5810
5811 ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
5812
5813 ::fidl_next::Encode::encode(&self.mode, encoder_, mode, ())?;
5814
5815 ::fidl_next::Encode::encode(&self.path, encoder_, path, 4095)?;
5816
5817 ::fidl_next::Encode::encode(&self.object, encoder_, object, ())?;
5818
5819 Ok(())
5820 }
5821 }
5822
5823 pub struct DirectoryCreateSymlinkRequest<T0, T1, T2> {
5825 pub name: T0,
5826
5827 pub target: T1,
5828
5829 pub connection: T2,
5830 }
5831
5832 unsafe impl<___E, T0, T1, T2>
5833 ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkRequest<'static>, ___E>
5834 for DirectoryCreateSymlinkRequest<T0, T1, T2>
5835 where
5836 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5837 ___E: ::fidl_next::Encoder,
5838 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5839 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5840 T1: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
5841 T2: ::fidl_next::Encode<
5842 ::fidl_next::ServerEnd<
5843 crate::Symlink,
5844 ::fdomain_client::fidl_next::wire::OptionalHandle,
5845 >,
5846 ___E,
5847 >,
5848 {
5849 #[inline]
5850 fn encode(
5851 self,
5852 encoder_: &mut ___E,
5853 out_: &mut ::core::mem::MaybeUninit<
5854 crate::wire::DirectoryCreateSymlinkRequest<'static>,
5855 >,
5856 _: (),
5857 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5858 ::fidl_next::munge! {
5859 let crate::wire::DirectoryCreateSymlinkRequest {
5860 name,
5861 target,
5862 connection,
5863
5864 } = out_;
5865 }
5866
5867 ::fidl_next::Encode::encode(self.name, encoder_, name, 255)?;
5868
5869 ::fidl_next::Encode::encode(self.target, encoder_, target, (4095, ()))?;
5870
5871 ::fidl_next::Encode::encode(self.connection, encoder_, connection, ())?;
5872
5873 Ok(())
5874 }
5875 }
5876
5877 unsafe impl<'a, ___E, T0, T1, T2>
5878 ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkRequest<'static>, ___E>
5879 for &'a DirectoryCreateSymlinkRequest<T0, T1, T2>
5880 where
5881 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5882 ___E: ::fidl_next::Encoder,
5883 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5884 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5885 &'a T1: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
5886 &'a T2: ::fidl_next::Encode<
5887 ::fidl_next::ServerEnd<
5888 crate::Symlink,
5889 ::fdomain_client::fidl_next::wire::OptionalHandle,
5890 >,
5891 ___E,
5892 >,
5893 {
5894 #[inline]
5895 fn encode(
5896 self,
5897 encoder_: &mut ___E,
5898 out_: &mut ::core::mem::MaybeUninit<
5899 crate::wire::DirectoryCreateSymlinkRequest<'static>,
5900 >,
5901 _: (),
5902 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5903 ::fidl_next::munge! {
5904 let crate::wire::DirectoryCreateSymlinkRequest {
5905 name,
5906 target,
5907 connection,
5908
5909 } = out_;
5910 }
5911
5912 ::fidl_next::Encode::encode(&self.name, encoder_, name, 255)?;
5913
5914 ::fidl_next::Encode::encode(&self.target, encoder_, target, (4095, ()))?;
5915
5916 ::fidl_next::Encode::encode(&self.connection, encoder_, connection, ())?;
5917
5918 Ok(())
5919 }
5920 }
5921
5922 pub struct FileGetBackingMemoryResponse<T0> {
5924 pub vmo: T0,
5925 }
5926
5927 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryResponse, ___E>
5928 for FileGetBackingMemoryResponse<T0>
5929 where
5930 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5931 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5932 T0: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::Handle, ___E>,
5933 {
5934 #[inline]
5935 fn encode(
5936 self,
5937 encoder_: &mut ___E,
5938 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryResponse>,
5939 _: (),
5940 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5941 ::fidl_next::munge! {
5942 let crate::wire::FileGetBackingMemoryResponse {
5943 vmo,
5944
5945 } = out_;
5946 }
5947
5948 ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
5949
5950 Ok(())
5951 }
5952 }
5953
5954 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryResponse, ___E>
5955 for &'a FileGetBackingMemoryResponse<T0>
5956 where
5957 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5958 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5959 &'a T0: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::Handle, ___E>,
5960 {
5961 #[inline]
5962 fn encode(
5963 self,
5964 encoder_: &mut ___E,
5965 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryResponse>,
5966 _: (),
5967 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5968 ::fidl_next::munge! {
5969 let crate::wire::FileGetBackingMemoryResponse {
5970 vmo,
5971
5972 } = out_;
5973 }
5974
5975 ::fidl_next::Encode::encode(&self.vmo, encoder_, vmo, ())?;
5976
5977 Ok(())
5978 }
5979 }
5980
5981 pub struct LinkableLinkIntoRequest<T0, T1> {
5983 pub dst_parent_token: T0,
5984
5985 pub dst: T1,
5986 }
5987
5988 unsafe impl<___E, T0, T1>
5989 ::fidl_next::Encode<crate::wire::LinkableLinkIntoRequest<'static>, ___E>
5990 for LinkableLinkIntoRequest<T0, T1>
5991 where
5992 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5993 ___E: ::fidl_next::Encoder,
5994 ___E: ::fdomain_client::fidl_next::HandleEncoder,
5995 T0: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::Handle, ___E>,
5996 T1: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5997 {
5998 #[inline]
5999 fn encode(
6000 self,
6001 encoder_: &mut ___E,
6002 out_: &mut ::core::mem::MaybeUninit<crate::wire::LinkableLinkIntoRequest<'static>>,
6003 _: (),
6004 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6005 ::fidl_next::munge! {
6006 let crate::wire::LinkableLinkIntoRequest {
6007 dst_parent_token,
6008 dst,
6009
6010 } = out_;
6011 }
6012
6013 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
6014
6015 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
6016
6017 Ok(())
6018 }
6019 }
6020
6021 unsafe impl<'a, ___E, T0, T1>
6022 ::fidl_next::Encode<crate::wire::LinkableLinkIntoRequest<'static>, ___E>
6023 for &'a LinkableLinkIntoRequest<T0, T1>
6024 where
6025 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6026 ___E: ::fidl_next::Encoder,
6027 ___E: ::fdomain_client::fidl_next::HandleEncoder,
6028 &'a T0: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::Handle, ___E>,
6029 &'a T1: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
6030 {
6031 #[inline]
6032 fn encode(
6033 self,
6034 encoder_: &mut ___E,
6035 out_: &mut ::core::mem::MaybeUninit<crate::wire::LinkableLinkIntoRequest<'static>>,
6036 _: (),
6037 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6038 ::fidl_next::munge! {
6039 let crate::wire::LinkableLinkIntoRequest {
6040 dst_parent_token,
6041 dst,
6042
6043 } = out_;
6044 }
6045
6046 ::fidl_next::Encode::encode(&self.dst_parent_token, encoder_, dst_parent_token, ())?;
6047
6048 ::fidl_next::Encode::encode(&self.dst, encoder_, dst, 255)?;
6049
6050 Ok(())
6051 }
6052 }
6053
6054 pub struct FileAllocateRequest<T0, T1, T2> {
6056 pub offset: T0,
6057
6058 pub length: T1,
6059
6060 pub mode: T2,
6061 }
6062
6063 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::FileAllocateRequest, ___E>
6064 for FileAllocateRequest<T0, T1, T2>
6065 where
6066 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6067 ___E: ::fdomain_client::fidl_next::HandleEncoder,
6068 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
6069 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
6070 T2: ::fidl_next::Encode<crate::wire::AllocateMode, ___E>,
6071 {
6072 #[inline]
6073 fn encode(
6074 self,
6075 encoder_: &mut ___E,
6076 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileAllocateRequest>,
6077 _: (),
6078 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6079 ::fidl_next::munge! {
6080 let crate::wire::FileAllocateRequest {
6081 offset,
6082 length,
6083 mode,
6084
6085 } = out_;
6086 }
6087
6088 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
6089
6090 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
6091
6092 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
6093
6094 Ok(())
6095 }
6096 }
6097
6098 unsafe impl<'a, ___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::FileAllocateRequest, ___E>
6099 for &'a FileAllocateRequest<T0, T1, T2>
6100 where
6101 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6102 ___E: ::fdomain_client::fidl_next::HandleEncoder,
6103 &'a T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
6104 &'a T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
6105 &'a T2: ::fidl_next::Encode<crate::wire::AllocateMode, ___E>,
6106 {
6107 #[inline]
6108 fn encode(
6109 self,
6110 encoder_: &mut ___E,
6111 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileAllocateRequest>,
6112 _: (),
6113 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6114 ::fidl_next::munge! {
6115 let crate::wire::FileAllocateRequest {
6116 offset,
6117 length,
6118 mode,
6119
6120 } = out_;
6121 }
6122
6123 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
6124
6125 ::fidl_next::Encode::encode(&self.length, encoder_, length, ())?;
6126
6127 ::fidl_next::Encode::encode(&self.mode, encoder_, mode, ())?;
6128
6129 Ok(())
6130 }
6131 }
6132
6133 pub struct FileEnableVerityRequest<T0> {
6135 pub options: T0,
6136 }
6137
6138 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileEnableVerityRequest<'static>, ___E>
6139 for FileEnableVerityRequest<T0>
6140 where
6141 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6142 ___E: ::fidl_next::Encoder,
6143 ___E: ::fdomain_client::fidl_next::HandleEncoder,
6144 T0: ::fidl_next::Encode<crate::wire::VerificationOptions<'static>, ___E>,
6145 {
6146 #[inline]
6147 fn encode(
6148 self,
6149 encoder_: &mut ___E,
6150 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileEnableVerityRequest<'static>>,
6151 _: (),
6152 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6153 ::fidl_next::munge! {
6154 let crate::wire::FileEnableVerityRequest {
6155 options,
6156
6157 } = out_;
6158 }
6159
6160 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
6161
6162 Ok(())
6163 }
6164 }
6165
6166 unsafe impl<'a, ___E, T0>
6167 ::fidl_next::Encode<crate::wire::FileEnableVerityRequest<'static>, ___E>
6168 for &'a FileEnableVerityRequest<T0>
6169 where
6170 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6171 ___E: ::fidl_next::Encoder,
6172 ___E: ::fdomain_client::fidl_next::HandleEncoder,
6173 &'a T0: ::fidl_next::Encode<crate::wire::VerificationOptions<'static>, ___E>,
6174 {
6175 #[inline]
6176 fn encode(
6177 self,
6178 encoder_: &mut ___E,
6179 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileEnableVerityRequest<'static>>,
6180 _: (),
6181 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6182 ::fidl_next::munge! {
6183 let crate::wire::FileEnableVerityRequest {
6184 options,
6185
6186 } = out_;
6187 }
6188
6189 ::fidl_next::Encode::encode(&self.options, encoder_, options, ())?;
6190
6191 Ok(())
6192 }
6193 }
6194
6195 pub struct FileObject<T0, T1> {
6197 pub event: T0,
6198
6199 pub stream: T1,
6200 }
6201
6202 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::FileObject, ___E> for FileObject<T0, T1>
6203 where
6204 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6205 ___E: ::fdomain_client::fidl_next::HandleEncoder,
6206 T0: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::OptionalHandle, ___E>,
6207 T1: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::OptionalHandle, ___E>,
6208 {
6209 #[inline]
6210 fn encode(
6211 self,
6212 encoder_: &mut ___E,
6213 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileObject>,
6214 _: (),
6215 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6216 ::fidl_next::munge! {
6217 let crate::wire::FileObject {
6218 event,
6219 stream,
6220
6221 } = out_;
6222 }
6223
6224 ::fidl_next::Encode::encode(self.event, encoder_, event, ())?;
6225
6226 ::fidl_next::Encode::encode(self.stream, encoder_, stream, ())?;
6227
6228 Ok(())
6229 }
6230 }
6231
6232 unsafe impl<'a, ___E, T0, T1> ::fidl_next::Encode<crate::wire::FileObject, ___E>
6233 for &'a FileObject<T0, T1>
6234 where
6235 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6236 ___E: ::fdomain_client::fidl_next::HandleEncoder,
6237 &'a T0: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::OptionalHandle, ___E>,
6238 &'a T1: ::fidl_next::Encode<::fdomain_client::fidl_next::wire::OptionalHandle, ___E>,
6239 {
6240 #[inline]
6241 fn encode(
6242 self,
6243 encoder_: &mut ___E,
6244 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileObject>,
6245 _: (),
6246 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6247 ::fidl_next::munge! {
6248 let crate::wire::FileObject {
6249 event,
6250 stream,
6251
6252 } = out_;
6253 }
6254
6255 ::fidl_next::Encode::encode(&self.event, encoder_, event, ())?;
6256
6257 ::fidl_next::Encode::encode(&self.stream, encoder_, stream, ())?;
6258
6259 Ok(())
6260 }
6261 }
6262}
6263
6264pub use self::natural::*;
6265
6266#[doc = " Openable defines a node which is capable of opening other objects.\n"]
6268#[derive(PartialEq, Debug)]
6269pub struct Openable;
6270
6271#[cfg(target_os = "fuchsia")]
6272impl ::fidl_next::HasTransport for Openable {
6273 type Transport = ::fdomain_client::Channel;
6274}
6275
6276pub mod openable {
6277 pub mod prelude {
6278 pub use crate::{
6279 Openable, OpenableClientHandler, OpenableLocalClientHandler,
6280 OpenableLocalServerHandler, OpenableServerHandler, openable,
6281 };
6282
6283 pub use crate::natural::OpenableOpenRequest;
6284 }
6285
6286 pub struct Open;
6287
6288 impl ::fidl_next::Method for Open {
6289 const ORDINAL: u64 = 6236883748953765593;
6290 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6291 ::fidl_next::protocol::Flexibility::Flexible;
6292
6293 type Protocol = crate::Openable;
6294
6295 type Request = crate::wire::OpenableOpenRequest<'static>;
6296 }
6297
6298 mod ___detail {
6299 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Openable
6300 where
6301 ___T: ::fidl_next::Transport,
6302 {
6303 type Client = OpenableClient<___T>;
6304 type Server = OpenableServer<___T>;
6305 }
6306
6307 #[repr(transparent)]
6309 pub struct OpenableClient<___T: ::fidl_next::Transport> {
6310 #[allow(dead_code)]
6311 client: ::fidl_next::protocol::Client<___T>,
6312 }
6313
6314 impl<___T> OpenableClient<___T>
6315 where
6316 ___T: ::fidl_next::Transport,
6317 {
6318 #[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"]
6319 pub fn open(
6320 &self,
6321
6322 path: impl ::fidl_next::Encode<
6323 ::fidl_next::wire::String<'static>,
6324 <___T as ::fidl_next::Transport>::SendBuffer,
6325 >,
6326
6327 flags: impl ::fidl_next::Encode<
6328 crate::wire::Flags,
6329 <___T as ::fidl_next::Transport>::SendBuffer,
6330 >,
6331
6332 options: impl ::fidl_next::Encode<
6333 crate::wire::Options<'static>,
6334 <___T as ::fidl_next::Transport>::SendBuffer,
6335 >,
6336
6337 object: impl ::fidl_next::Encode<
6338 ::fdomain_client::fidl_next::wire::Handle,
6339 <___T as ::fidl_next::Transport>::SendBuffer,
6340 >,
6341 ) -> ::fidl_next::SendFuture<'_, ___T>
6342 where
6343 <___T as ::fidl_next::Transport>::SendBuffer:
6344 ::fidl_next::encoder::InternalHandleEncoder,
6345 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
6346 <___T as ::fidl_next::Transport>::SendBuffer:
6347 ::fdomain_client::fidl_next::HandleEncoder,
6348 {
6349 self.open_with(crate::generic::OpenableOpenRequest { path, flags, options, object })
6350 }
6351
6352 #[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"]
6353 pub fn open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
6354 where
6355 ___R: ::fidl_next::Encode<
6356 crate::wire::OpenableOpenRequest<'static>,
6357 <___T as ::fidl_next::Transport>::SendBuffer,
6358 >,
6359 {
6360 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
6361 6236883748953765593,
6362 <super::Open as ::fidl_next::Method>::FLEXIBILITY,
6363 request,
6364 ))
6365 }
6366 }
6367
6368 #[repr(transparent)]
6370 pub struct OpenableServer<___T: ::fidl_next::Transport> {
6371 server: ::fidl_next::protocol::Server<___T>,
6372 }
6373
6374 impl<___T> OpenableServer<___T> where ___T: ::fidl_next::Transport {}
6375 }
6376}
6377
6378#[diagnostic::on_unimplemented(
6379 note = "If {Self} implements the non-local OpenableClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
6380)]
6381
6382pub trait OpenableLocalClientHandler<
6386 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
6387 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6388>
6389{
6390 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
6391 ::core::future::ready(())
6392 }
6393}
6394
6395impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Openable
6396where
6397 ___H: OpenableLocalClientHandler<___T>,
6398 ___T: ::fidl_next::Transport,
6399{
6400 async fn on_event(
6401 handler: &mut ___H,
6402 mut message: ::fidl_next::Message<___T>,
6403 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
6404 match *message.header().ordinal {
6405 ordinal => {
6406 handler.on_unknown_interaction(ordinal).await;
6407 if ::core::matches!(
6408 message.header().flexibility(),
6409 ::fidl_next::protocol::Flexibility::Strict
6410 ) {
6411 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
6412 } else {
6413 Ok(())
6414 }
6415 }
6416 }
6417 }
6418}
6419
6420#[diagnostic::on_unimplemented(
6421 note = "If {Self} implements the non-local OpenableServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
6422)]
6423
6424pub trait OpenableLocalServerHandler<
6428 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
6429 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6430>
6431{
6432 #[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"]
6433 fn open(
6434 &mut self,
6435
6436 request: ::fidl_next::Request<openable::Open, ___T>,
6437 ) -> impl ::core::future::Future<Output = ()>;
6438
6439 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
6440 ::core::future::ready(())
6441 }
6442}
6443
6444impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Openable
6445where
6446 ___H: OpenableLocalServerHandler<___T>,
6447 ___T: ::fidl_next::Transport,
6448 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
6449 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
6450 Constraint = (),
6451 >,
6452{
6453 async fn on_one_way(
6454 handler: &mut ___H,
6455 mut message: ::fidl_next::Message<___T>,
6456 ) -> ::core::result::Result<
6457 (),
6458 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6459 > {
6460 match *message.header().ordinal {
6461 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
6462 Ok(decoded) => {
6463 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
6464 Ok(())
6465 }
6466 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
6467 ordinal: 6236883748953765593,
6468 error,
6469 }),
6470 },
6471
6472 ordinal => {
6473 handler.on_unknown_interaction(ordinal).await;
6474 if ::core::matches!(
6475 message.header().flexibility(),
6476 ::fidl_next::protocol::Flexibility::Strict
6477 ) {
6478 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
6479 } else {
6480 Ok(())
6481 }
6482 }
6483 }
6484 }
6485
6486 async fn on_two_way(
6487 handler: &mut ___H,
6488 mut message: ::fidl_next::Message<___T>,
6489 responder: ::fidl_next::protocol::Responder<___T>,
6490 ) -> ::core::result::Result<
6491 (),
6492 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6493 > {
6494 match *message.header().ordinal {
6495 ordinal => {
6496 handler.on_unknown_interaction(ordinal).await;
6497 if ::core::matches!(
6498 message.header().flexibility(),
6499 ::fidl_next::protocol::Flexibility::Strict
6500 ) {
6501 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
6502 } else {
6503 responder
6504 .respond_framework_error(
6505 ordinal,
6506 ::fidl_next::FrameworkError::UnknownMethod,
6507 )
6508 .expect("encoding a framework error should never fail")
6509 .await?;
6510 Ok(())
6511 }
6512 }
6513 }
6514 }
6515}
6516
6517pub trait OpenableClientHandler<
6521 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
6522 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6523>
6524{
6525 fn on_unknown_interaction(
6526 &mut self,
6527 ordinal: u64,
6528 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
6529 ::core::future::ready(())
6530 }
6531}
6532
6533impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Openable
6534where
6535 ___H: OpenableClientHandler<___T> + ::core::marker::Send,
6536 ___T: ::fidl_next::Transport,
6537{
6538 async fn on_event(
6539 handler: &mut ___H,
6540 mut message: ::fidl_next::Message<___T>,
6541 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
6542 match *message.header().ordinal {
6543 ordinal => {
6544 handler.on_unknown_interaction(ordinal).await;
6545 if ::core::matches!(
6546 message.header().flexibility(),
6547 ::fidl_next::protocol::Flexibility::Strict
6548 ) {
6549 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
6550 } else {
6551 Ok(())
6552 }
6553 }
6554 }
6555 }
6556}
6557
6558pub trait OpenableServerHandler<
6562 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
6563 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6564>
6565{
6566 #[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"]
6567 fn open(
6568 &mut self,
6569
6570 request: ::fidl_next::Request<openable::Open, ___T>,
6571 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6572
6573 fn on_unknown_interaction(
6574 &mut self,
6575 ordinal: u64,
6576 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
6577 ::core::future::ready(())
6578 }
6579}
6580
6581impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Openable
6582where
6583 ___H: OpenableServerHandler<___T> + ::core::marker::Send,
6584 ___T: ::fidl_next::Transport,
6585 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
6586 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
6587 Constraint = (),
6588 >,
6589{
6590 async fn on_one_way(
6591 handler: &mut ___H,
6592 mut message: ::fidl_next::Message<___T>,
6593 ) -> ::core::result::Result<
6594 (),
6595 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6596 > {
6597 match *message.header().ordinal {
6598 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
6599 Ok(decoded) => {
6600 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
6601 Ok(())
6602 }
6603 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
6604 ordinal: 6236883748953765593,
6605 error,
6606 }),
6607 },
6608
6609 ordinal => {
6610 handler.on_unknown_interaction(ordinal).await;
6611 if ::core::matches!(
6612 message.header().flexibility(),
6613 ::fidl_next::protocol::Flexibility::Strict
6614 ) {
6615 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
6616 } else {
6617 Ok(())
6618 }
6619 }
6620 }
6621 }
6622
6623 async fn on_two_way(
6624 handler: &mut ___H,
6625 mut message: ::fidl_next::Message<___T>,
6626 responder: ::fidl_next::protocol::Responder<___T>,
6627 ) -> ::core::result::Result<
6628 (),
6629 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6630 > {
6631 match *message.header().ordinal {
6632 ordinal => {
6633 handler.on_unknown_interaction(ordinal).await;
6634 if ::core::matches!(
6635 message.header().flexibility(),
6636 ::fidl_next::protocol::Flexibility::Strict
6637 ) {
6638 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
6639 } else {
6640 responder
6641 .respond_framework_error(
6642 ordinal,
6643 ::fidl_next::FrameworkError::UnknownMethod,
6644 )
6645 .expect("encoding a framework error should never fail")
6646 .await?;
6647 Ok(())
6648 }
6649 }
6650 }
6651 }
6652}
6653
6654impl<___T> OpenableClientHandler<___T> for ::fidl_next::IgnoreEvents
6655where
6656 ___T: ::fidl_next::Transport,
6657{
6658 async fn on_unknown_interaction(&mut self, _: u64) {}
6659}
6660
6661impl<___H, ___T> OpenableLocalClientHandler<___T> for ::fidl_next::Local<___H>
6662where
6663 ___H: OpenableClientHandler<___T>,
6664 ___T: ::fidl_next::Transport,
6665{
6666 async fn on_unknown_interaction(&mut self, ordinal: u64) {
6667 ___H::on_unknown_interaction(&mut self.0, ordinal).await
6668 }
6669}
6670
6671impl<___H, ___T> OpenableLocalServerHandler<___T> for ::fidl_next::Local<___H>
6672where
6673 ___H: OpenableServerHandler<___T>,
6674 ___T: ::fidl_next::Transport,
6675{
6676 async fn open(&mut self, request: ::fidl_next::Request<openable::Open, ___T>) {
6677 ___H::open(&mut self.0, request).await
6678 }
6679
6680 async fn on_unknown_interaction(&mut self, ordinal: u64) {
6681 ___H::on_unknown_interaction(&mut self.0, ordinal).await
6682 }
6683}
6684
6685#[doc = " Node defines the minimal interface for entities which can be accessed in a filesystem.\n"]
6687#[derive(PartialEq, Debug)]
6688pub struct Node;
6689
6690impl ::fidl_next::Discoverable for Node {
6691 const PROTOCOL_NAME: &'static str = "fuchsia.io.Node";
6692}
6693
6694#[cfg(target_os = "fuchsia")]
6695impl ::fidl_next::HasTransport for Node {
6696 type Transport = ::fdomain_client::Channel;
6697}
6698
6699pub mod node {
6700 pub mod prelude {
6701 pub use crate::{
6702 Node, NodeClientHandler, NodeLocalClientHandler, NodeLocalServerHandler,
6703 NodeServerHandler, node,
6704 };
6705
6706 pub use crate::natural::ExtendedAttributeValue;
6707
6708 pub use crate::natural::MutableNodeAttributes;
6709
6710 pub use crate::natural::NodeAttributes2;
6711
6712 pub use crate::natural::NodeDeprecatedGetAttrResponse;
6713
6714 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
6715
6716 pub use crate::natural::NodeDeprecatedSetAttrRequest;
6717
6718 pub use crate::natural::NodeDeprecatedSetAttrResponse;
6719
6720 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
6721
6722 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
6723
6724 pub use crate::natural::NodeGetAttributesRequest;
6725
6726 pub use crate::natural::NodeGetExtendedAttributeRequest;
6727
6728 pub use crate::natural::NodeListExtendedAttributesRequest;
6729
6730 pub use crate::natural::NodeOnOpenRequest;
6731
6732 pub use crate::natural::NodeQueryFilesystemResponse;
6733
6734 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
6735
6736 pub use crate::natural::NodeSetExtendedAttributeRequest;
6737
6738 pub use crate::natural::NodeSetFlagsRequest;
6739
6740 pub use crate::natural::NodeGetFlagsResponse;
6741
6742 pub use crate::natural::NodeGetTokenResponse;
6743
6744 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
6745
6746 pub use crate::natural::NodeSetExtendedAttributeResponse;
6747
6748 pub use crate::natural::NodeSetFlagsResponse;
6749
6750 pub use crate::natural::NodeSyncResponse;
6751
6752 pub use crate::natural::NodeUpdateAttributesResponse;
6753
6754 pub use crate::natural::Representation;
6755
6756 pub use ::fdomain_next_fuchsia_unknown::natural::CloneableCloneRequest;
6757
6758 pub use ::fdomain_next_fuchsia_unknown::natural::CloseableCloseResponse;
6759
6760 pub use ::fdomain_next_fuchsia_unknown::natural::QueryableQueryResponse;
6761 }
6762
6763 pub struct Clone;
6764
6765 impl ::fidl_next::Method for Clone {
6766 const ORDINAL: u64 = 2366825959783828089;
6767 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6768 ::fidl_next::protocol::Flexibility::Strict;
6769
6770 type Protocol = crate::Node;
6771
6772 type Request = ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest;
6773 }
6774
6775 pub struct Close;
6776
6777 impl ::fidl_next::Method for Close {
6778 const ORDINAL: u64 = 6540867515453498750;
6779 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6780 ::fidl_next::protocol::Flexibility::Strict;
6781
6782 type Protocol = crate::Node;
6783
6784 type Request = ::fidl_next::wire::EmptyMessageBody;
6785 }
6786
6787 impl ::fidl_next::TwoWayMethod for Close {
6788 type Response = ::fidl_next::wire::Result<
6789 'static,
6790 ::fdomain_next_fuchsia_unknown::wire::CloseableCloseResponse,
6791 ::fidl_next::wire::Int32,
6792 >;
6793 }
6794
6795 impl<___R> ::fidl_next::Respond<___R> for Close {
6796 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
6797
6798 fn respond(response: ___R) -> Self::Output {
6799 ::core::result::Result::Ok(response)
6800 }
6801 }
6802
6803 impl<___R> ::fidl_next::RespondErr<___R> for Close {
6804 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
6805
6806 fn respond_err(response: ___R) -> Self::Output {
6807 ::core::result::Result::Err(response)
6808 }
6809 }
6810
6811 pub struct Query;
6812
6813 impl ::fidl_next::Method for Query {
6814 const ORDINAL: u64 = 2763219980499352582;
6815 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6816 ::fidl_next::protocol::Flexibility::Strict;
6817
6818 type Protocol = crate::Node;
6819
6820 type Request = ::fidl_next::wire::EmptyMessageBody;
6821 }
6822
6823 impl ::fidl_next::TwoWayMethod for Query {
6824 type Response = ::fidl_next::wire::Strict<
6825 ::fdomain_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>,
6826 >;
6827 }
6828
6829 impl<___R> ::fidl_next::Respond<___R> for Query {
6830 type Output = ::fidl_next::Strict<
6831 ::fdomain_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>,
6832 >;
6833
6834 fn respond(response: ___R) -> Self::Output {
6835 ::fidl_next::Strict(::fdomain_next_fuchsia_unknown::generic::QueryableQueryResponse {
6836 protocol: response,
6837 })
6838 }
6839 }
6840
6841 pub struct OnOpen;
6842
6843 impl ::fidl_next::Method for OnOpen {
6844 const ORDINAL: u64 = 9207534335756671346;
6845 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6846 ::fidl_next::protocol::Flexibility::Flexible;
6847
6848 type Protocol = crate::Node;
6849
6850 type Request = crate::wire::NodeOnOpenRequest<'static>;
6851 }
6852
6853 pub struct DeprecatedGetAttr;
6854
6855 impl ::fidl_next::Method for DeprecatedGetAttr {
6856 const ORDINAL: u64 = 8689798978500614909;
6857 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6858 ::fidl_next::protocol::Flexibility::Strict;
6859
6860 type Protocol = crate::Node;
6861
6862 type Request = ::fidl_next::wire::EmptyMessageBody;
6863 }
6864
6865 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
6866 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetAttrResponse>;
6867 }
6868
6869 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
6870 type Output = ::fidl_next::Strict<___R>;
6871
6872 fn respond(response: ___R) -> Self::Output {
6873 ::fidl_next::Strict(response)
6874 }
6875 }
6876
6877 pub struct DeprecatedSetAttr;
6878
6879 impl ::fidl_next::Method for DeprecatedSetAttr {
6880 const ORDINAL: u64 = 4721673413776871238;
6881 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6882 ::fidl_next::protocol::Flexibility::Strict;
6883
6884 type Protocol = crate::Node;
6885
6886 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
6887 }
6888
6889 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
6890 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetAttrResponse>;
6891 }
6892
6893 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
6894 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetAttrResponse<___R>>;
6895
6896 fn respond(response: ___R) -> Self::Output {
6897 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetAttrResponse { s: response })
6898 }
6899 }
6900
6901 pub struct DeprecatedGetFlags;
6902
6903 impl ::fidl_next::Method for DeprecatedGetFlags {
6904 const ORDINAL: u64 = 6595803110182632097;
6905 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6906 ::fidl_next::protocol::Flexibility::Strict;
6907
6908 type Protocol = crate::Node;
6909
6910 type Request = ::fidl_next::wire::EmptyMessageBody;
6911 }
6912
6913 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
6914 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetFlagsResponse>;
6915 }
6916
6917 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
6918 type Output = ::fidl_next::Strict<___R>;
6919
6920 fn respond(response: ___R) -> Self::Output {
6921 ::fidl_next::Strict(response)
6922 }
6923 }
6924
6925 pub struct DeprecatedSetFlags;
6926
6927 impl ::fidl_next::Method for DeprecatedSetFlags {
6928 const ORDINAL: u64 = 5950864159036794675;
6929 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6930 ::fidl_next::protocol::Flexibility::Strict;
6931
6932 type Protocol = crate::Node;
6933
6934 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
6935 }
6936
6937 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
6938 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetFlagsResponse>;
6939 }
6940
6941 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
6942 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetFlagsResponse<___R>>;
6943
6944 fn respond(response: ___R) -> Self::Output {
6945 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetFlagsResponse { s: response })
6946 }
6947 }
6948
6949 pub struct GetFlags;
6950
6951 impl ::fidl_next::Method for GetFlags {
6952 const ORDINAL: u64 = 105530239381466147;
6953 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6954 ::fidl_next::protocol::Flexibility::Flexible;
6955
6956 type Protocol = crate::Node;
6957
6958 type Request = ::fidl_next::wire::EmptyMessageBody;
6959 }
6960
6961 impl ::fidl_next::TwoWayMethod for GetFlags {
6962 type Response = ::fidl_next::wire::Result<
6963 'static,
6964 crate::wire::NodeGetFlagsResponse,
6965 ::fidl_next::wire::fuchsia::Status,
6966 >;
6967 }
6968
6969 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
6970 type Output = ::core::result::Result<
6971 crate::generic::NodeGetFlagsResponse<___R>,
6972 ::fidl_next::never::Never,
6973 >;
6974
6975 fn respond(response: ___R) -> Self::Output {
6976 ::core::result::Result::Ok(crate::generic::NodeGetFlagsResponse { flags: response })
6977 }
6978 }
6979
6980 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
6981 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
6982
6983 fn respond_err(response: ___R) -> Self::Output {
6984 ::core::result::Result::Err(response)
6985 }
6986 }
6987
6988 pub struct SetFlags;
6989
6990 impl ::fidl_next::Method for SetFlags {
6991 const ORDINAL: u64 = 6172186066099445416;
6992 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6993 ::fidl_next::protocol::Flexibility::Flexible;
6994
6995 type Protocol = crate::Node;
6996
6997 type Request = crate::wire::NodeSetFlagsRequest;
6998 }
6999
7000 impl ::fidl_next::TwoWayMethod for SetFlags {
7001 type Response = ::fidl_next::wire::Result<
7002 'static,
7003 crate::wire::NodeSetFlagsResponse,
7004 ::fidl_next::wire::fuchsia::Status,
7005 >;
7006 }
7007
7008 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
7009 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
7010
7011 fn respond(response: ___R) -> Self::Output {
7012 ::core::result::Result::Ok(response)
7013 }
7014 }
7015
7016 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
7017 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
7018
7019 fn respond_err(response: ___R) -> Self::Output {
7020 ::core::result::Result::Err(response)
7021 }
7022 }
7023
7024 pub struct QueryFilesystem;
7025
7026 impl ::fidl_next::Method for QueryFilesystem {
7027 const ORDINAL: u64 = 8013111122914313744;
7028 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7029 ::fidl_next::protocol::Flexibility::Strict;
7030
7031 type Protocol = crate::Node;
7032
7033 type Request = ::fidl_next::wire::EmptyMessageBody;
7034 }
7035
7036 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
7037 type Response =
7038 ::fidl_next::wire::Strict<crate::wire::NodeQueryFilesystemResponse<'static>>;
7039 }
7040
7041 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
7042 type Output = ::fidl_next::Strict<___R>;
7043
7044 fn respond(response: ___R) -> Self::Output {
7045 ::fidl_next::Strict(response)
7046 }
7047 }
7048
7049 pub struct OnRepresentation;
7050
7051 impl ::fidl_next::Method for OnRepresentation {
7052 const ORDINAL: u64 = 6679970090861613324;
7053 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7054 ::fidl_next::protocol::Flexibility::Strict;
7055
7056 type Protocol = crate::Node;
7057
7058 type Request = crate::wire::Representation<'static>;
7059 }
7060
7061 pub struct GetToken;
7062
7063 impl ::fidl_next::Method for GetToken {
7064 const ORDINAL: u64 = 5788516050773961964;
7065 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7066 ::fidl_next::protocol::Flexibility::Flexible;
7067
7068 type Protocol = crate::Node;
7069
7070 type Request = ::fidl_next::wire::EmptyMessageBody;
7071 }
7072
7073 impl ::fidl_next::TwoWayMethod for GetToken {
7074 type Response = ::fidl_next::wire::Result<
7075 'static,
7076 crate::wire::NodeGetTokenResponse,
7077 ::fidl_next::wire::fuchsia::Status,
7078 >;
7079 }
7080
7081 impl<___R> ::fidl_next::Respond<___R> for GetToken {
7082 type Output = ::core::result::Result<
7083 crate::generic::NodeGetTokenResponse<___R>,
7084 ::fidl_next::never::Never,
7085 >;
7086
7087 fn respond(response: ___R) -> Self::Output {
7088 ::core::result::Result::Ok(crate::generic::NodeGetTokenResponse { token: response })
7089 }
7090 }
7091
7092 impl<___R> ::fidl_next::RespondErr<___R> for GetToken {
7093 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
7094
7095 fn respond_err(response: ___R) -> Self::Output {
7096 ::core::result::Result::Err(response)
7097 }
7098 }
7099
7100 pub struct GetAttributes;
7101
7102 impl ::fidl_next::Method for GetAttributes {
7103 const ORDINAL: u64 = 4414537700416816443;
7104 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7105 ::fidl_next::protocol::Flexibility::Strict;
7106
7107 type Protocol = crate::Node;
7108
7109 type Request = crate::wire::NodeGetAttributesRequest;
7110 }
7111
7112 impl ::fidl_next::TwoWayMethod for GetAttributes {
7113 type Response = ::fidl_next::wire::Result<
7114 'static,
7115 crate::wire::NodeAttributes2<'static>,
7116 ::fidl_next::wire::fuchsia::Status,
7117 >;
7118 }
7119
7120 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
7121 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
7122
7123 fn respond(response: ___R) -> Self::Output {
7124 ::core::result::Result::Ok(response)
7125 }
7126 }
7127
7128 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
7129 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
7130
7131 fn respond_err(response: ___R) -> Self::Output {
7132 ::core::result::Result::Err(response)
7133 }
7134 }
7135
7136 pub struct UpdateAttributes;
7137
7138 impl ::fidl_next::Method for UpdateAttributes {
7139 const ORDINAL: u64 = 3677402239314018056;
7140 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7141 ::fidl_next::protocol::Flexibility::Strict;
7142
7143 type Protocol = crate::Node;
7144
7145 type Request = crate::wire::MutableNodeAttributes<'static>;
7146 }
7147
7148 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
7149 type Response = ::fidl_next::wire::Result<
7150 'static,
7151 crate::wire::NodeUpdateAttributesResponse,
7152 ::fidl_next::wire::fuchsia::Status,
7153 >;
7154 }
7155
7156 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
7157 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
7158
7159 fn respond(response: ___R) -> Self::Output {
7160 ::core::result::Result::Ok(response)
7161 }
7162 }
7163
7164 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
7165 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
7166
7167 fn respond_err(response: ___R) -> Self::Output {
7168 ::core::result::Result::Err(response)
7169 }
7170 }
7171
7172 pub struct Sync;
7173
7174 impl ::fidl_next::Method for Sync {
7175 const ORDINAL: u64 = 3196473584242777161;
7176 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7177 ::fidl_next::protocol::Flexibility::Strict;
7178
7179 type Protocol = crate::Node;
7180
7181 type Request = ::fidl_next::wire::EmptyMessageBody;
7182 }
7183
7184 impl ::fidl_next::TwoWayMethod for Sync {
7185 type Response = ::fidl_next::wire::Result<
7186 'static,
7187 crate::wire::NodeSyncResponse,
7188 ::fidl_next::wire::fuchsia::Status,
7189 >;
7190 }
7191
7192 impl<___R> ::fidl_next::Respond<___R> for Sync {
7193 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
7194
7195 fn respond(response: ___R) -> Self::Output {
7196 ::core::result::Result::Ok(response)
7197 }
7198 }
7199
7200 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
7201 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
7202
7203 fn respond_err(response: ___R) -> Self::Output {
7204 ::core::result::Result::Err(response)
7205 }
7206 }
7207
7208 pub struct ListExtendedAttributes;
7209
7210 impl ::fidl_next::Method for ListExtendedAttributes {
7211 const ORDINAL: u64 = 5431626189872037072;
7212 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7213 ::fidl_next::protocol::Flexibility::Strict;
7214
7215 type Protocol = crate::Node;
7216
7217 type Request = crate::wire::NodeListExtendedAttributesRequest;
7218 }
7219
7220 pub struct GetExtendedAttribute;
7221
7222 impl ::fidl_next::Method for GetExtendedAttribute {
7223 const ORDINAL: u64 = 5043930208506967771;
7224 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7225 ::fidl_next::protocol::Flexibility::Strict;
7226
7227 type Protocol = crate::Node;
7228
7229 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
7230 }
7231
7232 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
7233 type Response = ::fidl_next::wire::Result<
7234 'static,
7235 crate::wire::ExtendedAttributeValue<'static>,
7236 ::fidl_next::wire::fuchsia::Status,
7237 >;
7238 }
7239
7240 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
7241 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
7242
7243 fn respond(response: ___R) -> Self::Output {
7244 ::core::result::Result::Ok(response)
7245 }
7246 }
7247
7248 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
7249 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
7250
7251 fn respond_err(response: ___R) -> Self::Output {
7252 ::core::result::Result::Err(response)
7253 }
7254 }
7255
7256 pub struct SetExtendedAttribute;
7257
7258 impl ::fidl_next::Method for SetExtendedAttribute {
7259 const ORDINAL: u64 = 5374223046099989052;
7260 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7261 ::fidl_next::protocol::Flexibility::Strict;
7262
7263 type Protocol = crate::Node;
7264
7265 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
7266 }
7267
7268 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
7269 type Response = ::fidl_next::wire::Result<
7270 'static,
7271 crate::wire::NodeSetExtendedAttributeResponse,
7272 ::fidl_next::wire::fuchsia::Status,
7273 >;
7274 }
7275
7276 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
7277 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
7278
7279 fn respond(response: ___R) -> Self::Output {
7280 ::core::result::Result::Ok(response)
7281 }
7282 }
7283
7284 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
7285 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
7286
7287 fn respond_err(response: ___R) -> Self::Output {
7288 ::core::result::Result::Err(response)
7289 }
7290 }
7291
7292 pub struct RemoveExtendedAttribute;
7293
7294 impl ::fidl_next::Method for RemoveExtendedAttribute {
7295 const ORDINAL: u64 = 8794297771444732717;
7296 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7297 ::fidl_next::protocol::Flexibility::Strict;
7298
7299 type Protocol = crate::Node;
7300
7301 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
7302 }
7303
7304 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
7305 type Response = ::fidl_next::wire::Result<
7306 'static,
7307 crate::wire::NodeRemoveExtendedAttributeResponse,
7308 ::fidl_next::wire::fuchsia::Status,
7309 >;
7310 }
7311
7312 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
7313 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
7314
7315 fn respond(response: ___R) -> Self::Output {
7316 ::core::result::Result::Ok(response)
7317 }
7318 }
7319
7320 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
7321 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
7322
7323 fn respond_err(response: ___R) -> Self::Output {
7324 ::core::result::Result::Err(response)
7325 }
7326 }
7327
7328 mod ___detail {
7329 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Node
7330 where
7331 ___T: ::fidl_next::Transport,
7332 {
7333 type Client = NodeClient<___T>;
7334 type Server = NodeServer<___T>;
7335 }
7336
7337 #[repr(transparent)]
7339 pub struct NodeClient<___T: ::fidl_next::Transport> {
7340 #[allow(dead_code)]
7341 client: ::fidl_next::protocol::Client<___T>,
7342 }
7343
7344 impl<___T> NodeClient<___T>
7345 where
7346 ___T: ::fidl_next::Transport,
7347 {
7348 pub fn clone(
7349 &self,
7350
7351 request: impl ::fidl_next::Encode<
7352 ::fidl_next::ServerEnd<
7353 ::fdomain_next_fuchsia_unknown::Cloneable,
7354 ::fdomain_client::fidl_next::wire::Handle,
7355 >,
7356 <___T as ::fidl_next::Transport>::SendBuffer,
7357 >,
7358 ) -> ::fidl_next::SendFuture<'_, ___T>
7359 where
7360 <___T as ::fidl_next::Transport>::SendBuffer:
7361 ::fidl_next::encoder::InternalHandleEncoder,
7362 <___T as ::fidl_next::Transport>::SendBuffer:
7363 ::fdomain_client::fidl_next::HandleEncoder,
7364 {
7365 self.clone_with(::fdomain_next_fuchsia_unknown::generic::CloneableCloneRequest {
7366 request,
7367 })
7368 }
7369
7370 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
7371 where
7372 ___R: ::fidl_next::Encode<
7373 ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest,
7374 <___T as ::fidl_next::Transport>::SendBuffer,
7375 >,
7376 {
7377 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
7378 2366825959783828089,
7379 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
7380 request,
7381 ))
7382 }
7383
7384 #[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"]
7385 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
7386 ::fidl_next::TwoWayFuture::from_untyped(
7387 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
7388 6540867515453498750,
7389 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
7390 (),
7391 ),
7392 )
7393 }
7394
7395 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
7396 ::fidl_next::TwoWayFuture::from_untyped(
7397 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
7398 2763219980499352582,
7399 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
7400 (),
7401 ),
7402 )
7403 }
7404
7405 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
7406 pub fn deprecated_get_attr(
7407 &self,
7408 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
7409 ::fidl_next::TwoWayFuture::from_untyped(
7410 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
7411 8689798978500614909,
7412 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
7413 (),
7414 ),
7415 )
7416 }
7417
7418 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
7419 pub fn deprecated_set_attr(
7420 &self,
7421
7422 flags: impl ::fidl_next::Encode<
7423 crate::wire::NodeAttributeFlags,
7424 <___T as ::fidl_next::Transport>::SendBuffer,
7425 >,
7426
7427 attributes: impl ::fidl_next::Encode<
7428 crate::wire::NodeAttributes,
7429 <___T as ::fidl_next::Transport>::SendBuffer,
7430 >,
7431 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
7432 where
7433 <___T as ::fidl_next::Transport>::SendBuffer:
7434 ::fidl_next::encoder::InternalHandleEncoder,
7435 {
7436 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
7437 flags,
7438
7439 attributes,
7440 })
7441 }
7442
7443 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
7444 pub fn deprecated_set_attr_with<___R>(
7445 &self,
7446 request: ___R,
7447 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
7448 where
7449 ___R: ::fidl_next::Encode<
7450 crate::wire::NodeDeprecatedSetAttrRequest,
7451 <___T as ::fidl_next::Transport>::SendBuffer,
7452 >,
7453 {
7454 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7455 4721673413776871238,
7456 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
7457 request,
7458 ))
7459 }
7460
7461 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
7462 pub fn deprecated_get_flags(
7463 &self,
7464 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
7465 ::fidl_next::TwoWayFuture::from_untyped(
7466 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
7467 6595803110182632097,
7468 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
7469 (),
7470 ),
7471 )
7472 }
7473
7474 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
7475 pub fn deprecated_set_flags(
7476 &self,
7477
7478 flags: impl ::fidl_next::Encode<
7479 crate::wire::OpenFlags,
7480 <___T as ::fidl_next::Transport>::SendBuffer,
7481 >,
7482 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
7483 where
7484 <___T as ::fidl_next::Transport>::SendBuffer:
7485 ::fidl_next::encoder::InternalHandleEncoder,
7486 {
7487 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
7488 flags,
7489 })
7490 }
7491
7492 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
7493 pub fn deprecated_set_flags_with<___R>(
7494 &self,
7495 request: ___R,
7496 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
7497 where
7498 ___R: ::fidl_next::Encode<
7499 crate::wire::NodeDeprecatedSetFlagsRequest,
7500 <___T as ::fidl_next::Transport>::SendBuffer,
7501 >,
7502 {
7503 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7504 5950864159036794675,
7505 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
7506 request,
7507 ))
7508 }
7509
7510 #[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"]
7511 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
7512 ::fidl_next::TwoWayFuture::from_untyped(
7513 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
7514 105530239381466147,
7515 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
7516 (),
7517 ),
7518 )
7519 }
7520
7521 #[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"]
7522 pub fn set_flags(
7523 &self,
7524
7525 flags: impl ::fidl_next::Encode<
7526 crate::wire::Flags,
7527 <___T as ::fidl_next::Transport>::SendBuffer,
7528 >,
7529 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
7530 where
7531 <___T as ::fidl_next::Transport>::SendBuffer:
7532 ::fidl_next::encoder::InternalHandleEncoder,
7533 {
7534 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
7535 }
7536
7537 #[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"]
7538 pub fn set_flags_with<___R>(
7539 &self,
7540 request: ___R,
7541 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
7542 where
7543 ___R: ::fidl_next::Encode<
7544 crate::wire::NodeSetFlagsRequest,
7545 <___T as ::fidl_next::Transport>::SendBuffer,
7546 >,
7547 {
7548 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7549 6172186066099445416,
7550 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
7551 request,
7552 ))
7553 }
7554
7555 #[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"]
7556 pub fn query_filesystem(
7557 &self,
7558 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
7559 ::fidl_next::TwoWayFuture::from_untyped(
7560 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
7561 8013111122914313744,
7562 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
7563 (),
7564 ),
7565 )
7566 }
7567
7568 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
7569 pub fn get_token(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetToken, ___T> {
7570 ::fidl_next::TwoWayFuture::from_untyped(
7571 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
7572 5788516050773961964,
7573 <super::GetToken as ::fidl_next::Method>::FLEXIBILITY,
7574 (),
7575 ),
7576 )
7577 }
7578
7579 #[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"]
7580 pub fn get_attributes(
7581 &self,
7582
7583 query: impl ::fidl_next::Encode<
7584 crate::wire::NodeAttributesQuery,
7585 <___T as ::fidl_next::Transport>::SendBuffer,
7586 >,
7587 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
7588 where
7589 <___T as ::fidl_next::Transport>::SendBuffer:
7590 ::fidl_next::encoder::InternalHandleEncoder,
7591 {
7592 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
7593 }
7594
7595 #[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"]
7596 pub fn get_attributes_with<___R>(
7597 &self,
7598 request: ___R,
7599 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
7600 where
7601 ___R: ::fidl_next::Encode<
7602 crate::wire::NodeGetAttributesRequest,
7603 <___T as ::fidl_next::Transport>::SendBuffer,
7604 >,
7605 {
7606 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7607 4414537700416816443,
7608 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
7609 request,
7610 ))
7611 }
7612
7613 #[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"]
7614 pub fn update_attributes_with<___R>(
7615 &self,
7616 request: ___R,
7617 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
7618 where
7619 ___R: ::fidl_next::Encode<
7620 crate::wire::MutableNodeAttributes<'static>,
7621 <___T as ::fidl_next::Transport>::SendBuffer,
7622 >,
7623 {
7624 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7625 3677402239314018056,
7626 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
7627 request,
7628 ))
7629 }
7630
7631 #[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"]
7632 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
7633 ::fidl_next::TwoWayFuture::from_untyped(
7634 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
7635 3196473584242777161,
7636 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
7637 (),
7638 ),
7639 )
7640 }
7641
7642 #[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.READ_BYTES`] right.\n"]
7643 pub fn list_extended_attributes(
7644 &self,
7645
7646 iterator: impl ::fidl_next::Encode<
7647 ::fidl_next::ServerEnd<
7648 crate::ExtendedAttributeIterator,
7649 ::fdomain_client::fidl_next::wire::Handle,
7650 >,
7651 <___T as ::fidl_next::Transport>::SendBuffer,
7652 >,
7653 ) -> ::fidl_next::SendFuture<'_, ___T>
7654 where
7655 <___T as ::fidl_next::Transport>::SendBuffer:
7656 ::fidl_next::encoder::InternalHandleEncoder,
7657 <___T as ::fidl_next::Transport>::SendBuffer:
7658 ::fdomain_client::fidl_next::HandleEncoder,
7659 {
7660 self.list_extended_attributes_with(
7661 crate::generic::NodeListExtendedAttributesRequest { iterator },
7662 )
7663 }
7664
7665 #[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.READ_BYTES`] right.\n"]
7666 pub fn list_extended_attributes_with<___R>(
7667 &self,
7668 request: ___R,
7669 ) -> ::fidl_next::SendFuture<'_, ___T>
7670 where
7671 ___R: ::fidl_next::Encode<
7672 crate::wire::NodeListExtendedAttributesRequest,
7673 <___T as ::fidl_next::Transport>::SendBuffer,
7674 >,
7675 {
7676 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
7677 5431626189872037072,
7678 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
7679 request,
7680 ))
7681 }
7682
7683 #[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.READ_BYTES`] right.\n"]
7684 pub fn get_extended_attribute(
7685 &self,
7686
7687 name: impl ::fidl_next::Encode<
7688 ::fidl_next::wire::Vector<'static, u8>,
7689 <___T as ::fidl_next::Transport>::SendBuffer,
7690 >,
7691 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
7692 where
7693 <___T as ::fidl_next::Transport>::SendBuffer:
7694 ::fidl_next::encoder::InternalHandleEncoder,
7695 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
7696 {
7697 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
7698 name,
7699 })
7700 }
7701
7702 #[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.READ_BYTES`] right.\n"]
7703 pub fn get_extended_attribute_with<___R>(
7704 &self,
7705 request: ___R,
7706 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
7707 where
7708 ___R: ::fidl_next::Encode<
7709 crate::wire::NodeGetExtendedAttributeRequest<'static>,
7710 <___T as ::fidl_next::Transport>::SendBuffer,
7711 >,
7712 {
7713 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7714 5043930208506967771,
7715 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
7716 request,
7717 ))
7718 }
7719
7720 #[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.WRITE_BYTES`] right.\n"]
7721 pub fn set_extended_attribute(
7722 &self,
7723
7724 name: impl ::fidl_next::Encode<
7725 ::fidl_next::wire::Vector<'static, u8>,
7726 <___T as ::fidl_next::Transport>::SendBuffer,
7727 >,
7728
7729 value: impl ::fidl_next::Encode<
7730 crate::wire::ExtendedAttributeValue<'static>,
7731 <___T as ::fidl_next::Transport>::SendBuffer,
7732 >,
7733
7734 mode: impl ::fidl_next::Encode<
7735 crate::wire::SetExtendedAttributeMode,
7736 <___T as ::fidl_next::Transport>::SendBuffer,
7737 >,
7738 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
7739 where
7740 <___T as ::fidl_next::Transport>::SendBuffer:
7741 ::fidl_next::encoder::InternalHandleEncoder,
7742 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
7743 <___T as ::fidl_next::Transport>::SendBuffer:
7744 ::fdomain_client::fidl_next::HandleEncoder,
7745 {
7746 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
7747 name,
7748
7749 value,
7750
7751 mode,
7752 })
7753 }
7754
7755 #[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.WRITE_BYTES`] right.\n"]
7756 pub fn set_extended_attribute_with<___R>(
7757 &self,
7758 request: ___R,
7759 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
7760 where
7761 ___R: ::fidl_next::Encode<
7762 crate::wire::NodeSetExtendedAttributeRequest<'static>,
7763 <___T as ::fidl_next::Transport>::SendBuffer,
7764 >,
7765 {
7766 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7767 5374223046099989052,
7768 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
7769 request,
7770 ))
7771 }
7772
7773 #[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.WRITE_BYTES`] right.\n"]
7774 pub fn remove_extended_attribute(
7775 &self,
7776
7777 name: impl ::fidl_next::Encode<
7778 ::fidl_next::wire::Vector<'static, u8>,
7779 <___T as ::fidl_next::Transport>::SendBuffer,
7780 >,
7781 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
7782 where
7783 <___T as ::fidl_next::Transport>::SendBuffer:
7784 ::fidl_next::encoder::InternalHandleEncoder,
7785 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
7786 {
7787 self.remove_extended_attribute_with(
7788 crate::generic::NodeRemoveExtendedAttributeRequest { name },
7789 )
7790 }
7791
7792 #[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.WRITE_BYTES`] right.\n"]
7793 pub fn remove_extended_attribute_with<___R>(
7794 &self,
7795 request: ___R,
7796 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
7797 where
7798 ___R: ::fidl_next::Encode<
7799 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
7800 <___T as ::fidl_next::Transport>::SendBuffer,
7801 >,
7802 {
7803 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7804 8794297771444732717,
7805 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
7806 request,
7807 ))
7808 }
7809 }
7810
7811 #[repr(transparent)]
7813 pub struct NodeServer<___T: ::fidl_next::Transport> {
7814 server: ::fidl_next::protocol::Server<___T>,
7815 }
7816
7817 impl<___T> NodeServer<___T>
7818 where
7819 ___T: ::fidl_next::Transport,
7820 {
7821 #[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"]
7822 pub fn on_open(
7823 &self,
7824
7825 s: impl ::fidl_next::Encode<
7826 ::fidl_next::wire::fuchsia::StatusResult,
7827 <___T as ::fidl_next::Transport>::SendBuffer,
7828 >,
7829
7830 info: impl ::fidl_next::Encode<
7831 crate::wire_optional::NodeInfoDeprecated<'static>,
7832 <___T as ::fidl_next::Transport>::SendBuffer,
7833 >,
7834 ) -> ::fidl_next::SendFuture<'_, ___T>
7835 where
7836 <___T as ::fidl_next::Transport>::SendBuffer:
7837 ::fidl_next::encoder::InternalHandleEncoder,
7838 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
7839 <___T as ::fidl_next::Transport>::SendBuffer:
7840 ::fdomain_client::fidl_next::HandleEncoder,
7841 {
7842 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
7843 }
7844
7845 #[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"]
7846
7847 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
7848 where
7849 ___R: ::fidl_next::Encode<
7850 <super::OnOpen as ::fidl_next::Method>::Request,
7851 <___T as ::fidl_next::Transport>::SendBuffer,
7852 >,
7853 {
7854 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
7855 9207534335756671346,
7856 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
7857 request,
7858 ))
7859 }
7860
7861 #[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"]
7862
7863 pub fn on_representation_with<___R>(
7864 &self,
7865 request: ___R,
7866 ) -> ::fidl_next::SendFuture<'_, ___T>
7867 where
7868 ___R: ::fidl_next::Encode<
7869 <super::OnRepresentation as ::fidl_next::Method>::Request,
7870 <___T as ::fidl_next::Transport>::SendBuffer,
7871 >,
7872 {
7873 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
7874 6679970090861613324,
7875 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
7876 request,
7877 ))
7878 }
7879 }
7880 }
7881}
7882
7883#[diagnostic::on_unimplemented(
7884 note = "If {Self} implements the non-local NodeClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
7885)]
7886
7887pub trait NodeLocalClientHandler<
7891 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
7892 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
7893>
7894{
7895 #[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"]
7896 fn on_open(
7897 &mut self,
7898
7899 request: ::fidl_next::Request<node::OnOpen, ___T>,
7900 ) -> impl ::core::future::Future<Output = ()>;
7901
7902 #[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"]
7903 fn on_representation(
7904 &mut self,
7905
7906 request: ::fidl_next::Request<node::OnRepresentation, ___T>,
7907 ) -> impl ::core::future::Future<Output = ()>;
7908
7909 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
7910 ::core::future::ready(())
7911 }
7912}
7913
7914impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Node
7915where
7916 ___H: NodeLocalClientHandler<___T>,
7917 ___T: ::fidl_next::Transport,
7918 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
7919 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7920 Constraint = (),
7921 >,
7922 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
7923 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7924 Constraint = (),
7925 >,
7926{
7927 async fn on_event(
7928 handler: &mut ___H,
7929 mut message: ::fidl_next::Message<___T>,
7930 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
7931 match *message.header().ordinal {
7932 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
7933 Ok(decoded) => {
7934 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
7935 Ok(())
7936 }
7937 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7938 ordinal: 9207534335756671346,
7939 error,
7940 }),
7941 },
7942
7943 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
7944 Ok(decoded) => {
7945 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
7946 Ok(())
7947 }
7948 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7949 ordinal: 6679970090861613324,
7950 error,
7951 }),
7952 },
7953
7954 ordinal => {
7955 handler.on_unknown_interaction(ordinal).await;
7956 if ::core::matches!(
7957 message.header().flexibility(),
7958 ::fidl_next::protocol::Flexibility::Strict
7959 ) {
7960 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
7961 } else {
7962 Ok(())
7963 }
7964 }
7965 }
7966 }
7967}
7968
7969#[diagnostic::on_unimplemented(
7970 note = "If {Self} implements the non-local NodeServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
7971)]
7972
7973pub trait NodeLocalServerHandler<
7977 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
7978 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
7979>
7980{
7981 fn clone(
7982 &mut self,
7983
7984 request: ::fidl_next::Request<node::Clone, ___T>,
7985 ) -> impl ::core::future::Future<Output = ()>;
7986
7987 #[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"]
7988 fn close(
7989 &mut self,
7990
7991 responder: ::fidl_next::Responder<node::Close, ___T>,
7992 ) -> impl ::core::future::Future<Output = ()>;
7993
7994 fn query(
7995 &mut self,
7996
7997 responder: ::fidl_next::Responder<node::Query, ___T>,
7998 ) -> impl ::core::future::Future<Output = ()>;
7999
8000 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
8001 fn deprecated_get_attr(
8002 &mut self,
8003
8004 responder: ::fidl_next::Responder<node::DeprecatedGetAttr, ___T>,
8005 ) -> impl ::core::future::Future<Output = ()>;
8006
8007 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
8008 fn deprecated_set_attr(
8009 &mut self,
8010
8011 request: ::fidl_next::Request<node::DeprecatedSetAttr, ___T>,
8012
8013 responder: ::fidl_next::Responder<node::DeprecatedSetAttr, ___T>,
8014 ) -> impl ::core::future::Future<Output = ()>;
8015
8016 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
8017 fn deprecated_get_flags(
8018 &mut self,
8019
8020 responder: ::fidl_next::Responder<node::DeprecatedGetFlags, ___T>,
8021 ) -> impl ::core::future::Future<Output = ()>;
8022
8023 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
8024 fn deprecated_set_flags(
8025 &mut self,
8026
8027 request: ::fidl_next::Request<node::DeprecatedSetFlags, ___T>,
8028
8029 responder: ::fidl_next::Responder<node::DeprecatedSetFlags, ___T>,
8030 ) -> impl ::core::future::Future<Output = ()>;
8031
8032 #[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"]
8033 fn get_flags(
8034 &mut self,
8035
8036 responder: ::fidl_next::Responder<node::GetFlags, ___T>,
8037 ) -> impl ::core::future::Future<Output = ()>;
8038
8039 #[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"]
8040 fn set_flags(
8041 &mut self,
8042
8043 request: ::fidl_next::Request<node::SetFlags, ___T>,
8044
8045 responder: ::fidl_next::Responder<node::SetFlags, ___T>,
8046 ) -> impl ::core::future::Future<Output = ()>;
8047
8048 #[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"]
8049 fn query_filesystem(
8050 &mut self,
8051
8052 responder: ::fidl_next::Responder<node::QueryFilesystem, ___T>,
8053 ) -> impl ::core::future::Future<Output = ()>;
8054
8055 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
8056 fn get_token(
8057 &mut self,
8058
8059 responder: ::fidl_next::Responder<node::GetToken, ___T>,
8060 ) -> impl ::core::future::Future<Output = ()>;
8061
8062 #[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"]
8063 fn get_attributes(
8064 &mut self,
8065
8066 request: ::fidl_next::Request<node::GetAttributes, ___T>,
8067
8068 responder: ::fidl_next::Responder<node::GetAttributes, ___T>,
8069 ) -> impl ::core::future::Future<Output = ()>;
8070
8071 #[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"]
8072 fn update_attributes(
8073 &mut self,
8074
8075 request: ::fidl_next::Request<node::UpdateAttributes, ___T>,
8076
8077 responder: ::fidl_next::Responder<node::UpdateAttributes, ___T>,
8078 ) -> impl ::core::future::Future<Output = ()>;
8079
8080 #[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"]
8081 fn sync(
8082 &mut self,
8083
8084 responder: ::fidl_next::Responder<node::Sync, ___T>,
8085 ) -> impl ::core::future::Future<Output = ()>;
8086
8087 #[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.READ_BYTES`] right.\n"]
8088 fn list_extended_attributes(
8089 &mut self,
8090
8091 request: ::fidl_next::Request<node::ListExtendedAttributes, ___T>,
8092 ) -> impl ::core::future::Future<Output = ()>;
8093
8094 #[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.READ_BYTES`] right.\n"]
8095 fn get_extended_attribute(
8096 &mut self,
8097
8098 request: ::fidl_next::Request<node::GetExtendedAttribute, ___T>,
8099
8100 responder: ::fidl_next::Responder<node::GetExtendedAttribute, ___T>,
8101 ) -> impl ::core::future::Future<Output = ()>;
8102
8103 #[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.WRITE_BYTES`] right.\n"]
8104 fn set_extended_attribute(
8105 &mut self,
8106
8107 request: ::fidl_next::Request<node::SetExtendedAttribute, ___T>,
8108
8109 responder: ::fidl_next::Responder<node::SetExtendedAttribute, ___T>,
8110 ) -> impl ::core::future::Future<Output = ()>;
8111
8112 #[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.WRITE_BYTES`] right.\n"]
8113 fn remove_extended_attribute(
8114 &mut self,
8115
8116 request: ::fidl_next::Request<node::RemoveExtendedAttribute, ___T>,
8117
8118 responder: ::fidl_next::Responder<node::RemoveExtendedAttribute, ___T>,
8119 ) -> impl ::core::future::Future<Output = ()>;
8120
8121 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
8122 ::core::future::ready(())
8123 }
8124}
8125
8126impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Node
8127where
8128 ___H: NodeLocalServerHandler<___T>,
8129 ___T: ::fidl_next::Transport,
8130 for<'de> ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
8131 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8132 Constraint = (),
8133 >,
8134 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
8135 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8136 Constraint = (),
8137 >,
8138 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
8139 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8140 Constraint = (),
8141 >,
8142 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
8143 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8144 Constraint = (),
8145 >,
8146 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
8147 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8148 Constraint = (),
8149 >,
8150 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
8151 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8152 Constraint = (),
8153 >,
8154 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
8155 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8156 Constraint = (),
8157 >,
8158 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
8159 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8160 Constraint = (),
8161 >,
8162 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
8163 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8164 Constraint = (),
8165 >,
8166 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
8167 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8168 Constraint = (),
8169 >,
8170{
8171 async fn on_one_way(
8172 handler: &mut ___H,
8173 mut message: ::fidl_next::Message<___T>,
8174 ) -> ::core::result::Result<
8175 (),
8176 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8177 > {
8178 match *message.header().ordinal {
8179 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
8180 Ok(decoded) => {
8181 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
8182 Ok(())
8183 }
8184 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8185 ordinal: 2366825959783828089,
8186 error,
8187 }),
8188 },
8189
8190 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
8191 Ok(decoded) => {
8192 handler
8193 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
8194 .await;
8195 Ok(())
8196 }
8197 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8198 ordinal: 5431626189872037072,
8199 error,
8200 }),
8201 },
8202
8203 ordinal => {
8204 handler.on_unknown_interaction(ordinal).await;
8205 if ::core::matches!(
8206 message.header().flexibility(),
8207 ::fidl_next::protocol::Flexibility::Strict
8208 ) {
8209 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8210 } else {
8211 Ok(())
8212 }
8213 }
8214 }
8215 }
8216
8217 async fn on_two_way(
8218 handler: &mut ___H,
8219 mut message: ::fidl_next::Message<___T>,
8220 responder: ::fidl_next::protocol::Responder<___T>,
8221 ) -> ::core::result::Result<
8222 (),
8223 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8224 > {
8225 match *message.header().ordinal {
8226 6540867515453498750 => {
8227 let responder = ::fidl_next::Responder::from_untyped(responder);
8228
8229 handler.close(responder).await;
8230 Ok(())
8231 }
8232
8233 2763219980499352582 => {
8234 let responder = ::fidl_next::Responder::from_untyped(responder);
8235
8236 handler.query(responder).await;
8237 Ok(())
8238 }
8239
8240 8689798978500614909 => {
8241 let responder = ::fidl_next::Responder::from_untyped(responder);
8242
8243 handler.deprecated_get_attr(responder).await;
8244 Ok(())
8245 }
8246
8247 4721673413776871238 => {
8248 let responder = ::fidl_next::Responder::from_untyped(responder);
8249
8250 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8251 Ok(decoded) => {
8252 handler
8253 .deprecated_set_attr(
8254 ::fidl_next::Request::from_decoded(decoded),
8255 responder,
8256 )
8257 .await;
8258 Ok(())
8259 }
8260 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8261 ordinal: 4721673413776871238,
8262 error,
8263 }),
8264 }
8265 }
8266
8267 6595803110182632097 => {
8268 let responder = ::fidl_next::Responder::from_untyped(responder);
8269
8270 handler.deprecated_get_flags(responder).await;
8271 Ok(())
8272 }
8273
8274 5950864159036794675 => {
8275 let responder = ::fidl_next::Responder::from_untyped(responder);
8276
8277 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8278 Ok(decoded) => {
8279 handler
8280 .deprecated_set_flags(
8281 ::fidl_next::Request::from_decoded(decoded),
8282 responder,
8283 )
8284 .await;
8285 Ok(())
8286 }
8287 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8288 ordinal: 5950864159036794675,
8289 error,
8290 }),
8291 }
8292 }
8293
8294 105530239381466147 => {
8295 let responder = ::fidl_next::Responder::from_untyped(responder);
8296
8297 handler.get_flags(responder).await;
8298 Ok(())
8299 }
8300
8301 6172186066099445416 => {
8302 let responder = ::fidl_next::Responder::from_untyped(responder);
8303
8304 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8305 Ok(decoded) => {
8306 handler
8307 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
8308 .await;
8309 Ok(())
8310 }
8311 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8312 ordinal: 6172186066099445416,
8313 error,
8314 }),
8315 }
8316 }
8317
8318 8013111122914313744 => {
8319 let responder = ::fidl_next::Responder::from_untyped(responder);
8320
8321 handler.query_filesystem(responder).await;
8322 Ok(())
8323 }
8324
8325 5788516050773961964 => {
8326 let responder = ::fidl_next::Responder::from_untyped(responder);
8327
8328 handler.get_token(responder).await;
8329 Ok(())
8330 }
8331
8332 4414537700416816443 => {
8333 let responder = ::fidl_next::Responder::from_untyped(responder);
8334
8335 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8336 Ok(decoded) => {
8337 handler
8338 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
8339 .await;
8340 Ok(())
8341 }
8342 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8343 ordinal: 4414537700416816443,
8344 error,
8345 }),
8346 }
8347 }
8348
8349 3677402239314018056 => {
8350 let responder = ::fidl_next::Responder::from_untyped(responder);
8351
8352 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8353 Ok(decoded) => {
8354 handler
8355 .update_attributes(
8356 ::fidl_next::Request::from_decoded(decoded),
8357 responder,
8358 )
8359 .await;
8360 Ok(())
8361 }
8362 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8363 ordinal: 3677402239314018056,
8364 error,
8365 }),
8366 }
8367 }
8368
8369 3196473584242777161 => {
8370 let responder = ::fidl_next::Responder::from_untyped(responder);
8371
8372 handler.sync(responder).await;
8373 Ok(())
8374 }
8375
8376 5043930208506967771 => {
8377 let responder = ::fidl_next::Responder::from_untyped(responder);
8378
8379 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8380 Ok(decoded) => {
8381 handler
8382 .get_extended_attribute(
8383 ::fidl_next::Request::from_decoded(decoded),
8384 responder,
8385 )
8386 .await;
8387 Ok(())
8388 }
8389 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8390 ordinal: 5043930208506967771,
8391 error,
8392 }),
8393 }
8394 }
8395
8396 5374223046099989052 => {
8397 let responder = ::fidl_next::Responder::from_untyped(responder);
8398
8399 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8400 Ok(decoded) => {
8401 handler
8402 .set_extended_attribute(
8403 ::fidl_next::Request::from_decoded(decoded),
8404 responder,
8405 )
8406 .await;
8407 Ok(())
8408 }
8409 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8410 ordinal: 5374223046099989052,
8411 error,
8412 }),
8413 }
8414 }
8415
8416 8794297771444732717 => {
8417 let responder = ::fidl_next::Responder::from_untyped(responder);
8418
8419 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8420 Ok(decoded) => {
8421 handler
8422 .remove_extended_attribute(
8423 ::fidl_next::Request::from_decoded(decoded),
8424 responder,
8425 )
8426 .await;
8427 Ok(())
8428 }
8429 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8430 ordinal: 8794297771444732717,
8431 error,
8432 }),
8433 }
8434 }
8435
8436 ordinal => {
8437 handler.on_unknown_interaction(ordinal).await;
8438 if ::core::matches!(
8439 message.header().flexibility(),
8440 ::fidl_next::protocol::Flexibility::Strict
8441 ) {
8442 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8443 } else {
8444 responder
8445 .respond_framework_error(
8446 ordinal,
8447 ::fidl_next::FrameworkError::UnknownMethod,
8448 )
8449 .expect("encoding a framework error should never fail")
8450 .await?;
8451 Ok(())
8452 }
8453 }
8454 }
8455 }
8456}
8457
8458pub trait NodeClientHandler<
8462 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
8463 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8464>
8465{
8466 #[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"]
8467 fn on_open(
8468 &mut self,
8469
8470 request: ::fidl_next::Request<node::OnOpen, ___T>,
8471 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8472
8473 #[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"]
8474 fn on_representation(
8475 &mut self,
8476
8477 request: ::fidl_next::Request<node::OnRepresentation, ___T>,
8478 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8479
8480 fn on_unknown_interaction(
8481 &mut self,
8482 ordinal: u64,
8483 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
8484 ::core::future::ready(())
8485 }
8486}
8487
8488impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Node
8489where
8490 ___H: NodeClientHandler<___T> + ::core::marker::Send,
8491 ___T: ::fidl_next::Transport,
8492 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
8493 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8494 Constraint = (),
8495 >,
8496 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
8497 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8498 Constraint = (),
8499 >,
8500{
8501 async fn on_event(
8502 handler: &mut ___H,
8503 mut message: ::fidl_next::Message<___T>,
8504 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
8505 match *message.header().ordinal {
8506 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
8507 Ok(decoded) => {
8508 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
8509 Ok(())
8510 }
8511 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8512 ordinal: 9207534335756671346,
8513 error,
8514 }),
8515 },
8516
8517 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
8518 Ok(decoded) => {
8519 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
8520 Ok(())
8521 }
8522 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8523 ordinal: 6679970090861613324,
8524 error,
8525 }),
8526 },
8527
8528 ordinal => {
8529 handler.on_unknown_interaction(ordinal).await;
8530 if ::core::matches!(
8531 message.header().flexibility(),
8532 ::fidl_next::protocol::Flexibility::Strict
8533 ) {
8534 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8535 } else {
8536 Ok(())
8537 }
8538 }
8539 }
8540 }
8541}
8542
8543pub trait NodeServerHandler<
8547 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
8548 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8549>
8550{
8551 fn clone(
8552 &mut self,
8553
8554 request: ::fidl_next::Request<node::Clone, ___T>,
8555 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8556
8557 #[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"]
8558 fn close(
8559 &mut self,
8560
8561 responder: ::fidl_next::Responder<node::Close, ___T>,
8562 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8563
8564 fn query(
8565 &mut self,
8566
8567 responder: ::fidl_next::Responder<node::Query, ___T>,
8568 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8569
8570 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
8571 fn deprecated_get_attr(
8572 &mut self,
8573
8574 responder: ::fidl_next::Responder<node::DeprecatedGetAttr, ___T>,
8575 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8576
8577 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
8578 fn deprecated_set_attr(
8579 &mut self,
8580
8581 request: ::fidl_next::Request<node::DeprecatedSetAttr, ___T>,
8582
8583 responder: ::fidl_next::Responder<node::DeprecatedSetAttr, ___T>,
8584 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8585
8586 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
8587 fn deprecated_get_flags(
8588 &mut self,
8589
8590 responder: ::fidl_next::Responder<node::DeprecatedGetFlags, ___T>,
8591 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8592
8593 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
8594 fn deprecated_set_flags(
8595 &mut self,
8596
8597 request: ::fidl_next::Request<node::DeprecatedSetFlags, ___T>,
8598
8599 responder: ::fidl_next::Responder<node::DeprecatedSetFlags, ___T>,
8600 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8601
8602 #[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"]
8603 fn get_flags(
8604 &mut self,
8605
8606 responder: ::fidl_next::Responder<node::GetFlags, ___T>,
8607 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8608
8609 #[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"]
8610 fn set_flags(
8611 &mut self,
8612
8613 request: ::fidl_next::Request<node::SetFlags, ___T>,
8614
8615 responder: ::fidl_next::Responder<node::SetFlags, ___T>,
8616 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8617
8618 #[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"]
8619 fn query_filesystem(
8620 &mut self,
8621
8622 responder: ::fidl_next::Responder<node::QueryFilesystem, ___T>,
8623 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8624
8625 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
8626 fn get_token(
8627 &mut self,
8628
8629 responder: ::fidl_next::Responder<node::GetToken, ___T>,
8630 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8631
8632 #[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"]
8633 fn get_attributes(
8634 &mut self,
8635
8636 request: ::fidl_next::Request<node::GetAttributes, ___T>,
8637
8638 responder: ::fidl_next::Responder<node::GetAttributes, ___T>,
8639 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8640
8641 #[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"]
8642 fn update_attributes(
8643 &mut self,
8644
8645 request: ::fidl_next::Request<node::UpdateAttributes, ___T>,
8646
8647 responder: ::fidl_next::Responder<node::UpdateAttributes, ___T>,
8648 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8649
8650 #[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"]
8651 fn sync(
8652 &mut self,
8653
8654 responder: ::fidl_next::Responder<node::Sync, ___T>,
8655 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8656
8657 #[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.READ_BYTES`] right.\n"]
8658 fn list_extended_attributes(
8659 &mut self,
8660
8661 request: ::fidl_next::Request<node::ListExtendedAttributes, ___T>,
8662 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8663
8664 #[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.READ_BYTES`] right.\n"]
8665 fn get_extended_attribute(
8666 &mut self,
8667
8668 request: ::fidl_next::Request<node::GetExtendedAttribute, ___T>,
8669
8670 responder: ::fidl_next::Responder<node::GetExtendedAttribute, ___T>,
8671 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8672
8673 #[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.WRITE_BYTES`] right.\n"]
8674 fn set_extended_attribute(
8675 &mut self,
8676
8677 request: ::fidl_next::Request<node::SetExtendedAttribute, ___T>,
8678
8679 responder: ::fidl_next::Responder<node::SetExtendedAttribute, ___T>,
8680 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8681
8682 #[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.WRITE_BYTES`] right.\n"]
8683 fn remove_extended_attribute(
8684 &mut self,
8685
8686 request: ::fidl_next::Request<node::RemoveExtendedAttribute, ___T>,
8687
8688 responder: ::fidl_next::Responder<node::RemoveExtendedAttribute, ___T>,
8689 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8690
8691 fn on_unknown_interaction(
8692 &mut self,
8693 ordinal: u64,
8694 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
8695 ::core::future::ready(())
8696 }
8697}
8698
8699impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Node
8700where
8701 ___H: NodeServerHandler<___T> + ::core::marker::Send,
8702 ___T: ::fidl_next::Transport,
8703 for<'de> ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
8704 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8705 Constraint = (),
8706 >,
8707 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
8708 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8709 Constraint = (),
8710 >,
8711 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
8712 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8713 Constraint = (),
8714 >,
8715 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
8716 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8717 Constraint = (),
8718 >,
8719 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
8720 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8721 Constraint = (),
8722 >,
8723 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
8724 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8725 Constraint = (),
8726 >,
8727 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
8728 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8729 Constraint = (),
8730 >,
8731 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
8732 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8733 Constraint = (),
8734 >,
8735 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
8736 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8737 Constraint = (),
8738 >,
8739 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
8740 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8741 Constraint = (),
8742 >,
8743{
8744 async fn on_one_way(
8745 handler: &mut ___H,
8746 mut message: ::fidl_next::Message<___T>,
8747 ) -> ::core::result::Result<
8748 (),
8749 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8750 > {
8751 match *message.header().ordinal {
8752 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
8753 Ok(decoded) => {
8754 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
8755 Ok(())
8756 }
8757 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8758 ordinal: 2366825959783828089,
8759 error,
8760 }),
8761 },
8762
8763 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
8764 Ok(decoded) => {
8765 handler
8766 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
8767 .await;
8768 Ok(())
8769 }
8770 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8771 ordinal: 5431626189872037072,
8772 error,
8773 }),
8774 },
8775
8776 ordinal => {
8777 handler.on_unknown_interaction(ordinal).await;
8778 if ::core::matches!(
8779 message.header().flexibility(),
8780 ::fidl_next::protocol::Flexibility::Strict
8781 ) {
8782 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8783 } else {
8784 Ok(())
8785 }
8786 }
8787 }
8788 }
8789
8790 async fn on_two_way(
8791 handler: &mut ___H,
8792 mut message: ::fidl_next::Message<___T>,
8793 responder: ::fidl_next::protocol::Responder<___T>,
8794 ) -> ::core::result::Result<
8795 (),
8796 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8797 > {
8798 match *message.header().ordinal {
8799 6540867515453498750 => {
8800 let responder = ::fidl_next::Responder::from_untyped(responder);
8801
8802 handler.close(responder).await;
8803 Ok(())
8804 }
8805
8806 2763219980499352582 => {
8807 let responder = ::fidl_next::Responder::from_untyped(responder);
8808
8809 handler.query(responder).await;
8810 Ok(())
8811 }
8812
8813 8689798978500614909 => {
8814 let responder = ::fidl_next::Responder::from_untyped(responder);
8815
8816 handler.deprecated_get_attr(responder).await;
8817 Ok(())
8818 }
8819
8820 4721673413776871238 => {
8821 let responder = ::fidl_next::Responder::from_untyped(responder);
8822
8823 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8824 Ok(decoded) => {
8825 handler
8826 .deprecated_set_attr(
8827 ::fidl_next::Request::from_decoded(decoded),
8828 responder,
8829 )
8830 .await;
8831 Ok(())
8832 }
8833 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8834 ordinal: 4721673413776871238,
8835 error,
8836 }),
8837 }
8838 }
8839
8840 6595803110182632097 => {
8841 let responder = ::fidl_next::Responder::from_untyped(responder);
8842
8843 handler.deprecated_get_flags(responder).await;
8844 Ok(())
8845 }
8846
8847 5950864159036794675 => {
8848 let responder = ::fidl_next::Responder::from_untyped(responder);
8849
8850 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8851 Ok(decoded) => {
8852 handler
8853 .deprecated_set_flags(
8854 ::fidl_next::Request::from_decoded(decoded),
8855 responder,
8856 )
8857 .await;
8858 Ok(())
8859 }
8860 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8861 ordinal: 5950864159036794675,
8862 error,
8863 }),
8864 }
8865 }
8866
8867 105530239381466147 => {
8868 let responder = ::fidl_next::Responder::from_untyped(responder);
8869
8870 handler.get_flags(responder).await;
8871 Ok(())
8872 }
8873
8874 6172186066099445416 => {
8875 let responder = ::fidl_next::Responder::from_untyped(responder);
8876
8877 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8878 Ok(decoded) => {
8879 handler
8880 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
8881 .await;
8882 Ok(())
8883 }
8884 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8885 ordinal: 6172186066099445416,
8886 error,
8887 }),
8888 }
8889 }
8890
8891 8013111122914313744 => {
8892 let responder = ::fidl_next::Responder::from_untyped(responder);
8893
8894 handler.query_filesystem(responder).await;
8895 Ok(())
8896 }
8897
8898 5788516050773961964 => {
8899 let responder = ::fidl_next::Responder::from_untyped(responder);
8900
8901 handler.get_token(responder).await;
8902 Ok(())
8903 }
8904
8905 4414537700416816443 => {
8906 let responder = ::fidl_next::Responder::from_untyped(responder);
8907
8908 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8909 Ok(decoded) => {
8910 handler
8911 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
8912 .await;
8913 Ok(())
8914 }
8915 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8916 ordinal: 4414537700416816443,
8917 error,
8918 }),
8919 }
8920 }
8921
8922 3677402239314018056 => {
8923 let responder = ::fidl_next::Responder::from_untyped(responder);
8924
8925 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8926 Ok(decoded) => {
8927 handler
8928 .update_attributes(
8929 ::fidl_next::Request::from_decoded(decoded),
8930 responder,
8931 )
8932 .await;
8933 Ok(())
8934 }
8935 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8936 ordinal: 3677402239314018056,
8937 error,
8938 }),
8939 }
8940 }
8941
8942 3196473584242777161 => {
8943 let responder = ::fidl_next::Responder::from_untyped(responder);
8944
8945 handler.sync(responder).await;
8946 Ok(())
8947 }
8948
8949 5043930208506967771 => {
8950 let responder = ::fidl_next::Responder::from_untyped(responder);
8951
8952 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8953 Ok(decoded) => {
8954 handler
8955 .get_extended_attribute(
8956 ::fidl_next::Request::from_decoded(decoded),
8957 responder,
8958 )
8959 .await;
8960 Ok(())
8961 }
8962 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8963 ordinal: 5043930208506967771,
8964 error,
8965 }),
8966 }
8967 }
8968
8969 5374223046099989052 => {
8970 let responder = ::fidl_next::Responder::from_untyped(responder);
8971
8972 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8973 Ok(decoded) => {
8974 handler
8975 .set_extended_attribute(
8976 ::fidl_next::Request::from_decoded(decoded),
8977 responder,
8978 )
8979 .await;
8980 Ok(())
8981 }
8982 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8983 ordinal: 5374223046099989052,
8984 error,
8985 }),
8986 }
8987 }
8988
8989 8794297771444732717 => {
8990 let responder = ::fidl_next::Responder::from_untyped(responder);
8991
8992 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8993 Ok(decoded) => {
8994 handler
8995 .remove_extended_attribute(
8996 ::fidl_next::Request::from_decoded(decoded),
8997 responder,
8998 )
8999 .await;
9000 Ok(())
9001 }
9002 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9003 ordinal: 8794297771444732717,
9004 error,
9005 }),
9006 }
9007 }
9008
9009 ordinal => {
9010 handler.on_unknown_interaction(ordinal).await;
9011 if ::core::matches!(
9012 message.header().flexibility(),
9013 ::fidl_next::protocol::Flexibility::Strict
9014 ) {
9015 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9016 } else {
9017 responder
9018 .respond_framework_error(
9019 ordinal,
9020 ::fidl_next::FrameworkError::UnknownMethod,
9021 )
9022 .expect("encoding a framework error should never fail")
9023 .await?;
9024 Ok(())
9025 }
9026 }
9027 }
9028 }
9029}
9030
9031impl<___T> NodeClientHandler<___T> for ::fidl_next::IgnoreEvents
9032where
9033 ___T: ::fidl_next::Transport,
9034{
9035 async fn on_open(&mut self, _: ::fidl_next::Request<node::OnOpen, ___T>) {}
9036
9037 async fn on_representation(&mut self, _: ::fidl_next::Request<node::OnRepresentation, ___T>) {}
9038
9039 async fn on_unknown_interaction(&mut self, _: u64) {}
9040}
9041
9042impl<___H, ___T> NodeLocalClientHandler<___T> for ::fidl_next::Local<___H>
9043where
9044 ___H: NodeClientHandler<___T>,
9045 ___T: ::fidl_next::Transport,
9046{
9047 async fn on_open(&mut self, request: ::fidl_next::Request<node::OnOpen, ___T>) {
9048 ___H::on_open(&mut self.0, request).await
9049 }
9050
9051 async fn on_representation(
9052 &mut self,
9053
9054 request: ::fidl_next::Request<node::OnRepresentation, ___T>,
9055 ) {
9056 ___H::on_representation(&mut self.0, request).await
9057 }
9058
9059 async fn on_unknown_interaction(&mut self, ordinal: u64) {
9060 ___H::on_unknown_interaction(&mut self.0, ordinal).await
9061 }
9062}
9063
9064impl<___H, ___T> NodeLocalServerHandler<___T> for ::fidl_next::Local<___H>
9065where
9066 ___H: NodeServerHandler<___T>,
9067 ___T: ::fidl_next::Transport,
9068{
9069 async fn clone(&mut self, request: ::fidl_next::Request<node::Clone, ___T>) {
9070 ___H::clone(&mut self.0, request).await
9071 }
9072
9073 async fn close(&mut self, responder: ::fidl_next::Responder<node::Close, ___T>) {
9074 ___H::close(&mut self.0, responder).await
9075 }
9076
9077 async fn query(&mut self, responder: ::fidl_next::Responder<node::Query, ___T>) {
9078 ___H::query(&mut self.0, responder).await
9079 }
9080
9081 async fn deprecated_get_attr(
9082 &mut self,
9083
9084 responder: ::fidl_next::Responder<node::DeprecatedGetAttr, ___T>,
9085 ) {
9086 ___H::deprecated_get_attr(&mut self.0, responder).await
9087 }
9088
9089 async fn deprecated_set_attr(
9090 &mut self,
9091
9092 request: ::fidl_next::Request<node::DeprecatedSetAttr, ___T>,
9093
9094 responder: ::fidl_next::Responder<node::DeprecatedSetAttr, ___T>,
9095 ) {
9096 ___H::deprecated_set_attr(&mut self.0, request, responder).await
9097 }
9098
9099 async fn deprecated_get_flags(
9100 &mut self,
9101
9102 responder: ::fidl_next::Responder<node::DeprecatedGetFlags, ___T>,
9103 ) {
9104 ___H::deprecated_get_flags(&mut self.0, responder).await
9105 }
9106
9107 async fn deprecated_set_flags(
9108 &mut self,
9109
9110 request: ::fidl_next::Request<node::DeprecatedSetFlags, ___T>,
9111
9112 responder: ::fidl_next::Responder<node::DeprecatedSetFlags, ___T>,
9113 ) {
9114 ___H::deprecated_set_flags(&mut self.0, request, responder).await
9115 }
9116
9117 async fn get_flags(&mut self, responder: ::fidl_next::Responder<node::GetFlags, ___T>) {
9118 ___H::get_flags(&mut self.0, responder).await
9119 }
9120
9121 async fn set_flags(
9122 &mut self,
9123
9124 request: ::fidl_next::Request<node::SetFlags, ___T>,
9125
9126 responder: ::fidl_next::Responder<node::SetFlags, ___T>,
9127 ) {
9128 ___H::set_flags(&mut self.0, request, responder).await
9129 }
9130
9131 async fn query_filesystem(
9132 &mut self,
9133
9134 responder: ::fidl_next::Responder<node::QueryFilesystem, ___T>,
9135 ) {
9136 ___H::query_filesystem(&mut self.0, responder).await
9137 }
9138
9139 async fn get_token(&mut self, responder: ::fidl_next::Responder<node::GetToken, ___T>) {
9140 ___H::get_token(&mut self.0, responder).await
9141 }
9142
9143 async fn get_attributes(
9144 &mut self,
9145
9146 request: ::fidl_next::Request<node::GetAttributes, ___T>,
9147
9148 responder: ::fidl_next::Responder<node::GetAttributes, ___T>,
9149 ) {
9150 ___H::get_attributes(&mut self.0, request, responder).await
9151 }
9152
9153 async fn update_attributes(
9154 &mut self,
9155
9156 request: ::fidl_next::Request<node::UpdateAttributes, ___T>,
9157
9158 responder: ::fidl_next::Responder<node::UpdateAttributes, ___T>,
9159 ) {
9160 ___H::update_attributes(&mut self.0, request, responder).await
9161 }
9162
9163 async fn sync(&mut self, responder: ::fidl_next::Responder<node::Sync, ___T>) {
9164 ___H::sync(&mut self.0, responder).await
9165 }
9166
9167 async fn list_extended_attributes(
9168 &mut self,
9169
9170 request: ::fidl_next::Request<node::ListExtendedAttributes, ___T>,
9171 ) {
9172 ___H::list_extended_attributes(&mut self.0, request).await
9173 }
9174
9175 async fn get_extended_attribute(
9176 &mut self,
9177
9178 request: ::fidl_next::Request<node::GetExtendedAttribute, ___T>,
9179
9180 responder: ::fidl_next::Responder<node::GetExtendedAttribute, ___T>,
9181 ) {
9182 ___H::get_extended_attribute(&mut self.0, request, responder).await
9183 }
9184
9185 async fn set_extended_attribute(
9186 &mut self,
9187
9188 request: ::fidl_next::Request<node::SetExtendedAttribute, ___T>,
9189
9190 responder: ::fidl_next::Responder<node::SetExtendedAttribute, ___T>,
9191 ) {
9192 ___H::set_extended_attribute(&mut self.0, request, responder).await
9193 }
9194
9195 async fn remove_extended_attribute(
9196 &mut self,
9197
9198 request: ::fidl_next::Request<node::RemoveExtendedAttribute, ___T>,
9199
9200 responder: ::fidl_next::Responder<node::RemoveExtendedAttribute, ___T>,
9201 ) {
9202 ___H::remove_extended_attribute(&mut self.0, request, responder).await
9203 }
9204
9205 async fn on_unknown_interaction(&mut self, ordinal: u64) {
9206 ___H::on_unknown_interaction(&mut self.0, ordinal).await
9207 }
9208}
9209
9210#[doc = " Directory defines a node which is capable of containing other Objects.\n"]
9212#[derive(PartialEq, Debug)]
9213pub struct Directory;
9214
9215impl ::fidl_next::Discoverable for Directory {
9216 const PROTOCOL_NAME: &'static str = "fuchsia.io.Directory";
9217}
9218
9219#[cfg(target_os = "fuchsia")]
9220impl ::fidl_next::HasTransport for Directory {
9221 type Transport = ::fdomain_client::Channel;
9222}
9223
9224pub mod directory {
9225 pub mod prelude {
9226 pub use crate::{
9227 Directory, DirectoryClientHandler, DirectoryLocalClientHandler,
9228 DirectoryLocalServerHandler, DirectoryServerHandler, directory,
9229 };
9230
9231 pub use crate::natural::AdvisoryLockingAdvisoryLockRequest;
9232
9233 pub use crate::natural::AdvisoryLockingAdvisoryLockResponse;
9234
9235 pub use crate::natural::DirectoryCreateSymlinkRequest;
9236
9237 pub use crate::natural::DirectoryDeprecatedGetTokenResponse;
9238
9239 pub use crate::natural::DirectoryDeprecatedOpenRequest;
9240
9241 pub use crate::natural::DirectoryLinkRequest;
9242
9243 pub use crate::natural::DirectoryLinkResponse;
9244
9245 pub use crate::natural::DirectoryReadDirentsRequest;
9246
9247 pub use crate::natural::DirectoryReadDirentsResponse;
9248
9249 pub use crate::natural::DirectoryRenameRequest;
9250
9251 pub use crate::natural::DirectoryRewindResponse;
9252
9253 pub use crate::natural::DirectoryUnlinkRequest;
9254
9255 pub use crate::natural::DirectoryWatchRequest;
9256
9257 pub use crate::natural::DirectoryWatchResponse;
9258
9259 pub use crate::natural::DirectoryCreateSymlinkResponse;
9260
9261 pub use crate::natural::DirectoryRenameResponse;
9262
9263 pub use crate::natural::DirectoryUnlinkResponse;
9264
9265 pub use crate::natural::ExtendedAttributeValue;
9266
9267 pub use crate::natural::MutableNodeAttributes;
9268
9269 pub use crate::natural::NodeAttributes2;
9270
9271 pub use crate::natural::NodeDeprecatedGetAttrResponse;
9272
9273 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
9274
9275 pub use crate::natural::NodeDeprecatedSetAttrRequest;
9276
9277 pub use crate::natural::NodeDeprecatedSetAttrResponse;
9278
9279 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
9280
9281 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
9282
9283 pub use crate::natural::NodeGetAttributesRequest;
9284
9285 pub use crate::natural::NodeGetExtendedAttributeRequest;
9286
9287 pub use crate::natural::NodeListExtendedAttributesRequest;
9288
9289 pub use crate::natural::NodeOnOpenRequest;
9290
9291 pub use crate::natural::NodeQueryFilesystemResponse;
9292
9293 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
9294
9295 pub use crate::natural::NodeSetExtendedAttributeRequest;
9296
9297 pub use crate::natural::NodeSetFlagsRequest;
9298
9299 pub use crate::natural::NodeGetFlagsResponse;
9300
9301 pub use crate::natural::NodeGetTokenResponse;
9302
9303 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
9304
9305 pub use crate::natural::NodeSetExtendedAttributeResponse;
9306
9307 pub use crate::natural::NodeSetFlagsResponse;
9308
9309 pub use crate::natural::NodeSyncResponse;
9310
9311 pub use crate::natural::NodeUpdateAttributesResponse;
9312
9313 pub use crate::natural::OpenableOpenRequest;
9314
9315 pub use crate::natural::Representation;
9316
9317 pub use ::fdomain_next_fuchsia_unknown::natural::CloneableCloneRequest;
9318
9319 pub use ::fdomain_next_fuchsia_unknown::natural::CloseableCloseResponse;
9320
9321 pub use ::fdomain_next_fuchsia_unknown::natural::QueryableQueryResponse;
9322 }
9323
9324 pub struct AdvisoryLock;
9325
9326 impl ::fidl_next::Method for AdvisoryLock {
9327 const ORDINAL: u64 = 7992130864415541162;
9328 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9329 ::fidl_next::protocol::Flexibility::Strict;
9330
9331 type Protocol = crate::Directory;
9332
9333 type Request = crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>;
9334 }
9335
9336 impl ::fidl_next::TwoWayMethod for AdvisoryLock {
9337 type Response = ::fidl_next::wire::Result<
9338 'static,
9339 crate::wire::AdvisoryLockingAdvisoryLockResponse,
9340 ::fidl_next::wire::fuchsia::Status,
9341 >;
9342 }
9343
9344 impl<___R> ::fidl_next::Respond<___R> for AdvisoryLock {
9345 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9346
9347 fn respond(response: ___R) -> Self::Output {
9348 ::core::result::Result::Ok(response)
9349 }
9350 }
9351
9352 impl<___R> ::fidl_next::RespondErr<___R> for AdvisoryLock {
9353 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9354
9355 fn respond_err(response: ___R) -> Self::Output {
9356 ::core::result::Result::Err(response)
9357 }
9358 }
9359
9360 pub struct Clone;
9361
9362 impl ::fidl_next::Method for Clone {
9363 const ORDINAL: u64 = 2366825959783828089;
9364 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9365 ::fidl_next::protocol::Flexibility::Strict;
9366
9367 type Protocol = crate::Directory;
9368
9369 type Request = ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest;
9370 }
9371
9372 pub struct Close;
9373
9374 impl ::fidl_next::Method for Close {
9375 const ORDINAL: u64 = 6540867515453498750;
9376 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9377 ::fidl_next::protocol::Flexibility::Strict;
9378
9379 type Protocol = crate::Directory;
9380
9381 type Request = ::fidl_next::wire::EmptyMessageBody;
9382 }
9383
9384 impl ::fidl_next::TwoWayMethod for Close {
9385 type Response = ::fidl_next::wire::Result<
9386 'static,
9387 ::fdomain_next_fuchsia_unknown::wire::CloseableCloseResponse,
9388 ::fidl_next::wire::Int32,
9389 >;
9390 }
9391
9392 impl<___R> ::fidl_next::Respond<___R> for Close {
9393 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9394
9395 fn respond(response: ___R) -> Self::Output {
9396 ::core::result::Result::Ok(response)
9397 }
9398 }
9399
9400 impl<___R> ::fidl_next::RespondErr<___R> for Close {
9401 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9402
9403 fn respond_err(response: ___R) -> Self::Output {
9404 ::core::result::Result::Err(response)
9405 }
9406 }
9407
9408 pub struct Query;
9409
9410 impl ::fidl_next::Method for Query {
9411 const ORDINAL: u64 = 2763219980499352582;
9412 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9413 ::fidl_next::protocol::Flexibility::Strict;
9414
9415 type Protocol = crate::Directory;
9416
9417 type Request = ::fidl_next::wire::EmptyMessageBody;
9418 }
9419
9420 impl ::fidl_next::TwoWayMethod for Query {
9421 type Response = ::fidl_next::wire::Strict<
9422 ::fdomain_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>,
9423 >;
9424 }
9425
9426 impl<___R> ::fidl_next::Respond<___R> for Query {
9427 type Output = ::fidl_next::Strict<
9428 ::fdomain_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>,
9429 >;
9430
9431 fn respond(response: ___R) -> Self::Output {
9432 ::fidl_next::Strict(::fdomain_next_fuchsia_unknown::generic::QueryableQueryResponse {
9433 protocol: response,
9434 })
9435 }
9436 }
9437
9438 pub struct OnOpen;
9439
9440 impl ::fidl_next::Method for OnOpen {
9441 const ORDINAL: u64 = 9207534335756671346;
9442 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9443 ::fidl_next::protocol::Flexibility::Flexible;
9444
9445 type Protocol = crate::Directory;
9446
9447 type Request = crate::wire::NodeOnOpenRequest<'static>;
9448 }
9449
9450 pub struct DeprecatedGetAttr;
9451
9452 impl ::fidl_next::Method for DeprecatedGetAttr {
9453 const ORDINAL: u64 = 8689798978500614909;
9454 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9455 ::fidl_next::protocol::Flexibility::Strict;
9456
9457 type Protocol = crate::Directory;
9458
9459 type Request = ::fidl_next::wire::EmptyMessageBody;
9460 }
9461
9462 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
9463 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetAttrResponse>;
9464 }
9465
9466 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
9467 type Output = ::fidl_next::Strict<___R>;
9468
9469 fn respond(response: ___R) -> Self::Output {
9470 ::fidl_next::Strict(response)
9471 }
9472 }
9473
9474 pub struct DeprecatedSetAttr;
9475
9476 impl ::fidl_next::Method for DeprecatedSetAttr {
9477 const ORDINAL: u64 = 4721673413776871238;
9478 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9479 ::fidl_next::protocol::Flexibility::Strict;
9480
9481 type Protocol = crate::Directory;
9482
9483 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
9484 }
9485
9486 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
9487 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetAttrResponse>;
9488 }
9489
9490 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
9491 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetAttrResponse<___R>>;
9492
9493 fn respond(response: ___R) -> Self::Output {
9494 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetAttrResponse { s: response })
9495 }
9496 }
9497
9498 pub struct DeprecatedGetFlags;
9499
9500 impl ::fidl_next::Method for DeprecatedGetFlags {
9501 const ORDINAL: u64 = 6595803110182632097;
9502 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9503 ::fidl_next::protocol::Flexibility::Strict;
9504
9505 type Protocol = crate::Directory;
9506
9507 type Request = ::fidl_next::wire::EmptyMessageBody;
9508 }
9509
9510 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
9511 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetFlagsResponse>;
9512 }
9513
9514 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
9515 type Output = ::fidl_next::Strict<___R>;
9516
9517 fn respond(response: ___R) -> Self::Output {
9518 ::fidl_next::Strict(response)
9519 }
9520 }
9521
9522 pub struct DeprecatedSetFlags;
9523
9524 impl ::fidl_next::Method for DeprecatedSetFlags {
9525 const ORDINAL: u64 = 5950864159036794675;
9526 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9527 ::fidl_next::protocol::Flexibility::Strict;
9528
9529 type Protocol = crate::Directory;
9530
9531 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
9532 }
9533
9534 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
9535 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetFlagsResponse>;
9536 }
9537
9538 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
9539 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetFlagsResponse<___R>>;
9540
9541 fn respond(response: ___R) -> Self::Output {
9542 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetFlagsResponse { s: response })
9543 }
9544 }
9545
9546 pub struct GetFlags;
9547
9548 impl ::fidl_next::Method for GetFlags {
9549 const ORDINAL: u64 = 105530239381466147;
9550 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9551 ::fidl_next::protocol::Flexibility::Flexible;
9552
9553 type Protocol = crate::Directory;
9554
9555 type Request = ::fidl_next::wire::EmptyMessageBody;
9556 }
9557
9558 impl ::fidl_next::TwoWayMethod for GetFlags {
9559 type Response = ::fidl_next::wire::Result<
9560 'static,
9561 crate::wire::NodeGetFlagsResponse,
9562 ::fidl_next::wire::fuchsia::Status,
9563 >;
9564 }
9565
9566 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
9567 type Output = ::core::result::Result<
9568 crate::generic::NodeGetFlagsResponse<___R>,
9569 ::fidl_next::never::Never,
9570 >;
9571
9572 fn respond(response: ___R) -> Self::Output {
9573 ::core::result::Result::Ok(crate::generic::NodeGetFlagsResponse { flags: response })
9574 }
9575 }
9576
9577 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
9578 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9579
9580 fn respond_err(response: ___R) -> Self::Output {
9581 ::core::result::Result::Err(response)
9582 }
9583 }
9584
9585 pub struct SetFlags;
9586
9587 impl ::fidl_next::Method for SetFlags {
9588 const ORDINAL: u64 = 6172186066099445416;
9589 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9590 ::fidl_next::protocol::Flexibility::Flexible;
9591
9592 type Protocol = crate::Directory;
9593
9594 type Request = crate::wire::NodeSetFlagsRequest;
9595 }
9596
9597 impl ::fidl_next::TwoWayMethod for SetFlags {
9598 type Response = ::fidl_next::wire::Result<
9599 'static,
9600 crate::wire::NodeSetFlagsResponse,
9601 ::fidl_next::wire::fuchsia::Status,
9602 >;
9603 }
9604
9605 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
9606 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9607
9608 fn respond(response: ___R) -> Self::Output {
9609 ::core::result::Result::Ok(response)
9610 }
9611 }
9612
9613 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
9614 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9615
9616 fn respond_err(response: ___R) -> Self::Output {
9617 ::core::result::Result::Err(response)
9618 }
9619 }
9620
9621 pub struct QueryFilesystem;
9622
9623 impl ::fidl_next::Method for QueryFilesystem {
9624 const ORDINAL: u64 = 8013111122914313744;
9625 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9626 ::fidl_next::protocol::Flexibility::Strict;
9627
9628 type Protocol = crate::Directory;
9629
9630 type Request = ::fidl_next::wire::EmptyMessageBody;
9631 }
9632
9633 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
9634 type Response =
9635 ::fidl_next::wire::Strict<crate::wire::NodeQueryFilesystemResponse<'static>>;
9636 }
9637
9638 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
9639 type Output = ::fidl_next::Strict<___R>;
9640
9641 fn respond(response: ___R) -> Self::Output {
9642 ::fidl_next::Strict(response)
9643 }
9644 }
9645
9646 pub struct OnRepresentation;
9647
9648 impl ::fidl_next::Method for OnRepresentation {
9649 const ORDINAL: u64 = 6679970090861613324;
9650 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9651 ::fidl_next::protocol::Flexibility::Strict;
9652
9653 type Protocol = crate::Directory;
9654
9655 type Request = crate::wire::Representation<'static>;
9656 }
9657
9658 pub struct GetToken;
9659
9660 impl ::fidl_next::Method for GetToken {
9661 const ORDINAL: u64 = 5788516050773961964;
9662 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9663 ::fidl_next::protocol::Flexibility::Flexible;
9664
9665 type Protocol = crate::Directory;
9666
9667 type Request = ::fidl_next::wire::EmptyMessageBody;
9668 }
9669
9670 impl ::fidl_next::TwoWayMethod for GetToken {
9671 type Response = ::fidl_next::wire::Result<
9672 'static,
9673 crate::wire::NodeGetTokenResponse,
9674 ::fidl_next::wire::fuchsia::Status,
9675 >;
9676 }
9677
9678 impl<___R> ::fidl_next::Respond<___R> for GetToken {
9679 type Output = ::core::result::Result<
9680 crate::generic::NodeGetTokenResponse<___R>,
9681 ::fidl_next::never::Never,
9682 >;
9683
9684 fn respond(response: ___R) -> Self::Output {
9685 ::core::result::Result::Ok(crate::generic::NodeGetTokenResponse { token: response })
9686 }
9687 }
9688
9689 impl<___R> ::fidl_next::RespondErr<___R> for GetToken {
9690 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9691
9692 fn respond_err(response: ___R) -> Self::Output {
9693 ::core::result::Result::Err(response)
9694 }
9695 }
9696
9697 pub struct GetAttributes;
9698
9699 impl ::fidl_next::Method for GetAttributes {
9700 const ORDINAL: u64 = 4414537700416816443;
9701 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9702 ::fidl_next::protocol::Flexibility::Strict;
9703
9704 type Protocol = crate::Directory;
9705
9706 type Request = crate::wire::NodeGetAttributesRequest;
9707 }
9708
9709 impl ::fidl_next::TwoWayMethod for GetAttributes {
9710 type Response = ::fidl_next::wire::Result<
9711 'static,
9712 crate::wire::NodeAttributes2<'static>,
9713 ::fidl_next::wire::fuchsia::Status,
9714 >;
9715 }
9716
9717 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
9718 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9719
9720 fn respond(response: ___R) -> Self::Output {
9721 ::core::result::Result::Ok(response)
9722 }
9723 }
9724
9725 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
9726 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9727
9728 fn respond_err(response: ___R) -> Self::Output {
9729 ::core::result::Result::Err(response)
9730 }
9731 }
9732
9733 pub struct UpdateAttributes;
9734
9735 impl ::fidl_next::Method for UpdateAttributes {
9736 const ORDINAL: u64 = 3677402239314018056;
9737 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9738 ::fidl_next::protocol::Flexibility::Strict;
9739
9740 type Protocol = crate::Directory;
9741
9742 type Request = crate::wire::MutableNodeAttributes<'static>;
9743 }
9744
9745 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
9746 type Response = ::fidl_next::wire::Result<
9747 'static,
9748 crate::wire::NodeUpdateAttributesResponse,
9749 ::fidl_next::wire::fuchsia::Status,
9750 >;
9751 }
9752
9753 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
9754 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9755
9756 fn respond(response: ___R) -> Self::Output {
9757 ::core::result::Result::Ok(response)
9758 }
9759 }
9760
9761 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
9762 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9763
9764 fn respond_err(response: ___R) -> Self::Output {
9765 ::core::result::Result::Err(response)
9766 }
9767 }
9768
9769 pub struct Sync;
9770
9771 impl ::fidl_next::Method for Sync {
9772 const ORDINAL: u64 = 3196473584242777161;
9773 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9774 ::fidl_next::protocol::Flexibility::Strict;
9775
9776 type Protocol = crate::Directory;
9777
9778 type Request = ::fidl_next::wire::EmptyMessageBody;
9779 }
9780
9781 impl ::fidl_next::TwoWayMethod for Sync {
9782 type Response = ::fidl_next::wire::Result<
9783 'static,
9784 crate::wire::NodeSyncResponse,
9785 ::fidl_next::wire::fuchsia::Status,
9786 >;
9787 }
9788
9789 impl<___R> ::fidl_next::Respond<___R> for Sync {
9790 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9791
9792 fn respond(response: ___R) -> Self::Output {
9793 ::core::result::Result::Ok(response)
9794 }
9795 }
9796
9797 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
9798 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9799
9800 fn respond_err(response: ___R) -> Self::Output {
9801 ::core::result::Result::Err(response)
9802 }
9803 }
9804
9805 pub struct ListExtendedAttributes;
9806
9807 impl ::fidl_next::Method for ListExtendedAttributes {
9808 const ORDINAL: u64 = 5431626189872037072;
9809 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9810 ::fidl_next::protocol::Flexibility::Strict;
9811
9812 type Protocol = crate::Directory;
9813
9814 type Request = crate::wire::NodeListExtendedAttributesRequest;
9815 }
9816
9817 pub struct GetExtendedAttribute;
9818
9819 impl ::fidl_next::Method for GetExtendedAttribute {
9820 const ORDINAL: u64 = 5043930208506967771;
9821 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9822 ::fidl_next::protocol::Flexibility::Strict;
9823
9824 type Protocol = crate::Directory;
9825
9826 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
9827 }
9828
9829 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
9830 type Response = ::fidl_next::wire::Result<
9831 'static,
9832 crate::wire::ExtendedAttributeValue<'static>,
9833 ::fidl_next::wire::fuchsia::Status,
9834 >;
9835 }
9836
9837 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
9838 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9839
9840 fn respond(response: ___R) -> Self::Output {
9841 ::core::result::Result::Ok(response)
9842 }
9843 }
9844
9845 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
9846 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9847
9848 fn respond_err(response: ___R) -> Self::Output {
9849 ::core::result::Result::Err(response)
9850 }
9851 }
9852
9853 pub struct SetExtendedAttribute;
9854
9855 impl ::fidl_next::Method for SetExtendedAttribute {
9856 const ORDINAL: u64 = 5374223046099989052;
9857 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9858 ::fidl_next::protocol::Flexibility::Strict;
9859
9860 type Protocol = crate::Directory;
9861
9862 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
9863 }
9864
9865 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
9866 type Response = ::fidl_next::wire::Result<
9867 'static,
9868 crate::wire::NodeSetExtendedAttributeResponse,
9869 ::fidl_next::wire::fuchsia::Status,
9870 >;
9871 }
9872
9873 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
9874 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9875
9876 fn respond(response: ___R) -> Self::Output {
9877 ::core::result::Result::Ok(response)
9878 }
9879 }
9880
9881 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
9882 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9883
9884 fn respond_err(response: ___R) -> Self::Output {
9885 ::core::result::Result::Err(response)
9886 }
9887 }
9888
9889 pub struct RemoveExtendedAttribute;
9890
9891 impl ::fidl_next::Method for RemoveExtendedAttribute {
9892 const ORDINAL: u64 = 8794297771444732717;
9893 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9894 ::fidl_next::protocol::Flexibility::Strict;
9895
9896 type Protocol = crate::Directory;
9897
9898 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
9899 }
9900
9901 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
9902 type Response = ::fidl_next::wire::Result<
9903 'static,
9904 crate::wire::NodeRemoveExtendedAttributeResponse,
9905 ::fidl_next::wire::fuchsia::Status,
9906 >;
9907 }
9908
9909 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
9910 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9911
9912 fn respond(response: ___R) -> Self::Output {
9913 ::core::result::Result::Ok(response)
9914 }
9915 }
9916
9917 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
9918 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9919
9920 fn respond_err(response: ___R) -> Self::Output {
9921 ::core::result::Result::Err(response)
9922 }
9923 }
9924
9925 pub struct Open;
9926
9927 impl ::fidl_next::Method for Open {
9928 const ORDINAL: u64 = 6236883748953765593;
9929 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9930 ::fidl_next::protocol::Flexibility::Flexible;
9931
9932 type Protocol = crate::Directory;
9933
9934 type Request = crate::wire::OpenableOpenRequest<'static>;
9935 }
9936
9937 pub struct DeprecatedOpen;
9938
9939 impl ::fidl_next::Method for DeprecatedOpen {
9940 const ORDINAL: u64 = 3193127272456937152;
9941 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9942 ::fidl_next::protocol::Flexibility::Flexible;
9943
9944 type Protocol = crate::Directory;
9945
9946 type Request = crate::wire::DirectoryDeprecatedOpenRequest<'static>;
9947 }
9948
9949 pub struct ReadDirents;
9950
9951 impl ::fidl_next::Method for ReadDirents {
9952 const ORDINAL: u64 = 3855785432100874762;
9953 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9954 ::fidl_next::protocol::Flexibility::Strict;
9955
9956 type Protocol = crate::Directory;
9957
9958 type Request = crate::wire::DirectoryReadDirentsRequest;
9959 }
9960
9961 impl ::fidl_next::TwoWayMethod for ReadDirents {
9962 type Response =
9963 ::fidl_next::wire::Strict<crate::wire::DirectoryReadDirentsResponse<'static>>;
9964 }
9965
9966 impl<___R> ::fidl_next::Respond<___R> for ReadDirents {
9967 type Output = ::fidl_next::Strict<___R>;
9968
9969 fn respond(response: ___R) -> Self::Output {
9970 ::fidl_next::Strict(response)
9971 }
9972 }
9973
9974 pub struct Rewind;
9975
9976 impl ::fidl_next::Method for Rewind {
9977 const ORDINAL: u64 = 1635123508515392625;
9978 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9979 ::fidl_next::protocol::Flexibility::Strict;
9980
9981 type Protocol = crate::Directory;
9982
9983 type Request = ::fidl_next::wire::EmptyMessageBody;
9984 }
9985
9986 impl ::fidl_next::TwoWayMethod for Rewind {
9987 type Response = ::fidl_next::wire::Strict<crate::wire::DirectoryRewindResponse>;
9988 }
9989
9990 impl<___R> ::fidl_next::Respond<___R> for Rewind {
9991 type Output = ::fidl_next::Strict<crate::generic::DirectoryRewindResponse<___R>>;
9992
9993 fn respond(response: ___R) -> Self::Output {
9994 ::fidl_next::Strict(crate::generic::DirectoryRewindResponse { s: response })
9995 }
9996 }
9997
9998 pub struct DeprecatedGetToken;
9999
10000 impl ::fidl_next::Method for DeprecatedGetToken {
10001 const ORDINAL: u64 = 2787337947777369685;
10002 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10003 ::fidl_next::protocol::Flexibility::Strict;
10004
10005 type Protocol = crate::Directory;
10006
10007 type Request = ::fidl_next::wire::EmptyMessageBody;
10008 }
10009
10010 impl ::fidl_next::TwoWayMethod for DeprecatedGetToken {
10011 type Response = ::fidl_next::wire::Strict<crate::wire::DirectoryDeprecatedGetTokenResponse>;
10012 }
10013
10014 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetToken {
10015 type Output = ::fidl_next::Strict<___R>;
10016
10017 fn respond(response: ___R) -> Self::Output {
10018 ::fidl_next::Strict(response)
10019 }
10020 }
10021
10022 pub struct Link;
10023
10024 impl ::fidl_next::Method for Link {
10025 const ORDINAL: u64 = 8360374984291987687;
10026 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10027 ::fidl_next::protocol::Flexibility::Strict;
10028
10029 type Protocol = crate::Directory;
10030
10031 type Request = crate::wire::DirectoryLinkRequest<'static>;
10032 }
10033
10034 impl ::fidl_next::TwoWayMethod for Link {
10035 type Response = ::fidl_next::wire::Strict<crate::wire::DirectoryLinkResponse>;
10036 }
10037
10038 impl<___R> ::fidl_next::Respond<___R> for Link {
10039 type Output = ::fidl_next::Strict<crate::generic::DirectoryLinkResponse<___R>>;
10040
10041 fn respond(response: ___R) -> Self::Output {
10042 ::fidl_next::Strict(crate::generic::DirectoryLinkResponse { s: response })
10043 }
10044 }
10045
10046 pub struct Unlink;
10047
10048 impl ::fidl_next::Method for Unlink {
10049 const ORDINAL: u64 = 8433556716759383021;
10050 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10051 ::fidl_next::protocol::Flexibility::Strict;
10052
10053 type Protocol = crate::Directory;
10054
10055 type Request = crate::wire::DirectoryUnlinkRequest<'static>;
10056 }
10057
10058 impl ::fidl_next::TwoWayMethod for Unlink {
10059 type Response = ::fidl_next::wire::Result<
10060 'static,
10061 crate::wire::DirectoryUnlinkResponse,
10062 ::fidl_next::wire::fuchsia::Status,
10063 >;
10064 }
10065
10066 impl<___R> ::fidl_next::Respond<___R> for Unlink {
10067 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10068
10069 fn respond(response: ___R) -> Self::Output {
10070 ::core::result::Result::Ok(response)
10071 }
10072 }
10073
10074 impl<___R> ::fidl_next::RespondErr<___R> for Unlink {
10075 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10076
10077 fn respond_err(response: ___R) -> Self::Output {
10078 ::core::result::Result::Err(response)
10079 }
10080 }
10081
10082 pub struct Rename;
10083
10084 impl ::fidl_next::Method for Rename {
10085 const ORDINAL: u64 = 8097726607824333022;
10086 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10087 ::fidl_next::protocol::Flexibility::Strict;
10088
10089 type Protocol = crate::Directory;
10090
10091 type Request = crate::wire::DirectoryRenameRequest<'static>;
10092 }
10093
10094 impl ::fidl_next::TwoWayMethod for Rename {
10095 type Response = ::fidl_next::wire::Result<
10096 'static,
10097 crate::wire::DirectoryRenameResponse,
10098 ::fidl_next::wire::fuchsia::Status,
10099 >;
10100 }
10101
10102 impl<___R> ::fidl_next::Respond<___R> for Rename {
10103 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10104
10105 fn respond(response: ___R) -> Self::Output {
10106 ::core::result::Result::Ok(response)
10107 }
10108 }
10109
10110 impl<___R> ::fidl_next::RespondErr<___R> for Rename {
10111 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10112
10113 fn respond_err(response: ___R) -> Self::Output {
10114 ::core::result::Result::Err(response)
10115 }
10116 }
10117
10118 pub struct CreateSymlink;
10119
10120 impl ::fidl_next::Method for CreateSymlink {
10121 const ORDINAL: u64 = 2435901052462315657;
10122 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10123 ::fidl_next::protocol::Flexibility::Strict;
10124
10125 type Protocol = crate::Directory;
10126
10127 type Request = crate::wire::DirectoryCreateSymlinkRequest<'static>;
10128 }
10129
10130 impl ::fidl_next::TwoWayMethod for CreateSymlink {
10131 type Response = ::fidl_next::wire::Result<
10132 'static,
10133 crate::wire::DirectoryCreateSymlinkResponse,
10134 ::fidl_next::wire::fuchsia::Status,
10135 >;
10136 }
10137
10138 impl<___R> ::fidl_next::Respond<___R> for CreateSymlink {
10139 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10140
10141 fn respond(response: ___R) -> Self::Output {
10142 ::core::result::Result::Ok(response)
10143 }
10144 }
10145
10146 impl<___R> ::fidl_next::RespondErr<___R> for CreateSymlink {
10147 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10148
10149 fn respond_err(response: ___R) -> Self::Output {
10150 ::core::result::Result::Err(response)
10151 }
10152 }
10153
10154 pub struct Watch;
10155
10156 impl ::fidl_next::Method for Watch {
10157 const ORDINAL: u64 = 6275512344170098065;
10158 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10159 ::fidl_next::protocol::Flexibility::Strict;
10160
10161 type Protocol = crate::Directory;
10162
10163 type Request = crate::wire::DirectoryWatchRequest;
10164 }
10165
10166 impl ::fidl_next::TwoWayMethod for Watch {
10167 type Response = ::fidl_next::wire::Strict<crate::wire::DirectoryWatchResponse>;
10168 }
10169
10170 impl<___R> ::fidl_next::Respond<___R> for Watch {
10171 type Output = ::fidl_next::Strict<crate::generic::DirectoryWatchResponse<___R>>;
10172
10173 fn respond(response: ___R) -> Self::Output {
10174 ::fidl_next::Strict(crate::generic::DirectoryWatchResponse { s: response })
10175 }
10176 }
10177
10178 mod ___detail {
10179 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Directory
10180 where
10181 ___T: ::fidl_next::Transport,
10182 {
10183 type Client = DirectoryClient<___T>;
10184 type Server = DirectoryServer<___T>;
10185 }
10186
10187 #[repr(transparent)]
10189 pub struct DirectoryClient<___T: ::fidl_next::Transport> {
10190 #[allow(dead_code)]
10191 client: ::fidl_next::protocol::Client<___T>,
10192 }
10193
10194 impl<___T> DirectoryClient<___T>
10195 where
10196 ___T: ::fidl_next::Transport,
10197 {
10198 #[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"]
10199 pub fn advisory_lock(
10200 &self,
10201
10202 request: impl ::fidl_next::Encode<
10203 crate::wire::AdvisoryLockRequest<'static>,
10204 <___T as ::fidl_next::Transport>::SendBuffer,
10205 >,
10206 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
10207 where
10208 <___T as ::fidl_next::Transport>::SendBuffer:
10209 ::fidl_next::encoder::InternalHandleEncoder,
10210 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10211 {
10212 self.advisory_lock_with(crate::generic::AdvisoryLockingAdvisoryLockRequest {
10213 request,
10214 })
10215 }
10216
10217 #[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"]
10218 pub fn advisory_lock_with<___R>(
10219 &self,
10220 request: ___R,
10221 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
10222 where
10223 ___R: ::fidl_next::Encode<
10224 crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
10225 <___T as ::fidl_next::Transport>::SendBuffer,
10226 >,
10227 {
10228 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10229 7992130864415541162,
10230 <super::AdvisoryLock as ::fidl_next::Method>::FLEXIBILITY,
10231 request,
10232 ))
10233 }
10234
10235 pub fn clone(
10236 &self,
10237
10238 request: impl ::fidl_next::Encode<
10239 ::fidl_next::ServerEnd<
10240 ::fdomain_next_fuchsia_unknown::Cloneable,
10241 ::fdomain_client::fidl_next::wire::Handle,
10242 >,
10243 <___T as ::fidl_next::Transport>::SendBuffer,
10244 >,
10245 ) -> ::fidl_next::SendFuture<'_, ___T>
10246 where
10247 <___T as ::fidl_next::Transport>::SendBuffer:
10248 ::fidl_next::encoder::InternalHandleEncoder,
10249 <___T as ::fidl_next::Transport>::SendBuffer:
10250 ::fdomain_client::fidl_next::HandleEncoder,
10251 {
10252 self.clone_with(::fdomain_next_fuchsia_unknown::generic::CloneableCloneRequest {
10253 request,
10254 })
10255 }
10256
10257 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
10258 where
10259 ___R: ::fidl_next::Encode<
10260 ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest,
10261 <___T as ::fidl_next::Transport>::SendBuffer,
10262 >,
10263 {
10264 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
10265 2366825959783828089,
10266 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
10267 request,
10268 ))
10269 }
10270
10271 #[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"]
10272 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
10273 ::fidl_next::TwoWayFuture::from_untyped(
10274 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10275 6540867515453498750,
10276 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
10277 (),
10278 ),
10279 )
10280 }
10281
10282 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
10283 ::fidl_next::TwoWayFuture::from_untyped(
10284 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10285 2763219980499352582,
10286 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
10287 (),
10288 ),
10289 )
10290 }
10291
10292 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
10293 pub fn deprecated_get_attr(
10294 &self,
10295 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
10296 ::fidl_next::TwoWayFuture::from_untyped(
10297 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10298 8689798978500614909,
10299 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
10300 (),
10301 ),
10302 )
10303 }
10304
10305 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
10306 pub fn deprecated_set_attr(
10307 &self,
10308
10309 flags: impl ::fidl_next::Encode<
10310 crate::wire::NodeAttributeFlags,
10311 <___T as ::fidl_next::Transport>::SendBuffer,
10312 >,
10313
10314 attributes: impl ::fidl_next::Encode<
10315 crate::wire::NodeAttributes,
10316 <___T as ::fidl_next::Transport>::SendBuffer,
10317 >,
10318 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
10319 where
10320 <___T as ::fidl_next::Transport>::SendBuffer:
10321 ::fidl_next::encoder::InternalHandleEncoder,
10322 {
10323 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
10324 flags,
10325
10326 attributes,
10327 })
10328 }
10329
10330 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
10331 pub fn deprecated_set_attr_with<___R>(
10332 &self,
10333 request: ___R,
10334 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
10335 where
10336 ___R: ::fidl_next::Encode<
10337 crate::wire::NodeDeprecatedSetAttrRequest,
10338 <___T as ::fidl_next::Transport>::SendBuffer,
10339 >,
10340 {
10341 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10342 4721673413776871238,
10343 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
10344 request,
10345 ))
10346 }
10347
10348 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
10349 pub fn deprecated_get_flags(
10350 &self,
10351 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
10352 ::fidl_next::TwoWayFuture::from_untyped(
10353 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10354 6595803110182632097,
10355 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
10356 (),
10357 ),
10358 )
10359 }
10360
10361 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
10362 pub fn deprecated_set_flags(
10363 &self,
10364
10365 flags: impl ::fidl_next::Encode<
10366 crate::wire::OpenFlags,
10367 <___T as ::fidl_next::Transport>::SendBuffer,
10368 >,
10369 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
10370 where
10371 <___T as ::fidl_next::Transport>::SendBuffer:
10372 ::fidl_next::encoder::InternalHandleEncoder,
10373 {
10374 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
10375 flags,
10376 })
10377 }
10378
10379 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
10380 pub fn deprecated_set_flags_with<___R>(
10381 &self,
10382 request: ___R,
10383 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
10384 where
10385 ___R: ::fidl_next::Encode<
10386 crate::wire::NodeDeprecatedSetFlagsRequest,
10387 <___T as ::fidl_next::Transport>::SendBuffer,
10388 >,
10389 {
10390 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10391 5950864159036794675,
10392 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
10393 request,
10394 ))
10395 }
10396
10397 #[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"]
10398 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
10399 ::fidl_next::TwoWayFuture::from_untyped(
10400 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10401 105530239381466147,
10402 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
10403 (),
10404 ),
10405 )
10406 }
10407
10408 #[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"]
10409 pub fn set_flags(
10410 &self,
10411
10412 flags: impl ::fidl_next::Encode<
10413 crate::wire::Flags,
10414 <___T as ::fidl_next::Transport>::SendBuffer,
10415 >,
10416 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
10417 where
10418 <___T as ::fidl_next::Transport>::SendBuffer:
10419 ::fidl_next::encoder::InternalHandleEncoder,
10420 {
10421 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
10422 }
10423
10424 #[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"]
10425 pub fn set_flags_with<___R>(
10426 &self,
10427 request: ___R,
10428 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
10429 where
10430 ___R: ::fidl_next::Encode<
10431 crate::wire::NodeSetFlagsRequest,
10432 <___T as ::fidl_next::Transport>::SendBuffer,
10433 >,
10434 {
10435 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10436 6172186066099445416,
10437 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
10438 request,
10439 ))
10440 }
10441
10442 #[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"]
10443 pub fn query_filesystem(
10444 &self,
10445 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
10446 ::fidl_next::TwoWayFuture::from_untyped(
10447 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10448 8013111122914313744,
10449 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
10450 (),
10451 ),
10452 )
10453 }
10454
10455 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
10456 pub fn get_token(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetToken, ___T> {
10457 ::fidl_next::TwoWayFuture::from_untyped(
10458 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10459 5788516050773961964,
10460 <super::GetToken as ::fidl_next::Method>::FLEXIBILITY,
10461 (),
10462 ),
10463 )
10464 }
10465
10466 #[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"]
10467 pub fn get_attributes(
10468 &self,
10469
10470 query: impl ::fidl_next::Encode<
10471 crate::wire::NodeAttributesQuery,
10472 <___T as ::fidl_next::Transport>::SendBuffer,
10473 >,
10474 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
10475 where
10476 <___T as ::fidl_next::Transport>::SendBuffer:
10477 ::fidl_next::encoder::InternalHandleEncoder,
10478 {
10479 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
10480 }
10481
10482 #[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"]
10483 pub fn get_attributes_with<___R>(
10484 &self,
10485 request: ___R,
10486 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
10487 where
10488 ___R: ::fidl_next::Encode<
10489 crate::wire::NodeGetAttributesRequest,
10490 <___T as ::fidl_next::Transport>::SendBuffer,
10491 >,
10492 {
10493 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10494 4414537700416816443,
10495 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
10496 request,
10497 ))
10498 }
10499
10500 #[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"]
10501 pub fn update_attributes_with<___R>(
10502 &self,
10503 request: ___R,
10504 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
10505 where
10506 ___R: ::fidl_next::Encode<
10507 crate::wire::MutableNodeAttributes<'static>,
10508 <___T as ::fidl_next::Transport>::SendBuffer,
10509 >,
10510 {
10511 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10512 3677402239314018056,
10513 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
10514 request,
10515 ))
10516 }
10517
10518 #[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"]
10519 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
10520 ::fidl_next::TwoWayFuture::from_untyped(
10521 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10522 3196473584242777161,
10523 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
10524 (),
10525 ),
10526 )
10527 }
10528
10529 #[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.READ_BYTES`] right.\n"]
10530 pub fn list_extended_attributes(
10531 &self,
10532
10533 iterator: impl ::fidl_next::Encode<
10534 ::fidl_next::ServerEnd<
10535 crate::ExtendedAttributeIterator,
10536 ::fdomain_client::fidl_next::wire::Handle,
10537 >,
10538 <___T as ::fidl_next::Transport>::SendBuffer,
10539 >,
10540 ) -> ::fidl_next::SendFuture<'_, ___T>
10541 where
10542 <___T as ::fidl_next::Transport>::SendBuffer:
10543 ::fidl_next::encoder::InternalHandleEncoder,
10544 <___T as ::fidl_next::Transport>::SendBuffer:
10545 ::fdomain_client::fidl_next::HandleEncoder,
10546 {
10547 self.list_extended_attributes_with(
10548 crate::generic::NodeListExtendedAttributesRequest { iterator },
10549 )
10550 }
10551
10552 #[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.READ_BYTES`] right.\n"]
10553 pub fn list_extended_attributes_with<___R>(
10554 &self,
10555 request: ___R,
10556 ) -> ::fidl_next::SendFuture<'_, ___T>
10557 where
10558 ___R: ::fidl_next::Encode<
10559 crate::wire::NodeListExtendedAttributesRequest,
10560 <___T as ::fidl_next::Transport>::SendBuffer,
10561 >,
10562 {
10563 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
10564 5431626189872037072,
10565 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
10566 request,
10567 ))
10568 }
10569
10570 #[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.READ_BYTES`] right.\n"]
10571 pub fn get_extended_attribute(
10572 &self,
10573
10574 name: impl ::fidl_next::Encode<
10575 ::fidl_next::wire::Vector<'static, u8>,
10576 <___T as ::fidl_next::Transport>::SendBuffer,
10577 >,
10578 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
10579 where
10580 <___T as ::fidl_next::Transport>::SendBuffer:
10581 ::fidl_next::encoder::InternalHandleEncoder,
10582 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10583 {
10584 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
10585 name,
10586 })
10587 }
10588
10589 #[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.READ_BYTES`] right.\n"]
10590 pub fn get_extended_attribute_with<___R>(
10591 &self,
10592 request: ___R,
10593 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
10594 where
10595 ___R: ::fidl_next::Encode<
10596 crate::wire::NodeGetExtendedAttributeRequest<'static>,
10597 <___T as ::fidl_next::Transport>::SendBuffer,
10598 >,
10599 {
10600 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10601 5043930208506967771,
10602 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
10603 request,
10604 ))
10605 }
10606
10607 #[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.WRITE_BYTES`] right.\n"]
10608 pub fn set_extended_attribute(
10609 &self,
10610
10611 name: impl ::fidl_next::Encode<
10612 ::fidl_next::wire::Vector<'static, u8>,
10613 <___T as ::fidl_next::Transport>::SendBuffer,
10614 >,
10615
10616 value: impl ::fidl_next::Encode<
10617 crate::wire::ExtendedAttributeValue<'static>,
10618 <___T as ::fidl_next::Transport>::SendBuffer,
10619 >,
10620
10621 mode: impl ::fidl_next::Encode<
10622 crate::wire::SetExtendedAttributeMode,
10623 <___T as ::fidl_next::Transport>::SendBuffer,
10624 >,
10625 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
10626 where
10627 <___T as ::fidl_next::Transport>::SendBuffer:
10628 ::fidl_next::encoder::InternalHandleEncoder,
10629 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10630 <___T as ::fidl_next::Transport>::SendBuffer:
10631 ::fdomain_client::fidl_next::HandleEncoder,
10632 {
10633 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
10634 name,
10635
10636 value,
10637
10638 mode,
10639 })
10640 }
10641
10642 #[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.WRITE_BYTES`] right.\n"]
10643 pub fn set_extended_attribute_with<___R>(
10644 &self,
10645 request: ___R,
10646 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
10647 where
10648 ___R: ::fidl_next::Encode<
10649 crate::wire::NodeSetExtendedAttributeRequest<'static>,
10650 <___T as ::fidl_next::Transport>::SendBuffer,
10651 >,
10652 {
10653 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10654 5374223046099989052,
10655 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
10656 request,
10657 ))
10658 }
10659
10660 #[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.WRITE_BYTES`] right.\n"]
10661 pub fn remove_extended_attribute(
10662 &self,
10663
10664 name: impl ::fidl_next::Encode<
10665 ::fidl_next::wire::Vector<'static, u8>,
10666 <___T as ::fidl_next::Transport>::SendBuffer,
10667 >,
10668 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
10669 where
10670 <___T as ::fidl_next::Transport>::SendBuffer:
10671 ::fidl_next::encoder::InternalHandleEncoder,
10672 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10673 {
10674 self.remove_extended_attribute_with(
10675 crate::generic::NodeRemoveExtendedAttributeRequest { name },
10676 )
10677 }
10678
10679 #[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.WRITE_BYTES`] right.\n"]
10680 pub fn remove_extended_attribute_with<___R>(
10681 &self,
10682 request: ___R,
10683 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
10684 where
10685 ___R: ::fidl_next::Encode<
10686 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
10687 <___T as ::fidl_next::Transport>::SendBuffer,
10688 >,
10689 {
10690 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10691 8794297771444732717,
10692 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
10693 request,
10694 ))
10695 }
10696
10697 #[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"]
10698 pub fn open(
10699 &self,
10700
10701 path: impl ::fidl_next::Encode<
10702 ::fidl_next::wire::String<'static>,
10703 <___T as ::fidl_next::Transport>::SendBuffer,
10704 >,
10705
10706 flags: impl ::fidl_next::Encode<
10707 crate::wire::Flags,
10708 <___T as ::fidl_next::Transport>::SendBuffer,
10709 >,
10710
10711 options: impl ::fidl_next::Encode<
10712 crate::wire::Options<'static>,
10713 <___T as ::fidl_next::Transport>::SendBuffer,
10714 >,
10715
10716 object: impl ::fidl_next::Encode<
10717 ::fdomain_client::fidl_next::wire::Handle,
10718 <___T as ::fidl_next::Transport>::SendBuffer,
10719 >,
10720 ) -> ::fidl_next::SendFuture<'_, ___T>
10721 where
10722 <___T as ::fidl_next::Transport>::SendBuffer:
10723 ::fidl_next::encoder::InternalHandleEncoder,
10724 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10725 <___T as ::fidl_next::Transport>::SendBuffer:
10726 ::fdomain_client::fidl_next::HandleEncoder,
10727 {
10728 self.open_with(crate::generic::OpenableOpenRequest { path, flags, options, object })
10729 }
10730
10731 #[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"]
10732 pub fn open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
10733 where
10734 ___R: ::fidl_next::Encode<
10735 crate::wire::OpenableOpenRequest<'static>,
10736 <___T as ::fidl_next::Transport>::SendBuffer,
10737 >,
10738 {
10739 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
10740 6236883748953765593,
10741 <super::Open as ::fidl_next::Method>::FLEXIBILITY,
10742 request,
10743 ))
10744 }
10745
10746 #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
10747 pub fn deprecated_open(
10748 &self,
10749
10750 flags: impl ::fidl_next::Encode<
10751 crate::wire::OpenFlags,
10752 <___T as ::fidl_next::Transport>::SendBuffer,
10753 >,
10754
10755 mode: impl ::fidl_next::Encode<
10756 crate::wire::ModeType,
10757 <___T as ::fidl_next::Transport>::SendBuffer,
10758 >,
10759
10760 path: impl ::fidl_next::Encode<
10761 ::fidl_next::wire::String<'static>,
10762 <___T as ::fidl_next::Transport>::SendBuffer,
10763 >,
10764
10765 object: impl ::fidl_next::Encode<
10766 ::fidl_next::ServerEnd<crate::Node, ::fdomain_client::fidl_next::wire::Handle>,
10767 <___T as ::fidl_next::Transport>::SendBuffer,
10768 >,
10769 ) -> ::fidl_next::SendFuture<'_, ___T>
10770 where
10771 <___T as ::fidl_next::Transport>::SendBuffer:
10772 ::fidl_next::encoder::InternalHandleEncoder,
10773 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10774 <___T as ::fidl_next::Transport>::SendBuffer:
10775 ::fdomain_client::fidl_next::HandleEncoder,
10776 {
10777 self.deprecated_open_with(crate::generic::DirectoryDeprecatedOpenRequest {
10778 flags,
10779
10780 mode,
10781
10782 path,
10783
10784 object,
10785 })
10786 }
10787
10788 #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
10789 pub fn deprecated_open_with<___R>(
10790 &self,
10791 request: ___R,
10792 ) -> ::fidl_next::SendFuture<'_, ___T>
10793 where
10794 ___R: ::fidl_next::Encode<
10795 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
10796 <___T as ::fidl_next::Transport>::SendBuffer,
10797 >,
10798 {
10799 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
10800 3193127272456937152,
10801 <super::DeprecatedOpen as ::fidl_next::Method>::FLEXIBILITY,
10802 request,
10803 ))
10804 }
10805
10806 #[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 requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
10807 pub fn read_dirents(
10808 &self,
10809
10810 max_bytes: impl ::fidl_next::Encode<
10811 ::fidl_next::wire::Uint64,
10812 <___T as ::fidl_next::Transport>::SendBuffer,
10813 >,
10814 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadDirents, ___T>
10815 where
10816 <___T as ::fidl_next::Transport>::SendBuffer:
10817 ::fidl_next::encoder::InternalHandleEncoder,
10818 {
10819 self.read_dirents_with(crate::generic::DirectoryReadDirentsRequest { max_bytes })
10820 }
10821
10822 #[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 requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
10823 pub fn read_dirents_with<___R>(
10824 &self,
10825 request: ___R,
10826 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadDirents, ___T>
10827 where
10828 ___R: ::fidl_next::Encode<
10829 crate::wire::DirectoryReadDirentsRequest,
10830 <___T as ::fidl_next::Transport>::SendBuffer,
10831 >,
10832 {
10833 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10834 3855785432100874762,
10835 <super::ReadDirents as ::fidl_next::Method>::FLEXIBILITY,
10836 request,
10837 ))
10838 }
10839
10840 #[doc = " Resets the directory seek offset.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
10841 pub fn rewind(&self) -> ::fidl_next::TwoWayFuture<'_, super::Rewind, ___T> {
10842 ::fidl_next::TwoWayFuture::from_untyped(
10843 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10844 1635123508515392625,
10845 <super::Rewind as ::fidl_next::Method>::FLEXIBILITY,
10846 (),
10847 ),
10848 )
10849 }
10850
10851 #[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\n This method is deprecated: use `fuchsia.io/Node.GetToken` instead (once it is added).\n"]
10852 pub fn deprecated_get_token(
10853 &self,
10854 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetToken, ___T> {
10855 ::fidl_next::TwoWayFuture::from_untyped(
10856 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10857 2787337947777369685,
10858 <super::DeprecatedGetToken as ::fidl_next::Method>::FLEXIBILITY,
10859 (),
10860 ),
10861 )
10862 }
10863
10864 #[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"]
10865 pub fn link(
10866 &self,
10867
10868 src: impl ::fidl_next::Encode<
10869 ::fidl_next::wire::String<'static>,
10870 <___T as ::fidl_next::Transport>::SendBuffer,
10871 >,
10872
10873 dst_parent_token: impl ::fidl_next::Encode<
10874 ::fdomain_client::fidl_next::wire::Handle,
10875 <___T as ::fidl_next::Transport>::SendBuffer,
10876 >,
10877
10878 dst: impl ::fidl_next::Encode<
10879 ::fidl_next::wire::String<'static>,
10880 <___T as ::fidl_next::Transport>::SendBuffer,
10881 >,
10882 ) -> ::fidl_next::TwoWayFuture<'_, super::Link, ___T>
10883 where
10884 <___T as ::fidl_next::Transport>::SendBuffer:
10885 ::fidl_next::encoder::InternalHandleEncoder,
10886 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10887 <___T as ::fidl_next::Transport>::SendBuffer:
10888 ::fdomain_client::fidl_next::HandleEncoder,
10889 {
10890 self.link_with(crate::generic::DirectoryLinkRequest { src, dst_parent_token, dst })
10891 }
10892
10893 #[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"]
10894 pub fn link_with<___R>(
10895 &self,
10896 request: ___R,
10897 ) -> ::fidl_next::TwoWayFuture<'_, super::Link, ___T>
10898 where
10899 ___R: ::fidl_next::Encode<
10900 crate::wire::DirectoryLinkRequest<'static>,
10901 <___T as ::fidl_next::Transport>::SendBuffer,
10902 >,
10903 {
10904 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10905 8360374984291987687,
10906 <super::Link as ::fidl_next::Method>::FLEXIBILITY,
10907 request,
10908 ))
10909 }
10910
10911 #[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"]
10912 pub fn unlink(
10913 &self,
10914
10915 name: impl ::fidl_next::Encode<
10916 ::fidl_next::wire::String<'static>,
10917 <___T as ::fidl_next::Transport>::SendBuffer,
10918 >,
10919
10920 options: impl ::fidl_next::Encode<
10921 crate::wire::UnlinkOptions<'static>,
10922 <___T as ::fidl_next::Transport>::SendBuffer,
10923 >,
10924 ) -> ::fidl_next::TwoWayFuture<'_, super::Unlink, ___T>
10925 where
10926 <___T as ::fidl_next::Transport>::SendBuffer:
10927 ::fidl_next::encoder::InternalHandleEncoder,
10928 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10929 {
10930 self.unlink_with(crate::generic::DirectoryUnlinkRequest { name, options })
10931 }
10932
10933 #[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"]
10934 pub fn unlink_with<___R>(
10935 &self,
10936 request: ___R,
10937 ) -> ::fidl_next::TwoWayFuture<'_, super::Unlink, ___T>
10938 where
10939 ___R: ::fidl_next::Encode<
10940 crate::wire::DirectoryUnlinkRequest<'static>,
10941 <___T as ::fidl_next::Transport>::SendBuffer,
10942 >,
10943 {
10944 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10945 8433556716759383021,
10946 <super::Unlink as ::fidl_next::Method>::FLEXIBILITY,
10947 request,
10948 ))
10949 }
10950
10951 #[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"]
10952 pub fn rename(
10953 &self,
10954
10955 src: impl ::fidl_next::Encode<
10956 ::fidl_next::wire::String<'static>,
10957 <___T as ::fidl_next::Transport>::SendBuffer,
10958 >,
10959
10960 dst_parent_token: impl ::fidl_next::Encode<
10961 ::fdomain_client::fidl_next::wire::Handle,
10962 <___T as ::fidl_next::Transport>::SendBuffer,
10963 >,
10964
10965 dst: impl ::fidl_next::Encode<
10966 ::fidl_next::wire::String<'static>,
10967 <___T as ::fidl_next::Transport>::SendBuffer,
10968 >,
10969 ) -> ::fidl_next::TwoWayFuture<'_, super::Rename, ___T>
10970 where
10971 <___T as ::fidl_next::Transport>::SendBuffer:
10972 ::fidl_next::encoder::InternalHandleEncoder,
10973 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10974 <___T as ::fidl_next::Transport>::SendBuffer:
10975 ::fdomain_client::fidl_next::HandleEncoder,
10976 {
10977 self.rename_with(crate::generic::DirectoryRenameRequest {
10978 src,
10979
10980 dst_parent_token,
10981
10982 dst,
10983 })
10984 }
10985
10986 #[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"]
10987 pub fn rename_with<___R>(
10988 &self,
10989 request: ___R,
10990 ) -> ::fidl_next::TwoWayFuture<'_, super::Rename, ___T>
10991 where
10992 ___R: ::fidl_next::Encode<
10993 crate::wire::DirectoryRenameRequest<'static>,
10994 <___T as ::fidl_next::Transport>::SendBuffer,
10995 >,
10996 {
10997 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10998 8097726607824333022,
10999 <super::Rename as ::fidl_next::Method>::FLEXIBILITY,
11000 request,
11001 ))
11002 }
11003
11004 #[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"]
11005 pub fn create_symlink(
11006 &self,
11007
11008 name: impl ::fidl_next::Encode<
11009 ::fidl_next::wire::String<'static>,
11010 <___T as ::fidl_next::Transport>::SendBuffer,
11011 >,
11012
11013 target: impl ::fidl_next::Encode<
11014 ::fidl_next::wire::Vector<'static, u8>,
11015 <___T as ::fidl_next::Transport>::SendBuffer,
11016 >,
11017
11018 connection: impl ::fidl_next::Encode<
11019 ::fidl_next::ServerEnd<
11020 crate::Symlink,
11021 ::fdomain_client::fidl_next::wire::OptionalHandle,
11022 >,
11023 <___T as ::fidl_next::Transport>::SendBuffer,
11024 >,
11025 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateSymlink, ___T>
11026 where
11027 <___T as ::fidl_next::Transport>::SendBuffer:
11028 ::fidl_next::encoder::InternalHandleEncoder,
11029 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11030 <___T as ::fidl_next::Transport>::SendBuffer:
11031 ::fdomain_client::fidl_next::HandleEncoder,
11032 {
11033 self.create_symlink_with(crate::generic::DirectoryCreateSymlinkRequest {
11034 name,
11035
11036 target,
11037
11038 connection,
11039 })
11040 }
11041
11042 #[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"]
11043 pub fn create_symlink_with<___R>(
11044 &self,
11045 request: ___R,
11046 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateSymlink, ___T>
11047 where
11048 ___R: ::fidl_next::Encode<
11049 crate::wire::DirectoryCreateSymlinkRequest<'static>,
11050 <___T as ::fidl_next::Transport>::SendBuffer,
11051 >,
11052 {
11053 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11054 2435901052462315657,
11055 <super::CreateSymlink as ::fidl_next::Method>::FLEXIBILITY,
11056 request,
11057 ))
11058 }
11059
11060 #[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 requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
11061 pub fn watch(
11062 &self,
11063
11064 mask: impl ::fidl_next::Encode<
11065 crate::wire::WatchMask,
11066 <___T as ::fidl_next::Transport>::SendBuffer,
11067 >,
11068
11069 options: impl ::fidl_next::Encode<
11070 ::fidl_next::wire::Uint32,
11071 <___T as ::fidl_next::Transport>::SendBuffer,
11072 >,
11073
11074 watcher: impl ::fidl_next::Encode<
11075 ::fidl_next::ServerEnd<
11076 crate::DirectoryWatcher,
11077 ::fdomain_client::fidl_next::wire::Handle,
11078 >,
11079 <___T as ::fidl_next::Transport>::SendBuffer,
11080 >,
11081 ) -> ::fidl_next::TwoWayFuture<'_, super::Watch, ___T>
11082 where
11083 <___T as ::fidl_next::Transport>::SendBuffer:
11084 ::fidl_next::encoder::InternalHandleEncoder,
11085 <___T as ::fidl_next::Transport>::SendBuffer:
11086 ::fdomain_client::fidl_next::HandleEncoder,
11087 {
11088 self.watch_with(crate::generic::DirectoryWatchRequest { mask, options, watcher })
11089 }
11090
11091 #[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 requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
11092 pub fn watch_with<___R>(
11093 &self,
11094 request: ___R,
11095 ) -> ::fidl_next::TwoWayFuture<'_, super::Watch, ___T>
11096 where
11097 ___R: ::fidl_next::Encode<
11098 crate::wire::DirectoryWatchRequest,
11099 <___T as ::fidl_next::Transport>::SendBuffer,
11100 >,
11101 {
11102 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11103 6275512344170098065,
11104 <super::Watch as ::fidl_next::Method>::FLEXIBILITY,
11105 request,
11106 ))
11107 }
11108 }
11109
11110 #[repr(transparent)]
11112 pub struct DirectoryServer<___T: ::fidl_next::Transport> {
11113 server: ::fidl_next::protocol::Server<___T>,
11114 }
11115
11116 impl<___T> DirectoryServer<___T>
11117 where
11118 ___T: ::fidl_next::Transport,
11119 {
11120 #[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"]
11121 pub fn on_open(
11122 &self,
11123
11124 s: impl ::fidl_next::Encode<
11125 ::fidl_next::wire::fuchsia::StatusResult,
11126 <___T as ::fidl_next::Transport>::SendBuffer,
11127 >,
11128
11129 info: impl ::fidl_next::Encode<
11130 crate::wire_optional::NodeInfoDeprecated<'static>,
11131 <___T as ::fidl_next::Transport>::SendBuffer,
11132 >,
11133 ) -> ::fidl_next::SendFuture<'_, ___T>
11134 where
11135 <___T as ::fidl_next::Transport>::SendBuffer:
11136 ::fidl_next::encoder::InternalHandleEncoder,
11137 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11138 <___T as ::fidl_next::Transport>::SendBuffer:
11139 ::fdomain_client::fidl_next::HandleEncoder,
11140 {
11141 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
11142 }
11143
11144 #[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"]
11145
11146 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
11147 where
11148 ___R: ::fidl_next::Encode<
11149 <super::OnOpen as ::fidl_next::Method>::Request,
11150 <___T as ::fidl_next::Transport>::SendBuffer,
11151 >,
11152 {
11153 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
11154 9207534335756671346,
11155 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
11156 request,
11157 ))
11158 }
11159
11160 #[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"]
11161
11162 pub fn on_representation_with<___R>(
11163 &self,
11164 request: ___R,
11165 ) -> ::fidl_next::SendFuture<'_, ___T>
11166 where
11167 ___R: ::fidl_next::Encode<
11168 <super::OnRepresentation as ::fidl_next::Method>::Request,
11169 <___T as ::fidl_next::Transport>::SendBuffer,
11170 >,
11171 {
11172 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
11173 6679970090861613324,
11174 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
11175 request,
11176 ))
11177 }
11178 }
11179 }
11180}
11181
11182#[diagnostic::on_unimplemented(
11183 note = "If {Self} implements the non-local DirectoryClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
11184)]
11185
11186pub trait DirectoryLocalClientHandler<
11190 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
11191 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11192>
11193{
11194 #[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"]
11195 fn on_open(
11196 &mut self,
11197
11198 request: ::fidl_next::Request<directory::OnOpen, ___T>,
11199 ) -> impl ::core::future::Future<Output = ()>;
11200
11201 #[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"]
11202 fn on_representation(
11203 &mut self,
11204
11205 request: ::fidl_next::Request<directory::OnRepresentation, ___T>,
11206 ) -> impl ::core::future::Future<Output = ()>;
11207
11208 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
11209 ::core::future::ready(())
11210 }
11211}
11212
11213impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Directory
11214where
11215 ___H: DirectoryLocalClientHandler<___T>,
11216 ___T: ::fidl_next::Transport,
11217 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
11218 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11219 Constraint = (),
11220 >,
11221 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
11222 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11223 Constraint = (),
11224 >,
11225{
11226 async fn on_event(
11227 handler: &mut ___H,
11228 mut message: ::fidl_next::Message<___T>,
11229 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11230 match *message.header().ordinal {
11231 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
11232 Ok(decoded) => {
11233 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
11234 Ok(())
11235 }
11236 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11237 ordinal: 9207534335756671346,
11238 error,
11239 }),
11240 },
11241
11242 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
11243 Ok(decoded) => {
11244 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
11245 Ok(())
11246 }
11247 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11248 ordinal: 6679970090861613324,
11249 error,
11250 }),
11251 },
11252
11253 ordinal => {
11254 handler.on_unknown_interaction(ordinal).await;
11255 if ::core::matches!(
11256 message.header().flexibility(),
11257 ::fidl_next::protocol::Flexibility::Strict
11258 ) {
11259 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11260 } else {
11261 Ok(())
11262 }
11263 }
11264 }
11265 }
11266}
11267
11268#[diagnostic::on_unimplemented(
11269 note = "If {Self} implements the non-local DirectoryServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
11270)]
11271
11272pub trait DirectoryLocalServerHandler<
11276 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
11277 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11278>
11279{
11280 #[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"]
11281 fn advisory_lock(
11282 &mut self,
11283
11284 request: ::fidl_next::Request<directory::AdvisoryLock, ___T>,
11285
11286 responder: ::fidl_next::Responder<directory::AdvisoryLock, ___T>,
11287 ) -> impl ::core::future::Future<Output = ()>;
11288
11289 fn clone(
11290 &mut self,
11291
11292 request: ::fidl_next::Request<directory::Clone, ___T>,
11293 ) -> impl ::core::future::Future<Output = ()>;
11294
11295 #[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"]
11296 fn close(
11297 &mut self,
11298
11299 responder: ::fidl_next::Responder<directory::Close, ___T>,
11300 ) -> impl ::core::future::Future<Output = ()>;
11301
11302 fn query(
11303 &mut self,
11304
11305 responder: ::fidl_next::Responder<directory::Query, ___T>,
11306 ) -> impl ::core::future::Future<Output = ()>;
11307
11308 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
11309 fn deprecated_get_attr(
11310 &mut self,
11311
11312 responder: ::fidl_next::Responder<directory::DeprecatedGetAttr, ___T>,
11313 ) -> impl ::core::future::Future<Output = ()>;
11314
11315 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
11316 fn deprecated_set_attr(
11317 &mut self,
11318
11319 request: ::fidl_next::Request<directory::DeprecatedSetAttr, ___T>,
11320
11321 responder: ::fidl_next::Responder<directory::DeprecatedSetAttr, ___T>,
11322 ) -> impl ::core::future::Future<Output = ()>;
11323
11324 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
11325 fn deprecated_get_flags(
11326 &mut self,
11327
11328 responder: ::fidl_next::Responder<directory::DeprecatedGetFlags, ___T>,
11329 ) -> impl ::core::future::Future<Output = ()>;
11330
11331 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
11332 fn deprecated_set_flags(
11333 &mut self,
11334
11335 request: ::fidl_next::Request<directory::DeprecatedSetFlags, ___T>,
11336
11337 responder: ::fidl_next::Responder<directory::DeprecatedSetFlags, ___T>,
11338 ) -> impl ::core::future::Future<Output = ()>;
11339
11340 #[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"]
11341 fn get_flags(
11342 &mut self,
11343
11344 responder: ::fidl_next::Responder<directory::GetFlags, ___T>,
11345 ) -> impl ::core::future::Future<Output = ()>;
11346
11347 #[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"]
11348 fn set_flags(
11349 &mut self,
11350
11351 request: ::fidl_next::Request<directory::SetFlags, ___T>,
11352
11353 responder: ::fidl_next::Responder<directory::SetFlags, ___T>,
11354 ) -> impl ::core::future::Future<Output = ()>;
11355
11356 #[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"]
11357 fn query_filesystem(
11358 &mut self,
11359
11360 responder: ::fidl_next::Responder<directory::QueryFilesystem, ___T>,
11361 ) -> impl ::core::future::Future<Output = ()>;
11362
11363 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
11364 fn get_token(
11365 &mut self,
11366
11367 responder: ::fidl_next::Responder<directory::GetToken, ___T>,
11368 ) -> impl ::core::future::Future<Output = ()>;
11369
11370 #[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"]
11371 fn get_attributes(
11372 &mut self,
11373
11374 request: ::fidl_next::Request<directory::GetAttributes, ___T>,
11375
11376 responder: ::fidl_next::Responder<directory::GetAttributes, ___T>,
11377 ) -> impl ::core::future::Future<Output = ()>;
11378
11379 #[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"]
11380 fn update_attributes(
11381 &mut self,
11382
11383 request: ::fidl_next::Request<directory::UpdateAttributes, ___T>,
11384
11385 responder: ::fidl_next::Responder<directory::UpdateAttributes, ___T>,
11386 ) -> impl ::core::future::Future<Output = ()>;
11387
11388 #[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"]
11389 fn sync(
11390 &mut self,
11391
11392 responder: ::fidl_next::Responder<directory::Sync, ___T>,
11393 ) -> impl ::core::future::Future<Output = ()>;
11394
11395 #[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.READ_BYTES`] right.\n"]
11396 fn list_extended_attributes(
11397 &mut self,
11398
11399 request: ::fidl_next::Request<directory::ListExtendedAttributes, ___T>,
11400 ) -> impl ::core::future::Future<Output = ()>;
11401
11402 #[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.READ_BYTES`] right.\n"]
11403 fn get_extended_attribute(
11404 &mut self,
11405
11406 request: ::fidl_next::Request<directory::GetExtendedAttribute, ___T>,
11407
11408 responder: ::fidl_next::Responder<directory::GetExtendedAttribute, ___T>,
11409 ) -> impl ::core::future::Future<Output = ()>;
11410
11411 #[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.WRITE_BYTES`] right.\n"]
11412 fn set_extended_attribute(
11413 &mut self,
11414
11415 request: ::fidl_next::Request<directory::SetExtendedAttribute, ___T>,
11416
11417 responder: ::fidl_next::Responder<directory::SetExtendedAttribute, ___T>,
11418 ) -> impl ::core::future::Future<Output = ()>;
11419
11420 #[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.WRITE_BYTES`] right.\n"]
11421 fn remove_extended_attribute(
11422 &mut self,
11423
11424 request: ::fidl_next::Request<directory::RemoveExtendedAttribute, ___T>,
11425
11426 responder: ::fidl_next::Responder<directory::RemoveExtendedAttribute, ___T>,
11427 ) -> impl ::core::future::Future<Output = ()>;
11428
11429 #[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"]
11430 fn open(
11431 &mut self,
11432
11433 request: ::fidl_next::Request<directory::Open, ___T>,
11434 ) -> impl ::core::future::Future<Output = ()>;
11435
11436 #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
11437 fn deprecated_open(
11438 &mut self,
11439
11440 request: ::fidl_next::Request<directory::DeprecatedOpen, ___T>,
11441 ) -> impl ::core::future::Future<Output = ()>;
11442
11443 #[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 requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
11444 fn read_dirents(
11445 &mut self,
11446
11447 request: ::fidl_next::Request<directory::ReadDirents, ___T>,
11448
11449 responder: ::fidl_next::Responder<directory::ReadDirents, ___T>,
11450 ) -> impl ::core::future::Future<Output = ()>;
11451
11452 #[doc = " Resets the directory seek offset.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
11453 fn rewind(
11454 &mut self,
11455
11456 responder: ::fidl_next::Responder<directory::Rewind, ___T>,
11457 ) -> impl ::core::future::Future<Output = ()>;
11458
11459 #[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\n This method is deprecated: use `fuchsia.io/Node.GetToken` instead (once it is added).\n"]
11460 fn deprecated_get_token(
11461 &mut self,
11462
11463 responder: ::fidl_next::Responder<directory::DeprecatedGetToken, ___T>,
11464 ) -> impl ::core::future::Future<Output = ()>;
11465
11466 #[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"]
11467 fn link(
11468 &mut self,
11469
11470 request: ::fidl_next::Request<directory::Link, ___T>,
11471
11472 responder: ::fidl_next::Responder<directory::Link, ___T>,
11473 ) -> impl ::core::future::Future<Output = ()>;
11474
11475 #[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"]
11476 fn unlink(
11477 &mut self,
11478
11479 request: ::fidl_next::Request<directory::Unlink, ___T>,
11480
11481 responder: ::fidl_next::Responder<directory::Unlink, ___T>,
11482 ) -> impl ::core::future::Future<Output = ()>;
11483
11484 #[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"]
11485 fn rename(
11486 &mut self,
11487
11488 request: ::fidl_next::Request<directory::Rename, ___T>,
11489
11490 responder: ::fidl_next::Responder<directory::Rename, ___T>,
11491 ) -> impl ::core::future::Future<Output = ()>;
11492
11493 #[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"]
11494 fn create_symlink(
11495 &mut self,
11496
11497 request: ::fidl_next::Request<directory::CreateSymlink, ___T>,
11498
11499 responder: ::fidl_next::Responder<directory::CreateSymlink, ___T>,
11500 ) -> impl ::core::future::Future<Output = ()>;
11501
11502 #[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 requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
11503 fn watch(
11504 &mut self,
11505
11506 request: ::fidl_next::Request<directory::Watch, ___T>,
11507
11508 responder: ::fidl_next::Responder<directory::Watch, ___T>,
11509 ) -> impl ::core::future::Future<Output = ()>;
11510
11511 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
11512 ::core::future::ready(())
11513 }
11514}
11515
11516impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Directory
11517where
11518 ___H: DirectoryLocalServerHandler<___T>,
11519 ___T: ::fidl_next::Transport,
11520 for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
11521 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11522 Constraint = (),
11523 >,
11524 for<'de> ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
11525 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11526 Constraint = (),
11527 >,
11528 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
11529 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11530 Constraint = (),
11531 >,
11532 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
11533 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11534 Constraint = (),
11535 >,
11536 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
11537 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11538 Constraint = (),
11539 >,
11540 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
11541 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11542 Constraint = (),
11543 >,
11544 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
11545 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11546 Constraint = (),
11547 >,
11548 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
11549 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11550 Constraint = (),
11551 >,
11552 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
11553 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11554 Constraint = (),
11555 >,
11556 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
11557 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11558 Constraint = (),
11559 >,
11560 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
11561 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11562 Constraint = (),
11563 >,
11564 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
11565 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11566 Constraint = (),
11567 >,
11568 for<'de> crate::wire::DirectoryDeprecatedOpenRequest<'de>: ::fidl_next::Decode<
11569 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11570 Constraint = (),
11571 >,
11572 for<'de> crate::wire::DirectoryReadDirentsRequest: ::fidl_next::Decode<
11573 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11574 Constraint = (),
11575 >,
11576 for<'de> crate::wire::DirectoryLinkRequest<'de>: ::fidl_next::Decode<
11577 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11578 Constraint = (),
11579 >,
11580 for<'de> crate::wire::DirectoryUnlinkRequest<'de>: ::fidl_next::Decode<
11581 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11582 Constraint = (),
11583 >,
11584 for<'de> crate::wire::DirectoryRenameRequest<'de>: ::fidl_next::Decode<
11585 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11586 Constraint = (),
11587 >,
11588 for<'de> crate::wire::DirectoryCreateSymlinkRequest<'de>: ::fidl_next::Decode<
11589 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11590 Constraint = (),
11591 >,
11592 for<'de> crate::wire::DirectoryWatchRequest: ::fidl_next::Decode<
11593 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11594 Constraint = (),
11595 >,
11596{
11597 async fn on_one_way(
11598 handler: &mut ___H,
11599 mut message: ::fidl_next::Message<___T>,
11600 ) -> ::core::result::Result<
11601 (),
11602 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11603 > {
11604 match *message.header().ordinal {
11605 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
11606 Ok(decoded) => {
11607 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
11608 Ok(())
11609 }
11610 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11611 ordinal: 2366825959783828089,
11612 error,
11613 }),
11614 },
11615
11616 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
11617 Ok(decoded) => {
11618 handler
11619 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
11620 .await;
11621 Ok(())
11622 }
11623 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11624 ordinal: 5431626189872037072,
11625 error,
11626 }),
11627 },
11628
11629 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
11630 Ok(decoded) => {
11631 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
11632 Ok(())
11633 }
11634 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11635 ordinal: 6236883748953765593,
11636 error,
11637 }),
11638 },
11639
11640 3193127272456937152 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
11641 Ok(decoded) => {
11642 handler.deprecated_open(::fidl_next::Request::from_decoded(decoded)).await;
11643 Ok(())
11644 }
11645 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11646 ordinal: 3193127272456937152,
11647 error,
11648 }),
11649 },
11650
11651 ordinal => {
11652 handler.on_unknown_interaction(ordinal).await;
11653 if ::core::matches!(
11654 message.header().flexibility(),
11655 ::fidl_next::protocol::Flexibility::Strict
11656 ) {
11657 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11658 } else {
11659 Ok(())
11660 }
11661 }
11662 }
11663 }
11664
11665 async fn on_two_way(
11666 handler: &mut ___H,
11667 mut message: ::fidl_next::Message<___T>,
11668 responder: ::fidl_next::protocol::Responder<___T>,
11669 ) -> ::core::result::Result<
11670 (),
11671 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11672 > {
11673 match *message.header().ordinal {
11674 7992130864415541162 => {
11675 let responder = ::fidl_next::Responder::from_untyped(responder);
11676
11677 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11678 Ok(decoded) => {
11679 handler
11680 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
11681 .await;
11682 Ok(())
11683 }
11684 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11685 ordinal: 7992130864415541162,
11686 error,
11687 }),
11688 }
11689 }
11690
11691 6540867515453498750 => {
11692 let responder = ::fidl_next::Responder::from_untyped(responder);
11693
11694 handler.close(responder).await;
11695 Ok(())
11696 }
11697
11698 2763219980499352582 => {
11699 let responder = ::fidl_next::Responder::from_untyped(responder);
11700
11701 handler.query(responder).await;
11702 Ok(())
11703 }
11704
11705 8689798978500614909 => {
11706 let responder = ::fidl_next::Responder::from_untyped(responder);
11707
11708 handler.deprecated_get_attr(responder).await;
11709 Ok(())
11710 }
11711
11712 4721673413776871238 => {
11713 let responder = ::fidl_next::Responder::from_untyped(responder);
11714
11715 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11716 Ok(decoded) => {
11717 handler
11718 .deprecated_set_attr(
11719 ::fidl_next::Request::from_decoded(decoded),
11720 responder,
11721 )
11722 .await;
11723 Ok(())
11724 }
11725 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11726 ordinal: 4721673413776871238,
11727 error,
11728 }),
11729 }
11730 }
11731
11732 6595803110182632097 => {
11733 let responder = ::fidl_next::Responder::from_untyped(responder);
11734
11735 handler.deprecated_get_flags(responder).await;
11736 Ok(())
11737 }
11738
11739 5950864159036794675 => {
11740 let responder = ::fidl_next::Responder::from_untyped(responder);
11741
11742 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11743 Ok(decoded) => {
11744 handler
11745 .deprecated_set_flags(
11746 ::fidl_next::Request::from_decoded(decoded),
11747 responder,
11748 )
11749 .await;
11750 Ok(())
11751 }
11752 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11753 ordinal: 5950864159036794675,
11754 error,
11755 }),
11756 }
11757 }
11758
11759 105530239381466147 => {
11760 let responder = ::fidl_next::Responder::from_untyped(responder);
11761
11762 handler.get_flags(responder).await;
11763 Ok(())
11764 }
11765
11766 6172186066099445416 => {
11767 let responder = ::fidl_next::Responder::from_untyped(responder);
11768
11769 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11770 Ok(decoded) => {
11771 handler
11772 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
11773 .await;
11774 Ok(())
11775 }
11776 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11777 ordinal: 6172186066099445416,
11778 error,
11779 }),
11780 }
11781 }
11782
11783 8013111122914313744 => {
11784 let responder = ::fidl_next::Responder::from_untyped(responder);
11785
11786 handler.query_filesystem(responder).await;
11787 Ok(())
11788 }
11789
11790 5788516050773961964 => {
11791 let responder = ::fidl_next::Responder::from_untyped(responder);
11792
11793 handler.get_token(responder).await;
11794 Ok(())
11795 }
11796
11797 4414537700416816443 => {
11798 let responder = ::fidl_next::Responder::from_untyped(responder);
11799
11800 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11801 Ok(decoded) => {
11802 handler
11803 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
11804 .await;
11805 Ok(())
11806 }
11807 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11808 ordinal: 4414537700416816443,
11809 error,
11810 }),
11811 }
11812 }
11813
11814 3677402239314018056 => {
11815 let responder = ::fidl_next::Responder::from_untyped(responder);
11816
11817 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11818 Ok(decoded) => {
11819 handler
11820 .update_attributes(
11821 ::fidl_next::Request::from_decoded(decoded),
11822 responder,
11823 )
11824 .await;
11825 Ok(())
11826 }
11827 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11828 ordinal: 3677402239314018056,
11829 error,
11830 }),
11831 }
11832 }
11833
11834 3196473584242777161 => {
11835 let responder = ::fidl_next::Responder::from_untyped(responder);
11836
11837 handler.sync(responder).await;
11838 Ok(())
11839 }
11840
11841 5043930208506967771 => {
11842 let responder = ::fidl_next::Responder::from_untyped(responder);
11843
11844 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11845 Ok(decoded) => {
11846 handler
11847 .get_extended_attribute(
11848 ::fidl_next::Request::from_decoded(decoded),
11849 responder,
11850 )
11851 .await;
11852 Ok(())
11853 }
11854 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11855 ordinal: 5043930208506967771,
11856 error,
11857 }),
11858 }
11859 }
11860
11861 5374223046099989052 => {
11862 let responder = ::fidl_next::Responder::from_untyped(responder);
11863
11864 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11865 Ok(decoded) => {
11866 handler
11867 .set_extended_attribute(
11868 ::fidl_next::Request::from_decoded(decoded),
11869 responder,
11870 )
11871 .await;
11872 Ok(())
11873 }
11874 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11875 ordinal: 5374223046099989052,
11876 error,
11877 }),
11878 }
11879 }
11880
11881 8794297771444732717 => {
11882 let responder = ::fidl_next::Responder::from_untyped(responder);
11883
11884 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11885 Ok(decoded) => {
11886 handler
11887 .remove_extended_attribute(
11888 ::fidl_next::Request::from_decoded(decoded),
11889 responder,
11890 )
11891 .await;
11892 Ok(())
11893 }
11894 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11895 ordinal: 8794297771444732717,
11896 error,
11897 }),
11898 }
11899 }
11900
11901 3855785432100874762 => {
11902 let responder = ::fidl_next::Responder::from_untyped(responder);
11903
11904 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11905 Ok(decoded) => {
11906 handler
11907 .read_dirents(::fidl_next::Request::from_decoded(decoded), responder)
11908 .await;
11909 Ok(())
11910 }
11911 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11912 ordinal: 3855785432100874762,
11913 error,
11914 }),
11915 }
11916 }
11917
11918 1635123508515392625 => {
11919 let responder = ::fidl_next::Responder::from_untyped(responder);
11920
11921 handler.rewind(responder).await;
11922 Ok(())
11923 }
11924
11925 2787337947777369685 => {
11926 let responder = ::fidl_next::Responder::from_untyped(responder);
11927
11928 handler.deprecated_get_token(responder).await;
11929 Ok(())
11930 }
11931
11932 8360374984291987687 => {
11933 let responder = ::fidl_next::Responder::from_untyped(responder);
11934
11935 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11936 Ok(decoded) => {
11937 handler.link(::fidl_next::Request::from_decoded(decoded), responder).await;
11938 Ok(())
11939 }
11940 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11941 ordinal: 8360374984291987687,
11942 error,
11943 }),
11944 }
11945 }
11946
11947 8433556716759383021 => {
11948 let responder = ::fidl_next::Responder::from_untyped(responder);
11949
11950 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11951 Ok(decoded) => {
11952 handler
11953 .unlink(::fidl_next::Request::from_decoded(decoded), responder)
11954 .await;
11955 Ok(())
11956 }
11957 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11958 ordinal: 8433556716759383021,
11959 error,
11960 }),
11961 }
11962 }
11963
11964 8097726607824333022 => {
11965 let responder = ::fidl_next::Responder::from_untyped(responder);
11966
11967 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11968 Ok(decoded) => {
11969 handler
11970 .rename(::fidl_next::Request::from_decoded(decoded), responder)
11971 .await;
11972 Ok(())
11973 }
11974 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11975 ordinal: 8097726607824333022,
11976 error,
11977 }),
11978 }
11979 }
11980
11981 2435901052462315657 => {
11982 let responder = ::fidl_next::Responder::from_untyped(responder);
11983
11984 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11985 Ok(decoded) => {
11986 handler
11987 .create_symlink(::fidl_next::Request::from_decoded(decoded), responder)
11988 .await;
11989 Ok(())
11990 }
11991 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11992 ordinal: 2435901052462315657,
11993 error,
11994 }),
11995 }
11996 }
11997
11998 6275512344170098065 => {
11999 let responder = ::fidl_next::Responder::from_untyped(responder);
12000
12001 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12002 Ok(decoded) => {
12003 handler.watch(::fidl_next::Request::from_decoded(decoded), responder).await;
12004 Ok(())
12005 }
12006 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12007 ordinal: 6275512344170098065,
12008 error,
12009 }),
12010 }
12011 }
12012
12013 ordinal => {
12014 handler.on_unknown_interaction(ordinal).await;
12015 if ::core::matches!(
12016 message.header().flexibility(),
12017 ::fidl_next::protocol::Flexibility::Strict
12018 ) {
12019 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12020 } else {
12021 responder
12022 .respond_framework_error(
12023 ordinal,
12024 ::fidl_next::FrameworkError::UnknownMethod,
12025 )
12026 .expect("encoding a framework error should never fail")
12027 .await?;
12028 Ok(())
12029 }
12030 }
12031 }
12032 }
12033}
12034
12035pub trait DirectoryClientHandler<
12039 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
12040 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12041>
12042{
12043 #[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"]
12044 fn on_open(
12045 &mut self,
12046
12047 request: ::fidl_next::Request<directory::OnOpen, ___T>,
12048 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12049
12050 #[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"]
12051 fn on_representation(
12052 &mut self,
12053
12054 request: ::fidl_next::Request<directory::OnRepresentation, ___T>,
12055 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12056
12057 fn on_unknown_interaction(
12058 &mut self,
12059 ordinal: u64,
12060 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12061 ::core::future::ready(())
12062 }
12063}
12064
12065impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Directory
12066where
12067 ___H: DirectoryClientHandler<___T> + ::core::marker::Send,
12068 ___T: ::fidl_next::Transport,
12069 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
12070 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12071 Constraint = (),
12072 >,
12073 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
12074 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12075 Constraint = (),
12076 >,
12077{
12078 async fn on_event(
12079 handler: &mut ___H,
12080 mut message: ::fidl_next::Message<___T>,
12081 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12082 match *message.header().ordinal {
12083 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
12084 Ok(decoded) => {
12085 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
12086 Ok(())
12087 }
12088 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12089 ordinal: 9207534335756671346,
12090 error,
12091 }),
12092 },
12093
12094 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
12095 Ok(decoded) => {
12096 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
12097 Ok(())
12098 }
12099 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12100 ordinal: 6679970090861613324,
12101 error,
12102 }),
12103 },
12104
12105 ordinal => {
12106 handler.on_unknown_interaction(ordinal).await;
12107 if ::core::matches!(
12108 message.header().flexibility(),
12109 ::fidl_next::protocol::Flexibility::Strict
12110 ) {
12111 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12112 } else {
12113 Ok(())
12114 }
12115 }
12116 }
12117 }
12118}
12119
12120pub trait DirectoryServerHandler<
12124 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
12125 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12126>
12127{
12128 #[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"]
12129 fn advisory_lock(
12130 &mut self,
12131
12132 request: ::fidl_next::Request<directory::AdvisoryLock, ___T>,
12133
12134 responder: ::fidl_next::Responder<directory::AdvisoryLock, ___T>,
12135 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12136
12137 fn clone(
12138 &mut self,
12139
12140 request: ::fidl_next::Request<directory::Clone, ___T>,
12141 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12142
12143 #[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"]
12144 fn close(
12145 &mut self,
12146
12147 responder: ::fidl_next::Responder<directory::Close, ___T>,
12148 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12149
12150 fn query(
12151 &mut self,
12152
12153 responder: ::fidl_next::Responder<directory::Query, ___T>,
12154 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12155
12156 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
12157 fn deprecated_get_attr(
12158 &mut self,
12159
12160 responder: ::fidl_next::Responder<directory::DeprecatedGetAttr, ___T>,
12161 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12162
12163 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
12164 fn deprecated_set_attr(
12165 &mut self,
12166
12167 request: ::fidl_next::Request<directory::DeprecatedSetAttr, ___T>,
12168
12169 responder: ::fidl_next::Responder<directory::DeprecatedSetAttr, ___T>,
12170 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12171
12172 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
12173 fn deprecated_get_flags(
12174 &mut self,
12175
12176 responder: ::fidl_next::Responder<directory::DeprecatedGetFlags, ___T>,
12177 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12178
12179 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
12180 fn deprecated_set_flags(
12181 &mut self,
12182
12183 request: ::fidl_next::Request<directory::DeprecatedSetFlags, ___T>,
12184
12185 responder: ::fidl_next::Responder<directory::DeprecatedSetFlags, ___T>,
12186 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12187
12188 #[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"]
12189 fn get_flags(
12190 &mut self,
12191
12192 responder: ::fidl_next::Responder<directory::GetFlags, ___T>,
12193 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12194
12195 #[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"]
12196 fn set_flags(
12197 &mut self,
12198
12199 request: ::fidl_next::Request<directory::SetFlags, ___T>,
12200
12201 responder: ::fidl_next::Responder<directory::SetFlags, ___T>,
12202 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12203
12204 #[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"]
12205 fn query_filesystem(
12206 &mut self,
12207
12208 responder: ::fidl_next::Responder<directory::QueryFilesystem, ___T>,
12209 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12210
12211 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
12212 fn get_token(
12213 &mut self,
12214
12215 responder: ::fidl_next::Responder<directory::GetToken, ___T>,
12216 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12217
12218 #[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"]
12219 fn get_attributes(
12220 &mut self,
12221
12222 request: ::fidl_next::Request<directory::GetAttributes, ___T>,
12223
12224 responder: ::fidl_next::Responder<directory::GetAttributes, ___T>,
12225 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12226
12227 #[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"]
12228 fn update_attributes(
12229 &mut self,
12230
12231 request: ::fidl_next::Request<directory::UpdateAttributes, ___T>,
12232
12233 responder: ::fidl_next::Responder<directory::UpdateAttributes, ___T>,
12234 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12235
12236 #[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"]
12237 fn sync(
12238 &mut self,
12239
12240 responder: ::fidl_next::Responder<directory::Sync, ___T>,
12241 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12242
12243 #[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.READ_BYTES`] right.\n"]
12244 fn list_extended_attributes(
12245 &mut self,
12246
12247 request: ::fidl_next::Request<directory::ListExtendedAttributes, ___T>,
12248 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12249
12250 #[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.READ_BYTES`] right.\n"]
12251 fn get_extended_attribute(
12252 &mut self,
12253
12254 request: ::fidl_next::Request<directory::GetExtendedAttribute, ___T>,
12255
12256 responder: ::fidl_next::Responder<directory::GetExtendedAttribute, ___T>,
12257 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12258
12259 #[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.WRITE_BYTES`] right.\n"]
12260 fn set_extended_attribute(
12261 &mut self,
12262
12263 request: ::fidl_next::Request<directory::SetExtendedAttribute, ___T>,
12264
12265 responder: ::fidl_next::Responder<directory::SetExtendedAttribute, ___T>,
12266 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12267
12268 #[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.WRITE_BYTES`] right.\n"]
12269 fn remove_extended_attribute(
12270 &mut self,
12271
12272 request: ::fidl_next::Request<directory::RemoveExtendedAttribute, ___T>,
12273
12274 responder: ::fidl_next::Responder<directory::RemoveExtendedAttribute, ___T>,
12275 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12276
12277 #[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"]
12278 fn open(
12279 &mut self,
12280
12281 request: ::fidl_next::Request<directory::Open, ___T>,
12282 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12283
12284 #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
12285 fn deprecated_open(
12286 &mut self,
12287
12288 request: ::fidl_next::Request<directory::DeprecatedOpen, ___T>,
12289 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12290
12291 #[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 requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
12292 fn read_dirents(
12293 &mut self,
12294
12295 request: ::fidl_next::Request<directory::ReadDirents, ___T>,
12296
12297 responder: ::fidl_next::Responder<directory::ReadDirents, ___T>,
12298 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12299
12300 #[doc = " Resets the directory seek offset.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
12301 fn rewind(
12302 &mut self,
12303
12304 responder: ::fidl_next::Responder<directory::Rewind, ___T>,
12305 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12306
12307 #[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\n This method is deprecated: use `fuchsia.io/Node.GetToken` instead (once it is added).\n"]
12308 fn deprecated_get_token(
12309 &mut self,
12310
12311 responder: ::fidl_next::Responder<directory::DeprecatedGetToken, ___T>,
12312 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12313
12314 #[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"]
12315 fn link(
12316 &mut self,
12317
12318 request: ::fidl_next::Request<directory::Link, ___T>,
12319
12320 responder: ::fidl_next::Responder<directory::Link, ___T>,
12321 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12322
12323 #[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"]
12324 fn unlink(
12325 &mut self,
12326
12327 request: ::fidl_next::Request<directory::Unlink, ___T>,
12328
12329 responder: ::fidl_next::Responder<directory::Unlink, ___T>,
12330 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12331
12332 #[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"]
12333 fn rename(
12334 &mut self,
12335
12336 request: ::fidl_next::Request<directory::Rename, ___T>,
12337
12338 responder: ::fidl_next::Responder<directory::Rename, ___T>,
12339 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12340
12341 #[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"]
12342 fn create_symlink(
12343 &mut self,
12344
12345 request: ::fidl_next::Request<directory::CreateSymlink, ___T>,
12346
12347 responder: ::fidl_next::Responder<directory::CreateSymlink, ___T>,
12348 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12349
12350 #[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 requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
12351 fn watch(
12352 &mut self,
12353
12354 request: ::fidl_next::Request<directory::Watch, ___T>,
12355
12356 responder: ::fidl_next::Responder<directory::Watch, ___T>,
12357 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12358
12359 fn on_unknown_interaction(
12360 &mut self,
12361 ordinal: u64,
12362 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12363 ::core::future::ready(())
12364 }
12365}
12366
12367impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Directory
12368where
12369 ___H: DirectoryServerHandler<___T> + ::core::marker::Send,
12370 ___T: ::fidl_next::Transport,
12371 for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
12372 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12373 Constraint = (),
12374 >,
12375 for<'de> ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
12376 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12377 Constraint = (),
12378 >,
12379 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
12380 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12381 Constraint = (),
12382 >,
12383 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
12384 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12385 Constraint = (),
12386 >,
12387 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
12388 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12389 Constraint = (),
12390 >,
12391 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
12392 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12393 Constraint = (),
12394 >,
12395 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
12396 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12397 Constraint = (),
12398 >,
12399 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
12400 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12401 Constraint = (),
12402 >,
12403 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
12404 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12405 Constraint = (),
12406 >,
12407 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
12408 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12409 Constraint = (),
12410 >,
12411 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
12412 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12413 Constraint = (),
12414 >,
12415 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
12416 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12417 Constraint = (),
12418 >,
12419 for<'de> crate::wire::DirectoryDeprecatedOpenRequest<'de>: ::fidl_next::Decode<
12420 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12421 Constraint = (),
12422 >,
12423 for<'de> crate::wire::DirectoryReadDirentsRequest: ::fidl_next::Decode<
12424 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12425 Constraint = (),
12426 >,
12427 for<'de> crate::wire::DirectoryLinkRequest<'de>: ::fidl_next::Decode<
12428 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12429 Constraint = (),
12430 >,
12431 for<'de> crate::wire::DirectoryUnlinkRequest<'de>: ::fidl_next::Decode<
12432 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12433 Constraint = (),
12434 >,
12435 for<'de> crate::wire::DirectoryRenameRequest<'de>: ::fidl_next::Decode<
12436 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12437 Constraint = (),
12438 >,
12439 for<'de> crate::wire::DirectoryCreateSymlinkRequest<'de>: ::fidl_next::Decode<
12440 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12441 Constraint = (),
12442 >,
12443 for<'de> crate::wire::DirectoryWatchRequest: ::fidl_next::Decode<
12444 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12445 Constraint = (),
12446 >,
12447{
12448 async fn on_one_way(
12449 handler: &mut ___H,
12450 mut message: ::fidl_next::Message<___T>,
12451 ) -> ::core::result::Result<
12452 (),
12453 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12454 > {
12455 match *message.header().ordinal {
12456 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
12457 Ok(decoded) => {
12458 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
12459 Ok(())
12460 }
12461 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12462 ordinal: 2366825959783828089,
12463 error,
12464 }),
12465 },
12466
12467 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
12468 Ok(decoded) => {
12469 handler
12470 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
12471 .await;
12472 Ok(())
12473 }
12474 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12475 ordinal: 5431626189872037072,
12476 error,
12477 }),
12478 },
12479
12480 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
12481 Ok(decoded) => {
12482 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
12483 Ok(())
12484 }
12485 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12486 ordinal: 6236883748953765593,
12487 error,
12488 }),
12489 },
12490
12491 3193127272456937152 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
12492 Ok(decoded) => {
12493 handler.deprecated_open(::fidl_next::Request::from_decoded(decoded)).await;
12494 Ok(())
12495 }
12496 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12497 ordinal: 3193127272456937152,
12498 error,
12499 }),
12500 },
12501
12502 ordinal => {
12503 handler.on_unknown_interaction(ordinal).await;
12504 if ::core::matches!(
12505 message.header().flexibility(),
12506 ::fidl_next::protocol::Flexibility::Strict
12507 ) {
12508 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12509 } else {
12510 Ok(())
12511 }
12512 }
12513 }
12514 }
12515
12516 async fn on_two_way(
12517 handler: &mut ___H,
12518 mut message: ::fidl_next::Message<___T>,
12519 responder: ::fidl_next::protocol::Responder<___T>,
12520 ) -> ::core::result::Result<
12521 (),
12522 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12523 > {
12524 match *message.header().ordinal {
12525 7992130864415541162 => {
12526 let responder = ::fidl_next::Responder::from_untyped(responder);
12527
12528 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12529 Ok(decoded) => {
12530 handler
12531 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
12532 .await;
12533 Ok(())
12534 }
12535 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12536 ordinal: 7992130864415541162,
12537 error,
12538 }),
12539 }
12540 }
12541
12542 6540867515453498750 => {
12543 let responder = ::fidl_next::Responder::from_untyped(responder);
12544
12545 handler.close(responder).await;
12546 Ok(())
12547 }
12548
12549 2763219980499352582 => {
12550 let responder = ::fidl_next::Responder::from_untyped(responder);
12551
12552 handler.query(responder).await;
12553 Ok(())
12554 }
12555
12556 8689798978500614909 => {
12557 let responder = ::fidl_next::Responder::from_untyped(responder);
12558
12559 handler.deprecated_get_attr(responder).await;
12560 Ok(())
12561 }
12562
12563 4721673413776871238 => {
12564 let responder = ::fidl_next::Responder::from_untyped(responder);
12565
12566 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12567 Ok(decoded) => {
12568 handler
12569 .deprecated_set_attr(
12570 ::fidl_next::Request::from_decoded(decoded),
12571 responder,
12572 )
12573 .await;
12574 Ok(())
12575 }
12576 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12577 ordinal: 4721673413776871238,
12578 error,
12579 }),
12580 }
12581 }
12582
12583 6595803110182632097 => {
12584 let responder = ::fidl_next::Responder::from_untyped(responder);
12585
12586 handler.deprecated_get_flags(responder).await;
12587 Ok(())
12588 }
12589
12590 5950864159036794675 => {
12591 let responder = ::fidl_next::Responder::from_untyped(responder);
12592
12593 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12594 Ok(decoded) => {
12595 handler
12596 .deprecated_set_flags(
12597 ::fidl_next::Request::from_decoded(decoded),
12598 responder,
12599 )
12600 .await;
12601 Ok(())
12602 }
12603 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12604 ordinal: 5950864159036794675,
12605 error,
12606 }),
12607 }
12608 }
12609
12610 105530239381466147 => {
12611 let responder = ::fidl_next::Responder::from_untyped(responder);
12612
12613 handler.get_flags(responder).await;
12614 Ok(())
12615 }
12616
12617 6172186066099445416 => {
12618 let responder = ::fidl_next::Responder::from_untyped(responder);
12619
12620 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12621 Ok(decoded) => {
12622 handler
12623 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
12624 .await;
12625 Ok(())
12626 }
12627 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12628 ordinal: 6172186066099445416,
12629 error,
12630 }),
12631 }
12632 }
12633
12634 8013111122914313744 => {
12635 let responder = ::fidl_next::Responder::from_untyped(responder);
12636
12637 handler.query_filesystem(responder).await;
12638 Ok(())
12639 }
12640
12641 5788516050773961964 => {
12642 let responder = ::fidl_next::Responder::from_untyped(responder);
12643
12644 handler.get_token(responder).await;
12645 Ok(())
12646 }
12647
12648 4414537700416816443 => {
12649 let responder = ::fidl_next::Responder::from_untyped(responder);
12650
12651 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12652 Ok(decoded) => {
12653 handler
12654 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
12655 .await;
12656 Ok(())
12657 }
12658 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12659 ordinal: 4414537700416816443,
12660 error,
12661 }),
12662 }
12663 }
12664
12665 3677402239314018056 => {
12666 let responder = ::fidl_next::Responder::from_untyped(responder);
12667
12668 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12669 Ok(decoded) => {
12670 handler
12671 .update_attributes(
12672 ::fidl_next::Request::from_decoded(decoded),
12673 responder,
12674 )
12675 .await;
12676 Ok(())
12677 }
12678 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12679 ordinal: 3677402239314018056,
12680 error,
12681 }),
12682 }
12683 }
12684
12685 3196473584242777161 => {
12686 let responder = ::fidl_next::Responder::from_untyped(responder);
12687
12688 handler.sync(responder).await;
12689 Ok(())
12690 }
12691
12692 5043930208506967771 => {
12693 let responder = ::fidl_next::Responder::from_untyped(responder);
12694
12695 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12696 Ok(decoded) => {
12697 handler
12698 .get_extended_attribute(
12699 ::fidl_next::Request::from_decoded(decoded),
12700 responder,
12701 )
12702 .await;
12703 Ok(())
12704 }
12705 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12706 ordinal: 5043930208506967771,
12707 error,
12708 }),
12709 }
12710 }
12711
12712 5374223046099989052 => {
12713 let responder = ::fidl_next::Responder::from_untyped(responder);
12714
12715 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12716 Ok(decoded) => {
12717 handler
12718 .set_extended_attribute(
12719 ::fidl_next::Request::from_decoded(decoded),
12720 responder,
12721 )
12722 .await;
12723 Ok(())
12724 }
12725 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12726 ordinal: 5374223046099989052,
12727 error,
12728 }),
12729 }
12730 }
12731
12732 8794297771444732717 => {
12733 let responder = ::fidl_next::Responder::from_untyped(responder);
12734
12735 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12736 Ok(decoded) => {
12737 handler
12738 .remove_extended_attribute(
12739 ::fidl_next::Request::from_decoded(decoded),
12740 responder,
12741 )
12742 .await;
12743 Ok(())
12744 }
12745 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12746 ordinal: 8794297771444732717,
12747 error,
12748 }),
12749 }
12750 }
12751
12752 3855785432100874762 => {
12753 let responder = ::fidl_next::Responder::from_untyped(responder);
12754
12755 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12756 Ok(decoded) => {
12757 handler
12758 .read_dirents(::fidl_next::Request::from_decoded(decoded), responder)
12759 .await;
12760 Ok(())
12761 }
12762 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12763 ordinal: 3855785432100874762,
12764 error,
12765 }),
12766 }
12767 }
12768
12769 1635123508515392625 => {
12770 let responder = ::fidl_next::Responder::from_untyped(responder);
12771
12772 handler.rewind(responder).await;
12773 Ok(())
12774 }
12775
12776 2787337947777369685 => {
12777 let responder = ::fidl_next::Responder::from_untyped(responder);
12778
12779 handler.deprecated_get_token(responder).await;
12780 Ok(())
12781 }
12782
12783 8360374984291987687 => {
12784 let responder = ::fidl_next::Responder::from_untyped(responder);
12785
12786 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12787 Ok(decoded) => {
12788 handler.link(::fidl_next::Request::from_decoded(decoded), responder).await;
12789 Ok(())
12790 }
12791 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12792 ordinal: 8360374984291987687,
12793 error,
12794 }),
12795 }
12796 }
12797
12798 8433556716759383021 => {
12799 let responder = ::fidl_next::Responder::from_untyped(responder);
12800
12801 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12802 Ok(decoded) => {
12803 handler
12804 .unlink(::fidl_next::Request::from_decoded(decoded), responder)
12805 .await;
12806 Ok(())
12807 }
12808 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12809 ordinal: 8433556716759383021,
12810 error,
12811 }),
12812 }
12813 }
12814
12815 8097726607824333022 => {
12816 let responder = ::fidl_next::Responder::from_untyped(responder);
12817
12818 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12819 Ok(decoded) => {
12820 handler
12821 .rename(::fidl_next::Request::from_decoded(decoded), responder)
12822 .await;
12823 Ok(())
12824 }
12825 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12826 ordinal: 8097726607824333022,
12827 error,
12828 }),
12829 }
12830 }
12831
12832 2435901052462315657 => {
12833 let responder = ::fidl_next::Responder::from_untyped(responder);
12834
12835 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12836 Ok(decoded) => {
12837 handler
12838 .create_symlink(::fidl_next::Request::from_decoded(decoded), responder)
12839 .await;
12840 Ok(())
12841 }
12842 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12843 ordinal: 2435901052462315657,
12844 error,
12845 }),
12846 }
12847 }
12848
12849 6275512344170098065 => {
12850 let responder = ::fidl_next::Responder::from_untyped(responder);
12851
12852 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12853 Ok(decoded) => {
12854 handler.watch(::fidl_next::Request::from_decoded(decoded), responder).await;
12855 Ok(())
12856 }
12857 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12858 ordinal: 6275512344170098065,
12859 error,
12860 }),
12861 }
12862 }
12863
12864 ordinal => {
12865 handler.on_unknown_interaction(ordinal).await;
12866 if ::core::matches!(
12867 message.header().flexibility(),
12868 ::fidl_next::protocol::Flexibility::Strict
12869 ) {
12870 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12871 } else {
12872 responder
12873 .respond_framework_error(
12874 ordinal,
12875 ::fidl_next::FrameworkError::UnknownMethod,
12876 )
12877 .expect("encoding a framework error should never fail")
12878 .await?;
12879 Ok(())
12880 }
12881 }
12882 }
12883 }
12884}
12885
12886impl<___T> DirectoryClientHandler<___T> for ::fidl_next::IgnoreEvents
12887where
12888 ___T: ::fidl_next::Transport,
12889{
12890 async fn on_open(&mut self, _: ::fidl_next::Request<directory::OnOpen, ___T>) {}
12891
12892 async fn on_representation(
12893 &mut self,
12894
12895 _: ::fidl_next::Request<directory::OnRepresentation, ___T>,
12896 ) {
12897 }
12898
12899 async fn on_unknown_interaction(&mut self, _: u64) {}
12900}
12901
12902impl<___H, ___T> DirectoryLocalClientHandler<___T> for ::fidl_next::Local<___H>
12903where
12904 ___H: DirectoryClientHandler<___T>,
12905 ___T: ::fidl_next::Transport,
12906{
12907 async fn on_open(&mut self, request: ::fidl_next::Request<directory::OnOpen, ___T>) {
12908 ___H::on_open(&mut self.0, request).await
12909 }
12910
12911 async fn on_representation(
12912 &mut self,
12913
12914 request: ::fidl_next::Request<directory::OnRepresentation, ___T>,
12915 ) {
12916 ___H::on_representation(&mut self.0, request).await
12917 }
12918
12919 async fn on_unknown_interaction(&mut self, ordinal: u64) {
12920 ___H::on_unknown_interaction(&mut self.0, ordinal).await
12921 }
12922}
12923
12924impl<___H, ___T> DirectoryLocalServerHandler<___T> for ::fidl_next::Local<___H>
12925where
12926 ___H: DirectoryServerHandler<___T>,
12927 ___T: ::fidl_next::Transport,
12928{
12929 async fn advisory_lock(
12930 &mut self,
12931
12932 request: ::fidl_next::Request<directory::AdvisoryLock, ___T>,
12933
12934 responder: ::fidl_next::Responder<directory::AdvisoryLock, ___T>,
12935 ) {
12936 ___H::advisory_lock(&mut self.0, request, responder).await
12937 }
12938
12939 async fn clone(&mut self, request: ::fidl_next::Request<directory::Clone, ___T>) {
12940 ___H::clone(&mut self.0, request).await
12941 }
12942
12943 async fn close(&mut self, responder: ::fidl_next::Responder<directory::Close, ___T>) {
12944 ___H::close(&mut self.0, responder).await
12945 }
12946
12947 async fn query(&mut self, responder: ::fidl_next::Responder<directory::Query, ___T>) {
12948 ___H::query(&mut self.0, responder).await
12949 }
12950
12951 async fn deprecated_get_attr(
12952 &mut self,
12953
12954 responder: ::fidl_next::Responder<directory::DeprecatedGetAttr, ___T>,
12955 ) {
12956 ___H::deprecated_get_attr(&mut self.0, responder).await
12957 }
12958
12959 async fn deprecated_set_attr(
12960 &mut self,
12961
12962 request: ::fidl_next::Request<directory::DeprecatedSetAttr, ___T>,
12963
12964 responder: ::fidl_next::Responder<directory::DeprecatedSetAttr, ___T>,
12965 ) {
12966 ___H::deprecated_set_attr(&mut self.0, request, responder).await
12967 }
12968
12969 async fn deprecated_get_flags(
12970 &mut self,
12971
12972 responder: ::fidl_next::Responder<directory::DeprecatedGetFlags, ___T>,
12973 ) {
12974 ___H::deprecated_get_flags(&mut self.0, responder).await
12975 }
12976
12977 async fn deprecated_set_flags(
12978 &mut self,
12979
12980 request: ::fidl_next::Request<directory::DeprecatedSetFlags, ___T>,
12981
12982 responder: ::fidl_next::Responder<directory::DeprecatedSetFlags, ___T>,
12983 ) {
12984 ___H::deprecated_set_flags(&mut self.0, request, responder).await
12985 }
12986
12987 async fn get_flags(&mut self, responder: ::fidl_next::Responder<directory::GetFlags, ___T>) {
12988 ___H::get_flags(&mut self.0, responder).await
12989 }
12990
12991 async fn set_flags(
12992 &mut self,
12993
12994 request: ::fidl_next::Request<directory::SetFlags, ___T>,
12995
12996 responder: ::fidl_next::Responder<directory::SetFlags, ___T>,
12997 ) {
12998 ___H::set_flags(&mut self.0, request, responder).await
12999 }
13000
13001 async fn query_filesystem(
13002 &mut self,
13003
13004 responder: ::fidl_next::Responder<directory::QueryFilesystem, ___T>,
13005 ) {
13006 ___H::query_filesystem(&mut self.0, responder).await
13007 }
13008
13009 async fn get_token(&mut self, responder: ::fidl_next::Responder<directory::GetToken, ___T>) {
13010 ___H::get_token(&mut self.0, responder).await
13011 }
13012
13013 async fn get_attributes(
13014 &mut self,
13015
13016 request: ::fidl_next::Request<directory::GetAttributes, ___T>,
13017
13018 responder: ::fidl_next::Responder<directory::GetAttributes, ___T>,
13019 ) {
13020 ___H::get_attributes(&mut self.0, request, responder).await
13021 }
13022
13023 async fn update_attributes(
13024 &mut self,
13025
13026 request: ::fidl_next::Request<directory::UpdateAttributes, ___T>,
13027
13028 responder: ::fidl_next::Responder<directory::UpdateAttributes, ___T>,
13029 ) {
13030 ___H::update_attributes(&mut self.0, request, responder).await
13031 }
13032
13033 async fn sync(&mut self, responder: ::fidl_next::Responder<directory::Sync, ___T>) {
13034 ___H::sync(&mut self.0, responder).await
13035 }
13036
13037 async fn list_extended_attributes(
13038 &mut self,
13039
13040 request: ::fidl_next::Request<directory::ListExtendedAttributes, ___T>,
13041 ) {
13042 ___H::list_extended_attributes(&mut self.0, request).await
13043 }
13044
13045 async fn get_extended_attribute(
13046 &mut self,
13047
13048 request: ::fidl_next::Request<directory::GetExtendedAttribute, ___T>,
13049
13050 responder: ::fidl_next::Responder<directory::GetExtendedAttribute, ___T>,
13051 ) {
13052 ___H::get_extended_attribute(&mut self.0, request, responder).await
13053 }
13054
13055 async fn set_extended_attribute(
13056 &mut self,
13057
13058 request: ::fidl_next::Request<directory::SetExtendedAttribute, ___T>,
13059
13060 responder: ::fidl_next::Responder<directory::SetExtendedAttribute, ___T>,
13061 ) {
13062 ___H::set_extended_attribute(&mut self.0, request, responder).await
13063 }
13064
13065 async fn remove_extended_attribute(
13066 &mut self,
13067
13068 request: ::fidl_next::Request<directory::RemoveExtendedAttribute, ___T>,
13069
13070 responder: ::fidl_next::Responder<directory::RemoveExtendedAttribute, ___T>,
13071 ) {
13072 ___H::remove_extended_attribute(&mut self.0, request, responder).await
13073 }
13074
13075 async fn open(&mut self, request: ::fidl_next::Request<directory::Open, ___T>) {
13076 ___H::open(&mut self.0, request).await
13077 }
13078
13079 async fn deprecated_open(
13080 &mut self,
13081
13082 request: ::fidl_next::Request<directory::DeprecatedOpen, ___T>,
13083 ) {
13084 ___H::deprecated_open(&mut self.0, request).await
13085 }
13086
13087 async fn read_dirents(
13088 &mut self,
13089
13090 request: ::fidl_next::Request<directory::ReadDirents, ___T>,
13091
13092 responder: ::fidl_next::Responder<directory::ReadDirents, ___T>,
13093 ) {
13094 ___H::read_dirents(&mut self.0, request, responder).await
13095 }
13096
13097 async fn rewind(&mut self, responder: ::fidl_next::Responder<directory::Rewind, ___T>) {
13098 ___H::rewind(&mut self.0, responder).await
13099 }
13100
13101 async fn deprecated_get_token(
13102 &mut self,
13103
13104 responder: ::fidl_next::Responder<directory::DeprecatedGetToken, ___T>,
13105 ) {
13106 ___H::deprecated_get_token(&mut self.0, responder).await
13107 }
13108
13109 async fn link(
13110 &mut self,
13111
13112 request: ::fidl_next::Request<directory::Link, ___T>,
13113
13114 responder: ::fidl_next::Responder<directory::Link, ___T>,
13115 ) {
13116 ___H::link(&mut self.0, request, responder).await
13117 }
13118
13119 async fn unlink(
13120 &mut self,
13121
13122 request: ::fidl_next::Request<directory::Unlink, ___T>,
13123
13124 responder: ::fidl_next::Responder<directory::Unlink, ___T>,
13125 ) {
13126 ___H::unlink(&mut self.0, request, responder).await
13127 }
13128
13129 async fn rename(
13130 &mut self,
13131
13132 request: ::fidl_next::Request<directory::Rename, ___T>,
13133
13134 responder: ::fidl_next::Responder<directory::Rename, ___T>,
13135 ) {
13136 ___H::rename(&mut self.0, request, responder).await
13137 }
13138
13139 async fn create_symlink(
13140 &mut self,
13141
13142 request: ::fidl_next::Request<directory::CreateSymlink, ___T>,
13143
13144 responder: ::fidl_next::Responder<directory::CreateSymlink, ___T>,
13145 ) {
13146 ___H::create_symlink(&mut self.0, request, responder).await
13147 }
13148
13149 async fn watch(
13150 &mut self,
13151
13152 request: ::fidl_next::Request<directory::Watch, ___T>,
13153
13154 responder: ::fidl_next::Responder<directory::Watch, ___T>,
13155 ) {
13156 ___H::watch(&mut self.0, request, responder).await
13157 }
13158
13159 async fn on_unknown_interaction(&mut self, ordinal: u64) {
13160 ___H::on_unknown_interaction(&mut self.0, ordinal).await
13161 }
13162}
13163
13164#[derive(PartialEq, Debug)]
13166pub struct Linkable;
13167
13168#[cfg(target_os = "fuchsia")]
13169impl ::fidl_next::HasTransport for Linkable {
13170 type Transport = ::fdomain_client::Channel;
13171}
13172
13173pub mod linkable {
13174 pub mod prelude {
13175 pub use crate::{
13176 Linkable, LinkableClientHandler, LinkableLocalClientHandler,
13177 LinkableLocalServerHandler, LinkableServerHandler, linkable,
13178 };
13179
13180 pub use crate::natural::LinkableLinkIntoRequest;
13181
13182 pub use crate::natural::LinkableLinkIntoResponse;
13183 }
13184
13185 pub struct LinkInto;
13186
13187 impl ::fidl_next::Method for LinkInto {
13188 const ORDINAL: u64 = 6121399674497678964;
13189 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13190 ::fidl_next::protocol::Flexibility::Strict;
13191
13192 type Protocol = crate::Linkable;
13193
13194 type Request = crate::wire::LinkableLinkIntoRequest<'static>;
13195 }
13196
13197 impl ::fidl_next::TwoWayMethod for LinkInto {
13198 type Response = ::fidl_next::wire::Result<
13199 'static,
13200 crate::wire::LinkableLinkIntoResponse,
13201 ::fidl_next::wire::fuchsia::Status,
13202 >;
13203 }
13204
13205 impl<___R> ::fidl_next::Respond<___R> for LinkInto {
13206 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
13207
13208 fn respond(response: ___R) -> Self::Output {
13209 ::core::result::Result::Ok(response)
13210 }
13211 }
13212
13213 impl<___R> ::fidl_next::RespondErr<___R> for LinkInto {
13214 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
13215
13216 fn respond_err(response: ___R) -> Self::Output {
13217 ::core::result::Result::Err(response)
13218 }
13219 }
13220
13221 mod ___detail {
13222 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Linkable
13223 where
13224 ___T: ::fidl_next::Transport,
13225 {
13226 type Client = LinkableClient<___T>;
13227 type Server = LinkableServer<___T>;
13228 }
13229
13230 #[repr(transparent)]
13232 pub struct LinkableClient<___T: ::fidl_next::Transport> {
13233 #[allow(dead_code)]
13234 client: ::fidl_next::protocol::Client<___T>,
13235 }
13236
13237 impl<___T> LinkableClient<___T>
13238 where
13239 ___T: ::fidl_next::Transport,
13240 {
13241 #[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"]
13242 pub fn link_into(
13243 &self,
13244
13245 dst_parent_token: impl ::fidl_next::Encode<
13246 ::fdomain_client::fidl_next::wire::Handle,
13247 <___T as ::fidl_next::Transport>::SendBuffer,
13248 >,
13249
13250 dst: impl ::fidl_next::Encode<
13251 ::fidl_next::wire::String<'static>,
13252 <___T as ::fidl_next::Transport>::SendBuffer,
13253 >,
13254 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
13255 where
13256 <___T as ::fidl_next::Transport>::SendBuffer:
13257 ::fidl_next::encoder::InternalHandleEncoder,
13258 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
13259 <___T as ::fidl_next::Transport>::SendBuffer:
13260 ::fdomain_client::fidl_next::HandleEncoder,
13261 {
13262 self.link_into_with(crate::generic::LinkableLinkIntoRequest {
13263 dst_parent_token,
13264
13265 dst,
13266 })
13267 }
13268
13269 #[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"]
13270 pub fn link_into_with<___R>(
13271 &self,
13272 request: ___R,
13273 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
13274 where
13275 ___R: ::fidl_next::Encode<
13276 crate::wire::LinkableLinkIntoRequest<'static>,
13277 <___T as ::fidl_next::Transport>::SendBuffer,
13278 >,
13279 {
13280 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
13281 6121399674497678964,
13282 <super::LinkInto as ::fidl_next::Method>::FLEXIBILITY,
13283 request,
13284 ))
13285 }
13286 }
13287
13288 #[repr(transparent)]
13290 pub struct LinkableServer<___T: ::fidl_next::Transport> {
13291 server: ::fidl_next::protocol::Server<___T>,
13292 }
13293
13294 impl<___T> LinkableServer<___T> where ___T: ::fidl_next::Transport {}
13295 }
13296}
13297
13298#[diagnostic::on_unimplemented(
13299 note = "If {Self} implements the non-local LinkableClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
13300)]
13301
13302pub trait LinkableLocalClientHandler<
13306 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
13307 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13308>
13309{
13310}
13311
13312impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Linkable
13313where
13314 ___H: LinkableLocalClientHandler<___T>,
13315 ___T: ::fidl_next::Transport,
13316{
13317 async fn on_event(
13318 handler: &mut ___H,
13319 mut message: ::fidl_next::Message<___T>,
13320 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13321 match *message.header().ordinal {
13322 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
13323 }
13324 }
13325}
13326
13327#[diagnostic::on_unimplemented(
13328 note = "If {Self} implements the non-local LinkableServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
13329)]
13330
13331pub trait LinkableLocalServerHandler<
13335 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
13336 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13337>
13338{
13339 #[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"]
13340 fn link_into(
13341 &mut self,
13342
13343 request: ::fidl_next::Request<linkable::LinkInto, ___T>,
13344
13345 responder: ::fidl_next::Responder<linkable::LinkInto, ___T>,
13346 ) -> impl ::core::future::Future<Output = ()>;
13347}
13348
13349impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Linkable
13350where
13351 ___H: LinkableLocalServerHandler<___T>,
13352 ___T: ::fidl_next::Transport,
13353 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
13354 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13355 Constraint = (),
13356 >,
13357{
13358 async fn on_one_way(
13359 handler: &mut ___H,
13360 mut message: ::fidl_next::Message<___T>,
13361 ) -> ::core::result::Result<
13362 (),
13363 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13364 > {
13365 match *message.header().ordinal {
13366 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
13367 }
13368 }
13369
13370 async fn on_two_way(
13371 handler: &mut ___H,
13372 mut message: ::fidl_next::Message<___T>,
13373 responder: ::fidl_next::protocol::Responder<___T>,
13374 ) -> ::core::result::Result<
13375 (),
13376 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13377 > {
13378 match *message.header().ordinal {
13379 6121399674497678964 => {
13380 let responder = ::fidl_next::Responder::from_untyped(responder);
13381
13382 match ::fidl_next::AsDecoderExt::into_decoded(message) {
13383 Ok(decoded) => {
13384 handler
13385 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
13386 .await;
13387 Ok(())
13388 }
13389 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13390 ordinal: 6121399674497678964,
13391 error,
13392 }),
13393 }
13394 }
13395
13396 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
13397 }
13398 }
13399}
13400
13401pub trait LinkableClientHandler<
13405 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
13406 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13407>
13408{
13409}
13410
13411impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Linkable
13412where
13413 ___H: LinkableClientHandler<___T> + ::core::marker::Send,
13414 ___T: ::fidl_next::Transport,
13415{
13416 async fn on_event(
13417 handler: &mut ___H,
13418 mut message: ::fidl_next::Message<___T>,
13419 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13420 match *message.header().ordinal {
13421 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
13422 }
13423 }
13424}
13425
13426pub trait LinkableServerHandler<
13430 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
13431 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13432>
13433{
13434 #[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"]
13435 fn link_into(
13436 &mut self,
13437
13438 request: ::fidl_next::Request<linkable::LinkInto, ___T>,
13439
13440 responder: ::fidl_next::Responder<linkable::LinkInto, ___T>,
13441 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13442}
13443
13444impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Linkable
13445where
13446 ___H: LinkableServerHandler<___T> + ::core::marker::Send,
13447 ___T: ::fidl_next::Transport,
13448 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
13449 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13450 Constraint = (),
13451 >,
13452{
13453 async fn on_one_way(
13454 handler: &mut ___H,
13455 mut message: ::fidl_next::Message<___T>,
13456 ) -> ::core::result::Result<
13457 (),
13458 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13459 > {
13460 match *message.header().ordinal {
13461 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
13462 }
13463 }
13464
13465 async fn on_two_way(
13466 handler: &mut ___H,
13467 mut message: ::fidl_next::Message<___T>,
13468 responder: ::fidl_next::protocol::Responder<___T>,
13469 ) -> ::core::result::Result<
13470 (),
13471 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13472 > {
13473 match *message.header().ordinal {
13474 6121399674497678964 => {
13475 let responder = ::fidl_next::Responder::from_untyped(responder);
13476
13477 match ::fidl_next::AsDecoderExt::into_decoded(message) {
13478 Ok(decoded) => {
13479 handler
13480 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
13481 .await;
13482 Ok(())
13483 }
13484 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13485 ordinal: 6121399674497678964,
13486 error,
13487 }),
13488 }
13489 }
13490
13491 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
13492 }
13493 }
13494}
13495
13496impl<___T> LinkableClientHandler<___T> for ::fidl_next::IgnoreEvents where
13497 ___T: ::fidl_next::Transport
13498{
13499}
13500
13501impl<___H, ___T> LinkableLocalClientHandler<___T> for ::fidl_next::Local<___H>
13502where
13503 ___H: LinkableClientHandler<___T>,
13504 ___T: ::fidl_next::Transport,
13505{
13506}
13507
13508impl<___H, ___T> LinkableLocalServerHandler<___T> for ::fidl_next::Local<___H>
13509where
13510 ___H: LinkableServerHandler<___T>,
13511 ___T: ::fidl_next::Transport,
13512{
13513 async fn link_into(
13514 &mut self,
13515
13516 request: ::fidl_next::Request<linkable::LinkInto, ___T>,
13517
13518 responder: ::fidl_next::Responder<linkable::LinkInto, ___T>,
13519 ) {
13520 ___H::link_into(&mut self.0, request, responder).await
13521 }
13522}
13523
13524#[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"]
13526#[derive(PartialEq, Debug)]
13527pub struct File;
13528
13529impl ::fidl_next::Discoverable for File {
13530 const PROTOCOL_NAME: &'static str = "fuchsia.io.File";
13531}
13532
13533#[cfg(target_os = "fuchsia")]
13534impl ::fidl_next::HasTransport for File {
13535 type Transport = ::fdomain_client::Channel;
13536}
13537
13538pub mod file {
13539 pub mod prelude {
13540 pub use crate::{
13541 File, FileClientHandler, FileLocalClientHandler, FileLocalServerHandler,
13542 FileServerHandler, file,
13543 };
13544
13545 pub use crate::natural::AdvisoryLockingAdvisoryLockRequest;
13546
13547 pub use crate::natural::AdvisoryLockingAdvisoryLockResponse;
13548
13549 pub use crate::natural::ExtendedAttributeValue;
13550
13551 pub use crate::natural::FileAllocateRequest;
13552
13553 pub use crate::natural::FileEnableVerityRequest;
13554
13555 pub use crate::natural::FileGetBackingMemoryRequest;
13556
13557 pub use crate::natural::FileInfo;
13558
13559 pub use crate::natural::FileReadAtRequest;
13560
13561 pub use crate::natural::FileResizeRequest;
13562
13563 pub use crate::natural::FileSeekRequest;
13564
13565 pub use crate::natural::FileWriteAtRequest;
13566
13567 pub use crate::natural::FileAllocateResponse;
13568
13569 pub use crate::natural::FileEnableVerityResponse;
13570
13571 pub use crate::natural::FileGetBackingMemoryResponse;
13572
13573 pub use crate::natural::FileReadAtResponse;
13574
13575 pub use crate::natural::FileResizeResponse;
13576
13577 pub use crate::natural::FileSeekResponse;
13578
13579 pub use crate::natural::FileWriteAtResponse;
13580
13581 pub use crate::natural::LinkableLinkIntoRequest;
13582
13583 pub use crate::natural::LinkableLinkIntoResponse;
13584
13585 pub use crate::natural::MutableNodeAttributes;
13586
13587 pub use crate::natural::NodeAttributes2;
13588
13589 pub use crate::natural::NodeDeprecatedGetAttrResponse;
13590
13591 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
13592
13593 pub use crate::natural::NodeDeprecatedSetAttrRequest;
13594
13595 pub use crate::natural::NodeDeprecatedSetAttrResponse;
13596
13597 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
13598
13599 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
13600
13601 pub use crate::natural::NodeGetAttributesRequest;
13602
13603 pub use crate::natural::NodeGetExtendedAttributeRequest;
13604
13605 pub use crate::natural::NodeListExtendedAttributesRequest;
13606
13607 pub use crate::natural::NodeOnOpenRequest;
13608
13609 pub use crate::natural::NodeQueryFilesystemResponse;
13610
13611 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
13612
13613 pub use crate::natural::NodeSetExtendedAttributeRequest;
13614
13615 pub use crate::natural::NodeSetFlagsRequest;
13616
13617 pub use crate::natural::NodeGetFlagsResponse;
13618
13619 pub use crate::natural::NodeGetTokenResponse;
13620
13621 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
13622
13623 pub use crate::natural::NodeSetExtendedAttributeResponse;
13624
13625 pub use crate::natural::NodeSetFlagsResponse;
13626
13627 pub use crate::natural::NodeSyncResponse;
13628
13629 pub use crate::natural::NodeUpdateAttributesResponse;
13630
13631 pub use crate::natural::ReadableReadRequest;
13632
13633 pub use crate::natural::ReadableReadResponse;
13634
13635 pub use crate::natural::Representation;
13636
13637 pub use crate::natural::WritableWriteRequest;
13638
13639 pub use crate::natural::WritableWriteResponse;
13640
13641 pub use ::fdomain_next_fuchsia_unknown::natural::CloneableCloneRequest;
13642
13643 pub use ::fdomain_next_fuchsia_unknown::natural::CloseableCloseResponse;
13644
13645 pub use ::fdomain_next_fuchsia_unknown::natural::QueryableQueryResponse;
13646 }
13647
13648 pub struct AdvisoryLock;
13649
13650 impl ::fidl_next::Method for AdvisoryLock {
13651 const ORDINAL: u64 = 7992130864415541162;
13652 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13653 ::fidl_next::protocol::Flexibility::Strict;
13654
13655 type Protocol = crate::File;
13656
13657 type Request = crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>;
13658 }
13659
13660 impl ::fidl_next::TwoWayMethod for AdvisoryLock {
13661 type Response = ::fidl_next::wire::Result<
13662 'static,
13663 crate::wire::AdvisoryLockingAdvisoryLockResponse,
13664 ::fidl_next::wire::fuchsia::Status,
13665 >;
13666 }
13667
13668 impl<___R> ::fidl_next::Respond<___R> for AdvisoryLock {
13669 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
13670
13671 fn respond(response: ___R) -> Self::Output {
13672 ::core::result::Result::Ok(response)
13673 }
13674 }
13675
13676 impl<___R> ::fidl_next::RespondErr<___R> for AdvisoryLock {
13677 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
13678
13679 fn respond_err(response: ___R) -> Self::Output {
13680 ::core::result::Result::Err(response)
13681 }
13682 }
13683
13684 pub struct LinkInto;
13685
13686 impl ::fidl_next::Method for LinkInto {
13687 const ORDINAL: u64 = 6121399674497678964;
13688 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13689 ::fidl_next::protocol::Flexibility::Strict;
13690
13691 type Protocol = crate::File;
13692
13693 type Request = crate::wire::LinkableLinkIntoRequest<'static>;
13694 }
13695
13696 impl ::fidl_next::TwoWayMethod for LinkInto {
13697 type Response = ::fidl_next::wire::Result<
13698 'static,
13699 crate::wire::LinkableLinkIntoResponse,
13700 ::fidl_next::wire::fuchsia::Status,
13701 >;
13702 }
13703
13704 impl<___R> ::fidl_next::Respond<___R> for LinkInto {
13705 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
13706
13707 fn respond(response: ___R) -> Self::Output {
13708 ::core::result::Result::Ok(response)
13709 }
13710 }
13711
13712 impl<___R> ::fidl_next::RespondErr<___R> for LinkInto {
13713 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
13714
13715 fn respond_err(response: ___R) -> Self::Output {
13716 ::core::result::Result::Err(response)
13717 }
13718 }
13719
13720 pub struct Clone;
13721
13722 impl ::fidl_next::Method for Clone {
13723 const ORDINAL: u64 = 2366825959783828089;
13724 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13725 ::fidl_next::protocol::Flexibility::Strict;
13726
13727 type Protocol = crate::File;
13728
13729 type Request = ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest;
13730 }
13731
13732 pub struct Close;
13733
13734 impl ::fidl_next::Method for Close {
13735 const ORDINAL: u64 = 6540867515453498750;
13736 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13737 ::fidl_next::protocol::Flexibility::Strict;
13738
13739 type Protocol = crate::File;
13740
13741 type Request = ::fidl_next::wire::EmptyMessageBody;
13742 }
13743
13744 impl ::fidl_next::TwoWayMethod for Close {
13745 type Response = ::fidl_next::wire::Result<
13746 'static,
13747 ::fdomain_next_fuchsia_unknown::wire::CloseableCloseResponse,
13748 ::fidl_next::wire::Int32,
13749 >;
13750 }
13751
13752 impl<___R> ::fidl_next::Respond<___R> for Close {
13753 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
13754
13755 fn respond(response: ___R) -> Self::Output {
13756 ::core::result::Result::Ok(response)
13757 }
13758 }
13759
13760 impl<___R> ::fidl_next::RespondErr<___R> for Close {
13761 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
13762
13763 fn respond_err(response: ___R) -> Self::Output {
13764 ::core::result::Result::Err(response)
13765 }
13766 }
13767
13768 pub struct Query;
13769
13770 impl ::fidl_next::Method for Query {
13771 const ORDINAL: u64 = 2763219980499352582;
13772 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13773 ::fidl_next::protocol::Flexibility::Strict;
13774
13775 type Protocol = crate::File;
13776
13777 type Request = ::fidl_next::wire::EmptyMessageBody;
13778 }
13779
13780 impl ::fidl_next::TwoWayMethod for Query {
13781 type Response = ::fidl_next::wire::Strict<
13782 ::fdomain_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>,
13783 >;
13784 }
13785
13786 impl<___R> ::fidl_next::Respond<___R> for Query {
13787 type Output = ::fidl_next::Strict<
13788 ::fdomain_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>,
13789 >;
13790
13791 fn respond(response: ___R) -> Self::Output {
13792 ::fidl_next::Strict(::fdomain_next_fuchsia_unknown::generic::QueryableQueryResponse {
13793 protocol: response,
13794 })
13795 }
13796 }
13797
13798 pub struct OnOpen;
13799
13800 impl ::fidl_next::Method for OnOpen {
13801 const ORDINAL: u64 = 9207534335756671346;
13802 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13803 ::fidl_next::protocol::Flexibility::Flexible;
13804
13805 type Protocol = crate::File;
13806
13807 type Request = crate::wire::NodeOnOpenRequest<'static>;
13808 }
13809
13810 pub struct DeprecatedGetAttr;
13811
13812 impl ::fidl_next::Method for DeprecatedGetAttr {
13813 const ORDINAL: u64 = 8689798978500614909;
13814 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13815 ::fidl_next::protocol::Flexibility::Strict;
13816
13817 type Protocol = crate::File;
13818
13819 type Request = ::fidl_next::wire::EmptyMessageBody;
13820 }
13821
13822 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
13823 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetAttrResponse>;
13824 }
13825
13826 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
13827 type Output = ::fidl_next::Strict<___R>;
13828
13829 fn respond(response: ___R) -> Self::Output {
13830 ::fidl_next::Strict(response)
13831 }
13832 }
13833
13834 pub struct DeprecatedSetAttr;
13835
13836 impl ::fidl_next::Method for DeprecatedSetAttr {
13837 const ORDINAL: u64 = 4721673413776871238;
13838 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13839 ::fidl_next::protocol::Flexibility::Strict;
13840
13841 type Protocol = crate::File;
13842
13843 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
13844 }
13845
13846 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
13847 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetAttrResponse>;
13848 }
13849
13850 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
13851 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetAttrResponse<___R>>;
13852
13853 fn respond(response: ___R) -> Self::Output {
13854 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetAttrResponse { s: response })
13855 }
13856 }
13857
13858 pub struct DeprecatedGetFlags;
13859
13860 impl ::fidl_next::Method for DeprecatedGetFlags {
13861 const ORDINAL: u64 = 6595803110182632097;
13862 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13863 ::fidl_next::protocol::Flexibility::Strict;
13864
13865 type Protocol = crate::File;
13866
13867 type Request = ::fidl_next::wire::EmptyMessageBody;
13868 }
13869
13870 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
13871 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetFlagsResponse>;
13872 }
13873
13874 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
13875 type Output = ::fidl_next::Strict<___R>;
13876
13877 fn respond(response: ___R) -> Self::Output {
13878 ::fidl_next::Strict(response)
13879 }
13880 }
13881
13882 pub struct DeprecatedSetFlags;
13883
13884 impl ::fidl_next::Method for DeprecatedSetFlags {
13885 const ORDINAL: u64 = 5950864159036794675;
13886 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13887 ::fidl_next::protocol::Flexibility::Strict;
13888
13889 type Protocol = crate::File;
13890
13891 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
13892 }
13893
13894 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
13895 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetFlagsResponse>;
13896 }
13897
13898 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
13899 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetFlagsResponse<___R>>;
13900
13901 fn respond(response: ___R) -> Self::Output {
13902 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetFlagsResponse { s: response })
13903 }
13904 }
13905
13906 pub struct GetFlags;
13907
13908 impl ::fidl_next::Method for GetFlags {
13909 const ORDINAL: u64 = 105530239381466147;
13910 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13911 ::fidl_next::protocol::Flexibility::Flexible;
13912
13913 type Protocol = crate::File;
13914
13915 type Request = ::fidl_next::wire::EmptyMessageBody;
13916 }
13917
13918 impl ::fidl_next::TwoWayMethod for GetFlags {
13919 type Response = ::fidl_next::wire::Result<
13920 'static,
13921 crate::wire::NodeGetFlagsResponse,
13922 ::fidl_next::wire::fuchsia::Status,
13923 >;
13924 }
13925
13926 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
13927 type Output = ::core::result::Result<
13928 crate::generic::NodeGetFlagsResponse<___R>,
13929 ::fidl_next::never::Never,
13930 >;
13931
13932 fn respond(response: ___R) -> Self::Output {
13933 ::core::result::Result::Ok(crate::generic::NodeGetFlagsResponse { flags: response })
13934 }
13935 }
13936
13937 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
13938 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
13939
13940 fn respond_err(response: ___R) -> Self::Output {
13941 ::core::result::Result::Err(response)
13942 }
13943 }
13944
13945 pub struct SetFlags;
13946
13947 impl ::fidl_next::Method for SetFlags {
13948 const ORDINAL: u64 = 6172186066099445416;
13949 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13950 ::fidl_next::protocol::Flexibility::Flexible;
13951
13952 type Protocol = crate::File;
13953
13954 type Request = crate::wire::NodeSetFlagsRequest;
13955 }
13956
13957 impl ::fidl_next::TwoWayMethod for SetFlags {
13958 type Response = ::fidl_next::wire::Result<
13959 'static,
13960 crate::wire::NodeSetFlagsResponse,
13961 ::fidl_next::wire::fuchsia::Status,
13962 >;
13963 }
13964
13965 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
13966 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
13967
13968 fn respond(response: ___R) -> Self::Output {
13969 ::core::result::Result::Ok(response)
13970 }
13971 }
13972
13973 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
13974 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
13975
13976 fn respond_err(response: ___R) -> Self::Output {
13977 ::core::result::Result::Err(response)
13978 }
13979 }
13980
13981 pub struct QueryFilesystem;
13982
13983 impl ::fidl_next::Method for QueryFilesystem {
13984 const ORDINAL: u64 = 8013111122914313744;
13985 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13986 ::fidl_next::protocol::Flexibility::Strict;
13987
13988 type Protocol = crate::File;
13989
13990 type Request = ::fidl_next::wire::EmptyMessageBody;
13991 }
13992
13993 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
13994 type Response =
13995 ::fidl_next::wire::Strict<crate::wire::NodeQueryFilesystemResponse<'static>>;
13996 }
13997
13998 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
13999 type Output = ::fidl_next::Strict<___R>;
14000
14001 fn respond(response: ___R) -> Self::Output {
14002 ::fidl_next::Strict(response)
14003 }
14004 }
14005
14006 pub struct OnRepresentation;
14007
14008 impl ::fidl_next::Method for OnRepresentation {
14009 const ORDINAL: u64 = 6679970090861613324;
14010 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14011 ::fidl_next::protocol::Flexibility::Strict;
14012
14013 type Protocol = crate::File;
14014
14015 type Request = crate::wire::Representation<'static>;
14016 }
14017
14018 pub struct GetToken;
14019
14020 impl ::fidl_next::Method for GetToken {
14021 const ORDINAL: u64 = 5788516050773961964;
14022 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14023 ::fidl_next::protocol::Flexibility::Flexible;
14024
14025 type Protocol = crate::File;
14026
14027 type Request = ::fidl_next::wire::EmptyMessageBody;
14028 }
14029
14030 impl ::fidl_next::TwoWayMethod for GetToken {
14031 type Response = ::fidl_next::wire::Result<
14032 'static,
14033 crate::wire::NodeGetTokenResponse,
14034 ::fidl_next::wire::fuchsia::Status,
14035 >;
14036 }
14037
14038 impl<___R> ::fidl_next::Respond<___R> for GetToken {
14039 type Output = ::core::result::Result<
14040 crate::generic::NodeGetTokenResponse<___R>,
14041 ::fidl_next::never::Never,
14042 >;
14043
14044 fn respond(response: ___R) -> Self::Output {
14045 ::core::result::Result::Ok(crate::generic::NodeGetTokenResponse { token: response })
14046 }
14047 }
14048
14049 impl<___R> ::fidl_next::RespondErr<___R> for GetToken {
14050 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14051
14052 fn respond_err(response: ___R) -> Self::Output {
14053 ::core::result::Result::Err(response)
14054 }
14055 }
14056
14057 pub struct GetAttributes;
14058
14059 impl ::fidl_next::Method for GetAttributes {
14060 const ORDINAL: u64 = 4414537700416816443;
14061 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14062 ::fidl_next::protocol::Flexibility::Strict;
14063
14064 type Protocol = crate::File;
14065
14066 type Request = crate::wire::NodeGetAttributesRequest;
14067 }
14068
14069 impl ::fidl_next::TwoWayMethod for GetAttributes {
14070 type Response = ::fidl_next::wire::Result<
14071 'static,
14072 crate::wire::NodeAttributes2<'static>,
14073 ::fidl_next::wire::fuchsia::Status,
14074 >;
14075 }
14076
14077 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
14078 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14079
14080 fn respond(response: ___R) -> Self::Output {
14081 ::core::result::Result::Ok(response)
14082 }
14083 }
14084
14085 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
14086 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14087
14088 fn respond_err(response: ___R) -> Self::Output {
14089 ::core::result::Result::Err(response)
14090 }
14091 }
14092
14093 pub struct UpdateAttributes;
14094
14095 impl ::fidl_next::Method for UpdateAttributes {
14096 const ORDINAL: u64 = 3677402239314018056;
14097 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14098 ::fidl_next::protocol::Flexibility::Strict;
14099
14100 type Protocol = crate::File;
14101
14102 type Request = crate::wire::MutableNodeAttributes<'static>;
14103 }
14104
14105 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
14106 type Response = ::fidl_next::wire::Result<
14107 'static,
14108 crate::wire::NodeUpdateAttributesResponse,
14109 ::fidl_next::wire::fuchsia::Status,
14110 >;
14111 }
14112
14113 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
14114 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14115
14116 fn respond(response: ___R) -> Self::Output {
14117 ::core::result::Result::Ok(response)
14118 }
14119 }
14120
14121 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
14122 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14123
14124 fn respond_err(response: ___R) -> Self::Output {
14125 ::core::result::Result::Err(response)
14126 }
14127 }
14128
14129 pub struct Sync;
14130
14131 impl ::fidl_next::Method for Sync {
14132 const ORDINAL: u64 = 3196473584242777161;
14133 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14134 ::fidl_next::protocol::Flexibility::Strict;
14135
14136 type Protocol = crate::File;
14137
14138 type Request = ::fidl_next::wire::EmptyMessageBody;
14139 }
14140
14141 impl ::fidl_next::TwoWayMethod for Sync {
14142 type Response = ::fidl_next::wire::Result<
14143 'static,
14144 crate::wire::NodeSyncResponse,
14145 ::fidl_next::wire::fuchsia::Status,
14146 >;
14147 }
14148
14149 impl<___R> ::fidl_next::Respond<___R> for Sync {
14150 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14151
14152 fn respond(response: ___R) -> Self::Output {
14153 ::core::result::Result::Ok(response)
14154 }
14155 }
14156
14157 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
14158 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14159
14160 fn respond_err(response: ___R) -> Self::Output {
14161 ::core::result::Result::Err(response)
14162 }
14163 }
14164
14165 pub struct ListExtendedAttributes;
14166
14167 impl ::fidl_next::Method for ListExtendedAttributes {
14168 const ORDINAL: u64 = 5431626189872037072;
14169 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14170 ::fidl_next::protocol::Flexibility::Strict;
14171
14172 type Protocol = crate::File;
14173
14174 type Request = crate::wire::NodeListExtendedAttributesRequest;
14175 }
14176
14177 pub struct GetExtendedAttribute;
14178
14179 impl ::fidl_next::Method for GetExtendedAttribute {
14180 const ORDINAL: u64 = 5043930208506967771;
14181 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14182 ::fidl_next::protocol::Flexibility::Strict;
14183
14184 type Protocol = crate::File;
14185
14186 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
14187 }
14188
14189 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
14190 type Response = ::fidl_next::wire::Result<
14191 'static,
14192 crate::wire::ExtendedAttributeValue<'static>,
14193 ::fidl_next::wire::fuchsia::Status,
14194 >;
14195 }
14196
14197 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
14198 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14199
14200 fn respond(response: ___R) -> Self::Output {
14201 ::core::result::Result::Ok(response)
14202 }
14203 }
14204
14205 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
14206 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14207
14208 fn respond_err(response: ___R) -> Self::Output {
14209 ::core::result::Result::Err(response)
14210 }
14211 }
14212
14213 pub struct SetExtendedAttribute;
14214
14215 impl ::fidl_next::Method for SetExtendedAttribute {
14216 const ORDINAL: u64 = 5374223046099989052;
14217 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14218 ::fidl_next::protocol::Flexibility::Strict;
14219
14220 type Protocol = crate::File;
14221
14222 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
14223 }
14224
14225 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
14226 type Response = ::fidl_next::wire::Result<
14227 'static,
14228 crate::wire::NodeSetExtendedAttributeResponse,
14229 ::fidl_next::wire::fuchsia::Status,
14230 >;
14231 }
14232
14233 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
14234 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14235
14236 fn respond(response: ___R) -> Self::Output {
14237 ::core::result::Result::Ok(response)
14238 }
14239 }
14240
14241 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
14242 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14243
14244 fn respond_err(response: ___R) -> Self::Output {
14245 ::core::result::Result::Err(response)
14246 }
14247 }
14248
14249 pub struct RemoveExtendedAttribute;
14250
14251 impl ::fidl_next::Method for RemoveExtendedAttribute {
14252 const ORDINAL: u64 = 8794297771444732717;
14253 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14254 ::fidl_next::protocol::Flexibility::Strict;
14255
14256 type Protocol = crate::File;
14257
14258 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
14259 }
14260
14261 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
14262 type Response = ::fidl_next::wire::Result<
14263 'static,
14264 crate::wire::NodeRemoveExtendedAttributeResponse,
14265 ::fidl_next::wire::fuchsia::Status,
14266 >;
14267 }
14268
14269 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
14270 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14271
14272 fn respond(response: ___R) -> Self::Output {
14273 ::core::result::Result::Ok(response)
14274 }
14275 }
14276
14277 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
14278 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14279
14280 fn respond_err(response: ___R) -> Self::Output {
14281 ::core::result::Result::Err(response)
14282 }
14283 }
14284
14285 pub struct Read;
14286
14287 impl ::fidl_next::Method for Read {
14288 const ORDINAL: u64 = 395825947633028830;
14289 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14290 ::fidl_next::protocol::Flexibility::Strict;
14291
14292 type Protocol = crate::File;
14293
14294 type Request = crate::wire::ReadableReadRequest;
14295 }
14296
14297 impl ::fidl_next::TwoWayMethod for Read {
14298 type Response = ::fidl_next::wire::Result<
14299 'static,
14300 crate::wire::ReadableReadResponse<'static>,
14301 ::fidl_next::wire::fuchsia::Status,
14302 >;
14303 }
14304
14305 impl<___R> ::fidl_next::Respond<___R> for Read {
14306 type Output = ::core::result::Result<
14307 crate::generic::ReadableReadResponse<___R>,
14308 ::fidl_next::never::Never,
14309 >;
14310
14311 fn respond(response: ___R) -> Self::Output {
14312 ::core::result::Result::Ok(crate::generic::ReadableReadResponse { data: response })
14313 }
14314 }
14315
14316 impl<___R> ::fidl_next::RespondErr<___R> for Read {
14317 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14318
14319 fn respond_err(response: ___R) -> Self::Output {
14320 ::core::result::Result::Err(response)
14321 }
14322 }
14323
14324 pub struct Write;
14325
14326 impl ::fidl_next::Method for Write {
14327 const ORDINAL: u64 = 7651971425397809026;
14328 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14329 ::fidl_next::protocol::Flexibility::Strict;
14330
14331 type Protocol = crate::File;
14332
14333 type Request = crate::wire::WritableWriteRequest<'static>;
14334 }
14335
14336 impl ::fidl_next::TwoWayMethod for Write {
14337 type Response = ::fidl_next::wire::Result<
14338 'static,
14339 crate::wire::WritableWriteResponse,
14340 ::fidl_next::wire::fuchsia::Status,
14341 >;
14342 }
14343
14344 impl<___R> ::fidl_next::Respond<___R> for Write {
14345 type Output = ::core::result::Result<
14346 crate::generic::WritableWriteResponse<___R>,
14347 ::fidl_next::never::Never,
14348 >;
14349
14350 fn respond(response: ___R) -> Self::Output {
14351 ::core::result::Result::Ok(crate::generic::WritableWriteResponse {
14352 actual_count: response,
14353 })
14354 }
14355 }
14356
14357 impl<___R> ::fidl_next::RespondErr<___R> for Write {
14358 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14359
14360 fn respond_err(response: ___R) -> Self::Output {
14361 ::core::result::Result::Err(response)
14362 }
14363 }
14364
14365 pub struct Describe;
14366
14367 impl ::fidl_next::Method for Describe {
14368 const ORDINAL: u64 = 7545125870053689020;
14369 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14370 ::fidl_next::protocol::Flexibility::Strict;
14371
14372 type Protocol = crate::File;
14373
14374 type Request = ::fidl_next::wire::EmptyMessageBody;
14375 }
14376
14377 impl ::fidl_next::TwoWayMethod for Describe {
14378 type Response = ::fidl_next::wire::Strict<crate::wire::FileInfo<'static>>;
14379 }
14380
14381 impl<___R> ::fidl_next::Respond<___R> for Describe {
14382 type Output = ::fidl_next::Strict<___R>;
14383
14384 fn respond(response: ___R) -> Self::Output {
14385 ::fidl_next::Strict(response)
14386 }
14387 }
14388
14389 pub struct Seek;
14390
14391 impl ::fidl_next::Method for Seek {
14392 const ORDINAL: u64 = 8649041485622956551;
14393 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14394 ::fidl_next::protocol::Flexibility::Strict;
14395
14396 type Protocol = crate::File;
14397
14398 type Request = crate::wire::FileSeekRequest;
14399 }
14400
14401 impl ::fidl_next::TwoWayMethod for Seek {
14402 type Response = ::fidl_next::wire::Result<
14403 'static,
14404 crate::wire::FileSeekResponse,
14405 ::fidl_next::wire::fuchsia::Status,
14406 >;
14407 }
14408
14409 impl<___R> ::fidl_next::Respond<___R> for Seek {
14410 type Output = ::core::result::Result<
14411 crate::generic::FileSeekResponse<___R>,
14412 ::fidl_next::never::Never,
14413 >;
14414
14415 fn respond(response: ___R) -> Self::Output {
14416 ::core::result::Result::Ok(crate::generic::FileSeekResponse {
14417 offset_from_start: response,
14418 })
14419 }
14420 }
14421
14422 impl<___R> ::fidl_next::RespondErr<___R> for Seek {
14423 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14424
14425 fn respond_err(response: ___R) -> Self::Output {
14426 ::core::result::Result::Err(response)
14427 }
14428 }
14429
14430 pub struct ReadAt;
14431
14432 impl ::fidl_next::Method for ReadAt {
14433 const ORDINAL: u64 = 1587416148701180478;
14434 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14435 ::fidl_next::protocol::Flexibility::Strict;
14436
14437 type Protocol = crate::File;
14438
14439 type Request = crate::wire::FileReadAtRequest;
14440 }
14441
14442 impl ::fidl_next::TwoWayMethod for ReadAt {
14443 type Response = ::fidl_next::wire::Result<
14444 'static,
14445 crate::wire::FileReadAtResponse<'static>,
14446 ::fidl_next::wire::fuchsia::Status,
14447 >;
14448 }
14449
14450 impl<___R> ::fidl_next::Respond<___R> for ReadAt {
14451 type Output = ::core::result::Result<
14452 crate::generic::FileReadAtResponse<___R>,
14453 ::fidl_next::never::Never,
14454 >;
14455
14456 fn respond(response: ___R) -> Self::Output {
14457 ::core::result::Result::Ok(crate::generic::FileReadAtResponse { data: response })
14458 }
14459 }
14460
14461 impl<___R> ::fidl_next::RespondErr<___R> for ReadAt {
14462 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14463
14464 fn respond_err(response: ___R) -> Self::Output {
14465 ::core::result::Result::Err(response)
14466 }
14467 }
14468
14469 pub struct WriteAt;
14470
14471 impl ::fidl_next::Method for WriteAt {
14472 const ORDINAL: u64 = 8736683935131400491;
14473 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14474 ::fidl_next::protocol::Flexibility::Strict;
14475
14476 type Protocol = crate::File;
14477
14478 type Request = crate::wire::FileWriteAtRequest<'static>;
14479 }
14480
14481 impl ::fidl_next::TwoWayMethod for WriteAt {
14482 type Response = ::fidl_next::wire::Result<
14483 'static,
14484 crate::wire::FileWriteAtResponse,
14485 ::fidl_next::wire::fuchsia::Status,
14486 >;
14487 }
14488
14489 impl<___R> ::fidl_next::Respond<___R> for WriteAt {
14490 type Output = ::core::result::Result<
14491 crate::generic::FileWriteAtResponse<___R>,
14492 ::fidl_next::never::Never,
14493 >;
14494
14495 fn respond(response: ___R) -> Self::Output {
14496 ::core::result::Result::Ok(crate::generic::FileWriteAtResponse {
14497 actual_count: response,
14498 })
14499 }
14500 }
14501
14502 impl<___R> ::fidl_next::RespondErr<___R> for WriteAt {
14503 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14504
14505 fn respond_err(response: ___R) -> Self::Output {
14506 ::core::result::Result::Err(response)
14507 }
14508 }
14509
14510 pub struct Resize;
14511
14512 impl ::fidl_next::Method for Resize {
14513 const ORDINAL: u64 = 3134648685270758458;
14514 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14515 ::fidl_next::protocol::Flexibility::Strict;
14516
14517 type Protocol = crate::File;
14518
14519 type Request = crate::wire::FileResizeRequest;
14520 }
14521
14522 impl ::fidl_next::TwoWayMethod for Resize {
14523 type Response = ::fidl_next::wire::Result<
14524 'static,
14525 crate::wire::FileResizeResponse,
14526 ::fidl_next::wire::fuchsia::Status,
14527 >;
14528 }
14529
14530 impl<___R> ::fidl_next::Respond<___R> for Resize {
14531 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14532
14533 fn respond(response: ___R) -> Self::Output {
14534 ::core::result::Result::Ok(response)
14535 }
14536 }
14537
14538 impl<___R> ::fidl_next::RespondErr<___R> for Resize {
14539 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14540
14541 fn respond_err(response: ___R) -> Self::Output {
14542 ::core::result::Result::Err(response)
14543 }
14544 }
14545
14546 pub struct GetBackingMemory;
14547
14548 impl ::fidl_next::Method for GetBackingMemory {
14549 const ORDINAL: u64 = 46911652864194091;
14550 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14551 ::fidl_next::protocol::Flexibility::Strict;
14552
14553 type Protocol = crate::File;
14554
14555 type Request = crate::wire::FileGetBackingMemoryRequest;
14556 }
14557
14558 impl ::fidl_next::TwoWayMethod for GetBackingMemory {
14559 type Response = ::fidl_next::wire::Result<
14560 'static,
14561 crate::wire::FileGetBackingMemoryResponse,
14562 ::fidl_next::wire::fuchsia::Status,
14563 >;
14564 }
14565
14566 impl<___R> ::fidl_next::Respond<___R> for GetBackingMemory {
14567 type Output = ::core::result::Result<
14568 crate::generic::FileGetBackingMemoryResponse<___R>,
14569 ::fidl_next::never::Never,
14570 >;
14571
14572 fn respond(response: ___R) -> Self::Output {
14573 ::core::result::Result::Ok(crate::generic::FileGetBackingMemoryResponse {
14574 vmo: response,
14575 })
14576 }
14577 }
14578
14579 impl<___R> ::fidl_next::RespondErr<___R> for GetBackingMemory {
14580 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14581
14582 fn respond_err(response: ___R) -> Self::Output {
14583 ::core::result::Result::Err(response)
14584 }
14585 }
14586
14587 pub struct Allocate;
14588
14589 impl ::fidl_next::Method for Allocate {
14590 const ORDINAL: u64 = 8645235848064269614;
14591 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14592 ::fidl_next::protocol::Flexibility::Flexible;
14593
14594 type Protocol = crate::File;
14595
14596 type Request = crate::wire::FileAllocateRequest;
14597 }
14598
14599 impl ::fidl_next::TwoWayMethod for Allocate {
14600 type Response = ::fidl_next::wire::Result<
14601 'static,
14602 crate::wire::FileAllocateResponse,
14603 ::fidl_next::wire::fuchsia::Status,
14604 >;
14605 }
14606
14607 impl<___R> ::fidl_next::Respond<___R> for Allocate {
14608 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14609
14610 fn respond(response: ___R) -> Self::Output {
14611 ::core::result::Result::Ok(response)
14612 }
14613 }
14614
14615 impl<___R> ::fidl_next::RespondErr<___R> for Allocate {
14616 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14617
14618 fn respond_err(response: ___R) -> Self::Output {
14619 ::core::result::Result::Err(response)
14620 }
14621 }
14622
14623 pub struct EnableVerity;
14624
14625 impl ::fidl_next::Method for EnableVerity {
14626 const ORDINAL: u64 = 3189145313204943035;
14627 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14628 ::fidl_next::protocol::Flexibility::Flexible;
14629
14630 type Protocol = crate::File;
14631
14632 type Request = crate::wire::FileEnableVerityRequest<'static>;
14633 }
14634
14635 impl ::fidl_next::TwoWayMethod for EnableVerity {
14636 type Response = ::fidl_next::wire::Result<
14637 'static,
14638 crate::wire::FileEnableVerityResponse,
14639 ::fidl_next::wire::fuchsia::Status,
14640 >;
14641 }
14642
14643 impl<___R> ::fidl_next::Respond<___R> for EnableVerity {
14644 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14645
14646 fn respond(response: ___R) -> Self::Output {
14647 ::core::result::Result::Ok(response)
14648 }
14649 }
14650
14651 impl<___R> ::fidl_next::RespondErr<___R> for EnableVerity {
14652 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14653
14654 fn respond_err(response: ___R) -> Self::Output {
14655 ::core::result::Result::Err(response)
14656 }
14657 }
14658
14659 mod ___detail {
14660 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::File
14661 where
14662 ___T: ::fidl_next::Transport,
14663 {
14664 type Client = FileClient<___T>;
14665 type Server = FileServer<___T>;
14666 }
14667
14668 #[repr(transparent)]
14670 pub struct FileClient<___T: ::fidl_next::Transport> {
14671 #[allow(dead_code)]
14672 client: ::fidl_next::protocol::Client<___T>,
14673 }
14674
14675 impl<___T> FileClient<___T>
14676 where
14677 ___T: ::fidl_next::Transport,
14678 {
14679 #[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"]
14680 pub fn advisory_lock(
14681 &self,
14682
14683 request: impl ::fidl_next::Encode<
14684 crate::wire::AdvisoryLockRequest<'static>,
14685 <___T as ::fidl_next::Transport>::SendBuffer,
14686 >,
14687 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
14688 where
14689 <___T as ::fidl_next::Transport>::SendBuffer:
14690 ::fidl_next::encoder::InternalHandleEncoder,
14691 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14692 {
14693 self.advisory_lock_with(crate::generic::AdvisoryLockingAdvisoryLockRequest {
14694 request,
14695 })
14696 }
14697
14698 #[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"]
14699 pub fn advisory_lock_with<___R>(
14700 &self,
14701 request: ___R,
14702 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
14703 where
14704 ___R: ::fidl_next::Encode<
14705 crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
14706 <___T as ::fidl_next::Transport>::SendBuffer,
14707 >,
14708 {
14709 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14710 7992130864415541162,
14711 <super::AdvisoryLock as ::fidl_next::Method>::FLEXIBILITY,
14712 request,
14713 ))
14714 }
14715
14716 #[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"]
14717 pub fn link_into(
14718 &self,
14719
14720 dst_parent_token: impl ::fidl_next::Encode<
14721 ::fdomain_client::fidl_next::wire::Handle,
14722 <___T as ::fidl_next::Transport>::SendBuffer,
14723 >,
14724
14725 dst: impl ::fidl_next::Encode<
14726 ::fidl_next::wire::String<'static>,
14727 <___T as ::fidl_next::Transport>::SendBuffer,
14728 >,
14729 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
14730 where
14731 <___T as ::fidl_next::Transport>::SendBuffer:
14732 ::fidl_next::encoder::InternalHandleEncoder,
14733 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14734 <___T as ::fidl_next::Transport>::SendBuffer:
14735 ::fdomain_client::fidl_next::HandleEncoder,
14736 {
14737 self.link_into_with(crate::generic::LinkableLinkIntoRequest {
14738 dst_parent_token,
14739
14740 dst,
14741 })
14742 }
14743
14744 #[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"]
14745 pub fn link_into_with<___R>(
14746 &self,
14747 request: ___R,
14748 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
14749 where
14750 ___R: ::fidl_next::Encode<
14751 crate::wire::LinkableLinkIntoRequest<'static>,
14752 <___T as ::fidl_next::Transport>::SendBuffer,
14753 >,
14754 {
14755 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14756 6121399674497678964,
14757 <super::LinkInto as ::fidl_next::Method>::FLEXIBILITY,
14758 request,
14759 ))
14760 }
14761
14762 pub fn clone(
14763 &self,
14764
14765 request: impl ::fidl_next::Encode<
14766 ::fidl_next::ServerEnd<
14767 ::fdomain_next_fuchsia_unknown::Cloneable,
14768 ::fdomain_client::fidl_next::wire::Handle,
14769 >,
14770 <___T as ::fidl_next::Transport>::SendBuffer,
14771 >,
14772 ) -> ::fidl_next::SendFuture<'_, ___T>
14773 where
14774 <___T as ::fidl_next::Transport>::SendBuffer:
14775 ::fidl_next::encoder::InternalHandleEncoder,
14776 <___T as ::fidl_next::Transport>::SendBuffer:
14777 ::fdomain_client::fidl_next::HandleEncoder,
14778 {
14779 self.clone_with(::fdomain_next_fuchsia_unknown::generic::CloneableCloneRequest {
14780 request,
14781 })
14782 }
14783
14784 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
14785 where
14786 ___R: ::fidl_next::Encode<
14787 ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest,
14788 <___T as ::fidl_next::Transport>::SendBuffer,
14789 >,
14790 {
14791 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
14792 2366825959783828089,
14793 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
14794 request,
14795 ))
14796 }
14797
14798 #[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"]
14799 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
14800 ::fidl_next::TwoWayFuture::from_untyped(
14801 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14802 6540867515453498750,
14803 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
14804 (),
14805 ),
14806 )
14807 }
14808
14809 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
14810 ::fidl_next::TwoWayFuture::from_untyped(
14811 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14812 2763219980499352582,
14813 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
14814 (),
14815 ),
14816 )
14817 }
14818
14819 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
14820 pub fn deprecated_get_attr(
14821 &self,
14822 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
14823 ::fidl_next::TwoWayFuture::from_untyped(
14824 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14825 8689798978500614909,
14826 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
14827 (),
14828 ),
14829 )
14830 }
14831
14832 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
14833 pub fn deprecated_set_attr(
14834 &self,
14835
14836 flags: impl ::fidl_next::Encode<
14837 crate::wire::NodeAttributeFlags,
14838 <___T as ::fidl_next::Transport>::SendBuffer,
14839 >,
14840
14841 attributes: impl ::fidl_next::Encode<
14842 crate::wire::NodeAttributes,
14843 <___T as ::fidl_next::Transport>::SendBuffer,
14844 >,
14845 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
14846 where
14847 <___T as ::fidl_next::Transport>::SendBuffer:
14848 ::fidl_next::encoder::InternalHandleEncoder,
14849 {
14850 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
14851 flags,
14852
14853 attributes,
14854 })
14855 }
14856
14857 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
14858 pub fn deprecated_set_attr_with<___R>(
14859 &self,
14860 request: ___R,
14861 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
14862 where
14863 ___R: ::fidl_next::Encode<
14864 crate::wire::NodeDeprecatedSetAttrRequest,
14865 <___T as ::fidl_next::Transport>::SendBuffer,
14866 >,
14867 {
14868 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14869 4721673413776871238,
14870 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
14871 request,
14872 ))
14873 }
14874
14875 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
14876 pub fn deprecated_get_flags(
14877 &self,
14878 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
14879 ::fidl_next::TwoWayFuture::from_untyped(
14880 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14881 6595803110182632097,
14882 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
14883 (),
14884 ),
14885 )
14886 }
14887
14888 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
14889 pub fn deprecated_set_flags(
14890 &self,
14891
14892 flags: impl ::fidl_next::Encode<
14893 crate::wire::OpenFlags,
14894 <___T as ::fidl_next::Transport>::SendBuffer,
14895 >,
14896 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
14897 where
14898 <___T as ::fidl_next::Transport>::SendBuffer:
14899 ::fidl_next::encoder::InternalHandleEncoder,
14900 {
14901 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
14902 flags,
14903 })
14904 }
14905
14906 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
14907 pub fn deprecated_set_flags_with<___R>(
14908 &self,
14909 request: ___R,
14910 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
14911 where
14912 ___R: ::fidl_next::Encode<
14913 crate::wire::NodeDeprecatedSetFlagsRequest,
14914 <___T as ::fidl_next::Transport>::SendBuffer,
14915 >,
14916 {
14917 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14918 5950864159036794675,
14919 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
14920 request,
14921 ))
14922 }
14923
14924 #[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"]
14925 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
14926 ::fidl_next::TwoWayFuture::from_untyped(
14927 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14928 105530239381466147,
14929 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
14930 (),
14931 ),
14932 )
14933 }
14934
14935 #[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"]
14936 pub fn set_flags(
14937 &self,
14938
14939 flags: impl ::fidl_next::Encode<
14940 crate::wire::Flags,
14941 <___T as ::fidl_next::Transport>::SendBuffer,
14942 >,
14943 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
14944 where
14945 <___T as ::fidl_next::Transport>::SendBuffer:
14946 ::fidl_next::encoder::InternalHandleEncoder,
14947 {
14948 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
14949 }
14950
14951 #[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"]
14952 pub fn set_flags_with<___R>(
14953 &self,
14954 request: ___R,
14955 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
14956 where
14957 ___R: ::fidl_next::Encode<
14958 crate::wire::NodeSetFlagsRequest,
14959 <___T as ::fidl_next::Transport>::SendBuffer,
14960 >,
14961 {
14962 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14963 6172186066099445416,
14964 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
14965 request,
14966 ))
14967 }
14968
14969 #[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"]
14970 pub fn query_filesystem(
14971 &self,
14972 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
14973 ::fidl_next::TwoWayFuture::from_untyped(
14974 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14975 8013111122914313744,
14976 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
14977 (),
14978 ),
14979 )
14980 }
14981
14982 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
14983 pub fn get_token(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetToken, ___T> {
14984 ::fidl_next::TwoWayFuture::from_untyped(
14985 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14986 5788516050773961964,
14987 <super::GetToken as ::fidl_next::Method>::FLEXIBILITY,
14988 (),
14989 ),
14990 )
14991 }
14992
14993 #[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"]
14994 pub fn get_attributes(
14995 &self,
14996
14997 query: impl ::fidl_next::Encode<
14998 crate::wire::NodeAttributesQuery,
14999 <___T as ::fidl_next::Transport>::SendBuffer,
15000 >,
15001 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
15002 where
15003 <___T as ::fidl_next::Transport>::SendBuffer:
15004 ::fidl_next::encoder::InternalHandleEncoder,
15005 {
15006 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
15007 }
15008
15009 #[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"]
15010 pub fn get_attributes_with<___R>(
15011 &self,
15012 request: ___R,
15013 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
15014 where
15015 ___R: ::fidl_next::Encode<
15016 crate::wire::NodeGetAttributesRequest,
15017 <___T as ::fidl_next::Transport>::SendBuffer,
15018 >,
15019 {
15020 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15021 4414537700416816443,
15022 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
15023 request,
15024 ))
15025 }
15026
15027 #[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"]
15028 pub fn update_attributes_with<___R>(
15029 &self,
15030 request: ___R,
15031 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
15032 where
15033 ___R: ::fidl_next::Encode<
15034 crate::wire::MutableNodeAttributes<'static>,
15035 <___T as ::fidl_next::Transport>::SendBuffer,
15036 >,
15037 {
15038 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15039 3677402239314018056,
15040 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
15041 request,
15042 ))
15043 }
15044
15045 #[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"]
15046 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
15047 ::fidl_next::TwoWayFuture::from_untyped(
15048 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
15049 3196473584242777161,
15050 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
15051 (),
15052 ),
15053 )
15054 }
15055
15056 #[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.READ_BYTES`] right.\n"]
15057 pub fn list_extended_attributes(
15058 &self,
15059
15060 iterator: impl ::fidl_next::Encode<
15061 ::fidl_next::ServerEnd<
15062 crate::ExtendedAttributeIterator,
15063 ::fdomain_client::fidl_next::wire::Handle,
15064 >,
15065 <___T as ::fidl_next::Transport>::SendBuffer,
15066 >,
15067 ) -> ::fidl_next::SendFuture<'_, ___T>
15068 where
15069 <___T as ::fidl_next::Transport>::SendBuffer:
15070 ::fidl_next::encoder::InternalHandleEncoder,
15071 <___T as ::fidl_next::Transport>::SendBuffer:
15072 ::fdomain_client::fidl_next::HandleEncoder,
15073 {
15074 self.list_extended_attributes_with(
15075 crate::generic::NodeListExtendedAttributesRequest { iterator },
15076 )
15077 }
15078
15079 #[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.READ_BYTES`] right.\n"]
15080 pub fn list_extended_attributes_with<___R>(
15081 &self,
15082 request: ___R,
15083 ) -> ::fidl_next::SendFuture<'_, ___T>
15084 where
15085 ___R: ::fidl_next::Encode<
15086 crate::wire::NodeListExtendedAttributesRequest,
15087 <___T as ::fidl_next::Transport>::SendBuffer,
15088 >,
15089 {
15090 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
15091 5431626189872037072,
15092 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
15093 request,
15094 ))
15095 }
15096
15097 #[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.READ_BYTES`] right.\n"]
15098 pub fn get_extended_attribute(
15099 &self,
15100
15101 name: impl ::fidl_next::Encode<
15102 ::fidl_next::wire::Vector<'static, u8>,
15103 <___T as ::fidl_next::Transport>::SendBuffer,
15104 >,
15105 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
15106 where
15107 <___T as ::fidl_next::Transport>::SendBuffer:
15108 ::fidl_next::encoder::InternalHandleEncoder,
15109 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
15110 {
15111 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
15112 name,
15113 })
15114 }
15115
15116 #[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.READ_BYTES`] right.\n"]
15117 pub fn get_extended_attribute_with<___R>(
15118 &self,
15119 request: ___R,
15120 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
15121 where
15122 ___R: ::fidl_next::Encode<
15123 crate::wire::NodeGetExtendedAttributeRequest<'static>,
15124 <___T as ::fidl_next::Transport>::SendBuffer,
15125 >,
15126 {
15127 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15128 5043930208506967771,
15129 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
15130 request,
15131 ))
15132 }
15133
15134 #[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.WRITE_BYTES`] right.\n"]
15135 pub fn set_extended_attribute(
15136 &self,
15137
15138 name: impl ::fidl_next::Encode<
15139 ::fidl_next::wire::Vector<'static, u8>,
15140 <___T as ::fidl_next::Transport>::SendBuffer,
15141 >,
15142
15143 value: impl ::fidl_next::Encode<
15144 crate::wire::ExtendedAttributeValue<'static>,
15145 <___T as ::fidl_next::Transport>::SendBuffer,
15146 >,
15147
15148 mode: impl ::fidl_next::Encode<
15149 crate::wire::SetExtendedAttributeMode,
15150 <___T as ::fidl_next::Transport>::SendBuffer,
15151 >,
15152 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
15153 where
15154 <___T as ::fidl_next::Transport>::SendBuffer:
15155 ::fidl_next::encoder::InternalHandleEncoder,
15156 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
15157 <___T as ::fidl_next::Transport>::SendBuffer:
15158 ::fdomain_client::fidl_next::HandleEncoder,
15159 {
15160 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
15161 name,
15162
15163 value,
15164
15165 mode,
15166 })
15167 }
15168
15169 #[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.WRITE_BYTES`] right.\n"]
15170 pub fn set_extended_attribute_with<___R>(
15171 &self,
15172 request: ___R,
15173 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
15174 where
15175 ___R: ::fidl_next::Encode<
15176 crate::wire::NodeSetExtendedAttributeRequest<'static>,
15177 <___T as ::fidl_next::Transport>::SendBuffer,
15178 >,
15179 {
15180 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15181 5374223046099989052,
15182 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
15183 request,
15184 ))
15185 }
15186
15187 #[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.WRITE_BYTES`] right.\n"]
15188 pub fn remove_extended_attribute(
15189 &self,
15190
15191 name: impl ::fidl_next::Encode<
15192 ::fidl_next::wire::Vector<'static, u8>,
15193 <___T as ::fidl_next::Transport>::SendBuffer,
15194 >,
15195 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
15196 where
15197 <___T as ::fidl_next::Transport>::SendBuffer:
15198 ::fidl_next::encoder::InternalHandleEncoder,
15199 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
15200 {
15201 self.remove_extended_attribute_with(
15202 crate::generic::NodeRemoveExtendedAttributeRequest { name },
15203 )
15204 }
15205
15206 #[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.WRITE_BYTES`] right.\n"]
15207 pub fn remove_extended_attribute_with<___R>(
15208 &self,
15209 request: ___R,
15210 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
15211 where
15212 ___R: ::fidl_next::Encode<
15213 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
15214 <___T as ::fidl_next::Transport>::SendBuffer,
15215 >,
15216 {
15217 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15218 8794297771444732717,
15219 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
15220 request,
15221 ))
15222 }
15223
15224 #[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"]
15225 pub fn read(
15226 &self,
15227
15228 count: impl ::fidl_next::Encode<
15229 ::fidl_next::wire::Uint64,
15230 <___T as ::fidl_next::Transport>::SendBuffer,
15231 >,
15232 ) -> ::fidl_next::TwoWayFuture<'_, super::Read, ___T>
15233 where
15234 <___T as ::fidl_next::Transport>::SendBuffer:
15235 ::fidl_next::encoder::InternalHandleEncoder,
15236 {
15237 self.read_with(crate::generic::ReadableReadRequest { count })
15238 }
15239
15240 #[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"]
15241 pub fn read_with<___R>(
15242 &self,
15243 request: ___R,
15244 ) -> ::fidl_next::TwoWayFuture<'_, super::Read, ___T>
15245 where
15246 ___R: ::fidl_next::Encode<
15247 crate::wire::ReadableReadRequest,
15248 <___T as ::fidl_next::Transport>::SendBuffer,
15249 >,
15250 {
15251 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15252 395825947633028830,
15253 <super::Read as ::fidl_next::Method>::FLEXIBILITY,
15254 request,
15255 ))
15256 }
15257
15258 #[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"]
15259 pub fn write(
15260 &self,
15261
15262 data: impl ::fidl_next::Encode<
15263 ::fidl_next::wire::Vector<'static, u8>,
15264 <___T as ::fidl_next::Transport>::SendBuffer,
15265 >,
15266 ) -> ::fidl_next::TwoWayFuture<'_, super::Write, ___T>
15267 where
15268 <___T as ::fidl_next::Transport>::SendBuffer:
15269 ::fidl_next::encoder::InternalHandleEncoder,
15270 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
15271 {
15272 self.write_with(crate::generic::WritableWriteRequest { data })
15273 }
15274
15275 #[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"]
15276 pub fn write_with<___R>(
15277 &self,
15278 request: ___R,
15279 ) -> ::fidl_next::TwoWayFuture<'_, super::Write, ___T>
15280 where
15281 ___R: ::fidl_next::Encode<
15282 crate::wire::WritableWriteRequest<'static>,
15283 <___T as ::fidl_next::Transport>::SendBuffer,
15284 >,
15285 {
15286 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15287 7651971425397809026,
15288 <super::Write as ::fidl_next::Method>::FLEXIBILITY,
15289 request,
15290 ))
15291 }
15292
15293 pub fn describe(&self) -> ::fidl_next::TwoWayFuture<'_, super::Describe, ___T> {
15294 ::fidl_next::TwoWayFuture::from_untyped(
15295 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
15296 7545125870053689020,
15297 <super::Describe as ::fidl_next::Method>::FLEXIBILITY,
15298 (),
15299 ),
15300 )
15301 }
15302
15303 #[doc = " Moves the offset at which the next invocation of [`Read`] or [`Write`]\n will occur. The seek offset is specific to each file connection.\n\n + request `origin` the reference point where `offset` will be based on.\n + request `offset` the number of bytes to seek.\n - response `offset_from_start` the adjusted seek offset, from the start\n of the file.\n\n This method does not require any rights.\n"]
15304 pub fn seek(
15305 &self,
15306
15307 origin: impl ::fidl_next::Encode<
15308 crate::wire::SeekOrigin,
15309 <___T as ::fidl_next::Transport>::SendBuffer,
15310 >,
15311
15312 offset: impl ::fidl_next::Encode<
15313 ::fidl_next::wire::Int64,
15314 <___T as ::fidl_next::Transport>::SendBuffer,
15315 >,
15316 ) -> ::fidl_next::TwoWayFuture<'_, super::Seek, ___T>
15317 where
15318 <___T as ::fidl_next::Transport>::SendBuffer:
15319 ::fidl_next::encoder::InternalHandleEncoder,
15320 {
15321 self.seek_with(crate::generic::FileSeekRequest { origin, offset })
15322 }
15323
15324 #[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"]
15325 pub fn seek_with<___R>(
15326 &self,
15327 request: ___R,
15328 ) -> ::fidl_next::TwoWayFuture<'_, super::Seek, ___T>
15329 where
15330 ___R: ::fidl_next::Encode<
15331 crate::wire::FileSeekRequest,
15332 <___T as ::fidl_next::Transport>::SendBuffer,
15333 >,
15334 {
15335 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15336 8649041485622956551,
15337 <super::Seek as ::fidl_next::Method>::FLEXIBILITY,
15338 request,
15339 ))
15340 }
15341
15342 #[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"]
15343 pub fn read_at(
15344 &self,
15345
15346 count: impl ::fidl_next::Encode<
15347 ::fidl_next::wire::Uint64,
15348 <___T as ::fidl_next::Transport>::SendBuffer,
15349 >,
15350
15351 offset: impl ::fidl_next::Encode<
15352 ::fidl_next::wire::Uint64,
15353 <___T as ::fidl_next::Transport>::SendBuffer,
15354 >,
15355 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadAt, ___T>
15356 where
15357 <___T as ::fidl_next::Transport>::SendBuffer:
15358 ::fidl_next::encoder::InternalHandleEncoder,
15359 {
15360 self.read_at_with(crate::generic::FileReadAtRequest { count, offset })
15361 }
15362
15363 #[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"]
15364 pub fn read_at_with<___R>(
15365 &self,
15366 request: ___R,
15367 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadAt, ___T>
15368 where
15369 ___R: ::fidl_next::Encode<
15370 crate::wire::FileReadAtRequest,
15371 <___T as ::fidl_next::Transport>::SendBuffer,
15372 >,
15373 {
15374 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15375 1587416148701180478,
15376 <super::ReadAt as ::fidl_next::Method>::FLEXIBILITY,
15377 request,
15378 ))
15379 }
15380
15381 #[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"]
15382 pub fn write_at(
15383 &self,
15384
15385 data: impl ::fidl_next::Encode<
15386 ::fidl_next::wire::Vector<'static, u8>,
15387 <___T as ::fidl_next::Transport>::SendBuffer,
15388 >,
15389
15390 offset: impl ::fidl_next::Encode<
15391 ::fidl_next::wire::Uint64,
15392 <___T as ::fidl_next::Transport>::SendBuffer,
15393 >,
15394 ) -> ::fidl_next::TwoWayFuture<'_, super::WriteAt, ___T>
15395 where
15396 <___T as ::fidl_next::Transport>::SendBuffer:
15397 ::fidl_next::encoder::InternalHandleEncoder,
15398 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
15399 {
15400 self.write_at_with(crate::generic::FileWriteAtRequest { data, offset })
15401 }
15402
15403 #[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"]
15404 pub fn write_at_with<___R>(
15405 &self,
15406 request: ___R,
15407 ) -> ::fidl_next::TwoWayFuture<'_, super::WriteAt, ___T>
15408 where
15409 ___R: ::fidl_next::Encode<
15410 crate::wire::FileWriteAtRequest<'static>,
15411 <___T as ::fidl_next::Transport>::SendBuffer,
15412 >,
15413 {
15414 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15415 8736683935131400491,
15416 <super::WriteAt as ::fidl_next::Method>::FLEXIBILITY,
15417 request,
15418 ))
15419 }
15420
15421 #[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"]
15422 pub fn resize(
15423 &self,
15424
15425 length: impl ::fidl_next::Encode<
15426 ::fidl_next::wire::Uint64,
15427 <___T as ::fidl_next::Transport>::SendBuffer,
15428 >,
15429 ) -> ::fidl_next::TwoWayFuture<'_, super::Resize, ___T>
15430 where
15431 <___T as ::fidl_next::Transport>::SendBuffer:
15432 ::fidl_next::encoder::InternalHandleEncoder,
15433 {
15434 self.resize_with(crate::generic::FileResizeRequest { length })
15435 }
15436
15437 #[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"]
15438 pub fn resize_with<___R>(
15439 &self,
15440 request: ___R,
15441 ) -> ::fidl_next::TwoWayFuture<'_, super::Resize, ___T>
15442 where
15443 ___R: ::fidl_next::Encode<
15444 crate::wire::FileResizeRequest,
15445 <___T as ::fidl_next::Transport>::SendBuffer,
15446 >,
15447 {
15448 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15449 3134648685270758458,
15450 <super::Resize as ::fidl_next::Method>::FLEXIBILITY,
15451 request,
15452 ))
15453 }
15454
15455 #[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"]
15456 pub fn get_backing_memory(
15457 &self,
15458
15459 flags: impl ::fidl_next::Encode<
15460 crate::wire::VmoFlags,
15461 <___T as ::fidl_next::Transport>::SendBuffer,
15462 >,
15463 ) -> ::fidl_next::TwoWayFuture<'_, super::GetBackingMemory, ___T>
15464 where
15465 <___T as ::fidl_next::Transport>::SendBuffer:
15466 ::fidl_next::encoder::InternalHandleEncoder,
15467 {
15468 self.get_backing_memory_with(crate::generic::FileGetBackingMemoryRequest { flags })
15469 }
15470
15471 #[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"]
15472 pub fn get_backing_memory_with<___R>(
15473 &self,
15474 request: ___R,
15475 ) -> ::fidl_next::TwoWayFuture<'_, super::GetBackingMemory, ___T>
15476 where
15477 ___R: ::fidl_next::Encode<
15478 crate::wire::FileGetBackingMemoryRequest,
15479 <___T as ::fidl_next::Transport>::SendBuffer,
15480 >,
15481 {
15482 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15483 46911652864194091,
15484 <super::GetBackingMemory as ::fidl_next::Method>::FLEXIBILITY,
15485 request,
15486 ))
15487 }
15488
15489 #[doc = " Pre-allocate on-disk space for this file.\n"]
15490 pub fn allocate(
15491 &self,
15492
15493 offset: impl ::fidl_next::Encode<
15494 ::fidl_next::wire::Uint64,
15495 <___T as ::fidl_next::Transport>::SendBuffer,
15496 >,
15497
15498 length: impl ::fidl_next::Encode<
15499 ::fidl_next::wire::Uint64,
15500 <___T as ::fidl_next::Transport>::SendBuffer,
15501 >,
15502
15503 mode: impl ::fidl_next::Encode<
15504 crate::wire::AllocateMode,
15505 <___T as ::fidl_next::Transport>::SendBuffer,
15506 >,
15507 ) -> ::fidl_next::TwoWayFuture<'_, super::Allocate, ___T>
15508 where
15509 <___T as ::fidl_next::Transport>::SendBuffer:
15510 ::fidl_next::encoder::InternalHandleEncoder,
15511 <___T as ::fidl_next::Transport>::SendBuffer:
15512 ::fdomain_client::fidl_next::HandleEncoder,
15513 {
15514 self.allocate_with(crate::generic::FileAllocateRequest { offset, length, mode })
15515 }
15516
15517 #[doc = " Pre-allocate on-disk space for this file.\n"]
15518 pub fn allocate_with<___R>(
15519 &self,
15520 request: ___R,
15521 ) -> ::fidl_next::TwoWayFuture<'_, super::Allocate, ___T>
15522 where
15523 ___R: ::fidl_next::Encode<
15524 crate::wire::FileAllocateRequest,
15525 <___T as ::fidl_next::Transport>::SendBuffer,
15526 >,
15527 {
15528 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15529 8645235848064269614,
15530 <super::Allocate as ::fidl_next::Method>::FLEXIBILITY,
15531 request,
15532 ))
15533 }
15534
15535 #[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"]
15536 pub fn enable_verity(
15537 &self,
15538
15539 options: impl ::fidl_next::Encode<
15540 crate::wire::VerificationOptions<'static>,
15541 <___T as ::fidl_next::Transport>::SendBuffer,
15542 >,
15543 ) -> ::fidl_next::TwoWayFuture<'_, super::EnableVerity, ___T>
15544 where
15545 <___T as ::fidl_next::Transport>::SendBuffer:
15546 ::fidl_next::encoder::InternalHandleEncoder,
15547 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
15548 <___T as ::fidl_next::Transport>::SendBuffer:
15549 ::fdomain_client::fidl_next::HandleEncoder,
15550 {
15551 self.enable_verity_with(crate::generic::FileEnableVerityRequest { options })
15552 }
15553
15554 #[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"]
15555 pub fn enable_verity_with<___R>(
15556 &self,
15557 request: ___R,
15558 ) -> ::fidl_next::TwoWayFuture<'_, super::EnableVerity, ___T>
15559 where
15560 ___R: ::fidl_next::Encode<
15561 crate::wire::FileEnableVerityRequest<'static>,
15562 <___T as ::fidl_next::Transport>::SendBuffer,
15563 >,
15564 {
15565 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15566 3189145313204943035,
15567 <super::EnableVerity as ::fidl_next::Method>::FLEXIBILITY,
15568 request,
15569 ))
15570 }
15571 }
15572
15573 #[repr(transparent)]
15575 pub struct FileServer<___T: ::fidl_next::Transport> {
15576 server: ::fidl_next::protocol::Server<___T>,
15577 }
15578
15579 impl<___T> FileServer<___T>
15580 where
15581 ___T: ::fidl_next::Transport,
15582 {
15583 #[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"]
15584 pub fn on_open(
15585 &self,
15586
15587 s: impl ::fidl_next::Encode<
15588 ::fidl_next::wire::fuchsia::StatusResult,
15589 <___T as ::fidl_next::Transport>::SendBuffer,
15590 >,
15591
15592 info: impl ::fidl_next::Encode<
15593 crate::wire_optional::NodeInfoDeprecated<'static>,
15594 <___T as ::fidl_next::Transport>::SendBuffer,
15595 >,
15596 ) -> ::fidl_next::SendFuture<'_, ___T>
15597 where
15598 <___T as ::fidl_next::Transport>::SendBuffer:
15599 ::fidl_next::encoder::InternalHandleEncoder,
15600 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
15601 <___T as ::fidl_next::Transport>::SendBuffer:
15602 ::fdomain_client::fidl_next::HandleEncoder,
15603 {
15604 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
15605 }
15606
15607 #[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"]
15608
15609 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
15610 where
15611 ___R: ::fidl_next::Encode<
15612 <super::OnOpen as ::fidl_next::Method>::Request,
15613 <___T as ::fidl_next::Transport>::SendBuffer,
15614 >,
15615 {
15616 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
15617 9207534335756671346,
15618 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
15619 request,
15620 ))
15621 }
15622
15623 #[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"]
15624
15625 pub fn on_representation_with<___R>(
15626 &self,
15627 request: ___R,
15628 ) -> ::fidl_next::SendFuture<'_, ___T>
15629 where
15630 ___R: ::fidl_next::Encode<
15631 <super::OnRepresentation as ::fidl_next::Method>::Request,
15632 <___T as ::fidl_next::Transport>::SendBuffer,
15633 >,
15634 {
15635 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
15636 6679970090861613324,
15637 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
15638 request,
15639 ))
15640 }
15641 }
15642 }
15643}
15644
15645#[diagnostic::on_unimplemented(
15646 note = "If {Self} implements the non-local FileClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
15647)]
15648
15649pub trait FileLocalClientHandler<
15653 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
15654 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15655>
15656{
15657 #[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"]
15658 fn on_open(
15659 &mut self,
15660
15661 request: ::fidl_next::Request<file::OnOpen, ___T>,
15662 ) -> impl ::core::future::Future<Output = ()>;
15663
15664 #[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"]
15665 fn on_representation(
15666 &mut self,
15667
15668 request: ::fidl_next::Request<file::OnRepresentation, ___T>,
15669 ) -> impl ::core::future::Future<Output = ()>;
15670
15671 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
15672 ::core::future::ready(())
15673 }
15674}
15675
15676impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for File
15677where
15678 ___H: FileLocalClientHandler<___T>,
15679 ___T: ::fidl_next::Transport,
15680 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
15681 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15682 Constraint = (),
15683 >,
15684 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
15685 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15686 Constraint = (),
15687 >,
15688{
15689 async fn on_event(
15690 handler: &mut ___H,
15691 mut message: ::fidl_next::Message<___T>,
15692 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
15693 match *message.header().ordinal {
15694 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
15695 Ok(decoded) => {
15696 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
15697 Ok(())
15698 }
15699 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15700 ordinal: 9207534335756671346,
15701 error,
15702 }),
15703 },
15704
15705 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
15706 Ok(decoded) => {
15707 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
15708 Ok(())
15709 }
15710 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15711 ordinal: 6679970090861613324,
15712 error,
15713 }),
15714 },
15715
15716 ordinal => {
15717 handler.on_unknown_interaction(ordinal).await;
15718 if ::core::matches!(
15719 message.header().flexibility(),
15720 ::fidl_next::protocol::Flexibility::Strict
15721 ) {
15722 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15723 } else {
15724 Ok(())
15725 }
15726 }
15727 }
15728 }
15729}
15730
15731#[diagnostic::on_unimplemented(
15732 note = "If {Self} implements the non-local FileServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
15733)]
15734
15735pub trait FileLocalServerHandler<
15739 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
15740 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15741>
15742{
15743 #[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"]
15744 fn advisory_lock(
15745 &mut self,
15746
15747 request: ::fidl_next::Request<file::AdvisoryLock, ___T>,
15748
15749 responder: ::fidl_next::Responder<file::AdvisoryLock, ___T>,
15750 ) -> impl ::core::future::Future<Output = ()>;
15751
15752 #[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"]
15753 fn link_into(
15754 &mut self,
15755
15756 request: ::fidl_next::Request<file::LinkInto, ___T>,
15757
15758 responder: ::fidl_next::Responder<file::LinkInto, ___T>,
15759 ) -> impl ::core::future::Future<Output = ()>;
15760
15761 fn clone(
15762 &mut self,
15763
15764 request: ::fidl_next::Request<file::Clone, ___T>,
15765 ) -> impl ::core::future::Future<Output = ()>;
15766
15767 #[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"]
15768 fn close(
15769 &mut self,
15770
15771 responder: ::fidl_next::Responder<file::Close, ___T>,
15772 ) -> impl ::core::future::Future<Output = ()>;
15773
15774 fn query(
15775 &mut self,
15776
15777 responder: ::fidl_next::Responder<file::Query, ___T>,
15778 ) -> impl ::core::future::Future<Output = ()>;
15779
15780 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
15781 fn deprecated_get_attr(
15782 &mut self,
15783
15784 responder: ::fidl_next::Responder<file::DeprecatedGetAttr, ___T>,
15785 ) -> impl ::core::future::Future<Output = ()>;
15786
15787 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
15788 fn deprecated_set_attr(
15789 &mut self,
15790
15791 request: ::fidl_next::Request<file::DeprecatedSetAttr, ___T>,
15792
15793 responder: ::fidl_next::Responder<file::DeprecatedSetAttr, ___T>,
15794 ) -> impl ::core::future::Future<Output = ()>;
15795
15796 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
15797 fn deprecated_get_flags(
15798 &mut self,
15799
15800 responder: ::fidl_next::Responder<file::DeprecatedGetFlags, ___T>,
15801 ) -> impl ::core::future::Future<Output = ()>;
15802
15803 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
15804 fn deprecated_set_flags(
15805 &mut self,
15806
15807 request: ::fidl_next::Request<file::DeprecatedSetFlags, ___T>,
15808
15809 responder: ::fidl_next::Responder<file::DeprecatedSetFlags, ___T>,
15810 ) -> impl ::core::future::Future<Output = ()>;
15811
15812 #[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"]
15813 fn get_flags(
15814 &mut self,
15815
15816 responder: ::fidl_next::Responder<file::GetFlags, ___T>,
15817 ) -> impl ::core::future::Future<Output = ()>;
15818
15819 #[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"]
15820 fn set_flags(
15821 &mut self,
15822
15823 request: ::fidl_next::Request<file::SetFlags, ___T>,
15824
15825 responder: ::fidl_next::Responder<file::SetFlags, ___T>,
15826 ) -> impl ::core::future::Future<Output = ()>;
15827
15828 #[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"]
15829 fn query_filesystem(
15830 &mut self,
15831
15832 responder: ::fidl_next::Responder<file::QueryFilesystem, ___T>,
15833 ) -> impl ::core::future::Future<Output = ()>;
15834
15835 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
15836 fn get_token(
15837 &mut self,
15838
15839 responder: ::fidl_next::Responder<file::GetToken, ___T>,
15840 ) -> impl ::core::future::Future<Output = ()>;
15841
15842 #[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"]
15843 fn get_attributes(
15844 &mut self,
15845
15846 request: ::fidl_next::Request<file::GetAttributes, ___T>,
15847
15848 responder: ::fidl_next::Responder<file::GetAttributes, ___T>,
15849 ) -> impl ::core::future::Future<Output = ()>;
15850
15851 #[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"]
15852 fn update_attributes(
15853 &mut self,
15854
15855 request: ::fidl_next::Request<file::UpdateAttributes, ___T>,
15856
15857 responder: ::fidl_next::Responder<file::UpdateAttributes, ___T>,
15858 ) -> impl ::core::future::Future<Output = ()>;
15859
15860 #[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"]
15861 fn sync(
15862 &mut self,
15863
15864 responder: ::fidl_next::Responder<file::Sync, ___T>,
15865 ) -> impl ::core::future::Future<Output = ()>;
15866
15867 #[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.READ_BYTES`] right.\n"]
15868 fn list_extended_attributes(
15869 &mut self,
15870
15871 request: ::fidl_next::Request<file::ListExtendedAttributes, ___T>,
15872 ) -> impl ::core::future::Future<Output = ()>;
15873
15874 #[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.READ_BYTES`] right.\n"]
15875 fn get_extended_attribute(
15876 &mut self,
15877
15878 request: ::fidl_next::Request<file::GetExtendedAttribute, ___T>,
15879
15880 responder: ::fidl_next::Responder<file::GetExtendedAttribute, ___T>,
15881 ) -> impl ::core::future::Future<Output = ()>;
15882
15883 #[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.WRITE_BYTES`] right.\n"]
15884 fn set_extended_attribute(
15885 &mut self,
15886
15887 request: ::fidl_next::Request<file::SetExtendedAttribute, ___T>,
15888
15889 responder: ::fidl_next::Responder<file::SetExtendedAttribute, ___T>,
15890 ) -> impl ::core::future::Future<Output = ()>;
15891
15892 #[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.WRITE_BYTES`] right.\n"]
15893 fn remove_extended_attribute(
15894 &mut self,
15895
15896 request: ::fidl_next::Request<file::RemoveExtendedAttribute, ___T>,
15897
15898 responder: ::fidl_next::Responder<file::RemoveExtendedAttribute, ___T>,
15899 ) -> impl ::core::future::Future<Output = ()>;
15900
15901 #[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"]
15902 fn read(
15903 &mut self,
15904
15905 request: ::fidl_next::Request<file::Read, ___T>,
15906
15907 responder: ::fidl_next::Responder<file::Read, ___T>,
15908 ) -> impl ::core::future::Future<Output = ()>;
15909
15910 #[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"]
15911 fn write(
15912 &mut self,
15913
15914 request: ::fidl_next::Request<file::Write, ___T>,
15915
15916 responder: ::fidl_next::Responder<file::Write, ___T>,
15917 ) -> impl ::core::future::Future<Output = ()>;
15918
15919 fn describe(
15920 &mut self,
15921
15922 responder: ::fidl_next::Responder<file::Describe, ___T>,
15923 ) -> impl ::core::future::Future<Output = ()>;
15924
15925 #[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"]
15926 fn seek(
15927 &mut self,
15928
15929 request: ::fidl_next::Request<file::Seek, ___T>,
15930
15931 responder: ::fidl_next::Responder<file::Seek, ___T>,
15932 ) -> impl ::core::future::Future<Output = ()>;
15933
15934 #[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"]
15935 fn read_at(
15936 &mut self,
15937
15938 request: ::fidl_next::Request<file::ReadAt, ___T>,
15939
15940 responder: ::fidl_next::Responder<file::ReadAt, ___T>,
15941 ) -> impl ::core::future::Future<Output = ()>;
15942
15943 #[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"]
15944 fn write_at(
15945 &mut self,
15946
15947 request: ::fidl_next::Request<file::WriteAt, ___T>,
15948
15949 responder: ::fidl_next::Responder<file::WriteAt, ___T>,
15950 ) -> impl ::core::future::Future<Output = ()>;
15951
15952 #[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"]
15953 fn resize(
15954 &mut self,
15955
15956 request: ::fidl_next::Request<file::Resize, ___T>,
15957
15958 responder: ::fidl_next::Responder<file::Resize, ___T>,
15959 ) -> impl ::core::future::Future<Output = ()>;
15960
15961 #[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"]
15962 fn get_backing_memory(
15963 &mut self,
15964
15965 request: ::fidl_next::Request<file::GetBackingMemory, ___T>,
15966
15967 responder: ::fidl_next::Responder<file::GetBackingMemory, ___T>,
15968 ) -> impl ::core::future::Future<Output = ()>;
15969
15970 #[doc = " Pre-allocate on-disk space for this file.\n"]
15971 fn allocate(
15972 &mut self,
15973
15974 request: ::fidl_next::Request<file::Allocate, ___T>,
15975
15976 responder: ::fidl_next::Responder<file::Allocate, ___T>,
15977 ) -> impl ::core::future::Future<Output = ()>;
15978
15979 #[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"]
15980 fn enable_verity(
15981 &mut self,
15982
15983 request: ::fidl_next::Request<file::EnableVerity, ___T>,
15984
15985 responder: ::fidl_next::Responder<file::EnableVerity, ___T>,
15986 ) -> impl ::core::future::Future<Output = ()>;
15987
15988 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
15989 ::core::future::ready(())
15990 }
15991}
15992
15993impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for File
15994where
15995 ___H: FileLocalServerHandler<___T>,
15996 ___T: ::fidl_next::Transport,
15997 for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
15998 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15999 Constraint = (),
16000 >,
16001 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
16002 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16003 Constraint = (),
16004 >,
16005 for<'de> ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
16006 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16007 Constraint = (),
16008 >,
16009 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
16010 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16011 Constraint = (),
16012 >,
16013 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
16014 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16015 Constraint = (),
16016 >,
16017 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
16018 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16019 Constraint = (),
16020 >,
16021 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
16022 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16023 Constraint = (),
16024 >,
16025 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
16026 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16027 Constraint = (),
16028 >,
16029 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
16030 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16031 Constraint = (),
16032 >,
16033 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
16034 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16035 Constraint = (),
16036 >,
16037 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
16038 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16039 Constraint = (),
16040 >,
16041 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
16042 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16043 Constraint = (),
16044 >,
16045 for<'de> crate::wire::ReadableReadRequest: ::fidl_next::Decode<
16046 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16047 Constraint = (),
16048 >,
16049 for<'de> crate::wire::WritableWriteRequest<'de>: ::fidl_next::Decode<
16050 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16051 Constraint = (),
16052 >,
16053 for<'de> crate::wire::FileSeekRequest: ::fidl_next::Decode<
16054 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16055 Constraint = (),
16056 >,
16057 for<'de> crate::wire::FileReadAtRequest: ::fidl_next::Decode<
16058 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16059 Constraint = (),
16060 >,
16061 for<'de> crate::wire::FileWriteAtRequest<'de>: ::fidl_next::Decode<
16062 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16063 Constraint = (),
16064 >,
16065 for<'de> crate::wire::FileResizeRequest: ::fidl_next::Decode<
16066 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16067 Constraint = (),
16068 >,
16069 for<'de> crate::wire::FileGetBackingMemoryRequest: ::fidl_next::Decode<
16070 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16071 Constraint = (),
16072 >,
16073 for<'de> crate::wire::FileAllocateRequest: ::fidl_next::Decode<
16074 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16075 Constraint = (),
16076 >,
16077 for<'de> crate::wire::FileEnableVerityRequest<'de>: ::fidl_next::Decode<
16078 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16079 Constraint = (),
16080 >,
16081{
16082 async fn on_one_way(
16083 handler: &mut ___H,
16084 mut message: ::fidl_next::Message<___T>,
16085 ) -> ::core::result::Result<
16086 (),
16087 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16088 > {
16089 match *message.header().ordinal {
16090 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
16091 Ok(decoded) => {
16092 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
16093 Ok(())
16094 }
16095 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16096 ordinal: 2366825959783828089,
16097 error,
16098 }),
16099 },
16100
16101 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
16102 Ok(decoded) => {
16103 handler
16104 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
16105 .await;
16106 Ok(())
16107 }
16108 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16109 ordinal: 5431626189872037072,
16110 error,
16111 }),
16112 },
16113
16114 ordinal => {
16115 handler.on_unknown_interaction(ordinal).await;
16116 if ::core::matches!(
16117 message.header().flexibility(),
16118 ::fidl_next::protocol::Flexibility::Strict
16119 ) {
16120 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16121 } else {
16122 Ok(())
16123 }
16124 }
16125 }
16126 }
16127
16128 async fn on_two_way(
16129 handler: &mut ___H,
16130 mut message: ::fidl_next::Message<___T>,
16131 responder: ::fidl_next::protocol::Responder<___T>,
16132 ) -> ::core::result::Result<
16133 (),
16134 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16135 > {
16136 match *message.header().ordinal {
16137 7992130864415541162 => {
16138 let responder = ::fidl_next::Responder::from_untyped(responder);
16139
16140 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16141 Ok(decoded) => {
16142 handler
16143 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
16144 .await;
16145 Ok(())
16146 }
16147 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16148 ordinal: 7992130864415541162,
16149 error,
16150 }),
16151 }
16152 }
16153
16154 6121399674497678964 => {
16155 let responder = ::fidl_next::Responder::from_untyped(responder);
16156
16157 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16158 Ok(decoded) => {
16159 handler
16160 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
16161 .await;
16162 Ok(())
16163 }
16164 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16165 ordinal: 6121399674497678964,
16166 error,
16167 }),
16168 }
16169 }
16170
16171 6540867515453498750 => {
16172 let responder = ::fidl_next::Responder::from_untyped(responder);
16173
16174 handler.close(responder).await;
16175 Ok(())
16176 }
16177
16178 2763219980499352582 => {
16179 let responder = ::fidl_next::Responder::from_untyped(responder);
16180
16181 handler.query(responder).await;
16182 Ok(())
16183 }
16184
16185 8689798978500614909 => {
16186 let responder = ::fidl_next::Responder::from_untyped(responder);
16187
16188 handler.deprecated_get_attr(responder).await;
16189 Ok(())
16190 }
16191
16192 4721673413776871238 => {
16193 let responder = ::fidl_next::Responder::from_untyped(responder);
16194
16195 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16196 Ok(decoded) => {
16197 handler
16198 .deprecated_set_attr(
16199 ::fidl_next::Request::from_decoded(decoded),
16200 responder,
16201 )
16202 .await;
16203 Ok(())
16204 }
16205 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16206 ordinal: 4721673413776871238,
16207 error,
16208 }),
16209 }
16210 }
16211
16212 6595803110182632097 => {
16213 let responder = ::fidl_next::Responder::from_untyped(responder);
16214
16215 handler.deprecated_get_flags(responder).await;
16216 Ok(())
16217 }
16218
16219 5950864159036794675 => {
16220 let responder = ::fidl_next::Responder::from_untyped(responder);
16221
16222 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16223 Ok(decoded) => {
16224 handler
16225 .deprecated_set_flags(
16226 ::fidl_next::Request::from_decoded(decoded),
16227 responder,
16228 )
16229 .await;
16230 Ok(())
16231 }
16232 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16233 ordinal: 5950864159036794675,
16234 error,
16235 }),
16236 }
16237 }
16238
16239 105530239381466147 => {
16240 let responder = ::fidl_next::Responder::from_untyped(responder);
16241
16242 handler.get_flags(responder).await;
16243 Ok(())
16244 }
16245
16246 6172186066099445416 => {
16247 let responder = ::fidl_next::Responder::from_untyped(responder);
16248
16249 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16250 Ok(decoded) => {
16251 handler
16252 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
16253 .await;
16254 Ok(())
16255 }
16256 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16257 ordinal: 6172186066099445416,
16258 error,
16259 }),
16260 }
16261 }
16262
16263 8013111122914313744 => {
16264 let responder = ::fidl_next::Responder::from_untyped(responder);
16265
16266 handler.query_filesystem(responder).await;
16267 Ok(())
16268 }
16269
16270 5788516050773961964 => {
16271 let responder = ::fidl_next::Responder::from_untyped(responder);
16272
16273 handler.get_token(responder).await;
16274 Ok(())
16275 }
16276
16277 4414537700416816443 => {
16278 let responder = ::fidl_next::Responder::from_untyped(responder);
16279
16280 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16281 Ok(decoded) => {
16282 handler
16283 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
16284 .await;
16285 Ok(())
16286 }
16287 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16288 ordinal: 4414537700416816443,
16289 error,
16290 }),
16291 }
16292 }
16293
16294 3677402239314018056 => {
16295 let responder = ::fidl_next::Responder::from_untyped(responder);
16296
16297 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16298 Ok(decoded) => {
16299 handler
16300 .update_attributes(
16301 ::fidl_next::Request::from_decoded(decoded),
16302 responder,
16303 )
16304 .await;
16305 Ok(())
16306 }
16307 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16308 ordinal: 3677402239314018056,
16309 error,
16310 }),
16311 }
16312 }
16313
16314 3196473584242777161 => {
16315 let responder = ::fidl_next::Responder::from_untyped(responder);
16316
16317 handler.sync(responder).await;
16318 Ok(())
16319 }
16320
16321 5043930208506967771 => {
16322 let responder = ::fidl_next::Responder::from_untyped(responder);
16323
16324 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16325 Ok(decoded) => {
16326 handler
16327 .get_extended_attribute(
16328 ::fidl_next::Request::from_decoded(decoded),
16329 responder,
16330 )
16331 .await;
16332 Ok(())
16333 }
16334 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16335 ordinal: 5043930208506967771,
16336 error,
16337 }),
16338 }
16339 }
16340
16341 5374223046099989052 => {
16342 let responder = ::fidl_next::Responder::from_untyped(responder);
16343
16344 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16345 Ok(decoded) => {
16346 handler
16347 .set_extended_attribute(
16348 ::fidl_next::Request::from_decoded(decoded),
16349 responder,
16350 )
16351 .await;
16352 Ok(())
16353 }
16354 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16355 ordinal: 5374223046099989052,
16356 error,
16357 }),
16358 }
16359 }
16360
16361 8794297771444732717 => {
16362 let responder = ::fidl_next::Responder::from_untyped(responder);
16363
16364 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16365 Ok(decoded) => {
16366 handler
16367 .remove_extended_attribute(
16368 ::fidl_next::Request::from_decoded(decoded),
16369 responder,
16370 )
16371 .await;
16372 Ok(())
16373 }
16374 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16375 ordinal: 8794297771444732717,
16376 error,
16377 }),
16378 }
16379 }
16380
16381 395825947633028830 => {
16382 let responder = ::fidl_next::Responder::from_untyped(responder);
16383
16384 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16385 Ok(decoded) => {
16386 handler.read(::fidl_next::Request::from_decoded(decoded), responder).await;
16387 Ok(())
16388 }
16389 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16390 ordinal: 395825947633028830,
16391 error,
16392 }),
16393 }
16394 }
16395
16396 7651971425397809026 => {
16397 let responder = ::fidl_next::Responder::from_untyped(responder);
16398
16399 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16400 Ok(decoded) => {
16401 handler.write(::fidl_next::Request::from_decoded(decoded), responder).await;
16402 Ok(())
16403 }
16404 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16405 ordinal: 7651971425397809026,
16406 error,
16407 }),
16408 }
16409 }
16410
16411 7545125870053689020 => {
16412 let responder = ::fidl_next::Responder::from_untyped(responder);
16413
16414 handler.describe(responder).await;
16415 Ok(())
16416 }
16417
16418 8649041485622956551 => {
16419 let responder = ::fidl_next::Responder::from_untyped(responder);
16420
16421 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16422 Ok(decoded) => {
16423 handler.seek(::fidl_next::Request::from_decoded(decoded), responder).await;
16424 Ok(())
16425 }
16426 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16427 ordinal: 8649041485622956551,
16428 error,
16429 }),
16430 }
16431 }
16432
16433 1587416148701180478 => {
16434 let responder = ::fidl_next::Responder::from_untyped(responder);
16435
16436 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16437 Ok(decoded) => {
16438 handler
16439 .read_at(::fidl_next::Request::from_decoded(decoded), responder)
16440 .await;
16441 Ok(())
16442 }
16443 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16444 ordinal: 1587416148701180478,
16445 error,
16446 }),
16447 }
16448 }
16449
16450 8736683935131400491 => {
16451 let responder = ::fidl_next::Responder::from_untyped(responder);
16452
16453 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16454 Ok(decoded) => {
16455 handler
16456 .write_at(::fidl_next::Request::from_decoded(decoded), responder)
16457 .await;
16458 Ok(())
16459 }
16460 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16461 ordinal: 8736683935131400491,
16462 error,
16463 }),
16464 }
16465 }
16466
16467 3134648685270758458 => {
16468 let responder = ::fidl_next::Responder::from_untyped(responder);
16469
16470 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16471 Ok(decoded) => {
16472 handler
16473 .resize(::fidl_next::Request::from_decoded(decoded), responder)
16474 .await;
16475 Ok(())
16476 }
16477 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16478 ordinal: 3134648685270758458,
16479 error,
16480 }),
16481 }
16482 }
16483
16484 46911652864194091 => {
16485 let responder = ::fidl_next::Responder::from_untyped(responder);
16486
16487 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16488 Ok(decoded) => {
16489 handler
16490 .get_backing_memory(
16491 ::fidl_next::Request::from_decoded(decoded),
16492 responder,
16493 )
16494 .await;
16495 Ok(())
16496 }
16497 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16498 ordinal: 46911652864194091,
16499 error,
16500 }),
16501 }
16502 }
16503
16504 8645235848064269614 => {
16505 let responder = ::fidl_next::Responder::from_untyped(responder);
16506
16507 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16508 Ok(decoded) => {
16509 handler
16510 .allocate(::fidl_next::Request::from_decoded(decoded), responder)
16511 .await;
16512 Ok(())
16513 }
16514 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16515 ordinal: 8645235848064269614,
16516 error,
16517 }),
16518 }
16519 }
16520
16521 3189145313204943035 => {
16522 let responder = ::fidl_next::Responder::from_untyped(responder);
16523
16524 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16525 Ok(decoded) => {
16526 handler
16527 .enable_verity(::fidl_next::Request::from_decoded(decoded), responder)
16528 .await;
16529 Ok(())
16530 }
16531 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16532 ordinal: 3189145313204943035,
16533 error,
16534 }),
16535 }
16536 }
16537
16538 ordinal => {
16539 handler.on_unknown_interaction(ordinal).await;
16540 if ::core::matches!(
16541 message.header().flexibility(),
16542 ::fidl_next::protocol::Flexibility::Strict
16543 ) {
16544 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16545 } else {
16546 responder
16547 .respond_framework_error(
16548 ordinal,
16549 ::fidl_next::FrameworkError::UnknownMethod,
16550 )
16551 .expect("encoding a framework error should never fail")
16552 .await?;
16553 Ok(())
16554 }
16555 }
16556 }
16557 }
16558}
16559
16560pub trait FileClientHandler<
16564 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
16565 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
16566>
16567{
16568 #[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"]
16569 fn on_open(
16570 &mut self,
16571
16572 request: ::fidl_next::Request<file::OnOpen, ___T>,
16573 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16574
16575 #[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"]
16576 fn on_representation(
16577 &mut self,
16578
16579 request: ::fidl_next::Request<file::OnRepresentation, ___T>,
16580 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16581
16582 fn on_unknown_interaction(
16583 &mut self,
16584 ordinal: u64,
16585 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
16586 ::core::future::ready(())
16587 }
16588}
16589
16590impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for File
16591where
16592 ___H: FileClientHandler<___T> + ::core::marker::Send,
16593 ___T: ::fidl_next::Transport,
16594 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
16595 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16596 Constraint = (),
16597 >,
16598 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
16599 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16600 Constraint = (),
16601 >,
16602{
16603 async fn on_event(
16604 handler: &mut ___H,
16605 mut message: ::fidl_next::Message<___T>,
16606 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
16607 match *message.header().ordinal {
16608 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
16609 Ok(decoded) => {
16610 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
16611 Ok(())
16612 }
16613 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16614 ordinal: 9207534335756671346,
16615 error,
16616 }),
16617 },
16618
16619 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
16620 Ok(decoded) => {
16621 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
16622 Ok(())
16623 }
16624 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16625 ordinal: 6679970090861613324,
16626 error,
16627 }),
16628 },
16629
16630 ordinal => {
16631 handler.on_unknown_interaction(ordinal).await;
16632 if ::core::matches!(
16633 message.header().flexibility(),
16634 ::fidl_next::protocol::Flexibility::Strict
16635 ) {
16636 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16637 } else {
16638 Ok(())
16639 }
16640 }
16641 }
16642 }
16643}
16644
16645pub trait FileServerHandler<
16649 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
16650 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
16651>
16652{
16653 #[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"]
16654 fn advisory_lock(
16655 &mut self,
16656
16657 request: ::fidl_next::Request<file::AdvisoryLock, ___T>,
16658
16659 responder: ::fidl_next::Responder<file::AdvisoryLock, ___T>,
16660 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16661
16662 #[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"]
16663 fn link_into(
16664 &mut self,
16665
16666 request: ::fidl_next::Request<file::LinkInto, ___T>,
16667
16668 responder: ::fidl_next::Responder<file::LinkInto, ___T>,
16669 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16670
16671 fn clone(
16672 &mut self,
16673
16674 request: ::fidl_next::Request<file::Clone, ___T>,
16675 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16676
16677 #[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"]
16678 fn close(
16679 &mut self,
16680
16681 responder: ::fidl_next::Responder<file::Close, ___T>,
16682 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16683
16684 fn query(
16685 &mut self,
16686
16687 responder: ::fidl_next::Responder<file::Query, ___T>,
16688 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16689
16690 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
16691 fn deprecated_get_attr(
16692 &mut self,
16693
16694 responder: ::fidl_next::Responder<file::DeprecatedGetAttr, ___T>,
16695 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16696
16697 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
16698 fn deprecated_set_attr(
16699 &mut self,
16700
16701 request: ::fidl_next::Request<file::DeprecatedSetAttr, ___T>,
16702
16703 responder: ::fidl_next::Responder<file::DeprecatedSetAttr, ___T>,
16704 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16705
16706 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
16707 fn deprecated_get_flags(
16708 &mut self,
16709
16710 responder: ::fidl_next::Responder<file::DeprecatedGetFlags, ___T>,
16711 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16712
16713 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
16714 fn deprecated_set_flags(
16715 &mut self,
16716
16717 request: ::fidl_next::Request<file::DeprecatedSetFlags, ___T>,
16718
16719 responder: ::fidl_next::Responder<file::DeprecatedSetFlags, ___T>,
16720 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16721
16722 #[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"]
16723 fn get_flags(
16724 &mut self,
16725
16726 responder: ::fidl_next::Responder<file::GetFlags, ___T>,
16727 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16728
16729 #[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"]
16730 fn set_flags(
16731 &mut self,
16732
16733 request: ::fidl_next::Request<file::SetFlags, ___T>,
16734
16735 responder: ::fidl_next::Responder<file::SetFlags, ___T>,
16736 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16737
16738 #[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"]
16739 fn query_filesystem(
16740 &mut self,
16741
16742 responder: ::fidl_next::Responder<file::QueryFilesystem, ___T>,
16743 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16744
16745 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
16746 fn get_token(
16747 &mut self,
16748
16749 responder: ::fidl_next::Responder<file::GetToken, ___T>,
16750 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16751
16752 #[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"]
16753 fn get_attributes(
16754 &mut self,
16755
16756 request: ::fidl_next::Request<file::GetAttributes, ___T>,
16757
16758 responder: ::fidl_next::Responder<file::GetAttributes, ___T>,
16759 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16760
16761 #[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"]
16762 fn update_attributes(
16763 &mut self,
16764
16765 request: ::fidl_next::Request<file::UpdateAttributes, ___T>,
16766
16767 responder: ::fidl_next::Responder<file::UpdateAttributes, ___T>,
16768 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16769
16770 #[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"]
16771 fn sync(
16772 &mut self,
16773
16774 responder: ::fidl_next::Responder<file::Sync, ___T>,
16775 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16776
16777 #[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.READ_BYTES`] right.\n"]
16778 fn list_extended_attributes(
16779 &mut self,
16780
16781 request: ::fidl_next::Request<file::ListExtendedAttributes, ___T>,
16782 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16783
16784 #[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.READ_BYTES`] right.\n"]
16785 fn get_extended_attribute(
16786 &mut self,
16787
16788 request: ::fidl_next::Request<file::GetExtendedAttribute, ___T>,
16789
16790 responder: ::fidl_next::Responder<file::GetExtendedAttribute, ___T>,
16791 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16792
16793 #[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.WRITE_BYTES`] right.\n"]
16794 fn set_extended_attribute(
16795 &mut self,
16796
16797 request: ::fidl_next::Request<file::SetExtendedAttribute, ___T>,
16798
16799 responder: ::fidl_next::Responder<file::SetExtendedAttribute, ___T>,
16800 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16801
16802 #[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.WRITE_BYTES`] right.\n"]
16803 fn remove_extended_attribute(
16804 &mut self,
16805
16806 request: ::fidl_next::Request<file::RemoveExtendedAttribute, ___T>,
16807
16808 responder: ::fidl_next::Responder<file::RemoveExtendedAttribute, ___T>,
16809 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16810
16811 #[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"]
16812 fn read(
16813 &mut self,
16814
16815 request: ::fidl_next::Request<file::Read, ___T>,
16816
16817 responder: ::fidl_next::Responder<file::Read, ___T>,
16818 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16819
16820 #[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"]
16821 fn write(
16822 &mut self,
16823
16824 request: ::fidl_next::Request<file::Write, ___T>,
16825
16826 responder: ::fidl_next::Responder<file::Write, ___T>,
16827 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16828
16829 fn describe(
16830 &mut self,
16831
16832 responder: ::fidl_next::Responder<file::Describe, ___T>,
16833 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16834
16835 #[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"]
16836 fn seek(
16837 &mut self,
16838
16839 request: ::fidl_next::Request<file::Seek, ___T>,
16840
16841 responder: ::fidl_next::Responder<file::Seek, ___T>,
16842 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16843
16844 #[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"]
16845 fn read_at(
16846 &mut self,
16847
16848 request: ::fidl_next::Request<file::ReadAt, ___T>,
16849
16850 responder: ::fidl_next::Responder<file::ReadAt, ___T>,
16851 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16852
16853 #[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"]
16854 fn write_at(
16855 &mut self,
16856
16857 request: ::fidl_next::Request<file::WriteAt, ___T>,
16858
16859 responder: ::fidl_next::Responder<file::WriteAt, ___T>,
16860 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16861
16862 #[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"]
16863 fn resize(
16864 &mut self,
16865
16866 request: ::fidl_next::Request<file::Resize, ___T>,
16867
16868 responder: ::fidl_next::Responder<file::Resize, ___T>,
16869 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16870
16871 #[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"]
16872 fn get_backing_memory(
16873 &mut self,
16874
16875 request: ::fidl_next::Request<file::GetBackingMemory, ___T>,
16876
16877 responder: ::fidl_next::Responder<file::GetBackingMemory, ___T>,
16878 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16879
16880 #[doc = " Pre-allocate on-disk space for this file.\n"]
16881 fn allocate(
16882 &mut self,
16883
16884 request: ::fidl_next::Request<file::Allocate, ___T>,
16885
16886 responder: ::fidl_next::Responder<file::Allocate, ___T>,
16887 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16888
16889 #[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"]
16890 fn enable_verity(
16891 &mut self,
16892
16893 request: ::fidl_next::Request<file::EnableVerity, ___T>,
16894
16895 responder: ::fidl_next::Responder<file::EnableVerity, ___T>,
16896 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16897
16898 fn on_unknown_interaction(
16899 &mut self,
16900 ordinal: u64,
16901 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
16902 ::core::future::ready(())
16903 }
16904}
16905
16906impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for File
16907where
16908 ___H: FileServerHandler<___T> + ::core::marker::Send,
16909 ___T: ::fidl_next::Transport,
16910 for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
16911 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16912 Constraint = (),
16913 >,
16914 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
16915 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16916 Constraint = (),
16917 >,
16918 for<'de> ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
16919 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16920 Constraint = (),
16921 >,
16922 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
16923 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16924 Constraint = (),
16925 >,
16926 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
16927 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16928 Constraint = (),
16929 >,
16930 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
16931 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16932 Constraint = (),
16933 >,
16934 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
16935 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16936 Constraint = (),
16937 >,
16938 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
16939 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16940 Constraint = (),
16941 >,
16942 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
16943 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16944 Constraint = (),
16945 >,
16946 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
16947 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16948 Constraint = (),
16949 >,
16950 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
16951 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16952 Constraint = (),
16953 >,
16954 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
16955 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16956 Constraint = (),
16957 >,
16958 for<'de> crate::wire::ReadableReadRequest: ::fidl_next::Decode<
16959 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16960 Constraint = (),
16961 >,
16962 for<'de> crate::wire::WritableWriteRequest<'de>: ::fidl_next::Decode<
16963 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16964 Constraint = (),
16965 >,
16966 for<'de> crate::wire::FileSeekRequest: ::fidl_next::Decode<
16967 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16968 Constraint = (),
16969 >,
16970 for<'de> crate::wire::FileReadAtRequest: ::fidl_next::Decode<
16971 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16972 Constraint = (),
16973 >,
16974 for<'de> crate::wire::FileWriteAtRequest<'de>: ::fidl_next::Decode<
16975 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16976 Constraint = (),
16977 >,
16978 for<'de> crate::wire::FileResizeRequest: ::fidl_next::Decode<
16979 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16980 Constraint = (),
16981 >,
16982 for<'de> crate::wire::FileGetBackingMemoryRequest: ::fidl_next::Decode<
16983 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16984 Constraint = (),
16985 >,
16986 for<'de> crate::wire::FileAllocateRequest: ::fidl_next::Decode<
16987 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16988 Constraint = (),
16989 >,
16990 for<'de> crate::wire::FileEnableVerityRequest<'de>: ::fidl_next::Decode<
16991 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16992 Constraint = (),
16993 >,
16994{
16995 async fn on_one_way(
16996 handler: &mut ___H,
16997 mut message: ::fidl_next::Message<___T>,
16998 ) -> ::core::result::Result<
16999 (),
17000 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17001 > {
17002 match *message.header().ordinal {
17003 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
17004 Ok(decoded) => {
17005 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
17006 Ok(())
17007 }
17008 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17009 ordinal: 2366825959783828089,
17010 error,
17011 }),
17012 },
17013
17014 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
17015 Ok(decoded) => {
17016 handler
17017 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
17018 .await;
17019 Ok(())
17020 }
17021 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17022 ordinal: 5431626189872037072,
17023 error,
17024 }),
17025 },
17026
17027 ordinal => {
17028 handler.on_unknown_interaction(ordinal).await;
17029 if ::core::matches!(
17030 message.header().flexibility(),
17031 ::fidl_next::protocol::Flexibility::Strict
17032 ) {
17033 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
17034 } else {
17035 Ok(())
17036 }
17037 }
17038 }
17039 }
17040
17041 async fn on_two_way(
17042 handler: &mut ___H,
17043 mut message: ::fidl_next::Message<___T>,
17044 responder: ::fidl_next::protocol::Responder<___T>,
17045 ) -> ::core::result::Result<
17046 (),
17047 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17048 > {
17049 match *message.header().ordinal {
17050 7992130864415541162 => {
17051 let responder = ::fidl_next::Responder::from_untyped(responder);
17052
17053 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17054 Ok(decoded) => {
17055 handler
17056 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
17057 .await;
17058 Ok(())
17059 }
17060 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17061 ordinal: 7992130864415541162,
17062 error,
17063 }),
17064 }
17065 }
17066
17067 6121399674497678964 => {
17068 let responder = ::fidl_next::Responder::from_untyped(responder);
17069
17070 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17071 Ok(decoded) => {
17072 handler
17073 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
17074 .await;
17075 Ok(())
17076 }
17077 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17078 ordinal: 6121399674497678964,
17079 error,
17080 }),
17081 }
17082 }
17083
17084 6540867515453498750 => {
17085 let responder = ::fidl_next::Responder::from_untyped(responder);
17086
17087 handler.close(responder).await;
17088 Ok(())
17089 }
17090
17091 2763219980499352582 => {
17092 let responder = ::fidl_next::Responder::from_untyped(responder);
17093
17094 handler.query(responder).await;
17095 Ok(())
17096 }
17097
17098 8689798978500614909 => {
17099 let responder = ::fidl_next::Responder::from_untyped(responder);
17100
17101 handler.deprecated_get_attr(responder).await;
17102 Ok(())
17103 }
17104
17105 4721673413776871238 => {
17106 let responder = ::fidl_next::Responder::from_untyped(responder);
17107
17108 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17109 Ok(decoded) => {
17110 handler
17111 .deprecated_set_attr(
17112 ::fidl_next::Request::from_decoded(decoded),
17113 responder,
17114 )
17115 .await;
17116 Ok(())
17117 }
17118 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17119 ordinal: 4721673413776871238,
17120 error,
17121 }),
17122 }
17123 }
17124
17125 6595803110182632097 => {
17126 let responder = ::fidl_next::Responder::from_untyped(responder);
17127
17128 handler.deprecated_get_flags(responder).await;
17129 Ok(())
17130 }
17131
17132 5950864159036794675 => {
17133 let responder = ::fidl_next::Responder::from_untyped(responder);
17134
17135 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17136 Ok(decoded) => {
17137 handler
17138 .deprecated_set_flags(
17139 ::fidl_next::Request::from_decoded(decoded),
17140 responder,
17141 )
17142 .await;
17143 Ok(())
17144 }
17145 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17146 ordinal: 5950864159036794675,
17147 error,
17148 }),
17149 }
17150 }
17151
17152 105530239381466147 => {
17153 let responder = ::fidl_next::Responder::from_untyped(responder);
17154
17155 handler.get_flags(responder).await;
17156 Ok(())
17157 }
17158
17159 6172186066099445416 => {
17160 let responder = ::fidl_next::Responder::from_untyped(responder);
17161
17162 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17163 Ok(decoded) => {
17164 handler
17165 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
17166 .await;
17167 Ok(())
17168 }
17169 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17170 ordinal: 6172186066099445416,
17171 error,
17172 }),
17173 }
17174 }
17175
17176 8013111122914313744 => {
17177 let responder = ::fidl_next::Responder::from_untyped(responder);
17178
17179 handler.query_filesystem(responder).await;
17180 Ok(())
17181 }
17182
17183 5788516050773961964 => {
17184 let responder = ::fidl_next::Responder::from_untyped(responder);
17185
17186 handler.get_token(responder).await;
17187 Ok(())
17188 }
17189
17190 4414537700416816443 => {
17191 let responder = ::fidl_next::Responder::from_untyped(responder);
17192
17193 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17194 Ok(decoded) => {
17195 handler
17196 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
17197 .await;
17198 Ok(())
17199 }
17200 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17201 ordinal: 4414537700416816443,
17202 error,
17203 }),
17204 }
17205 }
17206
17207 3677402239314018056 => {
17208 let responder = ::fidl_next::Responder::from_untyped(responder);
17209
17210 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17211 Ok(decoded) => {
17212 handler
17213 .update_attributes(
17214 ::fidl_next::Request::from_decoded(decoded),
17215 responder,
17216 )
17217 .await;
17218 Ok(())
17219 }
17220 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17221 ordinal: 3677402239314018056,
17222 error,
17223 }),
17224 }
17225 }
17226
17227 3196473584242777161 => {
17228 let responder = ::fidl_next::Responder::from_untyped(responder);
17229
17230 handler.sync(responder).await;
17231 Ok(())
17232 }
17233
17234 5043930208506967771 => {
17235 let responder = ::fidl_next::Responder::from_untyped(responder);
17236
17237 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17238 Ok(decoded) => {
17239 handler
17240 .get_extended_attribute(
17241 ::fidl_next::Request::from_decoded(decoded),
17242 responder,
17243 )
17244 .await;
17245 Ok(())
17246 }
17247 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17248 ordinal: 5043930208506967771,
17249 error,
17250 }),
17251 }
17252 }
17253
17254 5374223046099989052 => {
17255 let responder = ::fidl_next::Responder::from_untyped(responder);
17256
17257 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17258 Ok(decoded) => {
17259 handler
17260 .set_extended_attribute(
17261 ::fidl_next::Request::from_decoded(decoded),
17262 responder,
17263 )
17264 .await;
17265 Ok(())
17266 }
17267 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17268 ordinal: 5374223046099989052,
17269 error,
17270 }),
17271 }
17272 }
17273
17274 8794297771444732717 => {
17275 let responder = ::fidl_next::Responder::from_untyped(responder);
17276
17277 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17278 Ok(decoded) => {
17279 handler
17280 .remove_extended_attribute(
17281 ::fidl_next::Request::from_decoded(decoded),
17282 responder,
17283 )
17284 .await;
17285 Ok(())
17286 }
17287 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17288 ordinal: 8794297771444732717,
17289 error,
17290 }),
17291 }
17292 }
17293
17294 395825947633028830 => {
17295 let responder = ::fidl_next::Responder::from_untyped(responder);
17296
17297 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17298 Ok(decoded) => {
17299 handler.read(::fidl_next::Request::from_decoded(decoded), responder).await;
17300 Ok(())
17301 }
17302 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17303 ordinal: 395825947633028830,
17304 error,
17305 }),
17306 }
17307 }
17308
17309 7651971425397809026 => {
17310 let responder = ::fidl_next::Responder::from_untyped(responder);
17311
17312 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17313 Ok(decoded) => {
17314 handler.write(::fidl_next::Request::from_decoded(decoded), responder).await;
17315 Ok(())
17316 }
17317 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17318 ordinal: 7651971425397809026,
17319 error,
17320 }),
17321 }
17322 }
17323
17324 7545125870053689020 => {
17325 let responder = ::fidl_next::Responder::from_untyped(responder);
17326
17327 handler.describe(responder).await;
17328 Ok(())
17329 }
17330
17331 8649041485622956551 => {
17332 let responder = ::fidl_next::Responder::from_untyped(responder);
17333
17334 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17335 Ok(decoded) => {
17336 handler.seek(::fidl_next::Request::from_decoded(decoded), responder).await;
17337 Ok(())
17338 }
17339 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17340 ordinal: 8649041485622956551,
17341 error,
17342 }),
17343 }
17344 }
17345
17346 1587416148701180478 => {
17347 let responder = ::fidl_next::Responder::from_untyped(responder);
17348
17349 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17350 Ok(decoded) => {
17351 handler
17352 .read_at(::fidl_next::Request::from_decoded(decoded), responder)
17353 .await;
17354 Ok(())
17355 }
17356 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17357 ordinal: 1587416148701180478,
17358 error,
17359 }),
17360 }
17361 }
17362
17363 8736683935131400491 => {
17364 let responder = ::fidl_next::Responder::from_untyped(responder);
17365
17366 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17367 Ok(decoded) => {
17368 handler
17369 .write_at(::fidl_next::Request::from_decoded(decoded), responder)
17370 .await;
17371 Ok(())
17372 }
17373 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17374 ordinal: 8736683935131400491,
17375 error,
17376 }),
17377 }
17378 }
17379
17380 3134648685270758458 => {
17381 let responder = ::fidl_next::Responder::from_untyped(responder);
17382
17383 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17384 Ok(decoded) => {
17385 handler
17386 .resize(::fidl_next::Request::from_decoded(decoded), responder)
17387 .await;
17388 Ok(())
17389 }
17390 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17391 ordinal: 3134648685270758458,
17392 error,
17393 }),
17394 }
17395 }
17396
17397 46911652864194091 => {
17398 let responder = ::fidl_next::Responder::from_untyped(responder);
17399
17400 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17401 Ok(decoded) => {
17402 handler
17403 .get_backing_memory(
17404 ::fidl_next::Request::from_decoded(decoded),
17405 responder,
17406 )
17407 .await;
17408 Ok(())
17409 }
17410 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17411 ordinal: 46911652864194091,
17412 error,
17413 }),
17414 }
17415 }
17416
17417 8645235848064269614 => {
17418 let responder = ::fidl_next::Responder::from_untyped(responder);
17419
17420 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17421 Ok(decoded) => {
17422 handler
17423 .allocate(::fidl_next::Request::from_decoded(decoded), responder)
17424 .await;
17425 Ok(())
17426 }
17427 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17428 ordinal: 8645235848064269614,
17429 error,
17430 }),
17431 }
17432 }
17433
17434 3189145313204943035 => {
17435 let responder = ::fidl_next::Responder::from_untyped(responder);
17436
17437 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17438 Ok(decoded) => {
17439 handler
17440 .enable_verity(::fidl_next::Request::from_decoded(decoded), responder)
17441 .await;
17442 Ok(())
17443 }
17444 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17445 ordinal: 3189145313204943035,
17446 error,
17447 }),
17448 }
17449 }
17450
17451 ordinal => {
17452 handler.on_unknown_interaction(ordinal).await;
17453 if ::core::matches!(
17454 message.header().flexibility(),
17455 ::fidl_next::protocol::Flexibility::Strict
17456 ) {
17457 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
17458 } else {
17459 responder
17460 .respond_framework_error(
17461 ordinal,
17462 ::fidl_next::FrameworkError::UnknownMethod,
17463 )
17464 .expect("encoding a framework error should never fail")
17465 .await?;
17466 Ok(())
17467 }
17468 }
17469 }
17470 }
17471}
17472
17473impl<___T> FileClientHandler<___T> for ::fidl_next::IgnoreEvents
17474where
17475 ___T: ::fidl_next::Transport,
17476{
17477 async fn on_open(&mut self, _: ::fidl_next::Request<file::OnOpen, ___T>) {}
17478
17479 async fn on_representation(&mut self, _: ::fidl_next::Request<file::OnRepresentation, ___T>) {}
17480
17481 async fn on_unknown_interaction(&mut self, _: u64) {}
17482}
17483
17484impl<___H, ___T> FileLocalClientHandler<___T> for ::fidl_next::Local<___H>
17485where
17486 ___H: FileClientHandler<___T>,
17487 ___T: ::fidl_next::Transport,
17488{
17489 async fn on_open(&mut self, request: ::fidl_next::Request<file::OnOpen, ___T>) {
17490 ___H::on_open(&mut self.0, request).await
17491 }
17492
17493 async fn on_representation(
17494 &mut self,
17495
17496 request: ::fidl_next::Request<file::OnRepresentation, ___T>,
17497 ) {
17498 ___H::on_representation(&mut self.0, request).await
17499 }
17500
17501 async fn on_unknown_interaction(&mut self, ordinal: u64) {
17502 ___H::on_unknown_interaction(&mut self.0, ordinal).await
17503 }
17504}
17505
17506impl<___H, ___T> FileLocalServerHandler<___T> for ::fidl_next::Local<___H>
17507where
17508 ___H: FileServerHandler<___T>,
17509 ___T: ::fidl_next::Transport,
17510{
17511 async fn advisory_lock(
17512 &mut self,
17513
17514 request: ::fidl_next::Request<file::AdvisoryLock, ___T>,
17515
17516 responder: ::fidl_next::Responder<file::AdvisoryLock, ___T>,
17517 ) {
17518 ___H::advisory_lock(&mut self.0, request, responder).await
17519 }
17520
17521 async fn link_into(
17522 &mut self,
17523
17524 request: ::fidl_next::Request<file::LinkInto, ___T>,
17525
17526 responder: ::fidl_next::Responder<file::LinkInto, ___T>,
17527 ) {
17528 ___H::link_into(&mut self.0, request, responder).await
17529 }
17530
17531 async fn clone(&mut self, request: ::fidl_next::Request<file::Clone, ___T>) {
17532 ___H::clone(&mut self.0, request).await
17533 }
17534
17535 async fn close(&mut self, responder: ::fidl_next::Responder<file::Close, ___T>) {
17536 ___H::close(&mut self.0, responder).await
17537 }
17538
17539 async fn query(&mut self, responder: ::fidl_next::Responder<file::Query, ___T>) {
17540 ___H::query(&mut self.0, responder).await
17541 }
17542
17543 async fn deprecated_get_attr(
17544 &mut self,
17545
17546 responder: ::fidl_next::Responder<file::DeprecatedGetAttr, ___T>,
17547 ) {
17548 ___H::deprecated_get_attr(&mut self.0, responder).await
17549 }
17550
17551 async fn deprecated_set_attr(
17552 &mut self,
17553
17554 request: ::fidl_next::Request<file::DeprecatedSetAttr, ___T>,
17555
17556 responder: ::fidl_next::Responder<file::DeprecatedSetAttr, ___T>,
17557 ) {
17558 ___H::deprecated_set_attr(&mut self.0, request, responder).await
17559 }
17560
17561 async fn deprecated_get_flags(
17562 &mut self,
17563
17564 responder: ::fidl_next::Responder<file::DeprecatedGetFlags, ___T>,
17565 ) {
17566 ___H::deprecated_get_flags(&mut self.0, responder).await
17567 }
17568
17569 async fn deprecated_set_flags(
17570 &mut self,
17571
17572 request: ::fidl_next::Request<file::DeprecatedSetFlags, ___T>,
17573
17574 responder: ::fidl_next::Responder<file::DeprecatedSetFlags, ___T>,
17575 ) {
17576 ___H::deprecated_set_flags(&mut self.0, request, responder).await
17577 }
17578
17579 async fn get_flags(&mut self, responder: ::fidl_next::Responder<file::GetFlags, ___T>) {
17580 ___H::get_flags(&mut self.0, responder).await
17581 }
17582
17583 async fn set_flags(
17584 &mut self,
17585
17586 request: ::fidl_next::Request<file::SetFlags, ___T>,
17587
17588 responder: ::fidl_next::Responder<file::SetFlags, ___T>,
17589 ) {
17590 ___H::set_flags(&mut self.0, request, responder).await
17591 }
17592
17593 async fn query_filesystem(
17594 &mut self,
17595
17596 responder: ::fidl_next::Responder<file::QueryFilesystem, ___T>,
17597 ) {
17598 ___H::query_filesystem(&mut self.0, responder).await
17599 }
17600
17601 async fn get_token(&mut self, responder: ::fidl_next::Responder<file::GetToken, ___T>) {
17602 ___H::get_token(&mut self.0, responder).await
17603 }
17604
17605 async fn get_attributes(
17606 &mut self,
17607
17608 request: ::fidl_next::Request<file::GetAttributes, ___T>,
17609
17610 responder: ::fidl_next::Responder<file::GetAttributes, ___T>,
17611 ) {
17612 ___H::get_attributes(&mut self.0, request, responder).await
17613 }
17614
17615 async fn update_attributes(
17616 &mut self,
17617
17618 request: ::fidl_next::Request<file::UpdateAttributes, ___T>,
17619
17620 responder: ::fidl_next::Responder<file::UpdateAttributes, ___T>,
17621 ) {
17622 ___H::update_attributes(&mut self.0, request, responder).await
17623 }
17624
17625 async fn sync(&mut self, responder: ::fidl_next::Responder<file::Sync, ___T>) {
17626 ___H::sync(&mut self.0, responder).await
17627 }
17628
17629 async fn list_extended_attributes(
17630 &mut self,
17631
17632 request: ::fidl_next::Request<file::ListExtendedAttributes, ___T>,
17633 ) {
17634 ___H::list_extended_attributes(&mut self.0, request).await
17635 }
17636
17637 async fn get_extended_attribute(
17638 &mut self,
17639
17640 request: ::fidl_next::Request<file::GetExtendedAttribute, ___T>,
17641
17642 responder: ::fidl_next::Responder<file::GetExtendedAttribute, ___T>,
17643 ) {
17644 ___H::get_extended_attribute(&mut self.0, request, responder).await
17645 }
17646
17647 async fn set_extended_attribute(
17648 &mut self,
17649
17650 request: ::fidl_next::Request<file::SetExtendedAttribute, ___T>,
17651
17652 responder: ::fidl_next::Responder<file::SetExtendedAttribute, ___T>,
17653 ) {
17654 ___H::set_extended_attribute(&mut self.0, request, responder).await
17655 }
17656
17657 async fn remove_extended_attribute(
17658 &mut self,
17659
17660 request: ::fidl_next::Request<file::RemoveExtendedAttribute, ___T>,
17661
17662 responder: ::fidl_next::Responder<file::RemoveExtendedAttribute, ___T>,
17663 ) {
17664 ___H::remove_extended_attribute(&mut self.0, request, responder).await
17665 }
17666
17667 async fn read(
17668 &mut self,
17669
17670 request: ::fidl_next::Request<file::Read, ___T>,
17671
17672 responder: ::fidl_next::Responder<file::Read, ___T>,
17673 ) {
17674 ___H::read(&mut self.0, request, responder).await
17675 }
17676
17677 async fn write(
17678 &mut self,
17679
17680 request: ::fidl_next::Request<file::Write, ___T>,
17681
17682 responder: ::fidl_next::Responder<file::Write, ___T>,
17683 ) {
17684 ___H::write(&mut self.0, request, responder).await
17685 }
17686
17687 async fn describe(&mut self, responder: ::fidl_next::Responder<file::Describe, ___T>) {
17688 ___H::describe(&mut self.0, responder).await
17689 }
17690
17691 async fn seek(
17692 &mut self,
17693
17694 request: ::fidl_next::Request<file::Seek, ___T>,
17695
17696 responder: ::fidl_next::Responder<file::Seek, ___T>,
17697 ) {
17698 ___H::seek(&mut self.0, request, responder).await
17699 }
17700
17701 async fn read_at(
17702 &mut self,
17703
17704 request: ::fidl_next::Request<file::ReadAt, ___T>,
17705
17706 responder: ::fidl_next::Responder<file::ReadAt, ___T>,
17707 ) {
17708 ___H::read_at(&mut self.0, request, responder).await
17709 }
17710
17711 async fn write_at(
17712 &mut self,
17713
17714 request: ::fidl_next::Request<file::WriteAt, ___T>,
17715
17716 responder: ::fidl_next::Responder<file::WriteAt, ___T>,
17717 ) {
17718 ___H::write_at(&mut self.0, request, responder).await
17719 }
17720
17721 async fn resize(
17722 &mut self,
17723
17724 request: ::fidl_next::Request<file::Resize, ___T>,
17725
17726 responder: ::fidl_next::Responder<file::Resize, ___T>,
17727 ) {
17728 ___H::resize(&mut self.0, request, responder).await
17729 }
17730
17731 async fn get_backing_memory(
17732 &mut self,
17733
17734 request: ::fidl_next::Request<file::GetBackingMemory, ___T>,
17735
17736 responder: ::fidl_next::Responder<file::GetBackingMemory, ___T>,
17737 ) {
17738 ___H::get_backing_memory(&mut self.0, request, responder).await
17739 }
17740
17741 async fn allocate(
17742 &mut self,
17743
17744 request: ::fidl_next::Request<file::Allocate, ___T>,
17745
17746 responder: ::fidl_next::Responder<file::Allocate, ___T>,
17747 ) {
17748 ___H::allocate(&mut self.0, request, responder).await
17749 }
17750
17751 async fn enable_verity(
17752 &mut self,
17753
17754 request: ::fidl_next::Request<file::EnableVerity, ___T>,
17755
17756 responder: ::fidl_next::Responder<file::EnableVerity, ___T>,
17757 ) {
17758 ___H::enable_verity(&mut self.0, request, responder).await
17759 }
17760
17761 async fn on_unknown_interaction(&mut self, ordinal: u64) {
17762 ___H::on_unknown_interaction(&mut self.0, ordinal).await
17763 }
17764}
17765
17766#[doc = " A [\'Node\'] which contains a symbolic link.\n"]
17768#[derive(PartialEq, Debug)]
17769pub struct Symlink;
17770
17771impl ::fidl_next::Discoverable for Symlink {
17772 const PROTOCOL_NAME: &'static str = "fuchsia.io.Symlink";
17773}
17774
17775#[cfg(target_os = "fuchsia")]
17776impl ::fidl_next::HasTransport for Symlink {
17777 type Transport = ::fdomain_client::Channel;
17778}
17779
17780pub mod symlink {
17781 pub mod prelude {
17782 pub use crate::{
17783 Symlink, SymlinkClientHandler, SymlinkLocalClientHandler, SymlinkLocalServerHandler,
17784 SymlinkServerHandler, symlink,
17785 };
17786
17787 pub use crate::natural::ExtendedAttributeValue;
17788
17789 pub use crate::natural::LinkableLinkIntoRequest;
17790
17791 pub use crate::natural::LinkableLinkIntoResponse;
17792
17793 pub use crate::natural::MutableNodeAttributes;
17794
17795 pub use crate::natural::NodeAttributes2;
17796
17797 pub use crate::natural::NodeDeprecatedGetAttrResponse;
17798
17799 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
17800
17801 pub use crate::natural::NodeDeprecatedSetAttrRequest;
17802
17803 pub use crate::natural::NodeDeprecatedSetAttrResponse;
17804
17805 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
17806
17807 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
17808
17809 pub use crate::natural::NodeGetAttributesRequest;
17810
17811 pub use crate::natural::NodeGetExtendedAttributeRequest;
17812
17813 pub use crate::natural::NodeListExtendedAttributesRequest;
17814
17815 pub use crate::natural::NodeOnOpenRequest;
17816
17817 pub use crate::natural::NodeQueryFilesystemResponse;
17818
17819 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
17820
17821 pub use crate::natural::NodeSetExtendedAttributeRequest;
17822
17823 pub use crate::natural::NodeSetFlagsRequest;
17824
17825 pub use crate::natural::NodeGetFlagsResponse;
17826
17827 pub use crate::natural::NodeGetTokenResponse;
17828
17829 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
17830
17831 pub use crate::natural::NodeSetExtendedAttributeResponse;
17832
17833 pub use crate::natural::NodeSetFlagsResponse;
17834
17835 pub use crate::natural::NodeSyncResponse;
17836
17837 pub use crate::natural::NodeUpdateAttributesResponse;
17838
17839 pub use crate::natural::OpenableOpenRequest;
17840
17841 pub use crate::natural::Representation;
17842
17843 pub use crate::natural::SymlinkInfo;
17844
17845 pub use ::fdomain_next_fuchsia_unknown::natural::CloneableCloneRequest;
17846
17847 pub use ::fdomain_next_fuchsia_unknown::natural::CloseableCloseResponse;
17848
17849 pub use ::fdomain_next_fuchsia_unknown::natural::QueryableQueryResponse;
17850 }
17851
17852 pub struct LinkInto;
17853
17854 impl ::fidl_next::Method for LinkInto {
17855 const ORDINAL: u64 = 6121399674497678964;
17856 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17857 ::fidl_next::protocol::Flexibility::Strict;
17858
17859 type Protocol = crate::Symlink;
17860
17861 type Request = crate::wire::LinkableLinkIntoRequest<'static>;
17862 }
17863
17864 impl ::fidl_next::TwoWayMethod for LinkInto {
17865 type Response = ::fidl_next::wire::Result<
17866 'static,
17867 crate::wire::LinkableLinkIntoResponse,
17868 ::fidl_next::wire::fuchsia::Status,
17869 >;
17870 }
17871
17872 impl<___R> ::fidl_next::Respond<___R> for LinkInto {
17873 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
17874
17875 fn respond(response: ___R) -> Self::Output {
17876 ::core::result::Result::Ok(response)
17877 }
17878 }
17879
17880 impl<___R> ::fidl_next::RespondErr<___R> for LinkInto {
17881 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
17882
17883 fn respond_err(response: ___R) -> Self::Output {
17884 ::core::result::Result::Err(response)
17885 }
17886 }
17887
17888 pub struct Clone;
17889
17890 impl ::fidl_next::Method for Clone {
17891 const ORDINAL: u64 = 2366825959783828089;
17892 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17893 ::fidl_next::protocol::Flexibility::Strict;
17894
17895 type Protocol = crate::Symlink;
17896
17897 type Request = ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest;
17898 }
17899
17900 pub struct Close;
17901
17902 impl ::fidl_next::Method for Close {
17903 const ORDINAL: u64 = 6540867515453498750;
17904 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17905 ::fidl_next::protocol::Flexibility::Strict;
17906
17907 type Protocol = crate::Symlink;
17908
17909 type Request = ::fidl_next::wire::EmptyMessageBody;
17910 }
17911
17912 impl ::fidl_next::TwoWayMethod for Close {
17913 type Response = ::fidl_next::wire::Result<
17914 'static,
17915 ::fdomain_next_fuchsia_unknown::wire::CloseableCloseResponse,
17916 ::fidl_next::wire::Int32,
17917 >;
17918 }
17919
17920 impl<___R> ::fidl_next::Respond<___R> for Close {
17921 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
17922
17923 fn respond(response: ___R) -> Self::Output {
17924 ::core::result::Result::Ok(response)
17925 }
17926 }
17927
17928 impl<___R> ::fidl_next::RespondErr<___R> for Close {
17929 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
17930
17931 fn respond_err(response: ___R) -> Self::Output {
17932 ::core::result::Result::Err(response)
17933 }
17934 }
17935
17936 pub struct Query;
17937
17938 impl ::fidl_next::Method for Query {
17939 const ORDINAL: u64 = 2763219980499352582;
17940 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17941 ::fidl_next::protocol::Flexibility::Strict;
17942
17943 type Protocol = crate::Symlink;
17944
17945 type Request = ::fidl_next::wire::EmptyMessageBody;
17946 }
17947
17948 impl ::fidl_next::TwoWayMethod for Query {
17949 type Response = ::fidl_next::wire::Strict<
17950 ::fdomain_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>,
17951 >;
17952 }
17953
17954 impl<___R> ::fidl_next::Respond<___R> for Query {
17955 type Output = ::fidl_next::Strict<
17956 ::fdomain_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>,
17957 >;
17958
17959 fn respond(response: ___R) -> Self::Output {
17960 ::fidl_next::Strict(::fdomain_next_fuchsia_unknown::generic::QueryableQueryResponse {
17961 protocol: response,
17962 })
17963 }
17964 }
17965
17966 pub struct OnOpen;
17967
17968 impl ::fidl_next::Method for OnOpen {
17969 const ORDINAL: u64 = 9207534335756671346;
17970 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17971 ::fidl_next::protocol::Flexibility::Flexible;
17972
17973 type Protocol = crate::Symlink;
17974
17975 type Request = crate::wire::NodeOnOpenRequest<'static>;
17976 }
17977
17978 pub struct DeprecatedGetAttr;
17979
17980 impl ::fidl_next::Method for DeprecatedGetAttr {
17981 const ORDINAL: u64 = 8689798978500614909;
17982 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17983 ::fidl_next::protocol::Flexibility::Strict;
17984
17985 type Protocol = crate::Symlink;
17986
17987 type Request = ::fidl_next::wire::EmptyMessageBody;
17988 }
17989
17990 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
17991 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetAttrResponse>;
17992 }
17993
17994 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
17995 type Output = ::fidl_next::Strict<___R>;
17996
17997 fn respond(response: ___R) -> Self::Output {
17998 ::fidl_next::Strict(response)
17999 }
18000 }
18001
18002 pub struct DeprecatedSetAttr;
18003
18004 impl ::fidl_next::Method for DeprecatedSetAttr {
18005 const ORDINAL: u64 = 4721673413776871238;
18006 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18007 ::fidl_next::protocol::Flexibility::Strict;
18008
18009 type Protocol = crate::Symlink;
18010
18011 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
18012 }
18013
18014 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
18015 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetAttrResponse>;
18016 }
18017
18018 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
18019 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetAttrResponse<___R>>;
18020
18021 fn respond(response: ___R) -> Self::Output {
18022 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetAttrResponse { s: response })
18023 }
18024 }
18025
18026 pub struct DeprecatedGetFlags;
18027
18028 impl ::fidl_next::Method for DeprecatedGetFlags {
18029 const ORDINAL: u64 = 6595803110182632097;
18030 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18031 ::fidl_next::protocol::Flexibility::Strict;
18032
18033 type Protocol = crate::Symlink;
18034
18035 type Request = ::fidl_next::wire::EmptyMessageBody;
18036 }
18037
18038 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
18039 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetFlagsResponse>;
18040 }
18041
18042 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
18043 type Output = ::fidl_next::Strict<___R>;
18044
18045 fn respond(response: ___R) -> Self::Output {
18046 ::fidl_next::Strict(response)
18047 }
18048 }
18049
18050 pub struct DeprecatedSetFlags;
18051
18052 impl ::fidl_next::Method for DeprecatedSetFlags {
18053 const ORDINAL: u64 = 5950864159036794675;
18054 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18055 ::fidl_next::protocol::Flexibility::Strict;
18056
18057 type Protocol = crate::Symlink;
18058
18059 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
18060 }
18061
18062 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
18063 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetFlagsResponse>;
18064 }
18065
18066 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
18067 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetFlagsResponse<___R>>;
18068
18069 fn respond(response: ___R) -> Self::Output {
18070 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetFlagsResponse { s: response })
18071 }
18072 }
18073
18074 pub struct GetFlags;
18075
18076 impl ::fidl_next::Method for GetFlags {
18077 const ORDINAL: u64 = 105530239381466147;
18078 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18079 ::fidl_next::protocol::Flexibility::Flexible;
18080
18081 type Protocol = crate::Symlink;
18082
18083 type Request = ::fidl_next::wire::EmptyMessageBody;
18084 }
18085
18086 impl ::fidl_next::TwoWayMethod for GetFlags {
18087 type Response = ::fidl_next::wire::Result<
18088 'static,
18089 crate::wire::NodeGetFlagsResponse,
18090 ::fidl_next::wire::fuchsia::Status,
18091 >;
18092 }
18093
18094 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
18095 type Output = ::core::result::Result<
18096 crate::generic::NodeGetFlagsResponse<___R>,
18097 ::fidl_next::never::Never,
18098 >;
18099
18100 fn respond(response: ___R) -> Self::Output {
18101 ::core::result::Result::Ok(crate::generic::NodeGetFlagsResponse { flags: response })
18102 }
18103 }
18104
18105 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
18106 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18107
18108 fn respond_err(response: ___R) -> Self::Output {
18109 ::core::result::Result::Err(response)
18110 }
18111 }
18112
18113 pub struct SetFlags;
18114
18115 impl ::fidl_next::Method for SetFlags {
18116 const ORDINAL: u64 = 6172186066099445416;
18117 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18118 ::fidl_next::protocol::Flexibility::Flexible;
18119
18120 type Protocol = crate::Symlink;
18121
18122 type Request = crate::wire::NodeSetFlagsRequest;
18123 }
18124
18125 impl ::fidl_next::TwoWayMethod for SetFlags {
18126 type Response = ::fidl_next::wire::Result<
18127 'static,
18128 crate::wire::NodeSetFlagsResponse,
18129 ::fidl_next::wire::fuchsia::Status,
18130 >;
18131 }
18132
18133 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
18134 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
18135
18136 fn respond(response: ___R) -> Self::Output {
18137 ::core::result::Result::Ok(response)
18138 }
18139 }
18140
18141 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
18142 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18143
18144 fn respond_err(response: ___R) -> Self::Output {
18145 ::core::result::Result::Err(response)
18146 }
18147 }
18148
18149 pub struct QueryFilesystem;
18150
18151 impl ::fidl_next::Method for QueryFilesystem {
18152 const ORDINAL: u64 = 8013111122914313744;
18153 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18154 ::fidl_next::protocol::Flexibility::Strict;
18155
18156 type Protocol = crate::Symlink;
18157
18158 type Request = ::fidl_next::wire::EmptyMessageBody;
18159 }
18160
18161 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
18162 type Response =
18163 ::fidl_next::wire::Strict<crate::wire::NodeQueryFilesystemResponse<'static>>;
18164 }
18165
18166 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
18167 type Output = ::fidl_next::Strict<___R>;
18168
18169 fn respond(response: ___R) -> Self::Output {
18170 ::fidl_next::Strict(response)
18171 }
18172 }
18173
18174 pub struct OnRepresentation;
18175
18176 impl ::fidl_next::Method for OnRepresentation {
18177 const ORDINAL: u64 = 6679970090861613324;
18178 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18179 ::fidl_next::protocol::Flexibility::Strict;
18180
18181 type Protocol = crate::Symlink;
18182
18183 type Request = crate::wire::Representation<'static>;
18184 }
18185
18186 pub struct GetToken;
18187
18188 impl ::fidl_next::Method for GetToken {
18189 const ORDINAL: u64 = 5788516050773961964;
18190 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18191 ::fidl_next::protocol::Flexibility::Flexible;
18192
18193 type Protocol = crate::Symlink;
18194
18195 type Request = ::fidl_next::wire::EmptyMessageBody;
18196 }
18197
18198 impl ::fidl_next::TwoWayMethod for GetToken {
18199 type Response = ::fidl_next::wire::Result<
18200 'static,
18201 crate::wire::NodeGetTokenResponse,
18202 ::fidl_next::wire::fuchsia::Status,
18203 >;
18204 }
18205
18206 impl<___R> ::fidl_next::Respond<___R> for GetToken {
18207 type Output = ::core::result::Result<
18208 crate::generic::NodeGetTokenResponse<___R>,
18209 ::fidl_next::never::Never,
18210 >;
18211
18212 fn respond(response: ___R) -> Self::Output {
18213 ::core::result::Result::Ok(crate::generic::NodeGetTokenResponse { token: response })
18214 }
18215 }
18216
18217 impl<___R> ::fidl_next::RespondErr<___R> for GetToken {
18218 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18219
18220 fn respond_err(response: ___R) -> Self::Output {
18221 ::core::result::Result::Err(response)
18222 }
18223 }
18224
18225 pub struct GetAttributes;
18226
18227 impl ::fidl_next::Method for GetAttributes {
18228 const ORDINAL: u64 = 4414537700416816443;
18229 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18230 ::fidl_next::protocol::Flexibility::Strict;
18231
18232 type Protocol = crate::Symlink;
18233
18234 type Request = crate::wire::NodeGetAttributesRequest;
18235 }
18236
18237 impl ::fidl_next::TwoWayMethod for GetAttributes {
18238 type Response = ::fidl_next::wire::Result<
18239 'static,
18240 crate::wire::NodeAttributes2<'static>,
18241 ::fidl_next::wire::fuchsia::Status,
18242 >;
18243 }
18244
18245 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
18246 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
18247
18248 fn respond(response: ___R) -> Self::Output {
18249 ::core::result::Result::Ok(response)
18250 }
18251 }
18252
18253 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
18254 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18255
18256 fn respond_err(response: ___R) -> Self::Output {
18257 ::core::result::Result::Err(response)
18258 }
18259 }
18260
18261 pub struct UpdateAttributes;
18262
18263 impl ::fidl_next::Method for UpdateAttributes {
18264 const ORDINAL: u64 = 3677402239314018056;
18265 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18266 ::fidl_next::protocol::Flexibility::Strict;
18267
18268 type Protocol = crate::Symlink;
18269
18270 type Request = crate::wire::MutableNodeAttributes<'static>;
18271 }
18272
18273 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
18274 type Response = ::fidl_next::wire::Result<
18275 'static,
18276 crate::wire::NodeUpdateAttributesResponse,
18277 ::fidl_next::wire::fuchsia::Status,
18278 >;
18279 }
18280
18281 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
18282 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
18283
18284 fn respond(response: ___R) -> Self::Output {
18285 ::core::result::Result::Ok(response)
18286 }
18287 }
18288
18289 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
18290 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18291
18292 fn respond_err(response: ___R) -> Self::Output {
18293 ::core::result::Result::Err(response)
18294 }
18295 }
18296
18297 pub struct Sync;
18298
18299 impl ::fidl_next::Method for Sync {
18300 const ORDINAL: u64 = 3196473584242777161;
18301 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18302 ::fidl_next::protocol::Flexibility::Strict;
18303
18304 type Protocol = crate::Symlink;
18305
18306 type Request = ::fidl_next::wire::EmptyMessageBody;
18307 }
18308
18309 impl ::fidl_next::TwoWayMethod for Sync {
18310 type Response = ::fidl_next::wire::Result<
18311 'static,
18312 crate::wire::NodeSyncResponse,
18313 ::fidl_next::wire::fuchsia::Status,
18314 >;
18315 }
18316
18317 impl<___R> ::fidl_next::Respond<___R> for Sync {
18318 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
18319
18320 fn respond(response: ___R) -> Self::Output {
18321 ::core::result::Result::Ok(response)
18322 }
18323 }
18324
18325 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
18326 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18327
18328 fn respond_err(response: ___R) -> Self::Output {
18329 ::core::result::Result::Err(response)
18330 }
18331 }
18332
18333 pub struct ListExtendedAttributes;
18334
18335 impl ::fidl_next::Method for ListExtendedAttributes {
18336 const ORDINAL: u64 = 5431626189872037072;
18337 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18338 ::fidl_next::protocol::Flexibility::Strict;
18339
18340 type Protocol = crate::Symlink;
18341
18342 type Request = crate::wire::NodeListExtendedAttributesRequest;
18343 }
18344
18345 pub struct GetExtendedAttribute;
18346
18347 impl ::fidl_next::Method for GetExtendedAttribute {
18348 const ORDINAL: u64 = 5043930208506967771;
18349 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18350 ::fidl_next::protocol::Flexibility::Strict;
18351
18352 type Protocol = crate::Symlink;
18353
18354 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
18355 }
18356
18357 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
18358 type Response = ::fidl_next::wire::Result<
18359 'static,
18360 crate::wire::ExtendedAttributeValue<'static>,
18361 ::fidl_next::wire::fuchsia::Status,
18362 >;
18363 }
18364
18365 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
18366 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
18367
18368 fn respond(response: ___R) -> Self::Output {
18369 ::core::result::Result::Ok(response)
18370 }
18371 }
18372
18373 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
18374 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18375
18376 fn respond_err(response: ___R) -> Self::Output {
18377 ::core::result::Result::Err(response)
18378 }
18379 }
18380
18381 pub struct SetExtendedAttribute;
18382
18383 impl ::fidl_next::Method for SetExtendedAttribute {
18384 const ORDINAL: u64 = 5374223046099989052;
18385 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18386 ::fidl_next::protocol::Flexibility::Strict;
18387
18388 type Protocol = crate::Symlink;
18389
18390 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
18391 }
18392
18393 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
18394 type Response = ::fidl_next::wire::Result<
18395 'static,
18396 crate::wire::NodeSetExtendedAttributeResponse,
18397 ::fidl_next::wire::fuchsia::Status,
18398 >;
18399 }
18400
18401 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
18402 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
18403
18404 fn respond(response: ___R) -> Self::Output {
18405 ::core::result::Result::Ok(response)
18406 }
18407 }
18408
18409 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
18410 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18411
18412 fn respond_err(response: ___R) -> Self::Output {
18413 ::core::result::Result::Err(response)
18414 }
18415 }
18416
18417 pub struct RemoveExtendedAttribute;
18418
18419 impl ::fidl_next::Method for RemoveExtendedAttribute {
18420 const ORDINAL: u64 = 8794297771444732717;
18421 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18422 ::fidl_next::protocol::Flexibility::Strict;
18423
18424 type Protocol = crate::Symlink;
18425
18426 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
18427 }
18428
18429 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
18430 type Response = ::fidl_next::wire::Result<
18431 'static,
18432 crate::wire::NodeRemoveExtendedAttributeResponse,
18433 ::fidl_next::wire::fuchsia::Status,
18434 >;
18435 }
18436
18437 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
18438 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
18439
18440 fn respond(response: ___R) -> Self::Output {
18441 ::core::result::Result::Ok(response)
18442 }
18443 }
18444
18445 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
18446 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18447
18448 fn respond_err(response: ___R) -> Self::Output {
18449 ::core::result::Result::Err(response)
18450 }
18451 }
18452
18453 pub struct Open;
18454
18455 impl ::fidl_next::Method for Open {
18456 const ORDINAL: u64 = 6236883748953765593;
18457 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18458 ::fidl_next::protocol::Flexibility::Flexible;
18459
18460 type Protocol = crate::Symlink;
18461
18462 type Request = crate::wire::OpenableOpenRequest<'static>;
18463 }
18464
18465 pub struct Describe;
18466
18467 impl ::fidl_next::Method for Describe {
18468 const ORDINAL: u64 = 8371117097481679347;
18469 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18470 ::fidl_next::protocol::Flexibility::Flexible;
18471
18472 type Protocol = crate::Symlink;
18473
18474 type Request = ::fidl_next::wire::EmptyMessageBody;
18475 }
18476
18477 impl ::fidl_next::TwoWayMethod for Describe {
18478 type Response = ::fidl_next::wire::Flexible<'static, crate::wire::SymlinkInfo<'static>>;
18479 }
18480
18481 impl<___R> ::fidl_next::Respond<___R> for Describe {
18482 type Output = ::fidl_next::Flexible<___R>;
18483
18484 fn respond(response: ___R) -> Self::Output {
18485 ::fidl_next::Flexible(response)
18486 }
18487 }
18488
18489 mod ___detail {
18490 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Symlink
18491 where
18492 ___T: ::fidl_next::Transport,
18493 {
18494 type Client = SymlinkClient<___T>;
18495 type Server = SymlinkServer<___T>;
18496 }
18497
18498 #[repr(transparent)]
18500 pub struct SymlinkClient<___T: ::fidl_next::Transport> {
18501 #[allow(dead_code)]
18502 client: ::fidl_next::protocol::Client<___T>,
18503 }
18504
18505 impl<___T> SymlinkClient<___T>
18506 where
18507 ___T: ::fidl_next::Transport,
18508 {
18509 #[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"]
18510 pub fn link_into(
18511 &self,
18512
18513 dst_parent_token: impl ::fidl_next::Encode<
18514 ::fdomain_client::fidl_next::wire::Handle,
18515 <___T as ::fidl_next::Transport>::SendBuffer,
18516 >,
18517
18518 dst: impl ::fidl_next::Encode<
18519 ::fidl_next::wire::String<'static>,
18520 <___T as ::fidl_next::Transport>::SendBuffer,
18521 >,
18522 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
18523 where
18524 <___T as ::fidl_next::Transport>::SendBuffer:
18525 ::fidl_next::encoder::InternalHandleEncoder,
18526 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18527 <___T as ::fidl_next::Transport>::SendBuffer:
18528 ::fdomain_client::fidl_next::HandleEncoder,
18529 {
18530 self.link_into_with(crate::generic::LinkableLinkIntoRequest {
18531 dst_parent_token,
18532
18533 dst,
18534 })
18535 }
18536
18537 #[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"]
18538 pub fn link_into_with<___R>(
18539 &self,
18540 request: ___R,
18541 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
18542 where
18543 ___R: ::fidl_next::Encode<
18544 crate::wire::LinkableLinkIntoRequest<'static>,
18545 <___T as ::fidl_next::Transport>::SendBuffer,
18546 >,
18547 {
18548 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18549 6121399674497678964,
18550 <super::LinkInto as ::fidl_next::Method>::FLEXIBILITY,
18551 request,
18552 ))
18553 }
18554
18555 pub fn clone(
18556 &self,
18557
18558 request: impl ::fidl_next::Encode<
18559 ::fidl_next::ServerEnd<
18560 ::fdomain_next_fuchsia_unknown::Cloneable,
18561 ::fdomain_client::fidl_next::wire::Handle,
18562 >,
18563 <___T as ::fidl_next::Transport>::SendBuffer,
18564 >,
18565 ) -> ::fidl_next::SendFuture<'_, ___T>
18566 where
18567 <___T as ::fidl_next::Transport>::SendBuffer:
18568 ::fidl_next::encoder::InternalHandleEncoder,
18569 <___T as ::fidl_next::Transport>::SendBuffer:
18570 ::fdomain_client::fidl_next::HandleEncoder,
18571 {
18572 self.clone_with(::fdomain_next_fuchsia_unknown::generic::CloneableCloneRequest {
18573 request,
18574 })
18575 }
18576
18577 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
18578 where
18579 ___R: ::fidl_next::Encode<
18580 ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest,
18581 <___T as ::fidl_next::Transport>::SendBuffer,
18582 >,
18583 {
18584 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
18585 2366825959783828089,
18586 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
18587 request,
18588 ))
18589 }
18590
18591 #[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"]
18592 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
18593 ::fidl_next::TwoWayFuture::from_untyped(
18594 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18595 6540867515453498750,
18596 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
18597 (),
18598 ),
18599 )
18600 }
18601
18602 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
18603 ::fidl_next::TwoWayFuture::from_untyped(
18604 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18605 2763219980499352582,
18606 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
18607 (),
18608 ),
18609 )
18610 }
18611
18612 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
18613 pub fn deprecated_get_attr(
18614 &self,
18615 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
18616 ::fidl_next::TwoWayFuture::from_untyped(
18617 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18618 8689798978500614909,
18619 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
18620 (),
18621 ),
18622 )
18623 }
18624
18625 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
18626 pub fn deprecated_set_attr(
18627 &self,
18628
18629 flags: impl ::fidl_next::Encode<
18630 crate::wire::NodeAttributeFlags,
18631 <___T as ::fidl_next::Transport>::SendBuffer,
18632 >,
18633
18634 attributes: impl ::fidl_next::Encode<
18635 crate::wire::NodeAttributes,
18636 <___T as ::fidl_next::Transport>::SendBuffer,
18637 >,
18638 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
18639 where
18640 <___T as ::fidl_next::Transport>::SendBuffer:
18641 ::fidl_next::encoder::InternalHandleEncoder,
18642 {
18643 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
18644 flags,
18645
18646 attributes,
18647 })
18648 }
18649
18650 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
18651 pub fn deprecated_set_attr_with<___R>(
18652 &self,
18653 request: ___R,
18654 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
18655 where
18656 ___R: ::fidl_next::Encode<
18657 crate::wire::NodeDeprecatedSetAttrRequest,
18658 <___T as ::fidl_next::Transport>::SendBuffer,
18659 >,
18660 {
18661 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18662 4721673413776871238,
18663 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
18664 request,
18665 ))
18666 }
18667
18668 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
18669 pub fn deprecated_get_flags(
18670 &self,
18671 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
18672 ::fidl_next::TwoWayFuture::from_untyped(
18673 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18674 6595803110182632097,
18675 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
18676 (),
18677 ),
18678 )
18679 }
18680
18681 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
18682 pub fn deprecated_set_flags(
18683 &self,
18684
18685 flags: impl ::fidl_next::Encode<
18686 crate::wire::OpenFlags,
18687 <___T as ::fidl_next::Transport>::SendBuffer,
18688 >,
18689 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
18690 where
18691 <___T as ::fidl_next::Transport>::SendBuffer:
18692 ::fidl_next::encoder::InternalHandleEncoder,
18693 {
18694 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
18695 flags,
18696 })
18697 }
18698
18699 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
18700 pub fn deprecated_set_flags_with<___R>(
18701 &self,
18702 request: ___R,
18703 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
18704 where
18705 ___R: ::fidl_next::Encode<
18706 crate::wire::NodeDeprecatedSetFlagsRequest,
18707 <___T as ::fidl_next::Transport>::SendBuffer,
18708 >,
18709 {
18710 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18711 5950864159036794675,
18712 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
18713 request,
18714 ))
18715 }
18716
18717 #[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"]
18718 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
18719 ::fidl_next::TwoWayFuture::from_untyped(
18720 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18721 105530239381466147,
18722 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
18723 (),
18724 ),
18725 )
18726 }
18727
18728 #[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"]
18729 pub fn set_flags(
18730 &self,
18731
18732 flags: impl ::fidl_next::Encode<
18733 crate::wire::Flags,
18734 <___T as ::fidl_next::Transport>::SendBuffer,
18735 >,
18736 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
18737 where
18738 <___T as ::fidl_next::Transport>::SendBuffer:
18739 ::fidl_next::encoder::InternalHandleEncoder,
18740 {
18741 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
18742 }
18743
18744 #[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"]
18745 pub fn set_flags_with<___R>(
18746 &self,
18747 request: ___R,
18748 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
18749 where
18750 ___R: ::fidl_next::Encode<
18751 crate::wire::NodeSetFlagsRequest,
18752 <___T as ::fidl_next::Transport>::SendBuffer,
18753 >,
18754 {
18755 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18756 6172186066099445416,
18757 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
18758 request,
18759 ))
18760 }
18761
18762 #[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"]
18763 pub fn query_filesystem(
18764 &self,
18765 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
18766 ::fidl_next::TwoWayFuture::from_untyped(
18767 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18768 8013111122914313744,
18769 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
18770 (),
18771 ),
18772 )
18773 }
18774
18775 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
18776 pub fn get_token(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetToken, ___T> {
18777 ::fidl_next::TwoWayFuture::from_untyped(
18778 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18779 5788516050773961964,
18780 <super::GetToken as ::fidl_next::Method>::FLEXIBILITY,
18781 (),
18782 ),
18783 )
18784 }
18785
18786 #[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"]
18787 pub fn get_attributes(
18788 &self,
18789
18790 query: impl ::fidl_next::Encode<
18791 crate::wire::NodeAttributesQuery,
18792 <___T as ::fidl_next::Transport>::SendBuffer,
18793 >,
18794 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
18795 where
18796 <___T as ::fidl_next::Transport>::SendBuffer:
18797 ::fidl_next::encoder::InternalHandleEncoder,
18798 {
18799 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
18800 }
18801
18802 #[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"]
18803 pub fn get_attributes_with<___R>(
18804 &self,
18805 request: ___R,
18806 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
18807 where
18808 ___R: ::fidl_next::Encode<
18809 crate::wire::NodeGetAttributesRequest,
18810 <___T as ::fidl_next::Transport>::SendBuffer,
18811 >,
18812 {
18813 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18814 4414537700416816443,
18815 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
18816 request,
18817 ))
18818 }
18819
18820 #[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"]
18821 pub fn update_attributes_with<___R>(
18822 &self,
18823 request: ___R,
18824 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
18825 where
18826 ___R: ::fidl_next::Encode<
18827 crate::wire::MutableNodeAttributes<'static>,
18828 <___T as ::fidl_next::Transport>::SendBuffer,
18829 >,
18830 {
18831 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18832 3677402239314018056,
18833 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
18834 request,
18835 ))
18836 }
18837
18838 #[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"]
18839 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
18840 ::fidl_next::TwoWayFuture::from_untyped(
18841 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18842 3196473584242777161,
18843 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
18844 (),
18845 ),
18846 )
18847 }
18848
18849 #[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.READ_BYTES`] right.\n"]
18850 pub fn list_extended_attributes(
18851 &self,
18852
18853 iterator: impl ::fidl_next::Encode<
18854 ::fidl_next::ServerEnd<
18855 crate::ExtendedAttributeIterator,
18856 ::fdomain_client::fidl_next::wire::Handle,
18857 >,
18858 <___T as ::fidl_next::Transport>::SendBuffer,
18859 >,
18860 ) -> ::fidl_next::SendFuture<'_, ___T>
18861 where
18862 <___T as ::fidl_next::Transport>::SendBuffer:
18863 ::fidl_next::encoder::InternalHandleEncoder,
18864 <___T as ::fidl_next::Transport>::SendBuffer:
18865 ::fdomain_client::fidl_next::HandleEncoder,
18866 {
18867 self.list_extended_attributes_with(
18868 crate::generic::NodeListExtendedAttributesRequest { iterator },
18869 )
18870 }
18871
18872 #[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.READ_BYTES`] right.\n"]
18873 pub fn list_extended_attributes_with<___R>(
18874 &self,
18875 request: ___R,
18876 ) -> ::fidl_next::SendFuture<'_, ___T>
18877 where
18878 ___R: ::fidl_next::Encode<
18879 crate::wire::NodeListExtendedAttributesRequest,
18880 <___T as ::fidl_next::Transport>::SendBuffer,
18881 >,
18882 {
18883 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
18884 5431626189872037072,
18885 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
18886 request,
18887 ))
18888 }
18889
18890 #[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.READ_BYTES`] right.\n"]
18891 pub fn get_extended_attribute(
18892 &self,
18893
18894 name: impl ::fidl_next::Encode<
18895 ::fidl_next::wire::Vector<'static, u8>,
18896 <___T as ::fidl_next::Transport>::SendBuffer,
18897 >,
18898 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
18899 where
18900 <___T as ::fidl_next::Transport>::SendBuffer:
18901 ::fidl_next::encoder::InternalHandleEncoder,
18902 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18903 {
18904 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
18905 name,
18906 })
18907 }
18908
18909 #[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.READ_BYTES`] right.\n"]
18910 pub fn get_extended_attribute_with<___R>(
18911 &self,
18912 request: ___R,
18913 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
18914 where
18915 ___R: ::fidl_next::Encode<
18916 crate::wire::NodeGetExtendedAttributeRequest<'static>,
18917 <___T as ::fidl_next::Transport>::SendBuffer,
18918 >,
18919 {
18920 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18921 5043930208506967771,
18922 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
18923 request,
18924 ))
18925 }
18926
18927 #[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.WRITE_BYTES`] right.\n"]
18928 pub fn set_extended_attribute(
18929 &self,
18930
18931 name: impl ::fidl_next::Encode<
18932 ::fidl_next::wire::Vector<'static, u8>,
18933 <___T as ::fidl_next::Transport>::SendBuffer,
18934 >,
18935
18936 value: impl ::fidl_next::Encode<
18937 crate::wire::ExtendedAttributeValue<'static>,
18938 <___T as ::fidl_next::Transport>::SendBuffer,
18939 >,
18940
18941 mode: impl ::fidl_next::Encode<
18942 crate::wire::SetExtendedAttributeMode,
18943 <___T as ::fidl_next::Transport>::SendBuffer,
18944 >,
18945 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
18946 where
18947 <___T as ::fidl_next::Transport>::SendBuffer:
18948 ::fidl_next::encoder::InternalHandleEncoder,
18949 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18950 <___T as ::fidl_next::Transport>::SendBuffer:
18951 ::fdomain_client::fidl_next::HandleEncoder,
18952 {
18953 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
18954 name,
18955
18956 value,
18957
18958 mode,
18959 })
18960 }
18961
18962 #[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.WRITE_BYTES`] right.\n"]
18963 pub fn set_extended_attribute_with<___R>(
18964 &self,
18965 request: ___R,
18966 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
18967 where
18968 ___R: ::fidl_next::Encode<
18969 crate::wire::NodeSetExtendedAttributeRequest<'static>,
18970 <___T as ::fidl_next::Transport>::SendBuffer,
18971 >,
18972 {
18973 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18974 5374223046099989052,
18975 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
18976 request,
18977 ))
18978 }
18979
18980 #[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.WRITE_BYTES`] right.\n"]
18981 pub fn remove_extended_attribute(
18982 &self,
18983
18984 name: impl ::fidl_next::Encode<
18985 ::fidl_next::wire::Vector<'static, u8>,
18986 <___T as ::fidl_next::Transport>::SendBuffer,
18987 >,
18988 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
18989 where
18990 <___T as ::fidl_next::Transport>::SendBuffer:
18991 ::fidl_next::encoder::InternalHandleEncoder,
18992 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18993 {
18994 self.remove_extended_attribute_with(
18995 crate::generic::NodeRemoveExtendedAttributeRequest { name },
18996 )
18997 }
18998
18999 #[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.WRITE_BYTES`] right.\n"]
19000 pub fn remove_extended_attribute_with<___R>(
19001 &self,
19002 request: ___R,
19003 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
19004 where
19005 ___R: ::fidl_next::Encode<
19006 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
19007 <___T as ::fidl_next::Transport>::SendBuffer,
19008 >,
19009 {
19010 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
19011 8794297771444732717,
19012 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
19013 request,
19014 ))
19015 }
19016
19017 #[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"]
19018 pub fn open(
19019 &self,
19020
19021 path: impl ::fidl_next::Encode<
19022 ::fidl_next::wire::String<'static>,
19023 <___T as ::fidl_next::Transport>::SendBuffer,
19024 >,
19025
19026 flags: impl ::fidl_next::Encode<
19027 crate::wire::Flags,
19028 <___T as ::fidl_next::Transport>::SendBuffer,
19029 >,
19030
19031 options: impl ::fidl_next::Encode<
19032 crate::wire::Options<'static>,
19033 <___T as ::fidl_next::Transport>::SendBuffer,
19034 >,
19035
19036 object: impl ::fidl_next::Encode<
19037 ::fdomain_client::fidl_next::wire::Handle,
19038 <___T as ::fidl_next::Transport>::SendBuffer,
19039 >,
19040 ) -> ::fidl_next::SendFuture<'_, ___T>
19041 where
19042 <___T as ::fidl_next::Transport>::SendBuffer:
19043 ::fidl_next::encoder::InternalHandleEncoder,
19044 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
19045 <___T as ::fidl_next::Transport>::SendBuffer:
19046 ::fdomain_client::fidl_next::HandleEncoder,
19047 {
19048 self.open_with(crate::generic::OpenableOpenRequest { path, flags, options, object })
19049 }
19050
19051 #[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"]
19052 pub fn open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
19053 where
19054 ___R: ::fidl_next::Encode<
19055 crate::wire::OpenableOpenRequest<'static>,
19056 <___T as ::fidl_next::Transport>::SendBuffer,
19057 >,
19058 {
19059 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
19060 6236883748953765593,
19061 <super::Open as ::fidl_next::Method>::FLEXIBILITY,
19062 request,
19063 ))
19064 }
19065
19066 pub fn describe(&self) -> ::fidl_next::TwoWayFuture<'_, super::Describe, ___T> {
19067 ::fidl_next::TwoWayFuture::from_untyped(
19068 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
19069 8371117097481679347,
19070 <super::Describe as ::fidl_next::Method>::FLEXIBILITY,
19071 (),
19072 ),
19073 )
19074 }
19075 }
19076
19077 #[repr(transparent)]
19079 pub struct SymlinkServer<___T: ::fidl_next::Transport> {
19080 server: ::fidl_next::protocol::Server<___T>,
19081 }
19082
19083 impl<___T> SymlinkServer<___T>
19084 where
19085 ___T: ::fidl_next::Transport,
19086 {
19087 #[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"]
19088 pub fn on_open(
19089 &self,
19090
19091 s: impl ::fidl_next::Encode<
19092 ::fidl_next::wire::fuchsia::StatusResult,
19093 <___T as ::fidl_next::Transport>::SendBuffer,
19094 >,
19095
19096 info: impl ::fidl_next::Encode<
19097 crate::wire_optional::NodeInfoDeprecated<'static>,
19098 <___T as ::fidl_next::Transport>::SendBuffer,
19099 >,
19100 ) -> ::fidl_next::SendFuture<'_, ___T>
19101 where
19102 <___T as ::fidl_next::Transport>::SendBuffer:
19103 ::fidl_next::encoder::InternalHandleEncoder,
19104 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
19105 <___T as ::fidl_next::Transport>::SendBuffer:
19106 ::fdomain_client::fidl_next::HandleEncoder,
19107 {
19108 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
19109 }
19110
19111 #[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"]
19112
19113 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
19114 where
19115 ___R: ::fidl_next::Encode<
19116 <super::OnOpen as ::fidl_next::Method>::Request,
19117 <___T as ::fidl_next::Transport>::SendBuffer,
19118 >,
19119 {
19120 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
19121 9207534335756671346,
19122 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
19123 request,
19124 ))
19125 }
19126
19127 #[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"]
19128
19129 pub fn on_representation_with<___R>(
19130 &self,
19131 request: ___R,
19132 ) -> ::fidl_next::SendFuture<'_, ___T>
19133 where
19134 ___R: ::fidl_next::Encode<
19135 <super::OnRepresentation as ::fidl_next::Method>::Request,
19136 <___T as ::fidl_next::Transport>::SendBuffer,
19137 >,
19138 {
19139 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
19140 6679970090861613324,
19141 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
19142 request,
19143 ))
19144 }
19145 }
19146 }
19147}
19148
19149#[diagnostic::on_unimplemented(
19150 note = "If {Self} implements the non-local SymlinkClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
19151)]
19152
19153pub trait SymlinkLocalClientHandler<
19157 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
19158 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19159>
19160{
19161 #[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"]
19162 fn on_open(
19163 &mut self,
19164
19165 request: ::fidl_next::Request<symlink::OnOpen, ___T>,
19166 ) -> impl ::core::future::Future<Output = ()>;
19167
19168 #[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"]
19169 fn on_representation(
19170 &mut self,
19171
19172 request: ::fidl_next::Request<symlink::OnRepresentation, ___T>,
19173 ) -> impl ::core::future::Future<Output = ()>;
19174
19175 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
19176 ::core::future::ready(())
19177 }
19178}
19179
19180impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Symlink
19181where
19182 ___H: SymlinkLocalClientHandler<___T>,
19183 ___T: ::fidl_next::Transport,
19184 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
19185 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19186 Constraint = (),
19187 >,
19188 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
19189 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19190 Constraint = (),
19191 >,
19192{
19193 async fn on_event(
19194 handler: &mut ___H,
19195 mut message: ::fidl_next::Message<___T>,
19196 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
19197 match *message.header().ordinal {
19198 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19199 Ok(decoded) => {
19200 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
19201 Ok(())
19202 }
19203 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19204 ordinal: 9207534335756671346,
19205 error,
19206 }),
19207 },
19208
19209 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19210 Ok(decoded) => {
19211 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
19212 Ok(())
19213 }
19214 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19215 ordinal: 6679970090861613324,
19216 error,
19217 }),
19218 },
19219
19220 ordinal => {
19221 handler.on_unknown_interaction(ordinal).await;
19222 if ::core::matches!(
19223 message.header().flexibility(),
19224 ::fidl_next::protocol::Flexibility::Strict
19225 ) {
19226 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19227 } else {
19228 Ok(())
19229 }
19230 }
19231 }
19232 }
19233}
19234
19235#[diagnostic::on_unimplemented(
19236 note = "If {Self} implements the non-local SymlinkServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
19237)]
19238
19239pub trait SymlinkLocalServerHandler<
19243 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
19244 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19245>
19246{
19247 #[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"]
19248 fn link_into(
19249 &mut self,
19250
19251 request: ::fidl_next::Request<symlink::LinkInto, ___T>,
19252
19253 responder: ::fidl_next::Responder<symlink::LinkInto, ___T>,
19254 ) -> impl ::core::future::Future<Output = ()>;
19255
19256 fn clone(
19257 &mut self,
19258
19259 request: ::fidl_next::Request<symlink::Clone, ___T>,
19260 ) -> impl ::core::future::Future<Output = ()>;
19261
19262 #[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"]
19263 fn close(
19264 &mut self,
19265
19266 responder: ::fidl_next::Responder<symlink::Close, ___T>,
19267 ) -> impl ::core::future::Future<Output = ()>;
19268
19269 fn query(
19270 &mut self,
19271
19272 responder: ::fidl_next::Responder<symlink::Query, ___T>,
19273 ) -> impl ::core::future::Future<Output = ()>;
19274
19275 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
19276 fn deprecated_get_attr(
19277 &mut self,
19278
19279 responder: ::fidl_next::Responder<symlink::DeprecatedGetAttr, ___T>,
19280 ) -> impl ::core::future::Future<Output = ()>;
19281
19282 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
19283 fn deprecated_set_attr(
19284 &mut self,
19285
19286 request: ::fidl_next::Request<symlink::DeprecatedSetAttr, ___T>,
19287
19288 responder: ::fidl_next::Responder<symlink::DeprecatedSetAttr, ___T>,
19289 ) -> impl ::core::future::Future<Output = ()>;
19290
19291 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
19292 fn deprecated_get_flags(
19293 &mut self,
19294
19295 responder: ::fidl_next::Responder<symlink::DeprecatedGetFlags, ___T>,
19296 ) -> impl ::core::future::Future<Output = ()>;
19297
19298 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
19299 fn deprecated_set_flags(
19300 &mut self,
19301
19302 request: ::fidl_next::Request<symlink::DeprecatedSetFlags, ___T>,
19303
19304 responder: ::fidl_next::Responder<symlink::DeprecatedSetFlags, ___T>,
19305 ) -> impl ::core::future::Future<Output = ()>;
19306
19307 #[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"]
19308 fn get_flags(
19309 &mut self,
19310
19311 responder: ::fidl_next::Responder<symlink::GetFlags, ___T>,
19312 ) -> impl ::core::future::Future<Output = ()>;
19313
19314 #[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"]
19315 fn set_flags(
19316 &mut self,
19317
19318 request: ::fidl_next::Request<symlink::SetFlags, ___T>,
19319
19320 responder: ::fidl_next::Responder<symlink::SetFlags, ___T>,
19321 ) -> impl ::core::future::Future<Output = ()>;
19322
19323 #[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"]
19324 fn query_filesystem(
19325 &mut self,
19326
19327 responder: ::fidl_next::Responder<symlink::QueryFilesystem, ___T>,
19328 ) -> impl ::core::future::Future<Output = ()>;
19329
19330 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
19331 fn get_token(
19332 &mut self,
19333
19334 responder: ::fidl_next::Responder<symlink::GetToken, ___T>,
19335 ) -> impl ::core::future::Future<Output = ()>;
19336
19337 #[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"]
19338 fn get_attributes(
19339 &mut self,
19340
19341 request: ::fidl_next::Request<symlink::GetAttributes, ___T>,
19342
19343 responder: ::fidl_next::Responder<symlink::GetAttributes, ___T>,
19344 ) -> impl ::core::future::Future<Output = ()>;
19345
19346 #[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"]
19347 fn update_attributes(
19348 &mut self,
19349
19350 request: ::fidl_next::Request<symlink::UpdateAttributes, ___T>,
19351
19352 responder: ::fidl_next::Responder<symlink::UpdateAttributes, ___T>,
19353 ) -> impl ::core::future::Future<Output = ()>;
19354
19355 #[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"]
19356 fn sync(
19357 &mut self,
19358
19359 responder: ::fidl_next::Responder<symlink::Sync, ___T>,
19360 ) -> impl ::core::future::Future<Output = ()>;
19361
19362 #[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.READ_BYTES`] right.\n"]
19363 fn list_extended_attributes(
19364 &mut self,
19365
19366 request: ::fidl_next::Request<symlink::ListExtendedAttributes, ___T>,
19367 ) -> impl ::core::future::Future<Output = ()>;
19368
19369 #[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.READ_BYTES`] right.\n"]
19370 fn get_extended_attribute(
19371 &mut self,
19372
19373 request: ::fidl_next::Request<symlink::GetExtendedAttribute, ___T>,
19374
19375 responder: ::fidl_next::Responder<symlink::GetExtendedAttribute, ___T>,
19376 ) -> impl ::core::future::Future<Output = ()>;
19377
19378 #[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.WRITE_BYTES`] right.\n"]
19379 fn set_extended_attribute(
19380 &mut self,
19381
19382 request: ::fidl_next::Request<symlink::SetExtendedAttribute, ___T>,
19383
19384 responder: ::fidl_next::Responder<symlink::SetExtendedAttribute, ___T>,
19385 ) -> impl ::core::future::Future<Output = ()>;
19386
19387 #[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.WRITE_BYTES`] right.\n"]
19388 fn remove_extended_attribute(
19389 &mut self,
19390
19391 request: ::fidl_next::Request<symlink::RemoveExtendedAttribute, ___T>,
19392
19393 responder: ::fidl_next::Responder<symlink::RemoveExtendedAttribute, ___T>,
19394 ) -> impl ::core::future::Future<Output = ()>;
19395
19396 #[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"]
19397 fn open(
19398 &mut self,
19399
19400 request: ::fidl_next::Request<symlink::Open, ___T>,
19401 ) -> impl ::core::future::Future<Output = ()>;
19402
19403 fn describe(
19404 &mut self,
19405
19406 responder: ::fidl_next::Responder<symlink::Describe, ___T>,
19407 ) -> impl ::core::future::Future<Output = ()>;
19408
19409 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
19410 ::core::future::ready(())
19411 }
19412}
19413
19414impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Symlink
19415where
19416 ___H: SymlinkLocalServerHandler<___T>,
19417 ___T: ::fidl_next::Transport,
19418 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
19419 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19420 Constraint = (),
19421 >,
19422 for<'de> ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
19423 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19424 Constraint = (),
19425 >,
19426 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
19427 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19428 Constraint = (),
19429 >,
19430 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
19431 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19432 Constraint = (),
19433 >,
19434 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
19435 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19436 Constraint = (),
19437 >,
19438 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
19439 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19440 Constraint = (),
19441 >,
19442 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
19443 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19444 Constraint = (),
19445 >,
19446 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
19447 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19448 Constraint = (),
19449 >,
19450 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
19451 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19452 Constraint = (),
19453 >,
19454 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
19455 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19456 Constraint = (),
19457 >,
19458 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
19459 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19460 Constraint = (),
19461 >,
19462 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
19463 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19464 Constraint = (),
19465 >,
19466{
19467 async fn on_one_way(
19468 handler: &mut ___H,
19469 mut message: ::fidl_next::Message<___T>,
19470 ) -> ::core::result::Result<
19471 (),
19472 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19473 > {
19474 match *message.header().ordinal {
19475 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19476 Ok(decoded) => {
19477 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
19478 Ok(())
19479 }
19480 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19481 ordinal: 2366825959783828089,
19482 error,
19483 }),
19484 },
19485
19486 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19487 Ok(decoded) => {
19488 handler
19489 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
19490 .await;
19491 Ok(())
19492 }
19493 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19494 ordinal: 5431626189872037072,
19495 error,
19496 }),
19497 },
19498
19499 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19500 Ok(decoded) => {
19501 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
19502 Ok(())
19503 }
19504 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19505 ordinal: 6236883748953765593,
19506 error,
19507 }),
19508 },
19509
19510 ordinal => {
19511 handler.on_unknown_interaction(ordinal).await;
19512 if ::core::matches!(
19513 message.header().flexibility(),
19514 ::fidl_next::protocol::Flexibility::Strict
19515 ) {
19516 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19517 } else {
19518 Ok(())
19519 }
19520 }
19521 }
19522 }
19523
19524 async fn on_two_way(
19525 handler: &mut ___H,
19526 mut message: ::fidl_next::Message<___T>,
19527 responder: ::fidl_next::protocol::Responder<___T>,
19528 ) -> ::core::result::Result<
19529 (),
19530 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19531 > {
19532 match *message.header().ordinal {
19533 6121399674497678964 => {
19534 let responder = ::fidl_next::Responder::from_untyped(responder);
19535
19536 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19537 Ok(decoded) => {
19538 handler
19539 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
19540 .await;
19541 Ok(())
19542 }
19543 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19544 ordinal: 6121399674497678964,
19545 error,
19546 }),
19547 }
19548 }
19549
19550 6540867515453498750 => {
19551 let responder = ::fidl_next::Responder::from_untyped(responder);
19552
19553 handler.close(responder).await;
19554 Ok(())
19555 }
19556
19557 2763219980499352582 => {
19558 let responder = ::fidl_next::Responder::from_untyped(responder);
19559
19560 handler.query(responder).await;
19561 Ok(())
19562 }
19563
19564 8689798978500614909 => {
19565 let responder = ::fidl_next::Responder::from_untyped(responder);
19566
19567 handler.deprecated_get_attr(responder).await;
19568 Ok(())
19569 }
19570
19571 4721673413776871238 => {
19572 let responder = ::fidl_next::Responder::from_untyped(responder);
19573
19574 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19575 Ok(decoded) => {
19576 handler
19577 .deprecated_set_attr(
19578 ::fidl_next::Request::from_decoded(decoded),
19579 responder,
19580 )
19581 .await;
19582 Ok(())
19583 }
19584 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19585 ordinal: 4721673413776871238,
19586 error,
19587 }),
19588 }
19589 }
19590
19591 6595803110182632097 => {
19592 let responder = ::fidl_next::Responder::from_untyped(responder);
19593
19594 handler.deprecated_get_flags(responder).await;
19595 Ok(())
19596 }
19597
19598 5950864159036794675 => {
19599 let responder = ::fidl_next::Responder::from_untyped(responder);
19600
19601 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19602 Ok(decoded) => {
19603 handler
19604 .deprecated_set_flags(
19605 ::fidl_next::Request::from_decoded(decoded),
19606 responder,
19607 )
19608 .await;
19609 Ok(())
19610 }
19611 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19612 ordinal: 5950864159036794675,
19613 error,
19614 }),
19615 }
19616 }
19617
19618 105530239381466147 => {
19619 let responder = ::fidl_next::Responder::from_untyped(responder);
19620
19621 handler.get_flags(responder).await;
19622 Ok(())
19623 }
19624
19625 6172186066099445416 => {
19626 let responder = ::fidl_next::Responder::from_untyped(responder);
19627
19628 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19629 Ok(decoded) => {
19630 handler
19631 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
19632 .await;
19633 Ok(())
19634 }
19635 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19636 ordinal: 6172186066099445416,
19637 error,
19638 }),
19639 }
19640 }
19641
19642 8013111122914313744 => {
19643 let responder = ::fidl_next::Responder::from_untyped(responder);
19644
19645 handler.query_filesystem(responder).await;
19646 Ok(())
19647 }
19648
19649 5788516050773961964 => {
19650 let responder = ::fidl_next::Responder::from_untyped(responder);
19651
19652 handler.get_token(responder).await;
19653 Ok(())
19654 }
19655
19656 4414537700416816443 => {
19657 let responder = ::fidl_next::Responder::from_untyped(responder);
19658
19659 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19660 Ok(decoded) => {
19661 handler
19662 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
19663 .await;
19664 Ok(())
19665 }
19666 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19667 ordinal: 4414537700416816443,
19668 error,
19669 }),
19670 }
19671 }
19672
19673 3677402239314018056 => {
19674 let responder = ::fidl_next::Responder::from_untyped(responder);
19675
19676 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19677 Ok(decoded) => {
19678 handler
19679 .update_attributes(
19680 ::fidl_next::Request::from_decoded(decoded),
19681 responder,
19682 )
19683 .await;
19684 Ok(())
19685 }
19686 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19687 ordinal: 3677402239314018056,
19688 error,
19689 }),
19690 }
19691 }
19692
19693 3196473584242777161 => {
19694 let responder = ::fidl_next::Responder::from_untyped(responder);
19695
19696 handler.sync(responder).await;
19697 Ok(())
19698 }
19699
19700 5043930208506967771 => {
19701 let responder = ::fidl_next::Responder::from_untyped(responder);
19702
19703 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19704 Ok(decoded) => {
19705 handler
19706 .get_extended_attribute(
19707 ::fidl_next::Request::from_decoded(decoded),
19708 responder,
19709 )
19710 .await;
19711 Ok(())
19712 }
19713 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19714 ordinal: 5043930208506967771,
19715 error,
19716 }),
19717 }
19718 }
19719
19720 5374223046099989052 => {
19721 let responder = ::fidl_next::Responder::from_untyped(responder);
19722
19723 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19724 Ok(decoded) => {
19725 handler
19726 .set_extended_attribute(
19727 ::fidl_next::Request::from_decoded(decoded),
19728 responder,
19729 )
19730 .await;
19731 Ok(())
19732 }
19733 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19734 ordinal: 5374223046099989052,
19735 error,
19736 }),
19737 }
19738 }
19739
19740 8794297771444732717 => {
19741 let responder = ::fidl_next::Responder::from_untyped(responder);
19742
19743 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19744 Ok(decoded) => {
19745 handler
19746 .remove_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: 8794297771444732717,
19755 error,
19756 }),
19757 }
19758 }
19759
19760 8371117097481679347 => {
19761 let responder = ::fidl_next::Responder::from_untyped(responder);
19762
19763 handler.describe(responder).await;
19764 Ok(())
19765 }
19766
19767 ordinal => {
19768 handler.on_unknown_interaction(ordinal).await;
19769 if ::core::matches!(
19770 message.header().flexibility(),
19771 ::fidl_next::protocol::Flexibility::Strict
19772 ) {
19773 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19774 } else {
19775 responder
19776 .respond_framework_error(
19777 ordinal,
19778 ::fidl_next::FrameworkError::UnknownMethod,
19779 )
19780 .expect("encoding a framework error should never fail")
19781 .await?;
19782 Ok(())
19783 }
19784 }
19785 }
19786 }
19787}
19788
19789pub trait SymlinkClientHandler<
19793 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
19794 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19795>
19796{
19797 #[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"]
19798 fn on_open(
19799 &mut self,
19800
19801 request: ::fidl_next::Request<symlink::OnOpen, ___T>,
19802 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19803
19804 #[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"]
19805 fn on_representation(
19806 &mut self,
19807
19808 request: ::fidl_next::Request<symlink::OnRepresentation, ___T>,
19809 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19810
19811 fn on_unknown_interaction(
19812 &mut self,
19813 ordinal: u64,
19814 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19815 ::core::future::ready(())
19816 }
19817}
19818
19819impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Symlink
19820where
19821 ___H: SymlinkClientHandler<___T> + ::core::marker::Send,
19822 ___T: ::fidl_next::Transport,
19823 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
19824 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19825 Constraint = (),
19826 >,
19827 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
19828 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19829 Constraint = (),
19830 >,
19831{
19832 async fn on_event(
19833 handler: &mut ___H,
19834 mut message: ::fidl_next::Message<___T>,
19835 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
19836 match *message.header().ordinal {
19837 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19838 Ok(decoded) => {
19839 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
19840 Ok(())
19841 }
19842 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19843 ordinal: 9207534335756671346,
19844 error,
19845 }),
19846 },
19847
19848 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19849 Ok(decoded) => {
19850 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
19851 Ok(())
19852 }
19853 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19854 ordinal: 6679970090861613324,
19855 error,
19856 }),
19857 },
19858
19859 ordinal => {
19860 handler.on_unknown_interaction(ordinal).await;
19861 if ::core::matches!(
19862 message.header().flexibility(),
19863 ::fidl_next::protocol::Flexibility::Strict
19864 ) {
19865 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19866 } else {
19867 Ok(())
19868 }
19869 }
19870 }
19871 }
19872}
19873
19874pub trait SymlinkServerHandler<
19878 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fdomain_client::Channel,
19879 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19880>
19881{
19882 #[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"]
19883 fn link_into(
19884 &mut self,
19885
19886 request: ::fidl_next::Request<symlink::LinkInto, ___T>,
19887
19888 responder: ::fidl_next::Responder<symlink::LinkInto, ___T>,
19889 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19890
19891 fn clone(
19892 &mut self,
19893
19894 request: ::fidl_next::Request<symlink::Clone, ___T>,
19895 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19896
19897 #[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"]
19898 fn close(
19899 &mut self,
19900
19901 responder: ::fidl_next::Responder<symlink::Close, ___T>,
19902 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19903
19904 fn query(
19905 &mut self,
19906
19907 responder: ::fidl_next::Responder<symlink::Query, ___T>,
19908 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19909
19910 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
19911 fn deprecated_get_attr(
19912 &mut self,
19913
19914 responder: ::fidl_next::Responder<symlink::DeprecatedGetAttr, ___T>,
19915 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19916
19917 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
19918 fn deprecated_set_attr(
19919 &mut self,
19920
19921 request: ::fidl_next::Request<symlink::DeprecatedSetAttr, ___T>,
19922
19923 responder: ::fidl_next::Responder<symlink::DeprecatedSetAttr, ___T>,
19924 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19925
19926 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
19927 fn deprecated_get_flags(
19928 &mut self,
19929
19930 responder: ::fidl_next::Responder<symlink::DeprecatedGetFlags, ___T>,
19931 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19932
19933 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
19934 fn deprecated_set_flags(
19935 &mut self,
19936
19937 request: ::fidl_next::Request<symlink::DeprecatedSetFlags, ___T>,
19938
19939 responder: ::fidl_next::Responder<symlink::DeprecatedSetFlags, ___T>,
19940 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19941
19942 #[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"]
19943 fn get_flags(
19944 &mut self,
19945
19946 responder: ::fidl_next::Responder<symlink::GetFlags, ___T>,
19947 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19948
19949 #[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"]
19950 fn set_flags(
19951 &mut self,
19952
19953 request: ::fidl_next::Request<symlink::SetFlags, ___T>,
19954
19955 responder: ::fidl_next::Responder<symlink::SetFlags, ___T>,
19956 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19957
19958 #[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"]
19959 fn query_filesystem(
19960 &mut self,
19961
19962 responder: ::fidl_next::Responder<symlink::QueryFilesystem, ___T>,
19963 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19964
19965 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
19966 fn get_token(
19967 &mut self,
19968
19969 responder: ::fidl_next::Responder<symlink::GetToken, ___T>,
19970 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19971
19972 #[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"]
19973 fn get_attributes(
19974 &mut self,
19975
19976 request: ::fidl_next::Request<symlink::GetAttributes, ___T>,
19977
19978 responder: ::fidl_next::Responder<symlink::GetAttributes, ___T>,
19979 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19980
19981 #[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"]
19982 fn update_attributes(
19983 &mut self,
19984
19985 request: ::fidl_next::Request<symlink::UpdateAttributes, ___T>,
19986
19987 responder: ::fidl_next::Responder<symlink::UpdateAttributes, ___T>,
19988 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19989
19990 #[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"]
19991 fn sync(
19992 &mut self,
19993
19994 responder: ::fidl_next::Responder<symlink::Sync, ___T>,
19995 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19996
19997 #[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.READ_BYTES`] right.\n"]
19998 fn list_extended_attributes(
19999 &mut self,
20000
20001 request: ::fidl_next::Request<symlink::ListExtendedAttributes, ___T>,
20002 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
20003
20004 #[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.READ_BYTES`] right.\n"]
20005 fn get_extended_attribute(
20006 &mut self,
20007
20008 request: ::fidl_next::Request<symlink::GetExtendedAttribute, ___T>,
20009
20010 responder: ::fidl_next::Responder<symlink::GetExtendedAttribute, ___T>,
20011 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
20012
20013 #[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.WRITE_BYTES`] right.\n"]
20014 fn set_extended_attribute(
20015 &mut self,
20016
20017 request: ::fidl_next::Request<symlink::SetExtendedAttribute, ___T>,
20018
20019 responder: ::fidl_next::Responder<symlink::SetExtendedAttribute, ___T>,
20020 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
20021
20022 #[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.WRITE_BYTES`] right.\n"]
20023 fn remove_extended_attribute(
20024 &mut self,
20025
20026 request: ::fidl_next::Request<symlink::RemoveExtendedAttribute, ___T>,
20027
20028 responder: ::fidl_next::Responder<symlink::RemoveExtendedAttribute, ___T>,
20029 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
20030
20031 #[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"]
20032 fn open(
20033 &mut self,
20034
20035 request: ::fidl_next::Request<symlink::Open, ___T>,
20036 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
20037
20038 fn describe(
20039 &mut self,
20040
20041 responder: ::fidl_next::Responder<symlink::Describe, ___T>,
20042 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
20043
20044 fn on_unknown_interaction(
20045 &mut self,
20046 ordinal: u64,
20047 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
20048 ::core::future::ready(())
20049 }
20050}
20051
20052impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Symlink
20053where
20054 ___H: SymlinkServerHandler<___T> + ::core::marker::Send,
20055 ___T: ::fidl_next::Transport,
20056 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
20057 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20058 Constraint = (),
20059 >,
20060 for<'de> ::fdomain_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
20061 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20062 Constraint = (),
20063 >,
20064 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
20065 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20066 Constraint = (),
20067 >,
20068 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
20069 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20070 Constraint = (),
20071 >,
20072 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
20073 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20074 Constraint = (),
20075 >,
20076 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
20077 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20078 Constraint = (),
20079 >,
20080 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
20081 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20082 Constraint = (),
20083 >,
20084 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
20085 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20086 Constraint = (),
20087 >,
20088 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
20089 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20090 Constraint = (),
20091 >,
20092 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
20093 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20094 Constraint = (),
20095 >,
20096 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
20097 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20098 Constraint = (),
20099 >,
20100 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
20101 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20102 Constraint = (),
20103 >,
20104{
20105 async fn on_one_way(
20106 handler: &mut ___H,
20107 mut message: ::fidl_next::Message<___T>,
20108 ) -> ::core::result::Result<
20109 (),
20110 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20111 > {
20112 match *message.header().ordinal {
20113 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
20114 Ok(decoded) => {
20115 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
20116 Ok(())
20117 }
20118 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20119 ordinal: 2366825959783828089,
20120 error,
20121 }),
20122 },
20123
20124 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
20125 Ok(decoded) => {
20126 handler
20127 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
20128 .await;
20129 Ok(())
20130 }
20131 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20132 ordinal: 5431626189872037072,
20133 error,
20134 }),
20135 },
20136
20137 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
20138 Ok(decoded) => {
20139 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
20140 Ok(())
20141 }
20142 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20143 ordinal: 6236883748953765593,
20144 error,
20145 }),
20146 },
20147
20148 ordinal => {
20149 handler.on_unknown_interaction(ordinal).await;
20150 if ::core::matches!(
20151 message.header().flexibility(),
20152 ::fidl_next::protocol::Flexibility::Strict
20153 ) {
20154 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20155 } else {
20156 Ok(())
20157 }
20158 }
20159 }
20160 }
20161
20162 async fn on_two_way(
20163 handler: &mut ___H,
20164 mut message: ::fidl_next::Message<___T>,
20165 responder: ::fidl_next::protocol::Responder<___T>,
20166 ) -> ::core::result::Result<
20167 (),
20168 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20169 > {
20170 match *message.header().ordinal {
20171 6121399674497678964 => {
20172 let responder = ::fidl_next::Responder::from_untyped(responder);
20173
20174 match ::fidl_next::AsDecoderExt::into_decoded(message) {
20175 Ok(decoded) => {
20176 handler
20177 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
20178 .await;
20179 Ok(())
20180 }
20181 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20182 ordinal: 6121399674497678964,
20183 error,
20184 }),
20185 }
20186 }
20187
20188 6540867515453498750 => {
20189 let responder = ::fidl_next::Responder::from_untyped(responder);
20190
20191 handler.close(responder).await;
20192 Ok(())
20193 }
20194
20195 2763219980499352582 => {
20196 let responder = ::fidl_next::Responder::from_untyped(responder);
20197
20198 handler.query(responder).await;
20199 Ok(())
20200 }
20201
20202 8689798978500614909 => {
20203 let responder = ::fidl_next::Responder::from_untyped(responder);
20204
20205 handler.deprecated_get_attr(responder).await;
20206 Ok(())
20207 }
20208
20209 4721673413776871238 => {
20210 let responder = ::fidl_next::Responder::from_untyped(responder);
20211
20212 match ::fidl_next::AsDecoderExt::into_decoded(message) {
20213 Ok(decoded) => {
20214 handler
20215 .deprecated_set_attr(
20216 ::fidl_next::Request::from_decoded(decoded),
20217 responder,
20218 )
20219 .await;
20220 Ok(())
20221 }
20222 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20223 ordinal: 4721673413776871238,
20224 error,
20225 }),
20226 }
20227 }
20228
20229 6595803110182632097 => {
20230 let responder = ::fidl_next::Responder::from_untyped(responder);
20231
20232 handler.deprecated_get_flags(responder).await;
20233 Ok(())
20234 }
20235
20236 5950864159036794675 => {
20237 let responder = ::fidl_next::Responder::from_untyped(responder);
20238
20239 match ::fidl_next::AsDecoderExt::into_decoded(message) {
20240 Ok(decoded) => {
20241 handler
20242 .deprecated_set_flags(
20243 ::fidl_next::Request::from_decoded(decoded),
20244 responder,
20245 )
20246 .await;
20247 Ok(())
20248 }
20249 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20250 ordinal: 5950864159036794675,
20251 error,
20252 }),
20253 }
20254 }
20255
20256 105530239381466147 => {
20257 let responder = ::fidl_next::Responder::from_untyped(responder);
20258
20259 handler.get_flags(responder).await;
20260 Ok(())
20261 }
20262
20263 6172186066099445416 => {
20264 let responder = ::fidl_next::Responder::from_untyped(responder);
20265
20266 match ::fidl_next::AsDecoderExt::into_decoded(message) {
20267 Ok(decoded) => {
20268 handler
20269 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
20270 .await;
20271 Ok(())
20272 }
20273 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20274 ordinal: 6172186066099445416,
20275 error,
20276 }),
20277 }
20278 }
20279
20280 8013111122914313744 => {
20281 let responder = ::fidl_next::Responder::from_untyped(responder);
20282
20283 handler.query_filesystem(responder).await;
20284 Ok(())
20285 }
20286
20287 5788516050773961964 => {
20288 let responder = ::fidl_next::Responder::from_untyped(responder);
20289
20290 handler.get_token(responder).await;
20291 Ok(())
20292 }
20293
20294 4414537700416816443 => {
20295 let responder = ::fidl_next::Responder::from_untyped(responder);
20296
20297 match ::fidl_next::AsDecoderExt::into_decoded(message) {
20298 Ok(decoded) => {
20299 handler
20300 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
20301 .await;
20302 Ok(())
20303 }
20304 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20305 ordinal: 4414537700416816443,
20306 error,
20307 }),
20308 }
20309 }
20310
20311 3677402239314018056 => {
20312 let responder = ::fidl_next::Responder::from_untyped(responder);
20313
20314 match ::fidl_next::AsDecoderExt::into_decoded(message) {
20315 Ok(decoded) => {
20316 handler
20317 .update_attributes(
20318 ::fidl_next::Request::from_decoded(decoded),
20319 responder,
20320 )
20321 .await;
20322 Ok(())
20323 }
20324 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20325 ordinal: 3677402239314018056,
20326 error,
20327 }),
20328 }
20329 }
20330
20331 3196473584242777161 => {
20332 let responder = ::fidl_next::Responder::from_untyped(responder);
20333
20334 handler.sync(responder).await;
20335 Ok(())
20336 }
20337
20338 5043930208506967771 => {
20339 let responder = ::fidl_next::Responder::from_untyped(responder);
20340
20341 match ::fidl_next::AsDecoderExt::into_decoded(message) {
20342 Ok(decoded) => {
20343 handler
20344 .get_extended_attribute(
20345 ::fidl_next::Request::from_decoded(decoded),
20346 responder,
20347 )
20348 .await;
20349 Ok(())
20350 }
20351 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20352 ordinal: 5043930208506967771,
20353 error,
20354 }),
20355 }
20356 }
20357
20358 5374223046099989052 => {
20359 let responder = ::fidl_next::Responder::from_untyped(responder);
20360
20361 match ::fidl_next::AsDecoderExt::into_decoded(message) {
20362 Ok(decoded) => {
20363 handler
20364 .set_extended_attribute(
20365 ::fidl_next::Request::from_decoded(decoded),
20366 responder,
20367 )
20368 .await;
20369 Ok(())
20370 }
20371 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20372 ordinal: 5374223046099989052,
20373 error,
20374 }),
20375 }
20376 }
20377
20378 8794297771444732717 => {
20379 let responder = ::fidl_next::Responder::from_untyped(responder);
20380
20381 match ::fidl_next::AsDecoderExt::into_decoded(message) {
20382 Ok(decoded) => {
20383 handler
20384 .remove_extended_attribute(
20385 ::fidl_next::Request::from_decoded(decoded),
20386 responder,
20387 )
20388 .await;
20389 Ok(())
20390 }
20391 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20392 ordinal: 8794297771444732717,
20393 error,
20394 }),
20395 }
20396 }
20397
20398 8371117097481679347 => {
20399 let responder = ::fidl_next::Responder::from_untyped(responder);
20400
20401 handler.describe(responder).await;
20402 Ok(())
20403 }
20404
20405 ordinal => {
20406 handler.on_unknown_interaction(ordinal).await;
20407 if ::core::matches!(
20408 message.header().flexibility(),
20409 ::fidl_next::protocol::Flexibility::Strict
20410 ) {
20411 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20412 } else {
20413 responder
20414 .respond_framework_error(
20415 ordinal,
20416 ::fidl_next::FrameworkError::UnknownMethod,
20417 )
20418 .expect("encoding a framework error should never fail")
20419 .await?;
20420 Ok(())
20421 }
20422 }
20423 }
20424 }
20425}
20426
20427impl<___T> SymlinkClientHandler<___T> for ::fidl_next::IgnoreEvents
20428where
20429 ___T: ::fidl_next::Transport,
20430{
20431 async fn on_open(&mut self, _: ::fidl_next::Request<symlink::OnOpen, ___T>) {}
20432
20433 async fn on_representation(
20434 &mut self,
20435
20436 _: ::fidl_next::Request<symlink::OnRepresentation, ___T>,
20437 ) {
20438 }
20439
20440 async fn on_unknown_interaction(&mut self, _: u64) {}
20441}
20442
20443impl<___H, ___T> SymlinkLocalClientHandler<___T> for ::fidl_next::Local<___H>
20444where
20445 ___H: SymlinkClientHandler<___T>,
20446 ___T: ::fidl_next::Transport,
20447{
20448 async fn on_open(&mut self, request: ::fidl_next::Request<symlink::OnOpen, ___T>) {
20449 ___H::on_open(&mut self.0, request).await
20450 }
20451
20452 async fn on_representation(
20453 &mut self,
20454
20455 request: ::fidl_next::Request<symlink::OnRepresentation, ___T>,
20456 ) {
20457 ___H::on_representation(&mut self.0, request).await
20458 }
20459
20460 async fn on_unknown_interaction(&mut self, ordinal: u64) {
20461 ___H::on_unknown_interaction(&mut self.0, ordinal).await
20462 }
20463}
20464
20465impl<___H, ___T> SymlinkLocalServerHandler<___T> for ::fidl_next::Local<___H>
20466where
20467 ___H: SymlinkServerHandler<___T>,
20468 ___T: ::fidl_next::Transport,
20469{
20470 async fn link_into(
20471 &mut self,
20472
20473 request: ::fidl_next::Request<symlink::LinkInto, ___T>,
20474
20475 responder: ::fidl_next::Responder<symlink::LinkInto, ___T>,
20476 ) {
20477 ___H::link_into(&mut self.0, request, responder).await
20478 }
20479
20480 async fn clone(&mut self, request: ::fidl_next::Request<symlink::Clone, ___T>) {
20481 ___H::clone(&mut self.0, request).await
20482 }
20483
20484 async fn close(&mut self, responder: ::fidl_next::Responder<symlink::Close, ___T>) {
20485 ___H::close(&mut self.0, responder).await
20486 }
20487
20488 async fn query(&mut self, responder: ::fidl_next::Responder<symlink::Query, ___T>) {
20489 ___H::query(&mut self.0, responder).await
20490 }
20491
20492 async fn deprecated_get_attr(
20493 &mut self,
20494
20495 responder: ::fidl_next::Responder<symlink::DeprecatedGetAttr, ___T>,
20496 ) {
20497 ___H::deprecated_get_attr(&mut self.0, responder).await
20498 }
20499
20500 async fn deprecated_set_attr(
20501 &mut self,
20502
20503 request: ::fidl_next::Request<symlink::DeprecatedSetAttr, ___T>,
20504
20505 responder: ::fidl_next::Responder<symlink::DeprecatedSetAttr, ___T>,
20506 ) {
20507 ___H::deprecated_set_attr(&mut self.0, request, responder).await
20508 }
20509
20510 async fn deprecated_get_flags(
20511 &mut self,
20512
20513 responder: ::fidl_next::Responder<symlink::DeprecatedGetFlags, ___T>,
20514 ) {
20515 ___H::deprecated_get_flags(&mut self.0, responder).await
20516 }
20517
20518 async fn deprecated_set_flags(
20519 &mut self,
20520
20521 request: ::fidl_next::Request<symlink::DeprecatedSetFlags, ___T>,
20522
20523 responder: ::fidl_next::Responder<symlink::DeprecatedSetFlags, ___T>,
20524 ) {
20525 ___H::deprecated_set_flags(&mut self.0, request, responder).await
20526 }
20527
20528 async fn get_flags(&mut self, responder: ::fidl_next::Responder<symlink::GetFlags, ___T>) {
20529 ___H::get_flags(&mut self.0, responder).await
20530 }
20531
20532 async fn set_flags(
20533 &mut self,
20534
20535 request: ::fidl_next::Request<symlink::SetFlags, ___T>,
20536
20537 responder: ::fidl_next::Responder<symlink::SetFlags, ___T>,
20538 ) {
20539 ___H::set_flags(&mut self.0, request, responder).await
20540 }
20541
20542 async fn query_filesystem(
20543 &mut self,
20544
20545 responder: ::fidl_next::Responder<symlink::QueryFilesystem, ___T>,
20546 ) {
20547 ___H::query_filesystem(&mut self.0, responder).await
20548 }
20549
20550 async fn get_token(&mut self, responder: ::fidl_next::Responder<symlink::GetToken, ___T>) {
20551 ___H::get_token(&mut self.0, responder).await
20552 }
20553
20554 async fn get_attributes(
20555 &mut self,
20556
20557 request: ::fidl_next::Request<symlink::GetAttributes, ___T>,
20558
20559 responder: ::fidl_next::Responder<symlink::GetAttributes, ___T>,
20560 ) {
20561 ___H::get_attributes(&mut self.0, request, responder).await
20562 }
20563
20564 async fn update_attributes(
20565 &mut self,
20566
20567 request: ::fidl_next::Request<symlink::UpdateAttributes, ___T>,
20568
20569 responder: ::fidl_next::Responder<symlink::UpdateAttributes, ___T>,
20570 ) {
20571 ___H::update_attributes(&mut self.0, request, responder).await
20572 }
20573
20574 async fn sync(&mut self, responder: ::fidl_next::Responder<symlink::Sync, ___T>) {
20575 ___H::sync(&mut self.0, responder).await
20576 }
20577
20578 async fn list_extended_attributes(
20579 &mut self,
20580
20581 request: ::fidl_next::Request<symlink::ListExtendedAttributes, ___T>,
20582 ) {
20583 ___H::list_extended_attributes(&mut self.0, request).await
20584 }
20585
20586 async fn get_extended_attribute(
20587 &mut self,
20588
20589 request: ::fidl_next::Request<symlink::GetExtendedAttribute, ___T>,
20590
20591 responder: ::fidl_next::Responder<symlink::GetExtendedAttribute, ___T>,
20592 ) {
20593 ___H::get_extended_attribute(&mut self.0, request, responder).await
20594 }
20595
20596 async fn set_extended_attribute(
20597 &mut self,
20598
20599 request: ::fidl_next::Request<symlink::SetExtendedAttribute, ___T>,
20600
20601 responder: ::fidl_next::Responder<symlink::SetExtendedAttribute, ___T>,
20602 ) {
20603 ___H::set_extended_attribute(&mut self.0, request, responder).await
20604 }
20605
20606 async fn remove_extended_attribute(
20607 &mut self,
20608
20609 request: ::fidl_next::Request<symlink::RemoveExtendedAttribute, ___T>,
20610
20611 responder: ::fidl_next::Responder<symlink::RemoveExtendedAttribute, ___T>,
20612 ) {
20613 ___H::remove_extended_attribute(&mut self.0, request, responder).await
20614 }
20615
20616 async fn open(&mut self, request: ::fidl_next::Request<symlink::Open, ___T>) {
20617 ___H::open(&mut self.0, request).await
20618 }
20619
20620 async fn describe(&mut self, responder: ::fidl_next::Responder<symlink::Describe, ___T>) {
20621 ___H::describe(&mut self.0, responder).await
20622 }
20623
20624 async fn on_unknown_interaction(&mut self, ordinal: u64) {
20625 ___H::on_unknown_interaction(&mut self.0, ordinal).await
20626 }
20627}
20628
20629pub use fidl_next_common_fuchsia_io::*;