atomic-enum-derive 0.1.0

Provides a derive macro for `atomic-enum`.
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

use proc_macro2::Ident;
use syn::{DeriveInput, Expr};

#[derive(Debug)]
pub struct EnumValue {
    pub ident: Ident,
    pub discriminant: Expr,
}

pub struct ParsedInput {
    pub enum_ident: Ident,
    pub enum_values: Vec<EnumValue>,
}

impl ParsedInput {
    pub fn parse(input: DeriveInput) -> Self {
        let enum_input = match input.data {
            syn::Data::Enum(e) => e,
            _ => panic!("The trait is only for enums!"),
        };

        let mut has_invalid_field = false;
        let enum_values = enum_input
            .variants
            .iter()
            .map(|v| {
                let v = v.to_owned();

                if &v.ident.to_string() == "UnknownField" {
                    has_invalid_field = true;
                }

                EnumValue {
                    ident: v.ident,
                    discriminant: match v.discriminant {
                        Some((_, d)) => d,
                        None => panic!("A number must be assigned to each field!"),
                    },
                }
            })
            .collect();

        if !has_invalid_field {
            panic!("The enumeration must contain a field with the name \"UnknownField\"!");
        }

        Self {
            enum_ident: input.ident,
            enum_values,
        }
    }
}