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

use crate::generator::features::Features0;
use crate::generator::names::Names;
use crate::generator::Derive;
use crate::parser::feature::FeatureParser;
use proc_macro2::TokenStream;
use quote::quote;

pub(crate) struct FeatureTryFromTrait {
    pub(crate) enabled: bool,
}

impl FeatureTryFromTrait {
    pub(crate) fn parse(feature_parser: &mut FeatureParser) -> Self {
        if let Some(params) = feature_parser.get("TryFrom") {
            params.finish(Self { enabled: true })
        } else {
            Self { enabled: false }
        }
    }

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

        features.min_const.enabled = true;
        features.max_const.enabled = true;
        // range_table is only created when in with holes mode
        features.table_range.enabled = true;
    }

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

        let Derive {
            repr, ident_enum, ..
        } = derive;
        let Names {
            ident_min,
            ident_max,
            ident_table_range,
            ..
        } = names;

        if derive.mode.is_gapless() {
            quote! {
                impl ::core::convert::TryFrom<#repr> for #ident_enum {
                    type Error = ();

                    #[inline]
                    fn try_from(value: #repr) -> ::core::result::Result<Self, Self::Error> {
                        use ::core::result::Result::{Err, Ok};
                        if (value as #repr) >= (Self::#ident_min as #repr) && (value as #repr) <= (Self::#ident_max as #repr) {
                            // Safety: the number is known to be a valid enum
                            Ok(unsafe { ::core::mem::transmute(value as #repr) })
                        } else {
                            Err(())
                        }
                    }
                }
            }
        } else {
            quote! {
                impl ::core::convert::TryFrom<#repr> for #ident_enum {
                    type Error = ();

                    fn try_from(value: #repr) -> ::core::result::Result<Self, Self::Error> {
                        use ::core::result::Result::{Err, Ok};
                        if (value as #repr) >= (Self::#ident_min as #repr) && (value as #repr) <= (Self::#ident_max as #repr) {
                            for r in Self::#ident_table_range {
                                if r.0.contains(&value){
                                    // Safety: the number is known to be a valid enum
                                    return Ok(unsafe { ::core::mem::transmute(value as #repr) });
                                }
                            }
                        }
                        Err(())
                    }
                }
            }
        }
    }
}