tools/fidl/fidlgen_rust_next/goldens/serializable.rs.golden

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

impl ::fidl_next::Encodable for SerializableStruct {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireSerializableStruct> =
        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

    type Encoded = WireSerializableStruct;
}

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

            } = out_;
        }

        Ok(())
    }
}

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

            } = out_;
        }

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for SerializableStruct
where
    ___E: ::fidl_next::Encoder + ?Sized,
    SerializableStruct: ::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 SerializableStruct
where
    ___E: ::fidl_next::Encoder + ?Sized,
    SerializableStruct: ::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<WireSerializableStruct> for SerializableStruct {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireSerializableStruct, Self> =
        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

    #[inline]
    fn from_wire(wire: WireSerializableStruct) -> Self {
        Self {}
    }
}

impl ::fidl_next::IntoNatural for WireSerializableStruct {
    type Natural = SerializableStruct;
}

impl ::fidl_next::FromWireRef<WireSerializableStruct> for SerializableStruct {
    #[inline]
    fn from_wire_ref(wire: &WireSerializableStruct) -> Self {
        Self {}
    }
}

/// The wire type corresponding to [`SerializableStruct`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireSerializableStruct {}

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

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

            } = &mut *out_;
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireSerializableStruct
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 {

            } = slot_;
        }

        Ok(())
    }
}

#[derive(PartialEq, Clone, Debug, Default)]
pub struct SerializableTable {}

impl SerializableTable {
    fn __max_ordinal(&self) -> usize {
        0
    }
}

impl ::fidl_next::Encodable for SerializableTable {
    type Encoded = WireSerializableTable<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for SerializableTable
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireSerializableTable { 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 {
                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for SerializableTable
where
    ___E: ::fidl_next::Encoder + ?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 WireSerializableTable { 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 {
                _ => ::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<WireSerializableTable<'de>> for SerializableTable {
    #[inline]
    fn from_wire(wire_: WireSerializableTable<'de>) -> Self {
        let wire_ = ::core::mem::ManuallyDrop::new(wire_);

        Self {}
    }
}

impl<'de> ::fidl_next::IntoNatural for WireSerializableTable<'de> {
    type Natural = SerializableTable;
}

impl<'de> ::fidl_next::FromWireRef<WireSerializableTable<'de>> for SerializableTable {
    #[inline]
    fn from_wire_ref(wire: &WireSerializableTable<'de>) -> Self {
        Self {}
    }
}

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

impl<'de> Drop for WireSerializableTable<'de> {
    fn drop(&mut self) {}
}

unsafe impl ::fidl_next::Wire for WireSerializableTable<'static> {
    type Decoded<'de> = WireSerializableTable<'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 WireSerializableTable<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> ::core::result::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() },

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

impl<'de> WireSerializableTable<'de> {}

impl<'de> ::core::fmt::Debug for WireSerializableTable<'de> {
    fn fmt(
        &self,
        f: &mut ::core::fmt::Formatter<'_>,
    ) -> ::core::result::Result<(), ::core::fmt::Error> {
        f.debug_struct("SerializableTable").finish()
    }
}

#[derive(PartialEq, Clone, Debug)]
pub enum SerializableUnion {
    Unused(bool),
}

impl ::fidl_next::Encodable for SerializableUnion {
    type Encoded = WireSerializableUnion;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for SerializableUnion
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 WireSerializableUnion { raw, _phantom: _ } = out);

        match self {
            Self::Unused(value) => {
                ::fidl_next::RawWireUnion::encode_as_static::<___E, bool>(value, 1, encoder, raw)?
            }
        }

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for SerializableUnion
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 WireSerializableUnion { raw, _phantom: _ } = out);

        match self {
            Self::Unused(value) => {
                ::fidl_next::RawWireUnion::encode_as_static::<___E, &bool>(value, 1, encoder, raw)?
            }
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for SerializableUnion {
    type EncodedOption = WireOptionalSerializableUnion;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for SerializableUnion
where
    ___E: ?Sized,
    SerializableUnion: ::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> {
        ::fidl_next::munge!(let WireOptionalSerializableUnion { raw, _phantom: _ } = &mut *out);

        if let Some(inner) = this {
            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
            ::fidl_next::Encode::encode(inner, encoder, value_out)?;
        } else {
            ::fidl_next::RawWireUnion::encode_absent(raw);
        }

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for SerializableUnion
where
    ___E: ?Sized,
    SerializableUnion: ::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> {
        ::fidl_next::munge!(let WireOptionalSerializableUnion { raw, _phantom: _ } = &mut *out);

        if let Some(inner) = this {
            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
            ::fidl_next::EncodeRef::encode_ref(inner, encoder, value_out)?;
        } else {
            ::fidl_next::RawWireUnion::encode_absent(raw);
        }

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireSerializableUnion> for SerializableUnion {
    #[inline]
    fn from_wire(wire: WireSerializableUnion) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::Unused(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<bool>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl ::fidl_next::IntoNatural for WireSerializableUnion {
    type Natural = SerializableUnion;
}

impl ::fidl_next::FromWireRef<WireSerializableUnion> for SerializableUnion {
    #[inline]
    fn from_wire_ref(wire: &WireSerializableUnion) -> Self {
        match wire.raw.ordinal() {
            1 => Self::Unused(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<bool>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl ::fidl_next::FromWireOption<WireOptionalSerializableUnion> for SerializableUnion {
    #[inline]
    fn from_wire_option(wire: WireOptionalSerializableUnion) -> ::core::option::Option<Self> {
        if let Some(inner) = wire.into_option() {
            Some(::fidl_next::FromWire::from_wire(inner))
        } else {
            None
        }
    }
}

impl ::fidl_next::IntoNatural for WireOptionalSerializableUnion {
    type Natural = ::core::option::Option<SerializableUnion>;
}

impl ::fidl_next::FromWireOption<WireOptionalSerializableUnion> for Box<SerializableUnion> {
    #[inline]
    fn from_wire_option(wire: WireOptionalSerializableUnion) -> ::core::option::Option<Self> {
        <
            SerializableUnion as ::fidl_next::FromWireOption<WireOptionalSerializableUnion>
        >::from_wire_option(wire).map(Box::new)
    }
}

impl ::fidl_next::FromWireOptionRef<WireOptionalSerializableUnion> for Box<SerializableUnion> {
    #[inline]
    fn from_wire_option_ref(wire: &WireOptionalSerializableUnion) -> ::core::option::Option<Self> {
        if let Some(inner) = wire.as_ref() {
            Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
        } else {
            None
        }
    }
}

/// The wire type corresponding to [`SerializableUnion`].
#[repr(transparent)]
pub struct WireSerializableUnion {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<()>,
}

impl Drop for WireSerializableUnion {
    fn drop(&mut self) {
        match self.raw.ordinal() {
            1 => {
                let _ = unsafe { self.raw.get().read_unchecked::<bool>() };
            }

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

pub mod serializable_union {
    pub enum Ref<'de> {
        Unused(&'de bool),
    }
}

impl WireSerializableUnion {
    pub fn as_ref(&self) -> crate::serializable_union::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::serializable_union::Ref::Unused(unsafe {
                self.raw.get().deref_unchecked::<bool>()
            }),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl Clone for WireSerializableUnion {
    fn clone(&self) -> Self {
        match self.raw.ordinal() {
            1 => Self {
                raw: unsafe { self.raw.clone_inline_unchecked::<bool>() },
                _phantom: ::core::marker::PhantomData,
            },

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireSerializableUnion
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, bool>(raw, decoder)?,

            ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireSerializableUnion {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe { self.raw.get().deref_unchecked::<bool>().fmt(f) },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

#[repr(transparent)]
pub struct WireOptionalSerializableUnion {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<()>,
}

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

impl WireOptionalSerializableUnion {
    pub fn is_some(&self) -> bool {
        self.raw.is_some()
    }

    pub fn is_none(&self) -> bool {
        self.raw.is_none()
    }

    pub fn as_ref(&self) -> ::core::option::Option<&WireSerializableUnion> {
        if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
    }

    pub fn into_option(self) -> ::core::option::Option<WireSerializableUnion> {
        if self.is_some() {
            Some(WireSerializableUnion { raw: self.raw, _phantom: ::core::marker::PhantomData })
        } else {
            None
        }
    }
}

impl Clone for WireOptionalSerializableUnion {
    fn clone(&self) -> Self {
        if self.is_none() {
            return WireOptionalSerializableUnion {
                raw: ::fidl_next::RawWireUnion::absent(),
                _phantom: ::core::marker::PhantomData,
            };
        }

        match self.raw.ordinal() {
            1 => Self {
                raw: unsafe { self.raw.clone_inline_unchecked::<bool>() },
                _phantom: ::core::marker::PhantomData,
            },

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalSerializableUnion
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, bool>(raw, decoder)?,

            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
            _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireOptionalSerializableUnion {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        self.as_ref().fmt(f)
    }
}

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

    impl ::fidl_next::CompatFrom<crate::SerializableStruct>
        for ::fidl_test_serializable::SerializableStruct
    {
        #[inline]
        fn compat_from(value: crate::SerializableStruct) -> Self {
            Self {}
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_test_serializable::SerializableStruct>
        for crate::SerializableStruct
    {
        #[inline]
        fn compat_from(value: ::fidl_test_serializable::SerializableStruct) -> Self {
            Self {}
        }
    }

    impl ::fidl_next::CompatFrom<crate::SerializableTable>
        for ::fidl_test_serializable::SerializableTable
    {
        fn compat_from(value: crate::SerializableTable) -> Self {
            Self { __source_breaking: ::fidl::marker::SourceBreaking }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_test_serializable::SerializableTable>
        for crate::SerializableTable
    {
        fn compat_from(value: ::fidl_test_serializable::SerializableTable) -> Self {
            Self {}
        }
    }

    impl ::fidl_next::CompatFrom<crate::SerializableUnion>
        for ::fidl_test_serializable::SerializableUnion
    {
        fn compat_from(value: crate::SerializableUnion) -> Self {
            match value {
                crate::SerializableUnion::Unused(value) => {
                    Self::Unused(::fidl_next::CompatFrom::compat_from(value))
                }
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_test_serializable::SerializableUnion>
        for crate::SerializableUnion
    {
        fn compat_from(value: ::fidl_test_serializable::SerializableUnion) -> Self {
            match value {
                ::fidl_test_serializable::SerializableUnion::Unused(value) => {
                    Self::Unused(::fidl_next::CompatFrom::compat_from(value))
                }
            }
        }
    }
}