
pub enum {{ enum_ident }}{{ enum_generic_params }} {
    {%- for field in fields %}
    {{ field.ident }}({{ field.field_type }}),
    {%- endfor %}
}

{#- Enum getters. #}
{#- Note: It is guaranteed that the oneof's name and the oneof's items names are #}
{#- not conflicting. It's not explicitly written in the spec, though the official #}
{#- C++ code generator will fail to generate a valid code if the names are conflicting. #}
impl{{ enum_generic_params }} {{ enum_ident }}{{ enum_generic_params }} {
    {%- for field in fields %}
    pub fn {{ field.getter_ident }}(self) -> ::std::option::Option<{{ field.field_type }}> {
        match self {
            Self::{{ field.ident }}(v) => ::std::option::Option::Some(v),
            #[allow(unreachable_patterns)]
            _ => None,
        }
    }
    {%- endfor %}
}


impl{{ enum_generic_params }} ::std::fmt::Debug for {{ enum_ident }}{{ enum_generic_params }}
where
    {%- for field in fields %}
    {{ field.field_type }}: ::std::fmt::Debug,
    {%- endfor %} {#- for field in fields #}
{
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match self {
            {%- for field in fields %}
            Self::{{ field.ident }}(v) => f
                .debug_tuple("{{ enum_ident }}::{{ field.ident }}")
                .field(&v)
                .finish(),
            {%- endfor %} {#- for field in fields #}
        }
    }
}

impl{{ enum_generic_params }} ::std::clone::Clone for {{ enum_ident }}{{ enum_generic_params }}
where
    {%- for field in fields %}
    {{ field.field_type }}: ::std::clone::Clone,
    {%- endfor %} {#- for field in fields #}
{
    fn clone(&self) -> Self {
        match self {
            {%- for field in fields %}
            Self::{{ field.ident }}(ref v) => Self::{{ field.ident }}(
                <{{ field.field_type }} as ::std::clone::Clone>::clone(v)
            ),
            {%- endfor %} {#- for field in fields #}
        }
    }
}

impl{{ enum_generic_params }} ::std::cmp::PartialEq for {{ enum_ident }}{{ enum_generic_params }}
where
    {%- for field in fields %}
    {{ field.field_type }}: ::std::cmp::PartialEq,
    {%- endfor %} {#- for field in fields #}
{
    fn eq(&self, rhs: &Self) -> bool {
        match (self, rhs) {
            {%- for field in fields %}
            (Self::{{ field.ident }}(left), Self::{{ field.ident }}(right)) => left == right,
            {%- endfor %} {#- for field in fields #}
            #[allow(unreachable_patterns)]
            _ => false,
        }
    }
}
