fidl_next_fuchsia_examples_gizmo/

fidl_next_fuchsia_examples_gizmo.rs

// 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 DeviceGetHardwareIdResponse {
    pub response: u32,
}

impl ::fidl_next::Encodable for DeviceGetHardwareIdResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireDeviceGetHardwareIdResponse> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireDeviceGetHardwareIdResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DeviceGetHardwareIdResponse
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 {
                response,

            } = out_;
        }

        ::fidl_next::Encode::encode(self.response, encoder_, response)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DeviceGetHardwareIdResponse
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 {

                response,

            } = out_;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.response, encoder_, response)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for DeviceGetHardwareIdResponse {
    type EncodedOption = ::fidl_next::WireBox<'static, WireDeviceGetHardwareIdResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DeviceGetHardwareIdResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DeviceGetHardwareIdResponse: ::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 DeviceGetHardwareIdResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DeviceGetHardwareIdResponse: ::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<WireDeviceGetHardwareIdResponse> for DeviceGetHardwareIdResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDeviceGetHardwareIdResponse, 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: WireDeviceGetHardwareIdResponse) -> Self {
        Self { response: ::fidl_next::FromWire::from_wire(wire.response) }
    }
}

impl ::fidl_next::IntoNatural for WireDeviceGetHardwareIdResponse {
    type Natural = DeviceGetHardwareIdResponse;
}

impl ::fidl_next::FromWireRef<WireDeviceGetHardwareIdResponse> for DeviceGetHardwareIdResponse {
    #[inline]
    fn from_wire_ref(wire: &WireDeviceGetHardwareIdResponse) -> Self {
        Self { response: ::fidl_next::FromWireRef::from_wire_ref(&wire.response) }
    }
}

/// The wire type corresponding to [`DeviceGetHardwareIdResponse`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireDeviceGetHardwareIdResponse {
    pub response: ::fidl_next::WireU32,
}
static_assertions::const_assert_eq!(std::mem::size_of::<WireDeviceGetHardwareIdResponse>(), 4);
static_assertions::const_assert_eq!(std::mem::align_of::<WireDeviceGetHardwareIdResponse>(), 4);

static_assertions::const_assert_eq!(
    std::mem::offset_of!(WireDeviceGetHardwareIdResponse, response),
    0
);

unsafe impl ::fidl_next::Wire for WireDeviceGetHardwareIdResponse {
    type Decoded<'de> = WireDeviceGetHardwareIdResponse;

    #[inline]
    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge! {
            let Self {

                response,

            } = &mut *out_;
        }

        ::fidl_next::Wire::zero_padding(response);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDeviceGetHardwareIdResponse
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 response,

            } = slot_;
        }

        ::fidl_next::Decode::decode(response.as_mut(), decoder_)?;

        Ok(())
    }
}

#[derive(PartialEq, Debug)]
#[repr(C)]
pub struct DeviceGetEventResponse {
    pub event: ::fidl_next::fuchsia::zx::Event,
}

impl ::fidl_next::Encodable for DeviceGetEventResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireDeviceGetEventResponse> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::Encodable>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    type Encoded = WireDeviceGetEventResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DeviceGetEventResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[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 {
                event,

            } = out_;
        }

        ::fidl_next::Encode::encode(self.event, encoder_, event)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for DeviceGetEventResponse {
    type EncodedOption = ::fidl_next::WireBox<'static, WireDeviceGetEventResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DeviceGetEventResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DeviceGetEventResponse: ::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(())
    }
}

impl ::fidl_next::FromWire<WireDeviceGetEventResponse> for DeviceGetEventResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDeviceGetEventResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::FromWire<
                ::fidl_next::fuchsia::WireEvent,
            >>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireDeviceGetEventResponse) -> Self {
        Self { event: ::fidl_next::FromWire::from_wire(wire.event) }
    }
}

impl ::fidl_next::IntoNatural for WireDeviceGetEventResponse {
    type Natural = DeviceGetEventResponse;
}

/// The wire type corresponding to [`DeviceGetEventResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDeviceGetEventResponse {
    pub event: ::fidl_next::fuchsia::WireEvent,
}
static_assertions::const_assert_eq!(std::mem::size_of::<WireDeviceGetEventResponse>(), 4);
static_assertions::const_assert_eq!(std::mem::align_of::<WireDeviceGetEventResponse>(), 4);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireDeviceGetEventResponse, event), 0);

unsafe impl ::fidl_next::Wire for WireDeviceGetEventResponse {
    type Decoded<'de> = WireDeviceGetEventResponse;

    #[inline]
    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge! {
            let Self {

                event,

            } = &mut *out_;
        }

        ::fidl_next::Wire::zero_padding(event);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDeviceGetEventResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot_: ::fidl_next::Slot<'_, Self>,
        decoder_: &mut ___D,
    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {

                mut event,

            } = slot_;
        }

        ::fidl_next::Decode::decode(event.as_mut(), decoder_)?;

        Ok(())
    }
}

/// The type corresponding to the Device protocol.
#[doc = " The protocol provides access to functions of the driver.\n"]
#[derive(PartialEq, Debug)]
pub struct Device;

pub mod device {
    pub mod prelude {
        pub use crate::{Device, DeviceClientHandler, DeviceServerHandler, device};

        pub use crate::DeviceGetEventResponse;

        pub use crate::DeviceGetHardwareIdResponse;
    }

    pub struct GetHardwareId;

    impl ::fidl_next::Method for GetHardwareId {
        const ORDINAL: u64 = 7952116938191896180;

        type Protocol = crate::Device;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::WireDeviceGetHardwareIdResponse,
            ::fidl_next::WireI32,
        >;
    }

    pub struct GetEvent;

    impl ::fidl_next::Method for GetEvent {
        const ORDINAL: u64 = 6100331669860404750;

        type Protocol = crate::Device;

        type Request = ();

        type Response = crate::WireDeviceGetEventResponse;
    }

    mod ___detail {

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Device
        where
            ___T: ::fidl_next::Transport,
        {
            type Client = DeviceClient<___T>;
            type Server = DeviceServer<___T>;
        }

        /// The client for the `Device` protocol.
        #[repr(transparent)]
        pub struct DeviceClient<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            client: ::fidl_next::protocol::Client<___T>,
        }

        impl<___T> DeviceClient<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            #[doc = " Returns a unique identifier for this device.\n"]
            pub fn get_hardware_id(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::GetHardwareId, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(
                    self.client.send_two_way(7952116938191896180, ()),
                )
            }

            #[doc = " Returns a zircon event object handle!\n"]
            pub fn get_event(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetEvent, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(
                    self.client.send_two_way(6100331669860404750, ()),
                )
            }
        }

        /// The server for the `Device` protocol.
        #[repr(transparent)]
        pub struct DeviceServer<___T: ::fidl_next::Transport> {
            server: ::fidl_next::protocol::Server<___T>,
        }

        impl<___T> DeviceServer<___T> where ___T: ::fidl_next::Transport {}
    }
}

/// A client handler for the Device protocol.
///
/// See [`Device`] for more details.
pub trait DeviceClientHandler<
    #[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 Device
where
    ___H: DeviceClientHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
    <device::GetHardwareId as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <device::GetEvent as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_event(
        handler: &mut ___H,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
        match ordinal {
            ordinal => Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)),
        }
    }
}

/// A server handler for the Device protocol.
///
/// See [`Device`] for more details.
pub trait DeviceServerHandler<
    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
>
{
    #[doc = " Returns a unique identifier for this device.\n"]
    fn get_hardware_id(
        &mut self,

        responder: ::fidl_next::Responder<device::GetHardwareId, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " Returns a zircon event object handle!\n"]
    fn get_event(
        &mut self,

        responder: ::fidl_next::Responder<device::GetEvent, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
}

impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Device
where
    ___H: DeviceServerHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_one_way(
        handler: &mut ___H,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            ordinal => Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)),
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            7952116938191896180 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_hardware_id(responder).await;
                Ok(())
            }

            6100331669860404750 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_event(responder).await;
                Ok(())
            }

            ordinal => Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)),
        }
    }
}

/// Compatibility shims which mimic some API surfaces of the current Rust bindings.
pub mod compat {

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::DeviceGetHardwareIdResponse>
        for ::fidl_fuchsia_examples_gizmo::DeviceGetHardwareIdResponse
    {
        #[inline]
        fn compat_from(value: crate::DeviceGetHardwareIdResponse) -> Self {
            Self { response: ::fidl_next::CompatFrom::compat_from(value.response) }
        }
    }

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_fuchsia_examples_gizmo::DeviceGetHardwareIdResponse>
        for crate::DeviceGetHardwareIdResponse
    {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_examples_gizmo::DeviceGetHardwareIdResponse) -> Self {
            Self { response: ::fidl_next::CompatFrom::compat_from(value.response) }
        }
    }

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::DeviceGetEventResponse>
        for ::fidl_fuchsia_examples_gizmo::DeviceGetEventResponse
    {
        #[inline]
        fn compat_from(value: crate::DeviceGetEventResponse) -> Self {
            Self { event: ::fidl_next::CompatFrom::compat_from(value.event) }
        }
    }

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_fuchsia_examples_gizmo::DeviceGetEventResponse>
        for crate::DeviceGetEventResponse
    {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_examples_gizmo::DeviceGetEventResponse) -> Self {
            Self { event: ::fidl_next::CompatFrom::compat_from(value.event) }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client over `zx::Channel` for the `Device`
    /// protocol.
    pub type DeviceProxy = ::fidl_next::Client<crate::Device>;

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::Device> for ::fidl_fuchsia_examples_gizmo::DeviceMarker {
        fn compat_from(_: crate::Device) -> Self {
            Self
        }
    }

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_fuchsia_examples_gizmo::DeviceMarker> for crate::Device {
        fn compat_from(_: ::fidl_fuchsia_examples_gizmo::DeviceMarker) -> Self {
            Self
        }
    }
}