| // DO NOT EDIT: This file is machine-generated by fidlgen |
| #![warn(clippy::all)] |
| #![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)] |
| |
| pub mod natural { |
| |
| pub type Alias = u32; |
| |
| ::fidl_next::bitflags::bitflags! { |
| #[derive( |
| Clone, |
| Copy, |
| Debug, |
| PartialEq, |
| Eq, |
| Hash, |
| )] |
| pub struct ExampleBits: u32 { |
| const MEMBER = 1; |
| |
| } |
| } |
| |
| unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExampleBits, ___E> for ExampleBits |
| where |
| ___E: ?Sized, |
| { |
| #[inline] |
| fn encode( |
| self, |
| encoder: &mut ___E, |
| out: &mut ::core::mem::MaybeUninit<crate::wire::ExampleBits>, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::Encode::encode(&self, encoder, out, ()) |
| } |
| } |
| |
| unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExampleBits, ___E> for &'a ExampleBits |
| where |
| ___E: ?Sized, |
| { |
| #[inline] |
| fn encode( |
| self, |
| _: &mut ___E, |
| out: &mut ::core::mem::MaybeUninit<crate::wire::ExampleBits>, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge!(let crate::wire::ExampleBits { value } = out); |
| |
| if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) { |
| return Err(::fidl_next::EncodeError::InvalidStrictBits); |
| } |
| |
| let _ = value.write(::fidl_next::WireU32::from(self.bits())); |
| Ok(()) |
| } |
| } |
| |
| impl ::core::convert::From<crate::wire::ExampleBits> for ExampleBits { |
| fn from(wire: crate::wire::ExampleBits) -> Self { |
| Self::from_bits_retain(u32::from(wire.value)) |
| } |
| } |
| |
| impl ::fidl_next::FromWire<crate::wire::ExampleBits> for ExampleBits { |
| #[inline] |
| fn from_wire(wire: crate::wire::ExampleBits) -> Self { |
| Self::from(wire) |
| } |
| } |
| |
| impl ::fidl_next::FromWireRef<crate::wire::ExampleBits> for ExampleBits { |
| #[inline] |
| fn from_wire_ref(wire: &crate::wire::ExampleBits) -> Self { |
| Self::from(*wire) |
| } |
| } |
| |
| #[derive(Clone, Copy, Debug, PartialEq, Eq)] |
| #[repr(u32)] |
| pub enum ExampleEnum { |
| Member = 1, |
| } |
| impl ::core::convert::TryFrom<u32> for ExampleEnum { |
| type Error = ::fidl_next::UnknownStrictEnumMemberError; |
| fn try_from( |
| value: u32, |
| ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> { |
| match value { |
| 1 => Ok(Self::Member), |
| |
| _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())), |
| } |
| } |
| } |
| |
| unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExampleEnum, ___E> for ExampleEnum |
| where |
| ___E: ?Sized, |
| { |
| #[inline] |
| fn encode( |
| self, |
| encoder: &mut ___E, |
| out: &mut ::core::mem::MaybeUninit<crate::wire::ExampleEnum>, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::Encode::encode(&self, encoder, out, ()) |
| } |
| } |
| |
| unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExampleEnum, ___E> for &'a ExampleEnum |
| where |
| ___E: ?Sized, |
| { |
| #[inline] |
| fn encode( |
| self, |
| encoder: &mut ___E, |
| out: &mut ::core::mem::MaybeUninit<crate::wire::ExampleEnum>, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge!(let crate::wire::ExampleEnum { value } = out); |
| let _ = value.write(::fidl_next::WireU32::from(match *self { |
| ExampleEnum::Member => 1, |
| })); |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::core::convert::From<crate::wire::ExampleEnum> for ExampleEnum { |
| fn from(wire: crate::wire::ExampleEnum) -> Self { |
| match u32::from(wire.value) { |
| 1 => Self::Member, |
| |
| _ => unsafe { ::core::hint::unreachable_unchecked() }, |
| } |
| } |
| } |
| |
| impl ::fidl_next::FromWire<crate::wire::ExampleEnum> for ExampleEnum { |
| #[inline] |
| fn from_wire(wire: crate::wire::ExampleEnum) -> Self { |
| Self::from(wire) |
| } |
| } |
| |
| impl ::fidl_next::FromWireRef<crate::wire::ExampleEnum> for ExampleEnum { |
| #[inline] |
| fn from_wire_ref(wire: &crate::wire::ExampleEnum) -> Self { |
| Self::from(*wire) |
| } |
| } |
| |
| #[derive(PartialEq, Clone, Debug)] |
| #[repr(C)] |
| pub struct ExampleProtocolMethodRequest { |
| pub arg: ::fidl_next_common_test_exampleusing::natural::Empty, |
| } |
| |
| unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExampleProtocolMethodRequest, ___E> |
| for ExampleProtocolMethodRequest |
| where |
| ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized, |
| { |
| const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization< |
| Self, |
| crate::wire::ExampleProtocolMethodRequest, |
| > = unsafe { |
| ::fidl_next::CopyOptimization::enable_if( |
| true |
| |
| && < |
| ::fidl_next_common_test_exampleusing::natural::Empty as ::fidl_next::Encode<::fidl_next_common_test_exampleusing::wire::Empty, ___E> |
| >::COPY_OPTIMIZATION.is_enabled() |
| |
| ) |
| }; |
| |
| #[inline] |
| fn encode( |
| self, |
| encoder_: &mut ___E, |
| out_: &mut ::core::mem::MaybeUninit<crate::wire::ExampleProtocolMethodRequest>, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge! { |
| let crate::wire::ExampleProtocolMethodRequest { |
| arg, |
| |
| } = out_; |
| } |
| |
| ::fidl_next::Encode::encode(self.arg, encoder_, arg, ())?; |
| |
| let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(arg.as_mut_ptr()) }; |
| |
| Ok(()) |
| } |
| } |
| |
| unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExampleProtocolMethodRequest, ___E> |
| for &'a ExampleProtocolMethodRequest |
| where |
| ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized, |
| { |
| #[inline] |
| fn encode( |
| self, |
| encoder_: &mut ___E, |
| out_: &mut ::core::mem::MaybeUninit<crate::wire::ExampleProtocolMethodRequest>, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge! { |
| let crate::wire::ExampleProtocolMethodRequest { |
| |
| arg, |
| |
| } = out_; |
| } |
| |
| ::fidl_next::Encode::encode(&self.arg, encoder_, arg, ())?; |
| |
| let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(arg.as_mut_ptr()) }; |
| |
| Ok(()) |
| } |
| } |
| |
| unsafe impl<___E> |
| ::fidl_next::EncodeOption< |
| ::fidl_next::WireBox<'static, crate::wire::ExampleProtocolMethodRequest>, |
| ___E, |
| > for ExampleProtocolMethodRequest |
| where |
| ___E: ::fidl_next::Encoder + ?Sized, |
| ExampleProtocolMethodRequest: |
| ::fidl_next::Encode<crate::wire::ExampleProtocolMethodRequest, ___E>, |
| { |
| #[inline] |
| fn encode_option( |
| this: ::core::option::Option<Self>, |
| encoder: &mut ___E, |
| out: &mut ::core::mem::MaybeUninit< |
| ::fidl_next::WireBox<'static, crate::wire::ExampleProtocolMethodRequest>, |
| >, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| if let Some(inner) = this { |
| ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?; |
| ::fidl_next::WireBox::encode_present(out); |
| } else { |
| ::fidl_next::WireBox::encode_absent(out); |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| unsafe impl<'a, ___E> |
| ::fidl_next::EncodeOption< |
| ::fidl_next::WireBox<'static, crate::wire::ExampleProtocolMethodRequest>, |
| ___E, |
| > for &'a ExampleProtocolMethodRequest |
| where |
| ___E: ::fidl_next::Encoder + ?Sized, |
| &'a ExampleProtocolMethodRequest: |
| ::fidl_next::Encode<crate::wire::ExampleProtocolMethodRequest, ___E>, |
| { |
| #[inline] |
| fn encode_option( |
| this: ::core::option::Option<Self>, |
| encoder: &mut ___E, |
| out: &mut ::core::mem::MaybeUninit< |
| ::fidl_next::WireBox<'static, crate::wire::ExampleProtocolMethodRequest>, |
| >, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| if let Some(inner) = this { |
| ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?; |
| ::fidl_next::WireBox::encode_present(out); |
| } else { |
| ::fidl_next::WireBox::encode_absent(out); |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::fidl_next::FromWire<crate::wire::ExampleProtocolMethodRequest> |
| for ExampleProtocolMethodRequest |
| { |
| const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization< |
| crate::wire::ExampleProtocolMethodRequest, |
| Self, |
| > = unsafe { |
| ::fidl_next::CopyOptimization::enable_if( |
| true |
| |
| && < |
| ::fidl_next_common_test_exampleusing::natural::Empty as ::fidl_next::FromWire<::fidl_next_common_test_exampleusing::wire::Empty> |
| >::COPY_OPTIMIZATION.is_enabled() |
| |
| ) |
| }; |
| |
| #[inline] |
| fn from_wire(wire: crate::wire::ExampleProtocolMethodRequest) -> Self { |
| Self { arg: ::fidl_next::FromWire::from_wire(wire.arg) } |
| } |
| } |
| |
| impl ::fidl_next::FromWireRef<crate::wire::ExampleProtocolMethodRequest> |
| for ExampleProtocolMethodRequest |
| { |
| #[inline] |
| fn from_wire_ref(wire: &crate::wire::ExampleProtocolMethodRequest) -> Self { |
| Self { arg: ::fidl_next::FromWireRef::from_wire_ref(&wire.arg) } |
| } |
| } |
| |
| #[derive(PartialEq, Clone, Debug)] |
| #[repr(C)] |
| pub struct ExampleStruct { |
| pub member: u32, |
| } |
| |
| unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExampleStruct, ___E> for ExampleStruct |
| where |
| ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized, |
| { |
| const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::ExampleStruct> = unsafe { |
| ::fidl_next::CopyOptimization::enable_if( |
| true && <u32 as ::fidl_next::Encode<::fidl_next::WireU32, ___E>>::COPY_OPTIMIZATION |
| .is_enabled(), |
| ) |
| }; |
| |
| #[inline] |
| fn encode( |
| self, |
| encoder_: &mut ___E, |
| out_: &mut ::core::mem::MaybeUninit<crate::wire::ExampleStruct>, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge! { |
| let crate::wire::ExampleStruct { |
| member, |
| |
| } = out_; |
| } |
| |
| ::fidl_next::Encode::encode(self.member, encoder_, member, ())?; |
| |
| let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(member.as_mut_ptr()) }; |
| |
| Ok(()) |
| } |
| } |
| |
| unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExampleStruct, ___E> for &'a ExampleStruct |
| where |
| ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized, |
| { |
| #[inline] |
| fn encode( |
| self, |
| encoder_: &mut ___E, |
| out_: &mut ::core::mem::MaybeUninit<crate::wire::ExampleStruct>, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge! { |
| let crate::wire::ExampleStruct { |
| |
| member, |
| |
| } = out_; |
| } |
| |
| ::fidl_next::Encode::encode(&self.member, encoder_, member, ())?; |
| |
| let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(member.as_mut_ptr()) }; |
| |
| Ok(()) |
| } |
| } |
| |
| unsafe impl<___E> |
| ::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::ExampleStruct>, ___E> |
| for ExampleStruct |
| where |
| ___E: ::fidl_next::Encoder + ?Sized, |
| ExampleStruct: ::fidl_next::Encode<crate::wire::ExampleStruct, ___E>, |
| { |
| #[inline] |
| fn encode_option( |
| this: ::core::option::Option<Self>, |
| encoder: &mut ___E, |
| out: &mut ::core::mem::MaybeUninit< |
| ::fidl_next::WireBox<'static, crate::wire::ExampleStruct>, |
| >, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| if let Some(inner) = this { |
| ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?; |
| ::fidl_next::WireBox::encode_present(out); |
| } else { |
| ::fidl_next::WireBox::encode_absent(out); |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| unsafe impl<'a, ___E> |
| ::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::ExampleStruct>, ___E> |
| for &'a ExampleStruct |
| where |
| ___E: ::fidl_next::Encoder + ?Sized, |
| &'a ExampleStruct: ::fidl_next::Encode<crate::wire::ExampleStruct, ___E>, |
| { |
| #[inline] |
| fn encode_option( |
| this: ::core::option::Option<Self>, |
| encoder: &mut ___E, |
| out: &mut ::core::mem::MaybeUninit< |
| ::fidl_next::WireBox<'static, crate::wire::ExampleStruct>, |
| >, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| if let Some(inner) = this { |
| ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?; |
| ::fidl_next::WireBox::encode_present(out); |
| } else { |
| ::fidl_next::WireBox::encode_absent(out); |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::fidl_next::FromWire<crate::wire::ExampleStruct> for ExampleStruct { |
| const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::ExampleStruct, Self> = unsafe { |
| ::fidl_next::CopyOptimization::enable_if( |
| true && <u32 as ::fidl_next::FromWire<::fidl_next::WireU32>>::COPY_OPTIMIZATION |
| .is_enabled(), |
| ) |
| }; |
| |
| #[inline] |
| fn from_wire(wire: crate::wire::ExampleStruct) -> Self { |
| Self { member: ::fidl_next::FromWire::from_wire(wire.member) } |
| } |
| } |
| |
| impl ::fidl_next::FromWireRef<crate::wire::ExampleStruct> for ExampleStruct { |
| #[inline] |
| fn from_wire_ref(wire: &crate::wire::ExampleStruct) -> Self { |
| Self { member: ::fidl_next::FromWireRef::from_wire_ref(&wire.member) } |
| } |
| } |
| |
| #[derive(PartialEq, Clone, Debug, Default)] |
| pub struct ExampleTable { |
| pub member: ::core::option::Option<u32>, |
| } |
| |
| impl ExampleTable { |
| fn __max_ordinal(&self) -> usize { |
| if self.member.is_some() { |
| return 1; |
| } |
| |
| 0 |
| } |
| } |
| |
| unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExampleTable<'static>, ___E> for ExampleTable |
| where |
| ___E: ::fidl_next::Encoder + ?Sized, |
| { |
| #[inline] |
| fn encode( |
| mut self, |
| encoder: &mut ___E, |
| out: &mut ::core::mem::MaybeUninit<crate::wire::ExampleTable<'static>>, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge!(let crate::wire::ExampleTable { table } = out); |
| |
| let max_ord = self.__max_ordinal(); |
| |
| let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit(); |
| ::fidl_next::Wire::zero_padding(&mut out); |
| |
| let mut preallocated = |
| ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord); |
| |
| for i in 1..=max_ord { |
| match i { |
| 1 => { |
| if let Some(value) = self.member.take() { |
| ::fidl_next::WireEnvelope::encode_value::<::fidl_next::WireU32, ___E>( |
| value, |
| preallocated.encoder, |
| &mut out, |
| (), |
| )?; |
| } else { |
| ::fidl_next::WireEnvelope::encode_zero(&mut out) |
| } |
| } |
| |
| _ => ::fidl_next::WireEnvelope::encode_zero(&mut out), |
| } |
| unsafe { |
| preallocated.write_next(out.assume_init_ref()); |
| } |
| } |
| |
| ::fidl_next::WireTable::encode_len(table, max_ord); |
| |
| Ok(()) |
| } |
| } |
| |
| unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExampleTable<'static>, ___E> |
| for &'a ExampleTable |
| where |
| ___E: ::fidl_next::Encoder + ?Sized, |
| { |
| #[inline] |
| fn encode( |
| self, |
| encoder: &mut ___E, |
| out: &mut ::core::mem::MaybeUninit<crate::wire::ExampleTable<'static>>, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge!(let crate::wire::ExampleTable { table } = out); |
| |
| let max_ord = self.__max_ordinal(); |
| |
| let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit(); |
| ::fidl_next::Wire::zero_padding(&mut out); |
| |
| let mut preallocated = |
| ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord); |
| |
| for i in 1..=max_ord { |
| match i { |
| 1 => { |
| if let Some(value) = &self.member { |
| ::fidl_next::WireEnvelope::encode_value::<::fidl_next::WireU32, ___E>( |
| value, |
| preallocated.encoder, |
| &mut out, |
| (), |
| )?; |
| } else { |
| ::fidl_next::WireEnvelope::encode_zero(&mut out) |
| } |
| } |
| |
| _ => ::fidl_next::WireEnvelope::encode_zero(&mut out), |
| } |
| unsafe { |
| preallocated.write_next(out.assume_init_ref()); |
| } |
| } |
| |
| ::fidl_next::WireTable::encode_len(table, max_ord); |
| |
| Ok(()) |
| } |
| } |
| |
| impl<'de> ::fidl_next::FromWire<crate::wire::ExampleTable<'de>> for ExampleTable { |
| #[inline] |
| fn from_wire(wire_: crate::wire::ExampleTable<'de>) -> Self { |
| let wire_ = ::core::mem::ManuallyDrop::new(wire_); |
| |
| let member = wire_.table.get(1); |
| |
| Self { |
| member: member.map(|envelope| { |
| ::fidl_next::FromWire::from_wire(unsafe { |
| envelope.read_unchecked::<::fidl_next::WireU32>() |
| }) |
| }), |
| } |
| } |
| } |
| |
| impl<'de> ::fidl_next::FromWireRef<crate::wire::ExampleTable<'de>> for ExampleTable { |
| #[inline] |
| fn from_wire_ref(wire: &crate::wire::ExampleTable<'de>) -> Self { |
| Self { |
| member: wire.table.get(1).map(|envelope| { |
| ::fidl_next::FromWireRef::from_wire_ref(unsafe { |
| envelope.deref_unchecked::<::fidl_next::WireU32>() |
| }) |
| }), |
| } |
| } |
| } |
| |
| #[derive(PartialEq, Clone, Debug)] |
| pub enum ExampleUnion { |
| Variant(u32), |
| } |
| |
| unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExampleUnion, ___E> for ExampleUnion |
| where |
| ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized, |
| { |
| #[inline] |
| fn encode( |
| self, |
| encoder: &mut ___E, |
| out: &mut ::core::mem::MaybeUninit<crate::wire::ExampleUnion>, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge!(let crate::wire::ExampleUnion { raw, _phantom: _ } = out); |
| |
| match self { |
| Self::Variant(value) => ::fidl_next::RawWireUnion::encode_as_static::< |
| ___E, |
| ::fidl_next::WireU32, |
| >(value, 1, encoder, raw, ())?, |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExampleUnion, ___E> for &'a ExampleUnion |
| where |
| ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized, |
| { |
| #[inline] |
| fn encode( |
| self, |
| encoder: &mut ___E, |
| out: &mut ::core::mem::MaybeUninit<crate::wire::ExampleUnion>, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge!(let crate::wire::ExampleUnion { raw, _phantom: _ } = out); |
| |
| match self { |
| ExampleUnion::Variant(value) => ::fidl_next::RawWireUnion::encode_as_static::< |
| ___E, |
| ::fidl_next::WireU32, |
| >(value, 1, encoder, raw, ())?, |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::ExampleUnion, ___E> |
| for ExampleUnion |
| where |
| ___E: ?Sized, |
| ExampleUnion: ::fidl_next::Encode<crate::wire::ExampleUnion, ___E>, |
| { |
| #[inline] |
| fn encode_option( |
| this: ::core::option::Option<Self>, |
| encoder: &mut ___E, |
| out: &mut ::core::mem::MaybeUninit<crate::wire_optional::ExampleUnion>, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge!(let crate::wire_optional::ExampleUnion { raw, _phantom: _ } = &mut *out); |
| |
| if let Some(inner) = this { |
| let value_out = unsafe { &mut *out.as_mut_ptr().cast() }; |
| ::fidl_next::Encode::encode(inner, encoder, value_out, ())?; |
| } else { |
| ::fidl_next::RawWireUnion::encode_absent(raw); |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| unsafe impl<'a, ___E> ::fidl_next::EncodeOption<crate::wire_optional::ExampleUnion, ___E> |
| for &'a ExampleUnion |
| where |
| ___E: ?Sized, |
| &'a ExampleUnion: ::fidl_next::Encode<crate::wire::ExampleUnion, ___E>, |
| { |
| #[inline] |
| fn encode_option( |
| this: ::core::option::Option<Self>, |
| encoder: &mut ___E, |
| out: &mut ::core::mem::MaybeUninit<crate::wire_optional::ExampleUnion>, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge!(let crate::wire_optional::ExampleUnion { raw, _phantom: _ } = &mut *out); |
| |
| if let Some(inner) = this { |
| let value_out = unsafe { &mut *out.as_mut_ptr().cast() }; |
| ::fidl_next::Encode::encode(inner, encoder, value_out, ())?; |
| } else { |
| ::fidl_next::RawWireUnion::encode_absent(raw); |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::fidl_next::FromWire<crate::wire::ExampleUnion> for ExampleUnion { |
| #[inline] |
| fn from_wire(wire: crate::wire::ExampleUnion) -> Self { |
| let wire = ::core::mem::ManuallyDrop::new(wire); |
| match wire.raw.ordinal() { |
| 1 => Self::Variant(::fidl_next::FromWire::from_wire(unsafe { |
| wire.raw.get().read_unchecked::<::fidl_next::WireU32>() |
| })), |
| |
| _ => unsafe { ::core::hint::unreachable_unchecked() }, |
| } |
| } |
| } |
| |
| impl ::fidl_next::FromWireRef<crate::wire::ExampleUnion> for ExampleUnion { |
| #[inline] |
| fn from_wire_ref(wire: &crate::wire::ExampleUnion) -> Self { |
| match wire.raw.ordinal() { |
| 1 => Self::Variant(::fidl_next::FromWireRef::from_wire_ref(unsafe { |
| wire.raw.get().deref_unchecked::<::fidl_next::WireU32>() |
| })), |
| |
| _ => unsafe { ::core::hint::unreachable_unchecked() }, |
| } |
| } |
| } |
| |
| impl ::fidl_next::FromWireOption<crate::wire_optional::ExampleUnion> for ExampleUnion { |
| #[inline] |
| fn from_wire_option( |
| wire: crate::wire_optional::ExampleUnion, |
| ) -> ::core::option::Option<Self> { |
| if let Some(inner) = wire.into_option() { |
| Some(::fidl_next::FromWire::from_wire(inner)) |
| } else { |
| None |
| } |
| } |
| } |
| |
| impl ::fidl_next::FromWireOption<crate::wire_optional::ExampleUnion> for Box<ExampleUnion> { |
| #[inline] |
| fn from_wire_option( |
| wire: crate::wire_optional::ExampleUnion, |
| ) -> ::core::option::Option<Self> { |
| < |
| ExampleUnion as ::fidl_next::FromWireOption<crate::wire_optional::ExampleUnion> |
| >::from_wire_option(wire).map(Box::new) |
| } |
| } |
| |
| impl ::fidl_next::FromWireOptionRef<crate::wire_optional::ExampleUnion> for Box<ExampleUnion> { |
| #[inline] |
| fn from_wire_option_ref( |
| wire: &crate::wire_optional::ExampleUnion, |
| ) -> ::core::option::Option<Self> { |
| if let Some(inner) = wire.as_ref() { |
| Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner))) |
| } else { |
| None |
| } |
| } |
| } |
| } |
| |
| pub mod wire { |
| |
| /// The wire type corresponding to [`Alias`](crate::natural::Alias). |
| pub type Alias = ::fidl_next::WireU32; |
| |
| /// The wire type corresponding to [`ExampleBits`](crate::natural::ExampleBits). |
| #[derive(Clone, Copy, Debug)] |
| #[repr(transparent)] |
| pub struct ExampleBits { |
| pub(crate) value: ::fidl_next::WireU32, |
| } |
| |
| unsafe impl ::fidl_next::Wire for ExampleBits { |
| type Owned<'de> = Self; |
| |
| #[inline] |
| fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) { |
| // Wire bits have no padding |
| } |
| } |
| |
| unsafe impl<___D> ::fidl_next::Decode<___D> for ExampleBits |
| where |
| ___D: ?Sized, |
| { |
| fn decode( |
| slot: ::fidl_next::Slot<'_, Self>, |
| _: &mut ___D, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::DecodeError> { |
| ::fidl_next::munge!(let Self { value } = slot); |
| let set = u32::from(*value); |
| if set & !crate::natural::ExampleBits::all().bits() != 0 { |
| return Err(::fidl_next::DecodeError::InvalidBits { |
| expected: crate::natural::ExampleBits::all().bits() as usize, |
| actual: set as usize, |
| }); |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::core::convert::From<crate::natural::ExampleBits> for ExampleBits { |
| fn from(natural: crate::natural::ExampleBits) -> Self { |
| Self { value: ::fidl_next::WireU32::from(natural.bits()) } |
| } |
| } |
| |
| impl ::fidl_next::IntoNatural for ExampleBits { |
| type Natural = crate::natural::ExampleBits; |
| } |
| |
| impl ::fidl_next::Unconstrained for ExampleBits {} |
| |
| /// The wire type corresponding to [`ExampleEnum`]. |
| #[derive(Clone, Copy, Debug, PartialEq, Eq)] |
| #[repr(transparent)] |
| pub struct ExampleEnum { |
| pub(crate) value: ::fidl_next::WireU32, |
| } |
| |
| unsafe impl ::fidl_next::Wire for ExampleEnum { |
| type Owned<'de> = Self; |
| |
| #[inline] |
| fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) { |
| // Wire enums have no padding |
| } |
| } |
| |
| impl ExampleEnum { |
| pub const MEMBER: ExampleEnum = ExampleEnum { value: ::fidl_next::WireU32(1) }; |
| } |
| |
| unsafe impl<___D> ::fidl_next::Decode<___D> for ExampleEnum |
| where |
| ___D: ?Sized, |
| { |
| fn decode( |
| slot: ::fidl_next::Slot<'_, Self>, |
| _: &mut ___D, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::DecodeError> { |
| ::fidl_next::munge!(let Self { value } = slot); |
| |
| match u32::from(*value) { |
| 1 => (), |
| unknown => { |
| return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128)); |
| } |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::core::convert::From<crate::natural::ExampleEnum> for ExampleEnum { |
| fn from(natural: crate::natural::ExampleEnum) -> Self { |
| match natural { |
| crate::natural::ExampleEnum::Member => ExampleEnum::MEMBER, |
| } |
| } |
| } |
| |
| impl ::fidl_next::IntoNatural for ExampleEnum { |
| type Natural = crate::natural::ExampleEnum; |
| } |
| |
| impl ::fidl_next::Unconstrained for ExampleEnum {} |
| |
| /// The wire type corresponding to [`ExampleProtocolMethodRequest`]. |
| #[derive(Clone, Debug)] |
| #[repr(C)] |
| pub struct ExampleProtocolMethodRequest { |
| pub arg: ::fidl_next_common_test_exampleusing::wire::Empty, |
| } |
| |
| static_assertions::const_assert_eq!(std::mem::size_of::<ExampleProtocolMethodRequest>(), 1); |
| static_assertions::const_assert_eq!(std::mem::align_of::<ExampleProtocolMethodRequest>(), 1); |
| |
| static_assertions::const_assert_eq!(std::mem::offset_of!(ExampleProtocolMethodRequest, arg), 0); |
| |
| unsafe impl ::fidl_next::Wire for ExampleProtocolMethodRequest { |
| type Owned<'de> = ExampleProtocolMethodRequest; |
| |
| #[inline] |
| fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) { |
| ::fidl_next::munge! { |
| let Self { |
| |
| arg, |
| |
| } = &mut *out_; |
| } |
| |
| ::fidl_next::Wire::zero_padding(arg); |
| } |
| } |
| |
| unsafe impl<___D> ::fidl_next::Decode<___D> for ExampleProtocolMethodRequest |
| where |
| ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized, |
| { |
| fn decode( |
| slot_: ::fidl_next::Slot<'_, Self>, |
| decoder_: &mut ___D, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::DecodeError> { |
| ::fidl_next::munge! { |
| let Self { |
| |
| mut arg, |
| |
| } = slot_; |
| } |
| |
| let _field = arg.as_mut(); |
| |
| ::fidl_next::Decode::decode(arg.as_mut(), decoder_, ())?; |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::fidl_next::IntoNatural for ExampleProtocolMethodRequest { |
| type Natural = crate::natural::ExampleProtocolMethodRequest; |
| } |
| |
| impl ::fidl_next::Unconstrained for ExampleProtocolMethodRequest {} |
| |
| /// The wire type corresponding to [`ExampleStruct`]. |
| #[derive(Clone, Debug)] |
| #[repr(C)] |
| pub struct ExampleStruct { |
| pub member: ::fidl_next::WireU32, |
| } |
| |
| static_assertions::const_assert_eq!(std::mem::size_of::<ExampleStruct>(), 4); |
| static_assertions::const_assert_eq!(std::mem::align_of::<ExampleStruct>(), 4); |
| |
| static_assertions::const_assert_eq!(std::mem::offset_of!(ExampleStruct, member), 0); |
| |
| unsafe impl ::fidl_next::Wire for ExampleStruct { |
| type Owned<'de> = ExampleStruct; |
| |
| #[inline] |
| fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) { |
| ::fidl_next::munge! { |
| let Self { |
| |
| member, |
| |
| } = &mut *out_; |
| } |
| |
| ::fidl_next::Wire::zero_padding(member); |
| } |
| } |
| |
| unsafe impl<___D> ::fidl_next::Decode<___D> for ExampleStruct |
| where |
| ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized, |
| { |
| fn decode( |
| slot_: ::fidl_next::Slot<'_, Self>, |
| decoder_: &mut ___D, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::DecodeError> { |
| ::fidl_next::munge! { |
| let Self { |
| |
| mut member, |
| |
| } = slot_; |
| } |
| |
| let _field = member.as_mut(); |
| |
| ::fidl_next::Decode::decode(member.as_mut(), decoder_, ())?; |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::fidl_next::IntoNatural for ExampleStruct { |
| type Natural = crate::natural::ExampleStruct; |
| } |
| |
| impl ::fidl_next::Unconstrained for ExampleStruct {} |
| |
| /// The wire type corresponding to [`ExampleTable`]. |
| #[repr(C)] |
| pub struct ExampleTable<'de> { |
| pub(crate) table: ::fidl_next::WireTable<'de>, |
| } |
| |
| impl<'de> Drop for ExampleTable<'de> { |
| fn drop(&mut self) { |
| let _ = self |
| .table |
| .get(1) |
| .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireU32>() }); |
| } |
| } |
| |
| unsafe impl ::fidl_next::Wire for ExampleTable<'static> { |
| type Owned<'de> = ExampleTable<'de>; |
| |
| #[inline] |
| fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) { |
| ::fidl_next::munge!(let Self { table } = out); |
| ::fidl_next::WireTable::zero_padding(table); |
| } |
| } |
| |
| unsafe impl<___D> ::fidl_next::Decode<___D> for ExampleTable<'static> |
| where |
| ___D: ::fidl_next::Decoder + ?Sized, |
| { |
| fn decode( |
| slot: ::fidl_next::Slot<'_, Self>, |
| decoder: &mut ___D, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::DecodeError> { |
| ::fidl_next::munge!(let Self { table } = slot); |
| |
| ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| { |
| match ordinal { |
| 0 => unsafe { ::core::hint::unreachable_unchecked() }, |
| |
| 1 => { |
| ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireU32>( |
| slot.as_mut(), |
| decoder, |
| (), |
| )?; |
| |
| Ok(()) |
| } |
| |
| _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder), |
| } |
| }) |
| } |
| } |
| |
| impl<'de> ExampleTable<'de> { |
| pub fn member(&self) -> ::core::option::Option<&::fidl_next::WireU32> { |
| unsafe { Some(self.table.get(1)?.deref_unchecked()) } |
| } |
| } |
| |
| impl<'de> ::core::fmt::Debug for ExampleTable<'de> { |
| fn fmt( |
| &self, |
| f: &mut ::core::fmt::Formatter<'_>, |
| ) -> ::core::result::Result<(), ::core::fmt::Error> { |
| f.debug_struct("ExampleTable").field("member", &self.member()).finish() |
| } |
| } |
| |
| impl<'de> ::fidl_next::IntoNatural for ExampleTable<'de> { |
| type Natural = crate::natural::ExampleTable; |
| } |
| |
| impl ::fidl_next::Unconstrained for ExampleTable<'_> {} |
| |
| /// The wire type corresponding to [`ExampleUnion`]. |
| #[repr(transparent)] |
| pub struct ExampleUnion { |
| pub(crate) raw: ::fidl_next::RawWireUnion, |
| pub(crate) _phantom: ::core::marker::PhantomData<()>, |
| } |
| |
| impl Drop for ExampleUnion { |
| fn drop(&mut self) { |
| match self.raw.ordinal() { |
| 1 => { |
| let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireU32>() }; |
| } |
| |
| _ => unsafe { ::core::hint::unreachable_unchecked() }, |
| } |
| } |
| } |
| |
| unsafe impl ::fidl_next::Wire for ExampleUnion { |
| type Owned<'de> = ExampleUnion; |
| |
| #[inline] |
| fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) { |
| ::fidl_next::munge!(let Self { raw, _phantom: _ } = out); |
| ::fidl_next::RawWireUnion::zero_padding(raw); |
| } |
| } |
| |
| pub mod example_union { |
| pub enum Ref<'de> { |
| Variant(&'de ::fidl_next::WireU32), |
| } |
| } |
| |
| impl ExampleUnion { |
| pub fn as_ref(&self) -> crate::wire::example_union::Ref<'_> { |
| match self.raw.ordinal() { |
| 1 => crate::wire::example_union::Ref::Variant(unsafe { |
| self.raw.get().deref_unchecked::<::fidl_next::WireU32>() |
| }), |
| |
| _ => unsafe { ::core::hint::unreachable_unchecked() }, |
| } |
| } |
| } |
| |
| impl Clone for ExampleUnion { |
| fn clone(&self) -> Self { |
| match self.raw.ordinal() { |
| 1 => Self { |
| raw: unsafe { self.raw.clone_inline_unchecked::<::fidl_next::WireU32>() }, |
| _phantom: ::core::marker::PhantomData, |
| }, |
| |
| _ => unsafe { ::core::hint::unreachable_unchecked() }, |
| } |
| } |
| } |
| |
| unsafe impl<___D> ::fidl_next::Decode<___D> for ExampleUnion |
| where |
| ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized, |
| { |
| fn decode( |
| mut slot: ::fidl_next::Slot<'_, Self>, |
| decoder: &mut ___D, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::DecodeError> { |
| ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut()); |
| match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) { |
| 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, ::fidl_next::WireU32>( |
| raw, |
| decoder, |
| (), |
| )?, |
| |
| ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)), |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::core::fmt::Debug for ExampleUnion { |
| fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { |
| match self.raw.ordinal() { |
| 1 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireU32>().fmt(f) }, |
| _ => unsafe { ::core::hint::unreachable_unchecked() }, |
| } |
| } |
| } |
| |
| impl ::fidl_next::IntoNatural for ExampleUnion { |
| type Natural = crate::natural::ExampleUnion; |
| } |
| |
| impl ::fidl_next::Unconstrained for ExampleUnion {} |
| } |
| |
| pub mod wire_optional { |
| |
| #[repr(transparent)] |
| pub struct ExampleUnion { |
| pub(crate) raw: ::fidl_next::RawWireUnion, |
| pub(crate) _phantom: ::core::marker::PhantomData<()>, |
| } |
| |
| unsafe impl ::fidl_next::Wire for ExampleUnion { |
| type Owned<'de> = ExampleUnion; |
| |
| #[inline] |
| fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) { |
| ::fidl_next::munge!(let Self { raw, _phantom: _ } = out); |
| ::fidl_next::RawWireUnion::zero_padding(raw); |
| } |
| } |
| |
| impl ExampleUnion { |
| pub fn is_some(&self) -> bool { |
| self.raw.is_some() |
| } |
| |
| pub fn is_none(&self) -> bool { |
| self.raw.is_none() |
| } |
| |
| pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::ExampleUnion> { |
| if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None } |
| } |
| |
| pub fn into_option(self) -> ::core::option::Option<crate::wire::ExampleUnion> { |
| if self.is_some() { |
| Some(crate::wire::ExampleUnion { |
| raw: self.raw, |
| _phantom: ::core::marker::PhantomData, |
| }) |
| } else { |
| None |
| } |
| } |
| } |
| |
| impl Clone for ExampleUnion { |
| fn clone(&self) -> Self { |
| if self.is_none() { |
| return ExampleUnion { |
| raw: ::fidl_next::RawWireUnion::absent(), |
| _phantom: ::core::marker::PhantomData, |
| }; |
| } |
| |
| match self.raw.ordinal() { |
| 1 => Self { |
| raw: unsafe { self.raw.clone_inline_unchecked::<::fidl_next::WireU32>() }, |
| _phantom: ::core::marker::PhantomData, |
| }, |
| |
| _ => unsafe { ::core::hint::unreachable_unchecked() }, |
| } |
| } |
| } |
| |
| unsafe impl<___D> ::fidl_next::Decode<___D> for ExampleUnion |
| where |
| ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized, |
| { |
| fn decode( |
| mut slot: ::fidl_next::Slot<'_, Self>, |
| decoder: &mut ___D, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::DecodeError> { |
| ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut()); |
| match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) { |
| 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, ::fidl_next::WireU32>( |
| raw, |
| decoder, |
| (), |
| )?, |
| |
| 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?, |
| _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?, |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::core::fmt::Debug for ExampleUnion { |
| fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { |
| self.as_ref().fmt(f) |
| } |
| } |
| |
| impl ::fidl_next::IntoNatural for ExampleUnion { |
| type Natural = ::core::option::Option<crate::natural::ExampleUnion>; |
| } |
| |
| impl ::fidl_next::Unconstrained for ExampleUnion {} |
| } |
| |
| pub mod generic { |
| |
| pub struct ExampleProtocolMethodRequest<T0> { |
| pub arg: T0, |
| } |
| |
| unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ExampleProtocolMethodRequest, ___E> |
| for ExampleProtocolMethodRequest<T0> |
| where |
| ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized, |
| T0: ::fidl_next::Encode<::fidl_next_common_test_exampleusing::wire::Empty, ___E>, |
| { |
| #[inline] |
| fn encode( |
| self, |
| encoder_: &mut ___E, |
| out_: &mut ::core::mem::MaybeUninit<crate::wire::ExampleProtocolMethodRequest>, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge! { |
| let crate::wire::ExampleProtocolMethodRequest { |
| |
| arg, |
| |
| } = out_; |
| } |
| |
| ::fidl_next::Encode::encode(self.arg, encoder_, arg, ())?; |
| |
| Ok(()) |
| } |
| } |
| |
| pub struct ExampleStruct<T0> { |
| pub member: T0, |
| } |
| |
| unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ExampleStruct, ___E> for ExampleStruct<T0> |
| where |
| ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized, |
| T0: ::fidl_next::Encode<::fidl_next::WireU32, ___E>, |
| { |
| #[inline] |
| fn encode( |
| self, |
| encoder_: &mut ___E, |
| out_: &mut ::core::mem::MaybeUninit<crate::wire::ExampleStruct>, |
| _: (), |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge! { |
| let crate::wire::ExampleStruct { |
| |
| member, |
| |
| } = out_; |
| } |
| |
| ::fidl_next::Encode::encode(self.member, encoder_, member, ())?; |
| |
| Ok(()) |
| } |
| } |
| } |
| |
| pub use self::natural::*; |
| |
| pub const EXAMPLE_CONST: u32 = 0 as u32; |
| |
| /// The type corresponding to the ExampleProtocol protocol. |
| #[derive(PartialEq, Debug)] |
| pub struct ExampleProtocol; |
| |
| #[cfg(target_os = "fuchsia")] |
| impl ::fidl_next::HasTransport for ExampleProtocol { |
| type Transport = ::fidl_next::fuchsia::zx::Channel; |
| } |
| |
| pub mod example_protocol { |
| pub mod prelude { |
| pub use crate::{ |
| ExampleProtocol, ExampleProtocolClientHandler, ExampleProtocolServerHandler, |
| example_protocol, |
| }; |
| |
| pub use crate::natural::ExampleProtocolMethodRequest; |
| } |
| |
| pub struct Method; |
| |
| impl ::fidl_next::Method for Method { |
| const ORDINAL: u64 = 6023439637367187273; |
| const FLEXIBILITY: ::fidl_next::protocol::Flexibility = |
| ::fidl_next::protocol::Flexibility::Strict; |
| |
| type Protocol = crate::ExampleProtocol; |
| |
| type Request = crate::wire::ExampleProtocolMethodRequest; |
| } |
| |
| mod ___detail { |
| unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ExampleProtocol |
| where |
| ___T: ::fidl_next::Transport, |
| { |
| type Client = ExampleProtocolClient<___T>; |
| type Server = ExampleProtocolServer<___T>; |
| } |
| |
| /// The client for the `ExampleProtocol` protocol. |
| #[repr(transparent)] |
| pub struct ExampleProtocolClient<___T: ::fidl_next::Transport> { |
| #[allow(dead_code)] |
| client: ::fidl_next::protocol::Client<___T>, |
| } |
| |
| impl<___T> ExampleProtocolClient<___T> |
| where |
| ___T: ::fidl_next::Transport, |
| { |
| pub fn method( |
| &self, |
| |
| arg: impl ::fidl_next::Encode< |
| ::fidl_next_common_test_exampleusing::wire::Empty, |
| <___T as ::fidl_next::Transport>::SendBuffer, |
| >, |
| ) -> ::fidl_next::SendFuture<'_, ___T> |
| where |
| <___T as ::fidl_next::Transport>::SendBuffer: |
| ::fidl_next::encoder::InternalHandleEncoder, |
| { |
| self.method_with(crate::generic::ExampleProtocolMethodRequest { arg }) |
| } |
| |
| pub fn method_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T> |
| where |
| ___R: ::fidl_next::Encode< |
| crate::wire::ExampleProtocolMethodRequest, |
| <___T as ::fidl_next::Transport>::SendBuffer, |
| >, |
| { |
| ::fidl_next::SendFuture::from_untyped(self.client.send_one_way( |
| 6023439637367187273, |
| <super::Method as ::fidl_next::Method>::FLEXIBILITY, |
| request, |
| )) |
| } |
| } |
| |
| /// The server for the `ExampleProtocol` protocol. |
| #[repr(transparent)] |
| pub struct ExampleProtocolServer<___T: ::fidl_next::Transport> { |
| server: ::fidl_next::protocol::Server<___T>, |
| } |
| |
| impl<___T> ExampleProtocolServer<___T> where ___T: ::fidl_next::Transport {} |
| } |
| } |
| |
| /// A client handler for the ExampleProtocol protocol. |
| /// |
| /// See [`ExampleProtocol`] for more details. |
| pub trait ExampleProtocolClientHandler< |
| #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel, |
| #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport, |
| > |
| { |
| } |
| |
| impl<___T> ExampleProtocolClientHandler<___T> for ::fidl_next::IgnoreEvents where |
| ___T: ::fidl_next::Transport |
| { |
| } |
| |
| impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ExampleProtocol |
| where |
| ___H: ExampleProtocolClientHandler<___T> + ::core::marker::Send, |
| ___T: ::fidl_next::Transport, |
| { |
| async fn on_event( |
| handler: &mut ___H, |
| ordinal: u64, |
| flexibility: ::fidl_next::protocol::Flexibility, |
| buffer: ___T::RecvBuffer, |
| ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> { |
| match ordinal { |
| ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)), |
| } |
| } |
| } |
| |
| /// A server handler for the ExampleProtocol protocol. |
| /// |
| /// See [`ExampleProtocol`] for more details. |
| pub trait ExampleProtocolServerHandler< |
| #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel, |
| #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport, |
| > |
| { |
| fn method( |
| &mut self, |
| |
| request: ::fidl_next::Request<example_protocol::Method, ___T>, |
| ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send; |
| } |
| |
| impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ExampleProtocol |
| where |
| ___H: ExampleProtocolServerHandler<___T> + ::core::marker::Send, |
| ___T: ::fidl_next::Transport, |
| <example_protocol::Method as ::fidl_next::Method>::Request: |
| ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>, |
| { |
| async fn on_one_way( |
| handler: &mut ___H, |
| ordinal: u64, |
| flexibility: ::fidl_next::protocol::Flexibility, |
| buffer: ___T::RecvBuffer, |
| ) -> ::core::result::Result< |
| (), |
| ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>, |
| > { |
| match ordinal { |
| 6023439637367187273 => match ::fidl_next::DecoderExt::decode(buffer) { |
| Ok(decoded) => { |
| handler.method(::fidl_next::Request::from_decoded(decoded)).await; |
| Ok(()) |
| } |
| Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage { |
| ordinal: 6023439637367187273, |
| error, |
| }), |
| }, |
| |
| ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)), |
| } |
| } |
| |
| async fn on_two_way( |
| handler: &mut ___H, |
| ordinal: u64, |
| flexibility: ::fidl_next::protocol::Flexibility, |
| buffer: ___T::RecvBuffer, |
| responder: ::fidl_next::protocol::Responder<___T>, |
| ) -> ::core::result::Result< |
| (), |
| ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>, |
| > { |
| match ordinal { |
| ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)), |
| } |
| } |
| } |
| |
| /// Compatibility shims which mimic some API surfaces of the current Rust bindings. |
| pub mod compat { |
| |
| impl ::fidl_next::CompatFrom<crate::ExampleBits> |
| for ::fidl_test_placementofattributes::ExampleBits |
| { |
| fn compat_from(value: crate::ExampleBits) -> Self { |
| Self::from_bits_retain(value.bits()) |
| } |
| } |
| |
| impl ::fidl_next::CompatFrom<::fidl_test_placementofattributes::ExampleBits> |
| for crate::ExampleBits |
| { |
| fn compat_from(value: ::fidl_test_placementofattributes::ExampleBits) -> Self { |
| Self::from_bits_retain(value.bits()) |
| } |
| } |
| |
| impl ::fidl_next::CompatFrom<crate::ExampleEnum> |
| for ::fidl_test_placementofattributes::ExampleEnum |
| { |
| fn compat_from(value: crate::ExampleEnum) -> Self { |
| match value { |
| crate::ExampleEnum::Member => Self::Member, |
| } |
| } |
| } |
| |
| impl ::fidl_next::CompatFrom<::fidl_test_placementofattributes::ExampleEnum> |
| for crate::ExampleEnum |
| { |
| fn compat_from(value: ::fidl_test_placementofattributes::ExampleEnum) -> Self { |
| match value { |
| ::fidl_test_placementofattributes::ExampleEnum::Member => Self::Member, |
| } |
| } |
| } |
| |
| impl ::fidl_next::CompatFrom<crate::ExampleProtocolMethodRequest> |
| for ::fidl_test_placementofattributes::ExampleProtocolMethodRequest |
| { |
| #[inline] |
| fn compat_from(value: crate::ExampleProtocolMethodRequest) -> Self { |
| Self { arg: ::fidl_next::CompatFrom::compat_from(value.arg) } |
| } |
| } |
| |
| impl ::fidl_next::CompatFrom<::fidl_test_placementofattributes::ExampleProtocolMethodRequest> |
| for crate::ExampleProtocolMethodRequest |
| { |
| #[inline] |
| fn compat_from( |
| value: ::fidl_test_placementofattributes::ExampleProtocolMethodRequest, |
| ) -> Self { |
| Self { arg: ::fidl_next::CompatFrom::compat_from(value.arg) } |
| } |
| } |
| |
| #[cfg(target_os = "fuchsia")] |
| /// An alias for a client over `zx::Channel` for the `ExampleProtocol` |
| /// protocol. |
| pub type ExampleProtocolProxy = ::fidl_next::Client<crate::ExampleProtocol>; |
| |
| impl ::fidl_next::CompatFrom<crate::ExampleProtocol> |
| for ::fidl_test_placementofattributes::ExampleProtocolMarker |
| { |
| fn compat_from(_: crate::ExampleProtocol) -> Self { |
| Self |
| } |
| } |
| |
| impl ::fidl_next::CompatFrom<::fidl_test_placementofattributes::ExampleProtocolMarker> |
| for crate::ExampleProtocol |
| { |
| fn compat_from(_: ::fidl_test_placementofattributes::ExampleProtocolMarker) -> Self { |
| Self |
| } |
| } |
| |
| #[cfg(target_os = "fuchsia")] |
| |
| impl ::fidl_next::ClientCompatFrom<::fidl_test_placementofattributes::ExampleProtocolProxy> |
| for crate::ExampleProtocol |
| { |
| fn client_compat_from( |
| proxy: ::fidl_test_placementofattributes::ExampleProtocolProxy, |
| ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> { |
| let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel(); |
| let client_end = ::fidl_next::ClientEnd::from_untyped(channel); |
| ::fidl_next::ClientDispatcher::new(client_end) |
| } |
| } |
| |
| impl ::fidl_next::CompatFrom<crate::ExampleStruct> |
| for ::fidl_test_placementofattributes::ExampleStruct |
| { |
| #[inline] |
| fn compat_from(value: crate::ExampleStruct) -> Self { |
| Self { member: ::fidl_next::CompatFrom::compat_from(value.member) } |
| } |
| } |
| |
| impl ::fidl_next::CompatFrom<::fidl_test_placementofattributes::ExampleStruct> |
| for crate::ExampleStruct |
| { |
| #[inline] |
| fn compat_from(value: ::fidl_test_placementofattributes::ExampleStruct) -> Self { |
| Self { member: ::fidl_next::CompatFrom::compat_from(value.member) } |
| } |
| } |
| |
| impl ::fidl_next::CompatFrom<crate::ExampleTable> |
| for ::fidl_test_placementofattributes::ExampleTable |
| { |
| fn compat_from(value: crate::ExampleTable) -> Self { |
| Self { |
| member: ::fidl_next::CompatFrom::compat_from(value.member), |
| |
| __source_breaking: ::fidl::marker::SourceBreaking, |
| } |
| } |
| } |
| |
| impl ::fidl_next::CompatFrom<::fidl_test_placementofattributes::ExampleTable> |
| for crate::ExampleTable |
| { |
| fn compat_from(value: ::fidl_test_placementofattributes::ExampleTable) -> Self { |
| Self { member: ::fidl_next::CompatFrom::compat_from(value.member) } |
| } |
| } |
| |
| impl ::fidl_next::CompatFrom<crate::ExampleUnion> |
| for ::fidl_test_placementofattributes::ExampleUnion |
| { |
| fn compat_from(value: crate::ExampleUnion) -> Self { |
| match value { |
| crate::ExampleUnion::Variant(value) => { |
| Self::Variant(::fidl_next::CompatFrom::compat_from(value)) |
| } |
| } |
| } |
| } |
| |
| impl ::fidl_next::CompatFrom<::fidl_test_placementofattributes::ExampleUnion> |
| for crate::ExampleUnion |
| { |
| fn compat_from(value: ::fidl_test_placementofattributes::ExampleUnion) -> Self { |
| match value { |
| ::fidl_test_placementofattributes::ExampleUnion::Variant(value) => { |
| Self::Variant(::fidl_next::CompatFrom::compat_from(value)) |
| } |
| } |
| } |
| } |
| } |
