| // 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(Clone, Debug)] |
| #[repr(C)] |
| pub struct Empty {} |
| |
| impl ::fidl_next::Encodable for Empty { |
| const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = |
| unsafe { ::fidl_next::CopyOptimization::enable_if(true) }; |
| |
| type Encoded = WireEmpty; |
| } |
| |
| impl<___E> ::fidl_next::Encode<___E> for Empty |
| where |
| ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized, |
| { |
| #[inline] |
| fn encode( |
| &mut self, |
| encoder: &mut ___E, |
| slot: ::fidl_next::Slot<'_, Self::Encoded>, |
| ) -> Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge! { |
| let Self::Encoded { |
| |
| } = slot; |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::fidl_next::EncodableOption for Box<Empty> { |
| type EncodedOption = ::fidl_next::WireBox<WireEmpty>; |
| } |
| |
| impl<___E> ::fidl_next::EncodeOption<___E> for Box<Empty> |
| where |
| ___E: ::fidl_next::Encoder + ?Sized, |
| Empty: ::fidl_next::Encode<___E>, |
| { |
| #[inline] |
| fn encode_option( |
| this: Option<&mut Self>, |
| encoder: &mut ___E, |
| slot: ::fidl_next::Slot<'_, Self::EncodedOption>, |
| ) -> Result<(), ::fidl_next::EncodeError> { |
| if let Some(inner) = this { |
| ::fidl_next::EncoderExt::encode_next(encoder, inner)?; |
| ::fidl_next::WireBox::encode_present(slot); |
| } else { |
| ::fidl_next::WireBox::encode_absent(slot); |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::fidl_next::TakeFrom<WireEmpty> for Empty { |
| const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = |
| unsafe { ::fidl_next::CopyOptimization::enable_if(true) }; |
| |
| #[inline] |
| fn take_from(from: &WireEmpty) -> Self { |
| Self {} |
| } |
| } |
| |
| /// The wire type corersponding to [`Empty`]. |
| #[derive(Clone, Debug)] |
| #[repr(C)] |
| pub struct WireEmpty {} |
| |
| unsafe impl ::fidl_next::ZeroPadding for WireEmpty { |
| #[inline] |
| unsafe fn zero_padding(ptr: *mut Self) {} |
| } |
| |
| unsafe impl<___D> ::fidl_next::Decode<___D> for WireEmpty |
| where |
| ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized, |
| { |
| fn decode( |
| slot: ::fidl_next::Slot<'_, Self>, |
| decoder: &mut ___D, |
| ) -> Result<(), ::fidl_next::DecodeError> { |
| ::fidl_next::munge! { |
| let Self { |
| |
| } = slot; |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| #[derive(Clone, Debug)] |
| #[repr(C)] |
| pub struct EmptyProtocolSendRequest { |
| pub e: crate::Empty, |
| } |
| |
| impl ::fidl_next::Encodable for EmptyProtocolSendRequest { |
| const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe { |
| ::fidl_next::CopyOptimization::enable_if( |
| true && <crate::Empty as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(), |
| ) |
| }; |
| |
| type Encoded = WireEmptyProtocolSendRequest; |
| } |
| |
| impl<___E> ::fidl_next::Encode<___E> for EmptyProtocolSendRequest |
| where |
| ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized, |
| { |
| #[inline] |
| fn encode( |
| &mut self, |
| encoder: &mut ___E, |
| slot: ::fidl_next::Slot<'_, Self::Encoded>, |
| ) -> Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge! { |
| let Self::Encoded { |
| e, |
| |
| } = slot; |
| } |
| |
| ::fidl_next::Encode::encode(&mut self.e, encoder, e)?; |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::fidl_next::EncodableOption for Box<EmptyProtocolSendRequest> { |
| type EncodedOption = ::fidl_next::WireBox<WireEmptyProtocolSendRequest>; |
| } |
| |
| impl<___E> ::fidl_next::EncodeOption<___E> for Box<EmptyProtocolSendRequest> |
| where |
| ___E: ::fidl_next::Encoder + ?Sized, |
| EmptyProtocolSendRequest: ::fidl_next::Encode<___E>, |
| { |
| #[inline] |
| fn encode_option( |
| this: Option<&mut Self>, |
| encoder: &mut ___E, |
| slot: ::fidl_next::Slot<'_, Self::EncodedOption>, |
| ) -> Result<(), ::fidl_next::EncodeError> { |
| if let Some(inner) = this { |
| ::fidl_next::EncoderExt::encode_next(encoder, inner)?; |
| ::fidl_next::WireBox::encode_present(slot); |
| } else { |
| ::fidl_next::WireBox::encode_absent(slot); |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::fidl_next::TakeFrom<WireEmptyProtocolSendRequest> for EmptyProtocolSendRequest { |
| const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe { |
| ::fidl_next::CopyOptimization::enable_if( |
| true && <crate::Empty as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(), |
| ) |
| }; |
| |
| #[inline] |
| fn take_from(from: &WireEmptyProtocolSendRequest) -> Self { |
| Self { e: ::fidl_next::TakeFrom::take_from(&from.e) } |
| } |
| } |
| |
| /// The wire type corersponding to [`EmptyProtocolSendRequest`]. |
| #[derive(Clone, Debug)] |
| #[repr(C)] |
| pub struct WireEmptyProtocolSendRequest { |
| pub e: crate::WireEmpty, |
| } |
| |
| unsafe impl ::fidl_next::ZeroPadding for WireEmptyProtocolSendRequest { |
| #[inline] |
| unsafe fn zero_padding(ptr: *mut Self) {} |
| } |
| |
| unsafe impl<___D> ::fidl_next::Decode<___D> for WireEmptyProtocolSendRequest |
| where |
| ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized, |
| { |
| fn decode( |
| slot: ::fidl_next::Slot<'_, Self>, |
| decoder: &mut ___D, |
| ) -> Result<(), ::fidl_next::DecodeError> { |
| ::fidl_next::munge! { |
| let Self { |
| mut e, |
| |
| } = slot; |
| } |
| |
| ::fidl_next::Decode::decode(e.as_mut(), decoder)?; |
| |
| Ok(()) |
| } |
| } |
| |
| #[derive(Clone, Debug)] |
| #[repr(C)] |
| pub struct EmptyProtocolReceiveRequest { |
| pub e: crate::Empty, |
| } |
| |
| impl ::fidl_next::Encodable for EmptyProtocolReceiveRequest { |
| const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe { |
| ::fidl_next::CopyOptimization::enable_if( |
| true && <crate::Empty as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(), |
| ) |
| }; |
| |
| type Encoded = WireEmptyProtocolReceiveRequest; |
| } |
| |
| impl<___E> ::fidl_next::Encode<___E> for EmptyProtocolReceiveRequest |
| where |
| ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized, |
| { |
| #[inline] |
| fn encode( |
| &mut self, |
| encoder: &mut ___E, |
| slot: ::fidl_next::Slot<'_, Self::Encoded>, |
| ) -> Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge! { |
| let Self::Encoded { |
| e, |
| |
| } = slot; |
| } |
| |
| ::fidl_next::Encode::encode(&mut self.e, encoder, e)?; |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::fidl_next::EncodableOption for Box<EmptyProtocolReceiveRequest> { |
| type EncodedOption = ::fidl_next::WireBox<WireEmptyProtocolReceiveRequest>; |
| } |
| |
| impl<___E> ::fidl_next::EncodeOption<___E> for Box<EmptyProtocolReceiveRequest> |
| where |
| ___E: ::fidl_next::Encoder + ?Sized, |
| EmptyProtocolReceiveRequest: ::fidl_next::Encode<___E>, |
| { |
| #[inline] |
| fn encode_option( |
| this: Option<&mut Self>, |
| encoder: &mut ___E, |
| slot: ::fidl_next::Slot<'_, Self::EncodedOption>, |
| ) -> Result<(), ::fidl_next::EncodeError> { |
| if let Some(inner) = this { |
| ::fidl_next::EncoderExt::encode_next(encoder, inner)?; |
| ::fidl_next::WireBox::encode_present(slot); |
| } else { |
| ::fidl_next::WireBox::encode_absent(slot); |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::fidl_next::TakeFrom<WireEmptyProtocolReceiveRequest> for EmptyProtocolReceiveRequest { |
| const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe { |
| ::fidl_next::CopyOptimization::enable_if( |
| true && <crate::Empty as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(), |
| ) |
| }; |
| |
| #[inline] |
| fn take_from(from: &WireEmptyProtocolReceiveRequest) -> Self { |
| Self { e: ::fidl_next::TakeFrom::take_from(&from.e) } |
| } |
| } |
| |
| /// The wire type corersponding to [`EmptyProtocolReceiveRequest`]. |
| #[derive(Clone, Debug)] |
| #[repr(C)] |
| pub struct WireEmptyProtocolReceiveRequest { |
| pub e: crate::WireEmpty, |
| } |
| |
| unsafe impl ::fidl_next::ZeroPadding for WireEmptyProtocolReceiveRequest { |
| #[inline] |
| unsafe fn zero_padding(ptr: *mut Self) {} |
| } |
| |
| unsafe impl<___D> ::fidl_next::Decode<___D> for WireEmptyProtocolReceiveRequest |
| where |
| ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized, |
| { |
| fn decode( |
| slot: ::fidl_next::Slot<'_, Self>, |
| decoder: &mut ___D, |
| ) -> Result<(), ::fidl_next::DecodeError> { |
| ::fidl_next::munge! { |
| let Self { |
| mut e, |
| |
| } = slot; |
| } |
| |
| ::fidl_next::Decode::decode(e.as_mut(), decoder)?; |
| |
| Ok(()) |
| } |
| } |
| |
| #[derive(Clone, Debug)] |
| #[repr(C)] |
| pub struct EmptyProtocolSendAndReceiveRequest { |
| pub e: crate::Empty, |
| } |
| |
| impl ::fidl_next::Encodable for EmptyProtocolSendAndReceiveRequest { |
| const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe { |
| ::fidl_next::CopyOptimization::enable_if( |
| true && <crate::Empty as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(), |
| ) |
| }; |
| |
| type Encoded = WireEmptyProtocolSendAndReceiveRequest; |
| } |
| |
| impl<___E> ::fidl_next::Encode<___E> for EmptyProtocolSendAndReceiveRequest |
| where |
| ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized, |
| { |
| #[inline] |
| fn encode( |
| &mut self, |
| encoder: &mut ___E, |
| slot: ::fidl_next::Slot<'_, Self::Encoded>, |
| ) -> Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge! { |
| let Self::Encoded { |
| e, |
| |
| } = slot; |
| } |
| |
| ::fidl_next::Encode::encode(&mut self.e, encoder, e)?; |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::fidl_next::EncodableOption for Box<EmptyProtocolSendAndReceiveRequest> { |
| type EncodedOption = ::fidl_next::WireBox<WireEmptyProtocolSendAndReceiveRequest>; |
| } |
| |
| impl<___E> ::fidl_next::EncodeOption<___E> for Box<EmptyProtocolSendAndReceiveRequest> |
| where |
| ___E: ::fidl_next::Encoder + ?Sized, |
| EmptyProtocolSendAndReceiveRequest: ::fidl_next::Encode<___E>, |
| { |
| #[inline] |
| fn encode_option( |
| this: Option<&mut Self>, |
| encoder: &mut ___E, |
| slot: ::fidl_next::Slot<'_, Self::EncodedOption>, |
| ) -> Result<(), ::fidl_next::EncodeError> { |
| if let Some(inner) = this { |
| ::fidl_next::EncoderExt::encode_next(encoder, inner)?; |
| ::fidl_next::WireBox::encode_present(slot); |
| } else { |
| ::fidl_next::WireBox::encode_absent(slot); |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::fidl_next::TakeFrom<WireEmptyProtocolSendAndReceiveRequest> |
| for EmptyProtocolSendAndReceiveRequest |
| { |
| const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe { |
| ::fidl_next::CopyOptimization::enable_if( |
| true && <crate::Empty as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(), |
| ) |
| }; |
| |
| #[inline] |
| fn take_from(from: &WireEmptyProtocolSendAndReceiveRequest) -> Self { |
| Self { e: ::fidl_next::TakeFrom::take_from(&from.e) } |
| } |
| } |
| |
| /// The wire type corersponding to [`EmptyProtocolSendAndReceiveRequest`]. |
| #[derive(Clone, Debug)] |
| #[repr(C)] |
| pub struct WireEmptyProtocolSendAndReceiveRequest { |
| pub e: crate::WireEmpty, |
| } |
| |
| unsafe impl ::fidl_next::ZeroPadding for WireEmptyProtocolSendAndReceiveRequest { |
| #[inline] |
| unsafe fn zero_padding(ptr: *mut Self) {} |
| } |
| |
| unsafe impl<___D> ::fidl_next::Decode<___D> for WireEmptyProtocolSendAndReceiveRequest |
| where |
| ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized, |
| { |
| fn decode( |
| slot: ::fidl_next::Slot<'_, Self>, |
| decoder: &mut ___D, |
| ) -> Result<(), ::fidl_next::DecodeError> { |
| ::fidl_next::munge! { |
| let Self { |
| mut e, |
| |
| } = slot; |
| } |
| |
| ::fidl_next::Decode::decode(e.as_mut(), decoder)?; |
| |
| Ok(()) |
| } |
| } |
| |
| #[derive(Clone, Debug)] |
| #[repr(C)] |
| pub struct EmptyProtocolSendAndReceiveResponse { |
| pub e: crate::Empty, |
| } |
| |
| impl ::fidl_next::Encodable for EmptyProtocolSendAndReceiveResponse { |
| const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe { |
| ::fidl_next::CopyOptimization::enable_if( |
| true && <crate::Empty as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(), |
| ) |
| }; |
| |
| type Encoded = WireEmptyProtocolSendAndReceiveResponse; |
| } |
| |
| impl<___E> ::fidl_next::Encode<___E> for EmptyProtocolSendAndReceiveResponse |
| where |
| ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized, |
| { |
| #[inline] |
| fn encode( |
| &mut self, |
| encoder: &mut ___E, |
| slot: ::fidl_next::Slot<'_, Self::Encoded>, |
| ) -> Result<(), ::fidl_next::EncodeError> { |
| ::fidl_next::munge! { |
| let Self::Encoded { |
| e, |
| |
| } = slot; |
| } |
| |
| ::fidl_next::Encode::encode(&mut self.e, encoder, e)?; |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::fidl_next::EncodableOption for Box<EmptyProtocolSendAndReceiveResponse> { |
| type EncodedOption = ::fidl_next::WireBox<WireEmptyProtocolSendAndReceiveResponse>; |
| } |
| |
| impl<___E> ::fidl_next::EncodeOption<___E> for Box<EmptyProtocolSendAndReceiveResponse> |
| where |
| ___E: ::fidl_next::Encoder + ?Sized, |
| EmptyProtocolSendAndReceiveResponse: ::fidl_next::Encode<___E>, |
| { |
| #[inline] |
| fn encode_option( |
| this: Option<&mut Self>, |
| encoder: &mut ___E, |
| slot: ::fidl_next::Slot<'_, Self::EncodedOption>, |
| ) -> Result<(), ::fidl_next::EncodeError> { |
| if let Some(inner) = this { |
| ::fidl_next::EncoderExt::encode_next(encoder, inner)?; |
| ::fidl_next::WireBox::encode_present(slot); |
| } else { |
| ::fidl_next::WireBox::encode_absent(slot); |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| impl ::fidl_next::TakeFrom<WireEmptyProtocolSendAndReceiveResponse> |
| for EmptyProtocolSendAndReceiveResponse |
| { |
| const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe { |
| ::fidl_next::CopyOptimization::enable_if( |
| true && <crate::Empty as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(), |
| ) |
| }; |
| |
| #[inline] |
| fn take_from(from: &WireEmptyProtocolSendAndReceiveResponse) -> Self { |
| Self { e: ::fidl_next::TakeFrom::take_from(&from.e) } |
| } |
| } |
| |
| /// The wire type corersponding to [`EmptyProtocolSendAndReceiveResponse`]. |
| #[derive(Clone, Debug)] |
| #[repr(C)] |
| pub struct WireEmptyProtocolSendAndReceiveResponse { |
| pub e: crate::WireEmpty, |
| } |
| |
| unsafe impl ::fidl_next::ZeroPadding for WireEmptyProtocolSendAndReceiveResponse { |
| #[inline] |
| unsafe fn zero_padding(ptr: *mut Self) {} |
| } |
| |
| unsafe impl<___D> ::fidl_next::Decode<___D> for WireEmptyProtocolSendAndReceiveResponse |
| where |
| ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized, |
| { |
| fn decode( |
| slot: ::fidl_next::Slot<'_, Self>, |
| decoder: &mut ___D, |
| ) -> Result<(), ::fidl_next::DecodeError> { |
| ::fidl_next::munge! { |
| let Self { |
| mut e, |
| |
| } = slot; |
| } |
| |
| ::fidl_next::Decode::decode(e.as_mut(), decoder)?; |
| |
| Ok(()) |
| } |
| } |
| |
| /// The type corresponding to the EmptyProtocol protocol. |
| #[derive(Debug)] |
| pub struct EmptyProtocol; |
| |
| pub mod empty_protocol { |
| pub mod prelude { |
| pub use crate::{ |
| empty_protocol, EmptyProtocol, EmptyProtocolClientHandler, EmptyProtocolClientSender, |
| EmptyProtocolServerHandler, EmptyProtocolServerSender, |
| }; |
| |
| pub use crate::EmptyProtocolReceiveRequest; |
| |
| pub use crate::EmptyProtocolSendAndReceiveRequest; |
| |
| pub use crate::EmptyProtocolSendAndReceiveResponse; |
| |
| pub use crate::EmptyProtocolSendRequest; |
| } |
| |
| pub struct Send; |
| |
| impl ::fidl_next::Method for Send { |
| const ORDINAL: u64 = 1378773277029173000; |
| |
| type Protocol = crate::EmptyProtocol; |
| |
| type Request = crate::WireEmptyProtocolSendRequest; |
| |
| type Response = ::fidl_next::Never; |
| } |
| |
| pub struct Receive; |
| |
| impl ::fidl_next::Method for Receive { |
| const ORDINAL: u64 = 2301564782476583487; |
| |
| type Protocol = crate::EmptyProtocol; |
| |
| type Request = ::fidl_next::Never; |
| |
| type Response = crate::WireEmptyProtocolReceiveRequest; |
| } |
| |
| pub struct SendAndReceive; |
| |
| impl ::fidl_next::Method for SendAndReceive { |
| const ORDINAL: u64 = 534401212734647530; |
| |
| type Protocol = crate::EmptyProtocol; |
| |
| type Request = crate::WireEmptyProtocolSendAndReceiveRequest; |
| |
| type Response = crate::WireEmptyProtocolSendAndReceiveResponse; |
| } |
| } |
| |
| /// A helper trait for the `EmptyProtocol` client sender. |
| pub trait EmptyProtocolClientSender { |
| type Transport: ::fidl_next::Transport; |
| |
| fn send<___R>( |
| &self, |
| request: &mut ___R, |
| ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError> |
| where |
| ___R: ::fidl_next::Encode< |
| <Self::Transport as ::fidl_next::Transport>::SendBuffer, |
| Encoded = crate::WireEmptyProtocolSendRequest, |
| >; |
| |
| fn send_and_receive<___R>( |
| &self, |
| request: &mut ___R, |
| ) -> Result< |
| ::fidl_next::ResponseFuture<'_, Self::Transport, empty_protocol::SendAndReceive>, |
| ::fidl_next::EncodeError, |
| > |
| where |
| ___R: ::fidl_next::Encode< |
| <Self::Transport as ::fidl_next::Transport>::SendBuffer, |
| Encoded = crate::WireEmptyProtocolSendAndReceiveRequest, |
| >; |
| } |
| |
| impl<___T> EmptyProtocolClientSender for ::fidl_next::ClientSender<___T, EmptyProtocol> |
| where |
| ___T: ::fidl_next::Transport, |
| { |
| type Transport = ___T; |
| |
| fn send<___R>( |
| &self, |
| request: &mut ___R, |
| ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError> |
| where |
| ___R: ::fidl_next::Encode< |
| <Self::Transport as ::fidl_next::Transport>::SendBuffer, |
| Encoded = crate::WireEmptyProtocolSendRequest, |
| >, |
| { |
| self.as_untyped().send_one_way(1378773277029173000, request) |
| } |
| |
| fn send_and_receive<___R>( |
| &self, |
| request: &mut ___R, |
| ) -> Result< |
| ::fidl_next::ResponseFuture<'_, Self::Transport, empty_protocol::SendAndReceive>, |
| ::fidl_next::EncodeError, |
| > |
| where |
| ___R: ::fidl_next::Encode< |
| <Self::Transport as ::fidl_next::Transport>::SendBuffer, |
| Encoded = crate::WireEmptyProtocolSendAndReceiveRequest, |
| >, |
| { |
| self.as_untyped() |
| .send_two_way(534401212734647530, request) |
| .map(::fidl_next::ResponseFuture::from_untyped) |
| } |
| } |
| |
| /// A client handler for the EmptyProtocol protocol. |
| /// |
| /// See [`EmptyProtocol`] for more details. |
| pub trait EmptyProtocolClientHandler<___T: ::fidl_next::Transport> { |
| fn receive( |
| &mut self, |
| sender: &::fidl_next::ClientSender<___T, EmptyProtocol>, |
| |
| message: ::fidl_next::ResponseBuffer<___T, empty_protocol::Receive>, |
| ); |
| } |
| |
| impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for EmptyProtocol |
| where |
| ___T: ::fidl_next::Transport, |
| ___H: EmptyProtocolClientHandler<___T>, |
| |
| <empty_protocol::Receive as ::fidl_next::Method>::Response: |
| ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>, |
| |
| <empty_protocol::SendAndReceive as ::fidl_next::Method>::Response: |
| ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>, |
| { |
| fn on_event( |
| handler: &mut ___H, |
| sender: &::fidl_next::ClientSender<___T, Self>, |
| ordinal: u64, |
| buffer: ___T::RecvBuffer, |
| ) { |
| match ordinal { |
| 2301564782476583487 => { |
| let buffer = ::fidl_next::ResponseBuffer::from_untyped(buffer); |
| handler.receive(sender, buffer); |
| } |
| |
| ordinal => { |
| sender.close(); |
| } |
| } |
| } |
| } |
| |
| /// A helper trait for the `EmptyProtocol` server sender. |
| pub trait EmptyProtocolServerSender { |
| type Transport: ::fidl_next::Transport; |
| |
| fn receive<___R>( |
| &self, |
| request: &mut ___R, |
| ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError> |
| where |
| ___R: ::fidl_next::Encode< |
| <Self::Transport as ::fidl_next::Transport>::SendBuffer, |
| Encoded = <empty_protocol::Receive as ::fidl_next::Method>::Response, |
| >; |
| } |
| |
| impl<___T> EmptyProtocolServerSender for ::fidl_next::ServerSender<___T, EmptyProtocol> |
| where |
| ___T: ::fidl_next::Transport, |
| { |
| type Transport = ___T; |
| |
| fn receive<___R>( |
| &self, |
| request: &mut ___R, |
| ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError> |
| where |
| ___R: ::fidl_next::Encode< |
| <Self::Transport as ::fidl_next::Transport>::SendBuffer, |
| Encoded = <empty_protocol::Receive as ::fidl_next::Method>::Response, |
| >, |
| { |
| self.as_untyped().send_event(2301564782476583487, request) |
| } |
| } |
| |
| /// A server handler for the EmptyProtocol protocol. |
| /// |
| /// See [`EmptyProtocol`] for more details. |
| pub trait EmptyProtocolServerHandler<___T: ::fidl_next::Transport> { |
| fn send( |
| &mut self, |
| sender: &::fidl_next::ServerSender<___T, EmptyProtocol>, |
| |
| request: ::fidl_next::RequestBuffer<___T, empty_protocol::Send>, |
| ); |
| |
| fn send_and_receive( |
| &mut self, |
| sender: &::fidl_next::ServerSender<___T, EmptyProtocol>, |
| |
| request: ::fidl_next::RequestBuffer<___T, empty_protocol::SendAndReceive>, |
| |
| responder: ::fidl_next::Responder<empty_protocol::SendAndReceive>, |
| ); |
| } |
| |
| impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for EmptyProtocol |
| where |
| ___T: ::fidl_next::Transport, |
| ___H: EmptyProtocolServerHandler<___T>, |
| |
| crate::WireEmptyProtocolSendRequest: |
| ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>, |
| |
| crate::WireEmptyProtocolSendAndReceiveRequest: |
| ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>, |
| { |
| fn on_one_way( |
| handler: &mut ___H, |
| sender: &::fidl_next::ServerSender<___T, Self>, |
| ordinal: u64, |
| buffer: ___T::RecvBuffer, |
| ) { |
| match ordinal { |
| 1378773277029173000 => { |
| let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer); |
| handler.send(sender, buffer); |
| } |
| |
| ordinal => { |
| sender.close(); |
| } |
| } |
| } |
| |
| fn on_two_way( |
| handler: &mut ___H, |
| sender: &::fidl_next::ServerSender<___T, Self>, |
| ordinal: u64, |
| buffer: ___T::RecvBuffer, |
| responder: ::fidl_next::protocol::Responder, |
| ) { |
| match ordinal { |
| 534401212734647530 => { |
| let responder = ::fidl_next::Responder::from_untyped(responder); |
| |
| let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer); |
| handler.send_and_receive(sender, buffer, responder); |
| } |
| |
| ordinal => { |
| sender.close(); |
| } |
| } |
| } |
| } |
| |
| /// Compatibility shims which mimic some API surfaces of the current Rust bindings. |
| pub mod compat { |
| |
| #[cfg(target_os = "fuchsia")] |
| /// An alias for a client sender over `zx::Channel` for the `EmptyProtocol` |
| /// protocol. |
| pub type EmptyProtocolProxy = |
| ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::EmptyProtocol>; |
| } |
