tools/fidl/fidlgen_rust_next/goldens/escaping.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)]

pub mod natural {

    #[doc = " \"pleaseescapethisdocommentproperly\"\n"]
    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct DocCommentWithQuotes {}

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DocCommentWithQuotes, ___E>
        for DocCommentWithQuotes
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::DocCommentWithQuotes>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            *out_ = ::core::mem::MaybeUninit::zeroed();

            Ok(())
        }
    }

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

                        _empty,


                } = out_;
            }

            Ok(())
        }
    }

    unsafe impl<___E>
        ::fidl_next::EncodeOption<
            ::fidl_next::WireBox<'static, crate::wire::DocCommentWithQuotes>,
            ___E,
        > for DocCommentWithQuotes
    where
        ___E: ::fidl_next::Encoder + ?Sized,
        DocCommentWithQuotes: ::fidl_next::Encode<crate::wire::DocCommentWithQuotes, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<
                ::fidl_next::WireBox<'static, crate::wire::DocCommentWithQuotes>,
            >,
            _: (),
        ) -> ::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<'a, ___E>
        ::fidl_next::EncodeOption<
            ::fidl_next::WireBox<'static, crate::wire::DocCommentWithQuotes>,
            ___E,
        > for &'a DocCommentWithQuotes
    where
        ___E: ::fidl_next::Encoder + ?Sized,
        &'a DocCommentWithQuotes: ::fidl_next::Encode<crate::wire::DocCommentWithQuotes, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<
                ::fidl_next::WireBox<'static, crate::wire::DocCommentWithQuotes>,
            >,
            _: (),
        ) -> ::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<crate::wire::DocCommentWithQuotes> for DocCommentWithQuotes {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::DocCommentWithQuotes,
            Self,
        > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

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

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

pub mod wire {

    /// The wire type corresponding to [`DocCommentWithQuotes`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct DocCommentWithQuotes {
        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
    }

    static_assertions::const_assert_eq!(std::mem::size_of::<DocCommentWithQuotes>(), 1);
    static_assertions::const_assert_eq!(std::mem::align_of::<DocCommentWithQuotes>(), 1);

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

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

                        _empty,


                } = &mut *out_;
            }
        }
    }

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

                        mut _empty,


                } = slot_;
            }

            if _empty.as_bytes() != &[0u8] {
                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
            }

            Ok(())
        }
    }

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

    impl ::fidl_next::Unconstrained for DocCommentWithQuotes {}
}

pub mod wire_optional {}

pub mod generic {

    pub struct DocCommentWithQuotes {}

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

                        _empty,


                } = out_;
            }

            Ok(())
        }
    }
}

pub use self::natural::*;

pub const BASIC: &str = "\'\"\\\n\r\t";

pub const DOLLAR: &str = "$";

pub const DOLLAR_BRACE: &str = "${";

pub const MAX: &str = "\u{10ffff}";

pub const NULL: &str = "\u{0}";

pub const SMILE_LEADING_ZERO: &str = "\u{1f600}";

pub const SMILE_LITERAL: &str = "\u{1f600}";

pub const SMILE_LOWER: &str = "\u{1f600}";

pub const SMILE_UPPER: &str = "\u{1f600}";

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

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

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