fidl_next_fuchsia_unknown/

fidl_next_fuchsia_unknown.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(Debug)]
#[repr(C)]
pub struct CloneableCloneRequest {
    pub request: ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel, crate::Cloneable>,
}

impl ::fidl_next::Encodable for CloneableCloneRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

                && <
                    ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel,crate::Cloneable,
        > as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    type Encoded = WireCloneableCloneRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for CloneableCloneRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                request,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.request, encoder, request)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CloneableCloneRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCloneableCloneRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<CloneableCloneRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    CloneableCloneRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> 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::TakeFrom<WireCloneableCloneRequest> for CloneableCloneRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

                && <
                    ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel,crate::Cloneable,
        > as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    #[inline]
    fn take_from(from: &WireCloneableCloneRequest) -> Self {
        Self { request: ::fidl_next::TakeFrom::take_from(&from.request) }
    }
}

/// The wire type corresponding to [`CloneableCloneRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireCloneableCloneRequest {
    pub request: ::fidl_next::ServerEnd<::fidl_next::fuchsia::WireChannel, crate::Cloneable>,
}

unsafe impl ::fidl_next::ZeroPadding for WireCloneableCloneRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCloneableCloneRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut request,

            } = slot;
        }

        ::fidl_next::Decode::decode(request.as_mut(), decoder)?;

        Ok(())
    }
}

/// The type corresponding to the Cloneable protocol.
#[doc = " Provides a means of duplicating a connection.\n\n See the composing protocol\'s documentation for a description of\n connection-scoped state, if any.\n"]
#[derive(Debug)]
pub struct Cloneable;

pub mod cloneable {
    pub mod prelude {
        pub use crate::{
            cloneable, Cloneable, CloneableClientHandler, CloneableClientSender,
            CloneableServerHandler, CloneableServerSender,
        };

        pub use crate::CloneableCloneRequest;
    }

    pub struct Clone;

    impl ::fidl_next::Method for Clone {
        const ORDINAL: u64 = 2366825959783828089;

        type Protocol = crate::Cloneable;

        type Request = crate::WireCloneableCloneRequest;

        type Response = ::fidl_next::Never;
    }
}

/// A helper trait for the `Cloneable` client sender.
pub trait CloneableClientSender {
    type Transport: ::fidl_next::Transport;

    fn clone<___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::WireCloneableCloneRequest,
        >;
}

impl<___T> CloneableClientSender for ::fidl_next::ClientSender<___T, Cloneable>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    fn clone<___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::WireCloneableCloneRequest,
        >,
    {
        self.as_untyped().send_one_way(2366825959783828089, request)
    }
}

/// A client handler for the Cloneable protocol.
///
/// See [`Cloneable`] for more details.
pub trait CloneableClientHandler<___T: ::fidl_next::Transport> {}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Cloneable
where
    ___T: ::fidl_next::Transport,
    ___H: CloneableClientHandler<___T>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }
}

/// A helper trait for the `Cloneable` server sender.
pub trait CloneableServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> CloneableServerSender for ::fidl_next::ServerSender<___T, Cloneable>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A server handler for the Cloneable protocol.
///
/// See [`Cloneable`] for more details.
pub trait CloneableServerHandler<___T: ::fidl_next::Transport> {
    fn clone(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Cloneable>,

        request: ::fidl_next::RequestBuffer<___T, cloneable::Clone>,
    );
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Cloneable
where
    ___T: ::fidl_next::Transport,
    ___H: CloneableServerHandler<___T>,

    crate::WireCloneableCloneRequest:
        ::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 {
            2366825959783828089 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.clone(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 {
            ordinal => {
                sender.close();
            }
        }
    }
}

pub type CloseableCloseResponse = ();

/// The wire type corresponding to [`CloseableCloseResponse`].
pub type WireCloseableCloseResponse = ();

/// The type corresponding to the Closeable protocol.
#[doc = " Provides a means of synchronously closing a connection.\n"]
#[derive(Debug)]
pub struct Closeable;

pub mod closeable {
    pub mod prelude {
        pub use crate::{
            closeable, Closeable, CloseableClientHandler, CloseableClientSender,
            CloseableServerHandler, CloseableServerSender,
        };

        pub use crate::CloseableCloseResponse;
    }

    pub struct Close;

    impl ::fidl_next::Method for Close {
        const ORDINAL: u64 = 6540867515453498750;

        type Protocol = crate::Closeable;

        type Request = ();

        type Response =
            ::fidl_next::WireResult<crate::WireCloseableCloseResponse, ::fidl_next::WireI32>;
    }
}

/// A helper trait for the `Closeable` client sender.
pub trait CloseableClientSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
    fn close(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, closeable::Close>,
        ::fidl_next::EncodeError,
    >;
}

impl<___T> CloseableClientSender for ::fidl_next::ClientSender<___T, Closeable>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
    fn close(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, closeable::Close>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(6540867515453498750, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the Closeable protocol.
///
/// See [`Closeable`] for more details.
pub trait CloseableClientHandler<___T: ::fidl_next::Transport> {}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Closeable
where
    ___T: ::fidl_next::Transport,
    ___H: CloseableClientHandler<___T>,

    <closeable::Close 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 {
            ordinal => {
                sender.close();
            }
        }
    }
}

/// A helper trait for the `Closeable` server sender.
pub trait CloseableServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> CloseableServerSender for ::fidl_next::ServerSender<___T, Closeable>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A server handler for the Closeable protocol.
///
/// See [`Closeable`] for more details.
pub trait CloseableServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
    fn close(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Closeable>,

        responder: ::fidl_next::Responder<closeable::Close>,
    );
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Closeable
where
    ___T: ::fidl_next::Transport,
    ___H: CloseableServerHandler<___T>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            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 {
            6540867515453498750 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.close(sender, responder);
            }

            ordinal => {
                sender.close();
            }
        }
    }
}

#[derive(Clone, Debug)]
pub struct QueryableQueryResponse {
    pub protocol: Vec<u8>,
}

impl ::fidl_next::Encodable for QueryableQueryResponse {
    type Encoded = WireQueryableQueryResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for QueryableQueryResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                protocol,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.protocol, encoder, protocol)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<QueryableQueryResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireQueryableQueryResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<QueryableQueryResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    QueryableQueryResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> 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::TakeFrom<WireQueryableQueryResponse> for QueryableQueryResponse {
    #[inline]
    fn take_from(from: &WireQueryableQueryResponse) -> Self {
        Self { protocol: ::fidl_next::TakeFrom::take_from(&from.protocol) }
    }
}

/// The wire type corresponding to [`QueryableQueryResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireQueryableQueryResponse {
    pub protocol: ::fidl_next::WireVector<u8>,
}

unsafe impl ::fidl_next::ZeroPadding for WireQueryableQueryResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireQueryableQueryResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut protocol,

            } = slot;
        }

        ::fidl_next::Decode::decode(protocol.as_mut(), decoder)?;

        Ok(())
    }
}

/// The type corresponding to the Queryable protocol.
#[doc = " Provides a means of identifying a type-erased protocol.\n"]
#[derive(Debug)]
pub struct Queryable;

pub mod queryable {
    pub mod prelude {
        pub use crate::{
            queryable, Queryable, QueryableClientHandler, QueryableClientSender,
            QueryableServerHandler, QueryableServerSender,
        };

        pub use crate::QueryableQueryResponse;
    }

    pub struct Query;

    impl ::fidl_next::Method for Query {
        const ORDINAL: u64 = 2763219980499352582;

        type Protocol = crate::Queryable;

        type Request = ();

        type Response = crate::WireQueryableQueryResponse;
    }
}

/// A helper trait for the `Queryable` client sender.
pub trait QueryableClientSender {
    type Transport: ::fidl_next::Transport;

    fn query(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, queryable::Query>,
        ::fidl_next::EncodeError,
    >;
}

impl<___T> QueryableClientSender for ::fidl_next::ClientSender<___T, Queryable>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    fn query(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, queryable::Query>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(2763219980499352582, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the Queryable protocol.
///
/// See [`Queryable`] for more details.
pub trait QueryableClientHandler<___T: ::fidl_next::Transport> {}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Queryable
where
    ___T: ::fidl_next::Transport,
    ___H: QueryableClientHandler<___T>,

    <queryable::Query 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 {
            ordinal => {
                sender.close();
            }
        }
    }
}

/// A helper trait for the `Queryable` server sender.
pub trait QueryableServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> QueryableServerSender for ::fidl_next::ServerSender<___T, Queryable>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A server handler for the Queryable protocol.
///
/// See [`Queryable`] for more details.
pub trait QueryableServerHandler<___T: ::fidl_next::Transport> {
    fn query(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Queryable>,

        responder: ::fidl_next::Responder<queryable::Query>,
    );
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Queryable
where
    ___T: ::fidl_next::Transport,
    ___H: QueryableServerHandler<___T>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            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 {
            2763219980499352582 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.query(sender, responder);
            }

            ordinal => {
                sender.close();
            }
        }
    }
}

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

    impl ::fidl_next::TakeFrom<crate::WireCloneableCloneRequest>
        for ::fidl_fuchsia_unknown::CloneableCloneRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCloneableCloneRequest) -> Self {
            Self { request: ::fidl_next::TakeFrom::take_from(&from.request) }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Cloneable`
    /// protocol.
    pub type CloneableProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Cloneable>;

    impl ::fidl_next::TakeFrom<crate::Cloneable> for ::fidl_fuchsia_unknown::CloneableMarker {
        #[inline]
        fn take_from(from: &crate::Cloneable) -> Self {
            Self
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Closeable`
    /// protocol.
    pub type CloseableProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Closeable>;

    impl ::fidl_next::TakeFrom<crate::Closeable> for ::fidl_fuchsia_unknown::CloseableMarker {
        #[inline]
        fn take_from(from: &crate::Closeable) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireQueryableQueryResponse>
        for ::fidl_fuchsia_unknown::QueryableQueryResponse
    {
        #[inline]
        fn take_from(from: &crate::WireQueryableQueryResponse) -> Self {
            Self { protocol: ::fidl_next::TakeFrom::take_from(&from.protocol) }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Queryable`
    /// protocol.
    pub type QueryableProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Queryable>;

    impl ::fidl_next::TakeFrom<crate::Queryable> for ::fidl_fuchsia_unknown::QueryableMarker {
        #[inline]
        fn take_from(from: &crate::Queryable) -> Self {
            Self
        }
    }
}