tools/fidl/fidlgen_rust_next/goldens/enum_common.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 {

    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(u32)]
    pub enum MyEmptyFlexibleEnum {
        UnknownOrdinal_(u32) = 0,
    }
    impl ::std::convert::From<u32> for MyEmptyFlexibleEnum {
        fn from(value: u32) -> Self {
            match value {
                _ => Self::UnknownOrdinal_(value),
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::MyEmptyFlexibleEnum, ___E>
        for MyEmptyFlexibleEnum
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::MyEmptyFlexibleEnum>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::MyEmptyFlexibleEnum, ___E>
        for &'a MyEmptyFlexibleEnum
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::MyEmptyFlexibleEnum>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::MyEmptyFlexibleEnum { value } = out);
            let _ = value.write(::fidl_next::WireU32::from(match *self {
                MyEmptyFlexibleEnum::UnknownOrdinal_(value) => value,
            }));

            Ok(())
        }
    }

    impl ::core::convert::From<crate::wire::MyEmptyFlexibleEnum> for MyEmptyFlexibleEnum {
        fn from(wire: crate::wire::MyEmptyFlexibleEnum) -> Self {
            match u32::from(wire.value) {
                value => Self::UnknownOrdinal_(value),
            }
        }
    }

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

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

    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(u32)]
    pub enum MyFlexibleEnum {
        Foo = 1,
        Bar = 2,
        UnknownOrdinal_(u32) = 3,
    }
    impl ::std::convert::From<u32> for MyFlexibleEnum {
        fn from(value: u32) -> Self {
            match value {
                1 => Self::Foo,
                2 => Self::Bar,

                _ => Self::UnknownOrdinal_(value),
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::MyFlexibleEnum, ___E> for MyFlexibleEnum
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::MyFlexibleEnum>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::MyFlexibleEnum, ___E> for &'a MyFlexibleEnum
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::MyFlexibleEnum>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::MyFlexibleEnum { value } = out);
            let _ = value.write(::fidl_next::WireU32::from(match *self {
                MyFlexibleEnum::Foo => 1,

                MyFlexibleEnum::Bar => 2,

                MyFlexibleEnum::UnknownOrdinal_(value) => value,
            }));

            Ok(())
        }
    }

    impl ::core::convert::From<crate::wire::MyFlexibleEnum> for MyFlexibleEnum {
        fn from(wire: crate::wire::MyFlexibleEnum) -> Self {
            match u32::from(wire.value) {
                1 => Self::Foo,

                2 => Self::Bar,

                value => Self::UnknownOrdinal_(value),
            }
        }
    }

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

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

    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(u32)]
    pub enum MyFlexibleEnumWithCustomUnknown {
        Foo = 1,
        Bar = 2,
        CustomUnknown = 3,
        UnknownOrdinal_(u32) = 4,
    }
    impl ::std::convert::From<u32> for MyFlexibleEnumWithCustomUnknown {
        fn from(value: u32) -> Self {
            match value {
                1 => Self::Foo,
                2 => Self::Bar,
                3 => Self::CustomUnknown,

                _ => Self::UnknownOrdinal_(value),
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::MyFlexibleEnumWithCustomUnknown, ___E>
        for MyFlexibleEnumWithCustomUnknown
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::MyFlexibleEnumWithCustomUnknown>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::MyFlexibleEnumWithCustomUnknown, ___E>
        for &'a MyFlexibleEnumWithCustomUnknown
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::MyFlexibleEnumWithCustomUnknown>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::MyFlexibleEnumWithCustomUnknown { value } = out);
            let _ = value.write(::fidl_next::WireU32::from(match *self {
                MyFlexibleEnumWithCustomUnknown::Foo => 1,

                MyFlexibleEnumWithCustomUnknown::Bar => 2,

                MyFlexibleEnumWithCustomUnknown::CustomUnknown => 3,

                MyFlexibleEnumWithCustomUnknown::UnknownOrdinal_(value) => value,
            }));

            Ok(())
        }
    }

    impl ::core::convert::From<crate::wire::MyFlexibleEnumWithCustomUnknown>
        for MyFlexibleEnumWithCustomUnknown
    {
        fn from(wire: crate::wire::MyFlexibleEnumWithCustomUnknown) -> Self {
            match u32::from(wire.value) {
                1 => Self::Foo,

                2 => Self::Bar,

                3 => Self::CustomUnknown,

                value => Self::UnknownOrdinal_(value),
            }
        }
    }

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

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

    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(u32)]
    pub enum MyStrictEnum {
        Foo = 1,
        Bar = 2,
    }
    impl ::core::convert::TryFrom<u32> for MyStrictEnum {
        type Error = ::fidl_next::UnknownStrictEnumMemberError;
        fn try_from(
            value: u32,
        ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
            match value {
                1 => Ok(Self::Foo),
                2 => Ok(Self::Bar),

                _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::MyStrictEnum, ___E> for MyStrictEnum
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::MyStrictEnum>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::MyStrictEnum, ___E> for &'a MyStrictEnum
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::MyStrictEnum>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::MyStrictEnum { value } = out);
            let _ = value.write(::fidl_next::WireU32::from(match *self {
                MyStrictEnum::Foo => 1,

                MyStrictEnum::Bar => 2,
            }));

            Ok(())
        }
    }

    impl ::core::convert::From<crate::wire::MyStrictEnum> for MyStrictEnum {
        fn from(wire: crate::wire::MyStrictEnum) -> Self {
            match u32::from(wire.value) {
                1 => Self::Foo,

                2 => Self::Bar,

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

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

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

pub mod wire {

    /// The wire type corresponding to [`MyEmptyFlexibleEnum`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct MyEmptyFlexibleEnum {
        pub(crate) value: ::fidl_next::WireU32,
    }

    unsafe impl ::fidl_next::Wire for MyEmptyFlexibleEnum {
        type Owned<'de> = Self;

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

    impl MyEmptyFlexibleEnum {}

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

    impl ::core::convert::From<crate::natural::MyEmptyFlexibleEnum> for MyEmptyFlexibleEnum {
        fn from(natural: crate::natural::MyEmptyFlexibleEnum) -> Self {
            match natural {
                crate::natural::MyEmptyFlexibleEnum::UnknownOrdinal_(value) => {
                    MyEmptyFlexibleEnum { value: ::fidl_next::WireU32::from(value) }
                }
            }
        }
    }

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

    impl ::fidl_next::Unconstrained for MyEmptyFlexibleEnum {}

    /// The wire type corresponding to [`MyFlexibleEnum`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct MyFlexibleEnum {
        pub(crate) value: ::fidl_next::WireU32,
    }

    unsafe impl ::fidl_next::Wire for MyFlexibleEnum {
        type Owned<'de> = Self;

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

    impl MyFlexibleEnum {
        pub const FOO: MyFlexibleEnum = MyFlexibleEnum { value: ::fidl_next::WireU32(1) };

        pub const BAR: MyFlexibleEnum = MyFlexibleEnum { value: ::fidl_next::WireU32(2) };
    }

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

    impl ::core::convert::From<crate::natural::MyFlexibleEnum> for MyFlexibleEnum {
        fn from(natural: crate::natural::MyFlexibleEnum) -> Self {
            match natural {
                crate::natural::MyFlexibleEnum::Foo => MyFlexibleEnum::FOO,

                crate::natural::MyFlexibleEnum::Bar => MyFlexibleEnum::BAR,

                crate::natural::MyFlexibleEnum::UnknownOrdinal_(value) => {
                    MyFlexibleEnum { value: ::fidl_next::WireU32::from(value) }
                }
            }
        }
    }

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

    impl ::fidl_next::Unconstrained for MyFlexibleEnum {}

    /// The wire type corresponding to [`MyFlexibleEnumWithCustomUnknown`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct MyFlexibleEnumWithCustomUnknown {
        pub(crate) value: ::fidl_next::WireU32,
    }

    unsafe impl ::fidl_next::Wire for MyFlexibleEnumWithCustomUnknown {
        type Owned<'de> = Self;

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

    impl MyFlexibleEnumWithCustomUnknown {
        pub const FOO: MyFlexibleEnumWithCustomUnknown =
            MyFlexibleEnumWithCustomUnknown { value: ::fidl_next::WireU32(1) };

        pub const BAR: MyFlexibleEnumWithCustomUnknown =
            MyFlexibleEnumWithCustomUnknown { value: ::fidl_next::WireU32(2) };

        pub const CUSTOM_UNKNOWN: MyFlexibleEnumWithCustomUnknown =
            MyFlexibleEnumWithCustomUnknown { value: ::fidl_next::WireU32(3) };
    }

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

    impl ::core::convert::From<crate::natural::MyFlexibleEnumWithCustomUnknown>
        for MyFlexibleEnumWithCustomUnknown
    {
        fn from(natural: crate::natural::MyFlexibleEnumWithCustomUnknown) -> Self {
            match natural {
                crate::natural::MyFlexibleEnumWithCustomUnknown::Foo => {
                    MyFlexibleEnumWithCustomUnknown::FOO
                }

                crate::natural::MyFlexibleEnumWithCustomUnknown::Bar => {
                    MyFlexibleEnumWithCustomUnknown::BAR
                }

                crate::natural::MyFlexibleEnumWithCustomUnknown::CustomUnknown => {
                    MyFlexibleEnumWithCustomUnknown::CUSTOM_UNKNOWN
                }

                crate::natural::MyFlexibleEnumWithCustomUnknown::UnknownOrdinal_(value) => {
                    MyFlexibleEnumWithCustomUnknown { value: ::fidl_next::WireU32::from(value) }
                }
            }
        }
    }

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

    impl ::fidl_next::Unconstrained for MyFlexibleEnumWithCustomUnknown {}

    /// The wire type corresponding to [`MyStrictEnum`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct MyStrictEnum {
        pub(crate) value: ::fidl_next::WireU32,
    }

    unsafe impl ::fidl_next::Wire for MyStrictEnum {
        type Owned<'de> = Self;

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

    impl MyStrictEnum {
        pub const FOO: MyStrictEnum = MyStrictEnum { value: ::fidl_next::WireU32(1) };

        pub const BAR: MyStrictEnum = MyStrictEnum { value: ::fidl_next::WireU32(2) };
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for MyStrictEnum
    where
        ___D: ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            _: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { value } = slot);

            match u32::from(*value) {
                1 | 2 => (),
                unknown => {
                    return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
                }
            }

            Ok(())
        }
    }

    impl ::core::convert::From<crate::natural::MyStrictEnum> for MyStrictEnum {
        fn from(natural: crate::natural::MyStrictEnum) -> Self {
            match natural {
                crate::natural::MyStrictEnum::Foo => MyStrictEnum::FOO,

                crate::natural::MyStrictEnum::Bar => MyStrictEnum::BAR,
            }
        }
    }

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

    impl ::fidl_next::Unconstrained for MyStrictEnum {}
}

pub mod wire_optional {}

pub mod generic {}

pub use self::natural::*;

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

    impl ::fidl_next::CompatFrom<crate::MyEmptyFlexibleEnum> for ::fidl_test_enum::MyEmptyFlexibleEnum {
        fn compat_from(value: crate::MyEmptyFlexibleEnum) -> Self {
            match value {
                crate::MyEmptyFlexibleEnum::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_test_enum::MyEmptyFlexibleEnum> for crate::MyEmptyFlexibleEnum {
        fn compat_from(value: ::fidl_test_enum::MyEmptyFlexibleEnum) -> Self {
            match value {
                ::fidl_test_enum::MyEmptyFlexibleEnum::__SourceBreaking {
                    unknown_ordinal: value,
                } => Self::UnknownOrdinal_(value),
            }
        }
    }

    impl ::fidl_next::CompatFrom<crate::MyFlexibleEnum> for ::fidl_test_enum::MyFlexibleEnum {
        fn compat_from(value: crate::MyFlexibleEnum) -> Self {
            match value {
                crate::MyFlexibleEnum::Foo => Self::Foo,

                crate::MyFlexibleEnum::Bar => Self::Bar,

                crate::MyFlexibleEnum::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_test_enum::MyFlexibleEnum> for crate::MyFlexibleEnum {
        fn compat_from(value: ::fidl_test_enum::MyFlexibleEnum) -> Self {
            match value {
                ::fidl_test_enum::MyFlexibleEnum::Foo => Self::Foo,

                ::fidl_test_enum::MyFlexibleEnum::Bar => Self::Bar,

                ::fidl_test_enum::MyFlexibleEnum::__SourceBreaking { unknown_ordinal: value } => {
                    Self::UnknownOrdinal_(value)
                }
            }
        }
    }

    impl ::fidl_next::CompatFrom<crate::MyFlexibleEnumWithCustomUnknown>
        for ::fidl_test_enum::MyFlexibleEnumWithCustomUnknown
    {
        fn compat_from(value: crate::MyFlexibleEnumWithCustomUnknown) -> Self {
            match value {
                crate::MyFlexibleEnumWithCustomUnknown::Foo => Self::Foo,

                crate::MyFlexibleEnumWithCustomUnknown::Bar => Self::Bar,

                crate::MyFlexibleEnumWithCustomUnknown::CustomUnknown => Self::CustomUnknown,

                crate::MyFlexibleEnumWithCustomUnknown::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_test_enum::MyFlexibleEnumWithCustomUnknown>
        for crate::MyFlexibleEnumWithCustomUnknown
    {
        fn compat_from(value: ::fidl_test_enum::MyFlexibleEnumWithCustomUnknown) -> Self {
            match value {
                ::fidl_test_enum::MyFlexibleEnumWithCustomUnknown::Foo => Self::Foo,

                ::fidl_test_enum::MyFlexibleEnumWithCustomUnknown::Bar => Self::Bar,

                ::fidl_test_enum::MyFlexibleEnumWithCustomUnknown::CustomUnknown => {
                    Self::CustomUnknown
                }

                ::fidl_test_enum::MyFlexibleEnumWithCustomUnknown::__SourceBreaking {
                    unknown_ordinal: value,
                } => Self::UnknownOrdinal_(value),
            }
        }
    }

    impl ::fidl_next::CompatFrom<crate::MyStrictEnum> for ::fidl_test_enum::MyStrictEnum {
        fn compat_from(value: crate::MyStrictEnum) -> Self {
            match value {
                crate::MyStrictEnum::Foo => Self::Foo,

                crate::MyStrictEnum::Bar => Self::Bar,
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_test_enum::MyStrictEnum> for crate::MyStrictEnum {
        fn compat_from(value: ::fidl_test_enum::MyStrictEnum) -> Self {
            match value {
                ::fidl_test_enum::MyStrictEnum::Foo => Self::Foo,

                ::fidl_test_enum::MyStrictEnum::Bar => Self::Bar,
            }
        }
    }
}