arraygen 0.3.2

Derive macro for generating arrays from struct fields.
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

use syn::parse::{Parse, ParseStream, Result};
use syn::punctuated::Punctuated;
use syn::token;
use syn::{braced, Error, Ident, Token};

use crate::FIELD_SELECTOR_NAME;

#[derive(Clone, PartialEq)]
pub enum CastKind {
    SafeCast,
    UnsafeTransmute,
}

pub struct Decorator {
    pub override_implicit: bool,
    pub cast: Option<CastKind>,
}

impl Decorator {
    pub fn new() -> Decorator {
        Decorator {
            override_implicit: false,
            cast: None,
        }
    }
}

impl Parse for Decorator {
    fn parse(input: ParseStream) -> Result<Self> {
        let mut decorator = Decorator::new();
        if input.peek(token::Brace) {
            let content;
            let _ = braced!(content in input);
            for ident in Punctuated::<Ident, Token![,]>::parse_separated_nonempty(&content)?.iter() {
                match ident.to_string().as_ref() {
                    "override_implicit" if !decorator.override_implicit => {
                        decorator.override_implicit = true
                    }
                    "cast" if decorator.cast.is_none() => decorator.cast = Some(CastKind::SafeCast),
                    "unsafe_transmute" if decorator.cast.is_none() => {
                        decorator.cast = Some(CastKind::UnsafeTransmute)
                    }
                    decorator => {
                        return Err(Error::new_spanned(
                            ident,
                            format!(
                                "{} doesn't allow '{}' as decorator here",
                                FIELD_SELECTOR_NAME, decorator
                            ),
                        ))
                    }
                };
            }
        }
        Ok(decorator)
    }
}