fidl_next_fuchsia_device_fs/

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

::fidl_next::bitflags! {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
    )]
    pub struct ConnectionType: u8 {
        #[doc = " Represents the fuchsia.io/Node protocol.\n"]const NODE = 1;
        #[doc = " Represents the fuchsia.device/Controller protocol.\n"]const CONTROLLER = 2;
        #[doc = " Represents the device specific FIDL.\n"]const DEVICE = 4;
        const _ = !0;
    }
}

impl ::fidl_next::Encodable for ConnectionType {
    type Encoded = WireConnectionType;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ConnectionType
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ConnectionType
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConnectionType { value } = out);
        let _ = value.write(u8::from(self.bits()));
        Ok(())
    }
}

impl ::core::convert::From<WireConnectionType> for ConnectionType {
    fn from(wire: WireConnectionType) -> Self {
        Self::from_bits_retain(u8::from(wire.value))
    }
}

impl ::fidl_next::FromWire<WireConnectionType> for ConnectionType {
    #[inline]
    fn from_wire(wire: WireConnectionType) -> Self {
        Self::from(wire)
    }
}

impl ::fidl_next::FromWireRef<WireConnectionType> for ConnectionType {
    #[inline]
    fn from_wire_ref(wire: &WireConnectionType) -> Self {
        Self::from(*wire)
    }
}

/// The wire type corresponding to [`ConnectionType`].
#[derive(Clone, Copy, Debug)]
#[repr(transparent)]
pub struct WireConnectionType {
    value: u8,
}

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

    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire bits have no padding
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireConnectionType
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        Ok(())
    }
}

impl ::core::convert::From<ConnectionType> for WireConnectionType {
    fn from(natural: ConnectionType) -> Self {
        Self { value: u8::from(natural.bits()) }
    }
}

#[derive(Debug)]
#[repr(C)]
pub struct ConnectorConnectRequest {
    pub server: ::fidl_next::fuchsia::zx::Handle,
}

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

    type Encoded = WireConnectorConnectRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ConnectorConnectRequest
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>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                server,

            } = out;
        }

        ::fidl_next::Encode::encode(self.server, encoder, server)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ConnectorConnectRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ConnectorConnectRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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::FromWire<WireConnectorConnectRequest> for ConnectorConnectRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireConnectorConnectRequest, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::fuchsia::zx::Handle as ::fidl_next::FromWire<
                ::fidl_next::fuchsia::WireHandle,
            >>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

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

/// The wire type corresponding to [`ConnectorConnectRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireConnectorConnectRequest {
    pub server: ::fidl_next::fuchsia::WireHandle,
}

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

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

            } = slot;
        }

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

        Ok(())
    }
}

/// The type corresponding to the Connector protocol.
#[doc = " A connector lets a client forward the server end of a protocol.\n"]
#[derive(Debug)]
pub struct Connector;

pub mod connector {
    pub mod prelude {
        pub use crate::{connector, Connector, ConnectorClientHandler, ConnectorServerHandler};

        pub use crate::ConnectorConnectRequest;
    }

    pub struct Connect;

    impl ::fidl_next::Method for Connect {
        const ORDINAL: u64 = 3169778387179902201;

        type Protocol = crate::Connector;

        type Request = crate::WireConnectorConnectRequest;

        type Response = ::fidl_next::Never;
    }

    mod ___detail {

        pub struct Connect<T0> {
            server: T0,
        }

        impl<T0> ::fidl_next::Encodable for Connect<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireHandle>,
        {
            type Encoded = crate::WireConnectorConnectRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

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

                    } = out;
                }

                ::fidl_next::Encode::encode(self.server, encoder, server)?;

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Connector
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = ConnectorClientSender<___T>;
            type ServerSender = ConnectorServerSender<___T>;
        }

        /// The client sender for the `Connector` protocol.
        pub struct ConnectorClientSender<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            sender: ::fidl_next::protocol::ClientSender<___T>,
        }

        impl<___T> ConnectorClientSender<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            #[doc = " Forward a server end of a protocol so that it can be connected.\n + request `server` the server end of the protocol to be served. The FIDL protocol that\n     this speaks is determined out-of-band.\n - response This function has no response. The function is one-way to match the pipelining\n     behaviors of other virtual filesystems.\n"]
            pub fn connect(
                &self,

                server: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::fuchsia::WireHandle,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.connect_with(Connect { server })
            }

            #[doc = " Forward a server end of a protocol so that it can be connected.\n + request `server` the server end of the protocol to be served. The FIDL protocol that\n     this speaks is determined out-of-band.\n - response This function has no response. The function is one-way to match the pipelining\n     behaviors of other virtual filesystems.\n"]
            pub fn connect_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireConnectorConnectRequest,
                >,
            {
                self.sender.send_one_way(3169778387179902201, request)
            }
        }

        /// The server sender for the `Connector` protocol.
        #[repr(transparent)]
        pub struct ConnectorServerSender<___T: ::fidl_next::Transport> {
            sender: ::fidl_next::protocol::ServerSender<___T>,
        }

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

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

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

/// A server handler for the Connector protocol.
///
/// See [`Connector`] for more details.
pub trait ConnectorServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Forward a server end of a protocol so that it can be connected.\n + request `server` the server end of the protocol to be served. The FIDL protocol that\n     this speaks is determined out-of-band.\n - response This function has no response. The function is one-way to match the pipelining\n     behaviors of other virtual filesystems.\n"]
    fn connect(
        &mut self,
        sender: &::fidl_next::ServerSender<Connector, ___T>,

        request: ::fidl_next::Request<connector::Connect, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for Connector
where
    ___H: ConnectorServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

    <connector::Connect as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            3169778387179902201 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.connect(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

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

    async fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }
}

#[doc = " This name is reserved for accessing the fuchsia.device/Controller protocol\n within /dev/. No devices can be created with this name.\n"]
pub const DEVICE_CONTROLLER_NAME: &str = "device_controller";

#[doc = " This name is reserved for accessing the device specific protocol\n within /dev/. No devices can be created with this name.\n"]
pub const DEVICE_PROTOCOL_NAME: &str = "device_protocol";

#[doc = " This name is reserved for accessing the fuchsia.device.fs/TopologicalPath protocol\n within /dev/. No devices can be created with this name.\n"]
pub const DEVICE_TOPOLOGY_NAME: &str = "device_topology";

#[derive(Debug, Default)]
pub struct DevfsAddArgs {
    pub connector:
        Option<::fidl_next::ClientEnd<crate::Connector, ::fidl_next::fuchsia::zx::Channel>>,

    pub class_name: Option<String>,

    pub inspect: Option<::fidl_next::fuchsia::zx::Handle>,

    pub connector_supports: Option<crate::ConnectionType>,

    pub controller_connector:
        Option<::fidl_next::ClientEnd<crate::Connector, ::fidl_next::fuchsia::zx::Channel>>,
}

impl DevfsAddArgs {
    fn __max_ordinal(&self) -> usize {
        if self.controller_connector.is_some() {
            return 5;
        }

        if self.connector_supports.is_some() {
            return 4;
        }

        if self.inspect.is_some() {
            return 3;
        }

        if self.class_name.is_some() {
            return 2;
        }

        if self.connector.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for DevfsAddArgs {
    type Encoded = WireDevfsAddArgs<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DevfsAddArgs
where
    ___E: ::fidl_next::Encoder + ?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 WireDevfsAddArgs { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                5 => {
                    if let Some(controller_connector) = self.controller_connector.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            controller_connector,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(connector_supports) = self.connector_supports.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            connector_supports,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(inspect) = self.inspect.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            inspect,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(class_name) = self.class_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            class_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(connector) = self.connector.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            connector,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireDevfsAddArgs<'de>> for DevfsAddArgs {
    #[inline]
    fn from_wire(wire: WireDevfsAddArgs<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let connector = wire.table.get(1);

        let class_name = wire.table.get(2);

        let inspect = wire.table.get(3);

        let connector_supports = wire.table.get(4);

        let controller_connector = wire.table.get(5);

        Self {
            connector:
                connector.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::ClientEnd<
                            crate::Connector,
                            ::fidl_next::fuchsia::WireChannel,
                        >>()
                    })
                }),

            class_name: class_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            inspect: inspect.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::fuchsia::WireHandle>()
                })
            }),

            connector_supports: connector_supports.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireConnectionType>()
                })
            }),

            controller_connector:
                controller_connector.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::ClientEnd<
                            crate::Connector,
                            ::fidl_next::fuchsia::WireChannel,
                        >>()
                    })
                }),
        }
    }
}

/// The wire type corresponding to [`DevfsAddArgs`].
#[repr(C)]
pub struct WireDevfsAddArgs<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireDevfsAddArgs<'de> {
    fn drop(&mut self) {
        let _ = self.table.get(1)
                .map(|envelope| unsafe {
                    envelope.read_unchecked::<::fidl_next::ClientEnd<crate::Connector, ::fidl_next::fuchsia::WireChannel>>()
                });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self.table.get(3).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::fuchsia::WireHandle>()
        });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireConnectionType>() });

        let _ = self.table.get(5)
                .map(|envelope| unsafe {
                    envelope.read_unchecked::<::fidl_next::ClientEnd<crate::Connector, ::fidl_next::fuchsia::WireChannel>>()
                });
    }
}

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDevfsAddArgs<'static>
where
    ___D: ::fidl_next::Decoder + ?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 { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::ClientEnd<crate::Connector, ::fidl_next::fuchsia::WireChannel>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let class_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if class_name.len() > 255 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: class_name.len() as u64,
                            limit: 255,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::fuchsia::WireHandle>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireConnectionType>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::ClientEnd<crate::Connector, ::fidl_next::fuchsia::WireChannel>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireDevfsAddArgs<'de> {
    pub fn connector(
        &self,
    ) -> Option<&::fidl_next::ClientEnd<crate::Connector, ::fidl_next::fuchsia::WireChannel>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn class_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn inspect(&self) -> Option<&::fidl_next::fuchsia::WireHandle> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn connector_supports(&self) -> Option<&crate::WireConnectionType> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn controller_connector(
        &self,
    ) -> Option<&::fidl_next::ClientEnd<crate::Connector, ::fidl_next::fuchsia::WireChannel>> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireDevfsAddArgs<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("DevfsAddArgs")
            .field("connector", &self.connector())
            .field("class_name", &self.class_name())
            .field("inspect", &self.inspect())
            .field("connector_supports", &self.connector_supports())
            .field("controller_connector", &self.controller_connector())
            .finish()
    }
}

#[doc = " Maximum length of a device path\n"]
pub const MAX_DEVICE_PATH_LEN: u64 = 1024;

#[doc = " Maximum length for a driver path\n"]
pub const MAX_DRIVER_PATH_LEN: u64 = 1024;

#[derive(Clone, Debug)]
pub struct TopologicalPathGetTopologicalPathResponse {
    pub path: String,
}

impl ::fidl_next::Encodable for TopologicalPathGetTopologicalPathResponse {
    type Encoded = WireTopologicalPathGetTopologicalPathResponse<'static>;
}

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

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

            } = out;
        }

        ::fidl_next::Encode::encode(self.path, encoder, path)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for TopologicalPathGetTopologicalPathResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

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

            } = out;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.path, encoder, path)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for TopologicalPathGetTopologicalPathResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    TopologicalPathGetTopologicalPathResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for TopologicalPathGetTopologicalPathResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    TopologicalPathGetTopologicalPathResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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<'de> ::fidl_next::FromWire<WireTopologicalPathGetTopologicalPathResponse<'de>>
    for TopologicalPathGetTopologicalPathResponse
{
    #[inline]
    fn from_wire(wire: WireTopologicalPathGetTopologicalPathResponse<'de>) -> Self {
        Self { path: ::fidl_next::FromWire::from_wire(wire.path) }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireTopologicalPathGetTopologicalPathResponse<'de>>
    for TopologicalPathGetTopologicalPathResponse
{
    #[inline]
    fn from_wire_ref(wire: &WireTopologicalPathGetTopologicalPathResponse<'de>) -> Self {
        Self { path: ::fidl_next::FromWireRef::from_wire_ref(&wire.path) }
    }
}

/// The wire type corresponding to [`TopologicalPathGetTopologicalPathResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireTopologicalPathGetTopologicalPathResponse<'de> {
    pub path: ::fidl_next::WireString<'de>,
}

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D>
    for WireTopologicalPathGetTopologicalPathResponse<'static>
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 path,

            } = slot;
        }

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

        let path = unsafe { path.deref_unchecked() };

        if path.len() > 1024 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: path.len() as u64,
                limit: 1024,
            });
        }

        Ok(())
    }
}

/// The type corresponding to the TopologicalPath protocol.
#[derive(Debug)]
pub struct TopologicalPath;

pub mod topological_path {
    pub mod prelude {
        pub use crate::{
            topological_path, TopologicalPath, TopologicalPathClientHandler,
            TopologicalPathServerHandler,
        };

        pub use crate::TopologicalPathGetTopologicalPathResponse;
    }

    pub struct GetTopologicalPath;

    impl ::fidl_next::Method for GetTopologicalPath {
        const ORDINAL: u64 = 6266213890697819096;

        type Protocol = crate::TopologicalPath;

        type Request = ();

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

    mod ___detail {

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::TopologicalPath
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = TopologicalPathClientSender<___T>;
            type ServerSender = TopologicalPathServerSender<___T>;
        }

        /// The client sender for the `TopologicalPath` protocol.
        pub struct TopologicalPathClientSender<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            sender: ::fidl_next::protocol::ClientSender<___T>,
        }

        impl<___T> TopologicalPathClientSender<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            #[doc = " Return the topological path for this device\n"]
            pub fn get_topological_path(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetTopologicalPath, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(6266213890697819096, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }
        }

        /// The server sender for the `TopologicalPath` protocol.
        #[repr(transparent)]
        pub struct TopologicalPathServerSender<___T: ::fidl_next::Transport> {
            sender: ::fidl_next::protocol::ServerSender<___T>,
        }

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

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

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for TopologicalPath
where
    ___H: TopologicalPathClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

    <topological_path::GetTopologicalPath as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }
}

/// A server handler for the TopologicalPath protocol.
///
/// See [`TopologicalPath`] for more details.
pub trait TopologicalPathServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Return the topological path for this device\n"]
    fn get_topological_path(
        &mut self,
        sender: &::fidl_next::ServerSender<TopologicalPath, ___T>,

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

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for TopologicalPath
where
    ___H: TopologicalPathServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            6266213890697819096 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_topological_path(sender, responder).await;
            }

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

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

    impl ::core::convert::From<crate::ConnectionType> for ::fidl_fuchsia_device_fs::ConnectionType {
        #[inline]
        fn from(from: crate::ConnectionType) -> Self {
            Self::from_bits_retain(from.bits())
        }
    }

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

    impl ::core::convert::From<crate::Connector> for ::fidl_fuchsia_device_fs::ConnectorMarker {
        #[inline]
        fn from(_: crate::Connector) -> Self {
            Self
        }
    }

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

    impl ::core::convert::From<crate::TopologicalPath>
        for ::fidl_fuchsia_device_fs::TopologicalPathMarker
    {
        #[inline]
        fn from(_: crate::TopologicalPath) -> Self {
            Self
        }
    }
}