enum-tools 0.5.5

Automatically derive functions and trait implementations for enums
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use crate::generator::features::Features1;
use crate::generator::names::Names;
use crate::generator::Derive;
use crate::parser::feature::FeatureParser;
use proc_macro2::TokenStream;
use proc_macro_error::emit_error;
use quote::quote;
use syn::Visibility;

#[derive(PartialEq, Eq)]
pub(crate) enum AsStrMode {
    Auto,
    Match,
    Table,
}

pub(crate) struct FeatureAsStrFn {
    pub(crate) enabled: bool,
    pub(crate) vis: Option<Visibility>,
    pub(crate) name: String,
    pub(crate) mode: AsStrMode,
}

impl FeatureAsStrFn {
    pub(crate) fn parse(feature_parser: &mut FeatureParser) -> Self {
        if let Some(mut params) = feature_parser.get("as_str") {
            let (vis, name) = params.get_vis_name("as_str");
            let mode = match params
                .get_str_opt("mode")
                .unwrap_or_else(|| "auto".to_string())
                .as_str()
            {
                "auto" => AsStrMode::Auto,
                "match" => AsStrMode::Match,
                "table" => AsStrMode::Table,
                _ => {
                    emit_error!(params.span(), "invalid mode");
                    AsStrMode::Auto
                }
            };
            params.finish(Self {
                enabled: true,
                vis,
                name,
                mode,
            })
        } else {
            Self {
                enabled: false,
                vis: Some(Visibility::Inherited),
                name: "__as_str".to_string(),
                mode: AsStrMode::Auto,
            }
        }
    }

    pub(crate) fn check(&mut self, derive: &Derive, features: &mut Features1) {
        if !self.enabled {
            return;
        }

        if self.mode == AsStrMode::Table {
            if derive.mode.is_gapless() {
                features.min_const.enabled = true;
            }
            features.table_name.enabled = true;
            // range_table is only created when in with holes mode
            features.table_range.enabled = true;
            features.table_range.with_offset = true;
        }
    }

    pub(crate) fn generate(self, derive: &Derive, names: &Names) -> TokenStream {
        if !self.enabled {
            return TokenStream::new();
        }

        let Derive {
            repr,
            repr_unsigned,
            ident_enum,
            ..
        } = derive;
        let Names {
            ident_min,
            ident_table_name,
            ident_table_range,
            ident_as_str,
            ..
        } = names;
        let vis = self.vis.as_ref().unwrap_or(&derive.vis_enum);

        match self.mode {
            AsStrMode::Auto => panic!("AsStrMode should've been resolved"),
            AsStrMode::Match => {
                let mut matches = Vec::new();
                for (_, (v, name)) in &derive.values {
                    matches.push(quote! {
                        #ident_enum::#v => #name,
                    });
                }
                quote! {
                    /// Returns the name of this element
                    #vis fn #ident_as_str(self) -> &'static str {
                        match self {
                            #(#matches)*
                        }
                    }
                }
            }
            AsStrMode::Table => {
                if derive.mode.is_gapless() {
                    quote! {
                        /// Returns the name of this element
                        #[inline]
                        #vis fn #ident_as_str(self) -> &'static str {
                            Self::#ident_table_name[(self as #repr).wrapping_sub(Self::#ident_min as #repr) as #repr_unsigned as usize]
                        }
                    }
                } else {
                    quote! {
                        /// Returns the name of this element
                        #vis fn #ident_as_str(self) -> &'static str {
                            use ::core::iter::Iterator;
                            // Safety: all enums are in that table and thus find will succeed
                            let t = unsafe {
                                Self::#ident_table_range
                                    .iter()
                                    .find(|t| t.0.contains(&(self as #repr)))
                                    .unwrap_unchecked()
                            };
                            Self::#ident_table_name[(self as #repr).wrapping_sub(t.1) as #repr_unsigned as usize]
                        }
                    }
                }
            }
        }
    }
}