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)]

pub mod natural {

    pub use fidl_next_common_fuchsia_examples_gizmo::natural::*;

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

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeviceGetEventResponse, ___E>
        for DeviceGetEventResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::fuchsia::HandleEncoder,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::DeviceGetEventResponse,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::Encode<
                    ::fidl_next::wire::fuchsia::Event,
                    ___E,
                >>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetEventResponse>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::DeviceGetEventResponse {
                    event,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(event.as_mut_ptr()) };

            Ok(())
        }
    }

    unsafe impl<___E>
        ::fidl_next::EncodeOption<
            ::fidl_next::wire::Box<'static, crate::wire::DeviceGetEventResponse>,
            ___E,
        > for DeviceGetEventResponse
    where
        ___E: ::fidl_next::Encoder + ?Sized,
        DeviceGetEventResponse: ::fidl_next::Encode<crate::wire::DeviceGetEventResponse, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<
                ::fidl_next::wire::Box<'static, crate::wire::DeviceGetEventResponse>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            if let Some(inner) = this {
                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
                ::fidl_next::wire::Box::encode_present(out);
            } else {
                ::fidl_next::wire::Box::encode_absent(out);
            }

            Ok(())
        }
    }

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

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

pub mod wire {

    pub use fidl_next_common_fuchsia_examples_gizmo::wire::*;

    /// The wire type corresponding to [`DeviceGetEventResponse`].
    #[derive(Debug)]
    #[repr(C)]
    pub struct DeviceGetEventResponse {
        pub event: ::fidl_next::wire::fuchsia::Event,
    }

    static_assertions::const_assert_eq!(std::mem::size_of::<DeviceGetEventResponse>(), 4);
    static_assertions::const_assert_eq!(std::mem::align_of::<DeviceGetEventResponse>(), 4);

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

    impl ::fidl_next::Constrained for DeviceGetEventResponse {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for DeviceGetEventResponse {
        type Narrowed<'de> = DeviceGetEventResponse;

        #[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 DeviceGetEventResponse
    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_;
            }

            let _field = event.as_mut();

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

            Ok(())
        }
    }

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

pub mod wire_optional {

    pub use fidl_next_common_fuchsia_examples_gizmo::wire_optional::*;
}

pub mod generic {

    pub use fidl_next_common_fuchsia_examples_gizmo::generic::*;

    /// The generic type corresponding to [`DeviceGetEventResponse`].
    pub struct DeviceGetEventResponse<T0> {
        pub event: T0,
    }

    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DeviceGetEventResponse, ___E>
        for DeviceGetEventResponse<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::fuchsia::HandleEncoder,
        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::DeviceGetEventResponse>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::DeviceGetEventResponse {
                    event,

                } = out_;
            }

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

            Ok(())
        }
    }
}

pub use self::natural::*;

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

#[cfg(feature = "driver")]
impl ::fidl_next::HasTransport for Device {
    type Transport = ::fdf_fidl::DriverChannel;
}

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

        pub use crate::natural::DeviceGetEventResponse;

        pub use crate::natural::DeviceGetHardwareIdResponse;
    }

    pub struct GetHardwareId;

    impl ::fidl_next::Method for GetHardwareId {
        const ORDINAL: u64 = 7952116938191896180;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::Device;

        type Request = ::fidl_next::wire::EmptyMessageBody;
    }

    impl ::fidl_next::TwoWayMethod for GetHardwareId {
        type Response = ::fidl_next::wire::Result<
            'static,
            crate::wire::DeviceGetHardwareIdResponse,
            ::fidl_next::wire::fuchsia::Status,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for GetHardwareId {
        type Output = ::core::result::Result<
            crate::generic::DeviceGetHardwareIdResponse<___R>,
            ::fidl_next::never::Never,
        >;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(crate::generic::DeviceGetHardwareIdResponse {
                response: response,
            })
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for GetHardwareId {
        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct GetEvent;

    impl ::fidl_next::Method for GetEvent {
        const ORDINAL: u64 = 6100331669860404750;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::Device;

        type Request = ::fidl_next::wire::EmptyMessageBody;
    }

    impl ::fidl_next::TwoWayMethod for GetEvent {
        type Response = ::fidl_next::wire::Strict<crate::wire::DeviceGetEventResponse>;
    }

    impl<___R> ::fidl_next::Respond<___R> for GetEvent {
        type Output = ::fidl_next::Strict<crate::generic::DeviceGetEventResponse<___R>>;

        fn respond(response: ___R) -> Self::Output {
            ::fidl_next::Strict(crate::generic::DeviceGetEventResponse { event: response })
        }
    }

    mod ___detail {
        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___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::<::fidl_next::wire::EmptyMessageBody>(
                        7952116938191896180,
                        <super::GetHardwareId as ::fidl_next::Method>::FLEXIBILITY,
                        (),
                    ),
                )
            }

            #[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::<::fidl_next::wire::EmptyMessageBody>(
                        6100331669860404750,
                        <super::GetEvent as ::fidl_next::Method>::FLEXIBILITY,
                        (),
                    ),
                )
            }
        }

        /// 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 {}
    }
}

#[diagnostic::on_unimplemented(
    note = "If {Self} implements the non-local DeviceClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
)]

/// A client handler for the Device protocol.
///
/// See [`Device`] for more details.
pub trait DeviceLocalClientHandler<
    #[cfg(feature = "driver")] ___T: ::fidl_next::Transport = ::fdf_fidl::DriverChannel,
    #[cfg(not(feature = "driver"))] ___T: ::fidl_next::Transport,
>
{
}

impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Device
where
    ___H: DeviceLocalClientHandler<___T>,
    ___T: ::fidl_next::Transport,
{
    async fn on_event(
        handler: &mut ___H,
        mut message: ::fidl_next::Message<___T>,
    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
        match *message.header().ordinal {
            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
        }
    }
}

#[diagnostic::on_unimplemented(
    note = "If {Self} implements the non-local DeviceServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
)]

/// A server handler for the Device protocol.
///
/// See [`Device`] for more details.
pub trait DeviceLocalServerHandler<
    #[cfg(feature = "driver")] ___T: ::fidl_next::Transport = ::fdf_fidl::DriverChannel,
    #[cfg(not(feature = "driver"))] ___T: ::fidl_next::Transport,
>
{
    #[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 = ()>;

    #[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 = ()>;
}

impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Device
where
    ___H: DeviceLocalServerHandler<___T>,
    ___T: ::fidl_next::Transport,
{
    async fn on_one_way(
        handler: &mut ___H,
        mut message: ::fidl_next::Message<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match *message.header().ordinal {
            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        mut message: ::fidl_next::Message<___T>,
        responder: ::fidl_next::protocol::Responder<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match *message.header().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::UnknownOrdinal(ordinal)),
        }
    }
}

/// A client handler for the Device protocol.
///
/// See [`Device`] for more details.
pub trait DeviceClientHandler<
    #[cfg(feature = "driver")] ___T: ::fidl_next::Transport = ::fdf_fidl::DriverChannel,
    #[cfg(not(feature = "driver"))] ___T: ::fidl_next::Transport,
>
{
}

impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Device
where
    ___H: DeviceClientHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_event(
        handler: &mut ___H,
        mut message: ::fidl_next::Message<___T>,
    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
        match *message.header().ordinal {
            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
        }
    }
}

/// A server handler for the Device protocol.
///
/// See [`Device`] for more details.
pub trait DeviceServerHandler<
    #[cfg(feature = "driver")] ___T: ::fidl_next::Transport = ::fdf_fidl::DriverChannel,
    #[cfg(not(feature = "driver"))] ___T: ::fidl_next::Transport,
>
{
    #[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,
        mut message: ::fidl_next::Message<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match *message.header().ordinal {
            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        mut message: ::fidl_next::Message<___T>,
        responder: ::fidl_next::protocol::Responder<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match *message.header().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::UnknownOrdinal(ordinal)),
        }
    }
}

impl<___T> DeviceClientHandler<___T> for ::fidl_next::IgnoreEvents where ___T: ::fidl_next::Transport
{}

impl<___H, ___T> DeviceLocalClientHandler<___T> for ::fidl_next::Local<___H>
where
    ___H: DeviceClientHandler<___T>,
    ___T: ::fidl_next::Transport,
{
}

impl<___H, ___T> DeviceLocalServerHandler<___T> for ::fidl_next::Local<___H>
where
    ___H: DeviceServerHandler<___T>,
    ___T: ::fidl_next::Transport,
{
    async fn get_hardware_id(
        &mut self,

        responder: ::fidl_next::Responder<device::GetHardwareId, ___T>,
    ) {
        ___H::get_hardware_id(&mut self.0, responder).await
    }

    async fn get_event(&mut self, responder: ::fidl_next::Responder<device::GetEvent, ___T>) {
        ___H::get_event(&mut self.0, responder).await
    }
}

pub use fidl_next_common_fuchsia_examples_gizmo::*;