tools/fidl/fidlgen_rust_next/templates/enum.askama

{{ self.doc_string(enm.attributes) -}}
#[derive(
    Clone,
    Copy,
    {% if self.emit_debug_impls() -%}
        Debug,
    {%- endif %}
    PartialEq,
    Eq,
)]
#[repr({{ natural_int }})]
pub enum {{ name }} {
    {% for member in enm.members -%}
        {{ member.name|camel }} = {{ member.value.value }},
    {%- endfor %}
    {%- if !enm.is_strict -%}
        UnknownOrdinal_({{ natural_int }}) = {{ unknown_ordinal_value }},
    {%- endif %}
}

impl ::fidl_next::Encodable for {{ name }} {
    type Encoded = {{ wire_name }};
}

{%- if enm.is_strict %}
impl ::core::convert::TryFrom<{{ natural_int }}> for {{ name }} {
    type Error = ::fidl_next::UnknownStrictEnumMemberError;
    fn try_from(value: {{ natural_int }}) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
        match value {
            {% for member in enm.members -%}
                {{ member.value.value }} => Ok(Self::{{ member.name|camel }}),
            {% endfor %}
            _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
        }
    }
}
{%- else %}
impl ::std::convert::From<{{ natural_int }}> for {{ name }} {
    fn from(value: {{ natural_int }}) -> Self {
        match value {
            {% for member in enm.members -%}
              {{ member.value.value }} => Self::{{ member.name|camel }},
            {% endfor %}
            _ => Self::UnknownOrdinal_(value),
        }
    }
}
{%- endif %}

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

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for {{ name }}
where
    ___E: ?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 {{ wire_name }} { value } = out);
        let _ = value.write({{ wire_int }}::from(match *self {
            {% for member in enm.members %}
                Self::{{ member.name|camel }} => {{ member.value.value }},
            {% endfor %}
            {% if !enm.is_strict %}
                Self::UnknownOrdinal_(value) => value,
            {% endif %}
        }));

        Ok(())
    }
}

impl ::core::convert::From<{{ wire_name }}> for {{ name }} {
    fn from(wire: {{ wire_name }}) -> Self {
        match {{ natural_int }}::from(wire.value) {
            {% for member in enm.members %}
                {{ member.value.value }} => Self::{{ member.name|camel }},
            {% endfor %}
            {% if enm.is_strict %}
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            {% else %}
                value => Self::UnknownOrdinal_(value),
            {% endif %}
        }
    }
}

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

impl ::fidl_next::IntoNatural for {{ wire_name }} {
    type Natural = {{ name }};
}

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

/// The wire type corresponding to [`{{ name }}`].
#[derive(
    Clone,
    Copy,
    {% if self.emit_debug_impls() -%}
        Debug,
    {%- endif %}
    PartialEq,
    Eq,
)]
#[repr(transparent)]
pub struct {{ wire_name }} {
    value: {{ wire_int }},
}

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

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

impl {{ wire_name }} {
    {% for member in enm.members %}
        pub const {{ member.name|screaming_snake }}: {{ wire_name }} = {{ wire_name }} {
            value:
            {% match enm.ty %}
                {% when IntType::Int8 %} {{ member.value.value }}
                {% when IntType::Uint8 %} {{ member.value.value }}
                {% else %} {{ wire_int }}({{ member.value.value }})
            {% endmatch %}
        };
    {% endfor %}
}

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

            match {{ natural_int }}::from(*value) {
                {% for member in enm.members %}
                    | {{ member.value.value }}
                {% endfor %}
                => (),
                unknown => return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(
                    unknown as i128,
                )),
            }
        {% endif %}

        Ok(())
    }
}

impl ::core::convert::From<{{ name }}> for {{ wire_name }} {
    fn from(natural: {{ name }}) -> Self {
        match natural {
            {% for member in enm.members %}
                {{ name }}::{{ member.name|camel }} => {{ wire_name }}::{{ member.name|screaming_snake }},
            {% endfor %}
            {% if !enm.is_strict %}
                {{ name }}::UnknownOrdinal_(value) => {{ wire_name }} {
                    value: {{ wire_int }}::from(value),
                }
            {% endif %}
        }
    }
}