| // DO NOT EDIT: This file is machine-generated by fidlgen |
| #![warn(clippy::all)] |
| #![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)] |
| |
| #[derive(PartialEq, Clone, Debug)] |
| #[repr(C)] |
| pub struct TwoWayAddRequest { |
| pub addend1: u16, |
| |
| pub addend2: u16, |
| } |
| |
| impl ::fidl_next::Encodable for TwoWayAddRequest { |
| const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireTwoWayAddRequest> = unsafe { |
| ::fidl_next::CopyOptimization::enable_if( |
| true && <u16 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled() |
| && <u16 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(), |
| ) |
| }; |
| |
| type Encoded = WireTwoWayAddRequest; |
| } |
| |
| unsafe impl<___E> ::fidl_next::Encode<___E> for TwoWayAddRequest |
| where |
| ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized, |
| { |
| #[inline] |
| fn encode( |
| self, |
| encoder_: &mut ___E, |
| out_: &mut ::core::mem::MaybeUninit<Self::Encoded>, |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge! { |
| let Self::Encoded { |
| addend1, |
| addend2, |
| |
| } = out_; |
| } |
| |
| ::fidl_next::Encode::encode(self.addend1, encoder_, addend1)?; |
| |
| ::fidl_next::Encode::encode(self.addend2, encoder_, addend2)?; |
| |
| Ok(()) |
| } |
| } |
| |
| unsafe impl<___E> ::fidl_next::EncodeRef<___E> for TwoWayAddRequest |
| where |
| ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized, |
| { |
| #[inline] |
| fn encode_ref( |
| &self, |
| encoder_: &mut ___E, |
| out_: &mut ::core::mem::MaybeUninit<Self::Encoded>, |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge! { |
| let Self::Encoded { |
| |
| addend1, |
| addend2, |
| |
| } = out_; |
| } |
| |
| ::fidl_next::EncodeRef::encode_ref(&self.addend1, encoder_, addend1)?; |
| |
| ::fidl_next::EncodeRef::encode_ref(&self.addend2, encoder_, addend2)?; |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::fidl_next::EncodableOption for TwoWayAddRequest { |
| type EncodedOption = ::fidl_next::WireBox<'static, WireTwoWayAddRequest>; |
| } |
| |
| unsafe impl<___E> ::fidl_next::EncodeOption<___E> for TwoWayAddRequest |
| where |
| ___E: ::fidl_next::Encoder + ?Sized, |
| TwoWayAddRequest: ::fidl_next::Encode<___E>, |
| { |
| #[inline] |
| fn encode_option( |
| this: ::core::option::Option<Self>, |
| encoder: &mut ___E, |
| out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>, |
| ) -> ::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<___E> ::fidl_next::EncodeOptionRef<___E> for TwoWayAddRequest |
| where |
| ___E: ::fidl_next::Encoder + ?Sized, |
| TwoWayAddRequest: ::fidl_next::EncodeRef<___E>, |
| { |
| #[inline] |
| fn encode_option_ref( |
| this: ::core::option::Option<&Self>, |
| encoder: &mut ___E, |
| out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>, |
| ) -> ::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<WireTwoWayAddRequest> for TwoWayAddRequest { |
| const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireTwoWayAddRequest, Self> = unsafe { |
| ::fidl_next::CopyOptimization::enable_if( |
| true && <u16 as ::fidl_next::FromWire<::fidl_next::WireU16>>::COPY_OPTIMIZATION |
| .is_enabled() |
| && <u16 as ::fidl_next::FromWire<::fidl_next::WireU16>>::COPY_OPTIMIZATION |
| .is_enabled(), |
| ) |
| }; |
| |
| #[inline] |
| fn from_wire(wire: WireTwoWayAddRequest) -> Self { |
| Self { |
| addend1: ::fidl_next::FromWire::from_wire(wire.addend1), |
| |
| addend2: ::fidl_next::FromWire::from_wire(wire.addend2), |
| } |
| } |
| } |
| |
| impl ::fidl_next::IntoNatural for WireTwoWayAddRequest { |
| type Natural = TwoWayAddRequest; |
| } |
| |
| impl ::fidl_next::FromWireRef<WireTwoWayAddRequest> for TwoWayAddRequest { |
| #[inline] |
| fn from_wire_ref(wire: &WireTwoWayAddRequest) -> Self { |
| Self { |
| addend1: ::fidl_next::FromWireRef::from_wire_ref(&wire.addend1), |
| |
| addend2: ::fidl_next::FromWireRef::from_wire_ref(&wire.addend2), |
| } |
| } |
| } |
| |
| /// The wire type corresponding to [`TwoWayAddRequest`]. |
| #[derive(Clone, Debug)] |
| #[repr(C)] |
| pub struct WireTwoWayAddRequest { |
| pub addend1: ::fidl_next::WireU16, |
| |
| pub addend2: ::fidl_next::WireU16, |
| } |
| static_assertions::const_assert_eq!(std::mem::size_of::<WireTwoWayAddRequest>(), 4); |
| static_assertions::const_assert_eq!(std::mem::align_of::<WireTwoWayAddRequest>(), 2); |
| |
| static_assertions::const_assert_eq!(std::mem::offset_of!(WireTwoWayAddRequest, addend1), 0); |
| |
| static_assertions::const_assert_eq!(std::mem::offset_of!(WireTwoWayAddRequest, addend2), 2); |
| |
| unsafe impl ::fidl_next::Wire for WireTwoWayAddRequest { |
| type Decoded<'de> = WireTwoWayAddRequest; |
| |
| #[inline] |
| fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) { |
| ::fidl_next::munge! { |
| let Self { |
| |
| addend1, |
| addend2, |
| |
| } = &mut *out_; |
| } |
| |
| ::fidl_next::Wire::zero_padding(addend1); |
| |
| ::fidl_next::Wire::zero_padding(addend2); |
| } |
| } |
| |
| unsafe impl<___D> ::fidl_next::Decode<___D> for WireTwoWayAddRequest |
| 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 addend1, |
| mut addend2, |
| |
| } = slot_; |
| } |
| |
| ::fidl_next::Decode::decode(addend1.as_mut(), decoder_)?; |
| |
| ::fidl_next::Decode::decode(addend2.as_mut(), decoder_)?; |
| |
| Ok(()) |
| } |
| } |
| |
| #[derive(PartialEq, Clone, Debug)] |
| #[repr(C)] |
| pub struct TwoWayAddResponse { |
| pub sum: u16, |
| } |
| |
| impl ::fidl_next::Encodable for TwoWayAddResponse { |
| const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireTwoWayAddResponse> = unsafe { |
| ::fidl_next::CopyOptimization::enable_if( |
| true && <u16 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(), |
| ) |
| }; |
| |
| type Encoded = WireTwoWayAddResponse; |
| } |
| |
| unsafe impl<___E> ::fidl_next::Encode<___E> for TwoWayAddResponse |
| where |
| ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized, |
| { |
| #[inline] |
| fn encode( |
| self, |
| encoder_: &mut ___E, |
| out_: &mut ::core::mem::MaybeUninit<Self::Encoded>, |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge! { |
| let Self::Encoded { |
| sum, |
| |
| } = out_; |
| } |
| |
| ::fidl_next::Encode::encode(self.sum, encoder_, sum)?; |
| |
| Ok(()) |
| } |
| } |
| |
| unsafe impl<___E> ::fidl_next::EncodeRef<___E> for TwoWayAddResponse |
| where |
| ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized, |
| { |
| #[inline] |
| fn encode_ref( |
| &self, |
| encoder_: &mut ___E, |
| out_: &mut ::core::mem::MaybeUninit<Self::Encoded>, |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge! { |
| let Self::Encoded { |
| |
| sum, |
| |
| } = out_; |
| } |
| |
| ::fidl_next::EncodeRef::encode_ref(&self.sum, encoder_, sum)?; |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::fidl_next::EncodableOption for TwoWayAddResponse { |
| type EncodedOption = ::fidl_next::WireBox<'static, WireTwoWayAddResponse>; |
| } |
| |
| unsafe impl<___E> ::fidl_next::EncodeOption<___E> for TwoWayAddResponse |
| where |
| ___E: ::fidl_next::Encoder + ?Sized, |
| TwoWayAddResponse: ::fidl_next::Encode<___E>, |
| { |
| #[inline] |
| fn encode_option( |
| this: ::core::option::Option<Self>, |
| encoder: &mut ___E, |
| out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>, |
| ) -> ::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<___E> ::fidl_next::EncodeOptionRef<___E> for TwoWayAddResponse |
| where |
| ___E: ::fidl_next::Encoder + ?Sized, |
| TwoWayAddResponse: ::fidl_next::EncodeRef<___E>, |
| { |
| #[inline] |
| fn encode_option_ref( |
| this: ::core::option::Option<&Self>, |
| encoder: &mut ___E, |
| out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>, |
| ) -> ::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<WireTwoWayAddResponse> for TwoWayAddResponse { |
| const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireTwoWayAddResponse, Self> = unsafe { |
| ::fidl_next::CopyOptimization::enable_if( |
| true && <u16 as ::fidl_next::FromWire<::fidl_next::WireU16>>::COPY_OPTIMIZATION |
| .is_enabled(), |
| ) |
| }; |
| |
| #[inline] |
| fn from_wire(wire: WireTwoWayAddResponse) -> Self { |
| Self { sum: ::fidl_next::FromWire::from_wire(wire.sum) } |
| } |
| } |
| |
| impl ::fidl_next::IntoNatural for WireTwoWayAddResponse { |
| type Natural = TwoWayAddResponse; |
| } |
| |
| impl ::fidl_next::FromWireRef<WireTwoWayAddResponse> for TwoWayAddResponse { |
| #[inline] |
| fn from_wire_ref(wire: &WireTwoWayAddResponse) -> Self { |
| Self { sum: ::fidl_next::FromWireRef::from_wire_ref(&wire.sum) } |
| } |
| } |
| |
| /// The wire type corresponding to [`TwoWayAddResponse`]. |
| #[derive(Clone, Debug)] |
| #[repr(C)] |
| pub struct WireTwoWayAddResponse { |
| pub sum: ::fidl_next::WireU16, |
| } |
| static_assertions::const_assert_eq!(std::mem::size_of::<WireTwoWayAddResponse>(), 2); |
| static_assertions::const_assert_eq!(std::mem::align_of::<WireTwoWayAddResponse>(), 2); |
| |
| static_assertions::const_assert_eq!(std::mem::offset_of!(WireTwoWayAddResponse, sum), 0); |
| |
| unsafe impl ::fidl_next::Wire for WireTwoWayAddResponse { |
| type Decoded<'de> = WireTwoWayAddResponse; |
| |
| #[inline] |
| fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) { |
| ::fidl_next::munge! { |
| let Self { |
| |
| sum, |
| |
| } = &mut *out_; |
| } |
| |
| ::fidl_next::Wire::zero_padding(sum); |
| } |
| } |
| |
| unsafe impl<___D> ::fidl_next::Decode<___D> for WireTwoWayAddResponse |
| 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 sum, |
| |
| } = slot_; |
| } |
| |
| ::fidl_next::Decode::decode(sum.as_mut(), decoder_)?; |
| |
| Ok(()) |
| } |
| } |
| |
| /// The type corresponding to the TwoWay protocol. |
| #[derive(PartialEq, Debug)] |
| pub struct TwoWay; |
| |
| pub mod two_way { |
| pub mod prelude { |
| pub use crate::{TwoWay, TwoWayClientHandler, TwoWayServerHandler, two_way}; |
| |
| pub use crate::TwoWayAddRequest; |
| |
| pub use crate::TwoWayAddResponse; |
| } |
| |
| pub struct Add; |
| |
| impl ::fidl_next::Method for Add { |
| const ORDINAL: u64 = 989730524426044687; |
| |
| type Protocol = crate::TwoWay; |
| |
| type Request = crate::WireTwoWayAddRequest; |
| |
| type Response = crate::WireTwoWayAddResponse; |
| } |
| |
| mod ___detail { |
| |
| pub struct Add<T0, T1> { |
| addend1: T0, |
| |
| addend2: T1, |
| } |
| |
| impl<T0, T1> ::fidl_next::Encodable for Add<T0, T1> |
| where |
| T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU16>, |
| T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU16>, |
| { |
| type Encoded = crate::WireTwoWayAddRequest; |
| } |
| |
| unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for Add<T0, T1> |
| where |
| ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized, |
| T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU16>, |
| T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU16>, |
| { |
| #[inline] |
| fn encode( |
| self, |
| encoder_: &mut ___E, |
| out_: &mut ::core::mem::MaybeUninit<Self::Encoded>, |
| ) -> ::core::result::Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge! { |
| let Self::Encoded { |
| addend1, |
| addend2, |
| |
| } = out_; |
| } |
| |
| ::fidl_next::Encode::encode(self.addend1, encoder_, addend1)?; |
| |
| ::fidl_next::Encode::encode(self.addend2, encoder_, addend2)?; |
| |
| Ok(()) |
| } |
| } |
| |
| unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::TwoWay |
| where |
| ___T: ::fidl_next::Transport, |
| { |
| type Client = TwoWayClient<___T>; |
| type Server = TwoWayServer<___T>; |
| } |
| |
| /// The client for the `TwoWay` protocol. |
| #[repr(transparent)] |
| pub struct TwoWayClient<___T: ::fidl_next::Transport> { |
| #[allow(dead_code)] |
| client: ::fidl_next::protocol::Client<___T>, |
| } |
| |
| impl<___T> TwoWayClient<___T> |
| where |
| ___T: ::fidl_next::Transport, |
| { |
| pub fn add( |
| &self, |
| |
| addend1: impl ::fidl_next::Encode< |
| <___T as ::fidl_next::Transport>::SendBuffer, |
| Encoded = ::fidl_next::WireU16, |
| >, |
| |
| addend2: impl ::fidl_next::Encode< |
| <___T as ::fidl_next::Transport>::SendBuffer, |
| Encoded = ::fidl_next::WireU16, |
| >, |
| ) -> ::fidl_next::TwoWayFuture<'_, super::Add, ___T> |
| where |
| <___T as ::fidl_next::Transport>::SendBuffer: |
| ::fidl_next::encoder::InternalHandleEncoder, |
| { |
| self.add_with(Add { addend1, addend2 }) |
| } |
| |
| pub fn add_with<___R>( |
| &self, |
| request: ___R, |
| ) -> ::fidl_next::TwoWayFuture<'_, super::Add, ___T> |
| where |
| ___R: ::fidl_next::Encode< |
| <___T as ::fidl_next::Transport>::SendBuffer, |
| Encoded = crate::WireTwoWayAddRequest, |
| >, |
| { |
| ::fidl_next::TwoWayFuture::from_untyped( |
| self.client.send_two_way(989730524426044687, request), |
| ) |
| } |
| } |
| |
| /// The server for the `TwoWay` protocol. |
| #[repr(transparent)] |
| pub struct TwoWayServer<___T: ::fidl_next::Transport> { |
| server: ::fidl_next::protocol::Server<___T>, |
| } |
| |
| impl<___T> TwoWayServer<___T> where ___T: ::fidl_next::Transport {} |
| } |
| } |
| |
| /// A client handler for the TwoWay protocol. |
| /// |
| /// See [`TwoWay`] for more details. |
| pub trait TwoWayClientHandler< |
| #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport, |
| #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel, |
| > |
| { |
| } |
| |
| impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for TwoWay |
| where |
| ___H: TwoWayClientHandler<___T> + ::core::marker::Send, |
| ___T: ::fidl_next::Transport, |
| <two_way::Add as ::fidl_next::Method>::Response: |
| ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>, |
| { |
| async fn on_event( |
| handler: &mut ___H, |
| client: &::fidl_next::Client<Self, ___T>, |
| ordinal: u64, |
| buffer: ___T::RecvBuffer, |
| ) { |
| match ordinal { |
| ordinal => client.close(), |
| } |
| } |
| } |
| |
| /// A server handler for the TwoWay protocol. |
| /// |
| /// See [`TwoWay`] for more details. |
| pub trait TwoWayServerHandler< |
| #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport, |
| #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel, |
| > |
| { |
| fn add( |
| &mut self, |
| |
| request: ::fidl_next::Request<two_way::Add, ___T>, |
| |
| responder: ::fidl_next::Responder<two_way::Add, ___T>, |
| ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send; |
| } |
| |
| impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for TwoWay |
| where |
| ___H: TwoWayServerHandler<___T> + ::core::marker::Send, |
| ___T: ::fidl_next::Transport, |
| <two_way::Add as ::fidl_next::Method>::Request: |
| ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>, |
| { |
| async fn on_one_way( |
| handler: &mut ___H, |
| server: &::fidl_next::Server<Self, ___T>, |
| ordinal: u64, |
| buffer: ___T::RecvBuffer, |
| ) { |
| match ordinal { |
| ordinal => server.close(), |
| } |
| } |
| |
| async fn on_two_way( |
| handler: &mut ___H, |
| ordinal: u64, |
| buffer: ___T::RecvBuffer, |
| responder: ::fidl_next::protocol::Responder<___T>, |
| ) { |
| match ordinal { |
| 989730524426044687 => { |
| let responder = ::fidl_next::Responder::from_untyped(responder); |
| |
| match ::fidl_next::DecoderExt::decode(buffer) { |
| Ok(decoded) => handler.add(decoded, responder).await, |
| Err(e) => drop(responder), |
| } |
| } |
| |
| ordinal => responder.server().close(), |
| } |
| } |
| } |
| |
| /// Compatibility shims which mimic some API surfaces of the current Rust bindings. |
| pub mod compat { |
| |
| #[cfg(feature = "driver")] |
| impl ::fidl_next::CompatFrom<crate::TwoWayAddRequest> |
| for ::fidl_test_drivertwoway::TwoWayAddRequest |
| { |
| #[inline] |
| fn compat_from(value: crate::TwoWayAddRequest) -> Self { |
| Self { |
| addend1: ::fidl_next::CompatFrom::compat_from(value.addend1), |
| |
| addend2: ::fidl_next::CompatFrom::compat_from(value.addend2), |
| } |
| } |
| } |
| |
| #[cfg(feature = "driver")] |
| impl ::fidl_next::CompatFrom<::fidl_test_drivertwoway::TwoWayAddRequest> |
| for crate::TwoWayAddRequest |
| { |
| #[inline] |
| fn compat_from(value: ::fidl_test_drivertwoway::TwoWayAddRequest) -> Self { |
| Self { |
| addend1: ::fidl_next::CompatFrom::compat_from(value.addend1), |
| |
| addend2: ::fidl_next::CompatFrom::compat_from(value.addend2), |
| } |
| } |
| } |
| |
| #[cfg(feature = "driver")] |
| impl ::fidl_next::CompatFrom<crate::TwoWayAddResponse> |
| for ::fidl_test_drivertwoway::TwoWayAddResponse |
| { |
| #[inline] |
| fn compat_from(value: crate::TwoWayAddResponse) -> Self { |
| Self { sum: ::fidl_next::CompatFrom::compat_from(value.sum) } |
| } |
| } |
| |
| #[cfg(feature = "driver")] |
| impl ::fidl_next::CompatFrom<::fidl_test_drivertwoway::TwoWayAddResponse> |
| for crate::TwoWayAddResponse |
| { |
| #[inline] |
| fn compat_from(value: ::fidl_test_drivertwoway::TwoWayAddResponse) -> Self { |
| Self { sum: ::fidl_next::CompatFrom::compat_from(value.sum) } |
| } |
| } |
| |
| #[cfg(target_os = "fuchsia")] |
| /// An alias for a client over `zx::Channel` for the `TwoWay` |
| /// protocol. |
| pub type TwoWayProxy = ::fidl_next::Client<crate::TwoWay>; |
| |
| #[cfg(feature = "driver")] |
| impl ::fidl_next::CompatFrom<crate::TwoWay> for ::fidl_test_drivertwoway::TwoWayMarker { |
| fn compat_from(_: crate::TwoWay) -> Self { |
| Self |
| } |
| } |
| |
| #[cfg(feature = "driver")] |
| impl ::fidl_next::CompatFrom<::fidl_test_drivertwoway::TwoWayMarker> for crate::TwoWay { |
| fn compat_from(_: ::fidl_test_drivertwoway::TwoWayMarker) -> Self { |
| Self |
| } |
| } |
| } |
