Struct EnumOptions 

pub struct EnumOptions {
    pub derived_traits: Cow<'static, [Cow<'static, str>]>,
    pub impl_default: bool,
    pub impl_display: bool,
    pub impl_from_str: bool,
    pub all_variants_const_name: Option<Cow<'static, str>>,
    pub all_values_const_name: Option<Cow<'static, str>>,
    pub values_struct: Option<ValuesStructOptions>,
    pub get_value_fn_name: Option<Cow<'static, str>>,
}

Options specific to how edres should generate enums.

Fields

derived_traits: Cow<'static, [Cow<'static, str>]>

A list of traits to derive.

These can either be unqualified (like Clone) or qualifier with a crate name (like serde::Serialize).

See the EnumOptions::new example to see how to easily set this value.

impl_default: bool

Whether generated enums should implement the Default trait.

This uses the first variant as the default value.

impl_display: bool

Whether generated enums should implement Display.

This just displays the name of the variant as a string. For example, MyEnum::First.to_string() == "First".

impl_from_str: bool

Whether generated enums should implement FromStr.

This works by matching the name of the variant. For example, "First".parse().unwrap() == MyEnum::First.

all_variants_const_name: Option<Cow<'static, str>>

If present, generates a const with this name that stores a slice of all variants of the generated enum.

all_values_const_name: Option<Cow<'static, str>>

If present, generates a const with this name that stores a slice of all values corresponding to the enum variants.

This requires values_struct to be set as well.

values_struct: Option<ValuesStructOptions>

If present, structs representing the values associated with enum variants will also be generated.

The ValuesStructOptions defines further options for how they are generated.

get_value_fn_name: Option<Cow<'static, str>>

If present, generates a method with this name for fetching the value associated with an enum variant.

Implementations

impl EnumOptions

pub const fn new() -> EnumOptions

Examples

assert_eq!(EnumOptions::new(), EnumOptions {
    derived_traits: vec![
        "Debug".into(),
        "Clone".into(),
        "Copy".into(),
        "PartialEq".into(),
        "Eq".into(),
        "Hash".into(),
    ].into(),
    impl_default: true,
    impl_display: true,
    impl_from_str: true,
    all_variants_const_name: Some("ALL".into()),
    all_values_const_name: Some("VALUES".into()),
    values_struct: Some(ValuesStructOptions::new()),
    get_value_fn_name: Some("get".into()),
});

pub const fn minimal() -> EnumOptions

Examples

assert_eq!(EnumOptions::minimal(), EnumOptions {
    derived_traits: vec![].into(),
    impl_default: false,
    impl_display: false,
    impl_from_str: false,
    all_variants_const_name: None,
    all_values_const_name: None,
    values_struct: None,
    get_value_fn_name: None,
});

Trait Implementations

impl Clone for EnumOptions

fn clone(&self) -> EnumOptions

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EnumOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for EnumOptions

fn default() -> EnumOptions

Examples

assert_eq!(EnumOptions::default(), EnumOptions::new());

impl PartialEq for EnumOptions

fn eq(&self, other: &EnumOptions) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for EnumOptions

impl StructuralPartialEq for EnumOptions