roopert_macro_common 0.2.0

Another object-oriented toolkit for Rust (common data)
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

use proc_macro2::TokenStream;
use syn::{Ident, Result, Token};
use syn::parse::{Parse, ParseStream};

use super::{ParentAttribute, ExtendsAttribute, AccessorsAttribute, GetterAttribute, SetterAttribute, Generate};

#[cfg_attr(feature="verbose", derive(Debug))]
pub enum RoopertAttributeType {
    Parent(ParentAttribute),
    Extends(ExtendsAttribute),
    Accessors(AccessorsAttribute),
    Get(GetterAttribute),
    Set(SetterAttribute),
}

impl RoopertAttributeType {
    pub fn is_parent(&self) -> bool {
        match self {
            Self::Parent(_) => true,
            _ => false,
        }
    }
    
    pub fn is_extends(&self) -> bool {
        match self {
            Self::Extends(_) => true,
            _ => false,
        }
    }
    
    pub fn is_getter(&self) -> bool {
        match self {
            Self::Get(_) => true,
            _ => false
        }
    }
    
    pub fn is_setter(&self) -> bool {
        match self {
            Self::Set(_) => true,
            _ => false
        }
    }
}

impl Generate for RoopertAttributeType {
    fn generate(&mut self, input: TokenStream) -> core::result::Result<TokenStream, String> {
        match self {
            Self::Parent(parent) => parent.generate(input),
            Self::Extends(extends) => extends.generate(input),
            Self::Accessors(accessors) => accessors.generate(input),
            Self::Get(getters) => getters.generate(input),
            Self::Set(setters) => setters.generate(input),
        }
    }
    
    fn auto_append(&self) -> bool {
        match self {
            Self::Parent(parent) => parent.auto_append(),
            Self::Extends(extends) => extends.auto_append(),
            Self::Accessors(accessors) => accessors.auto_append(),
            Self::Get(getters) => getters.auto_append(),
            Self::Set(setters) => setters.auto_append(),
        }
    }
}

#[cfg_attr(feature="verbose", derive(Debug))]
pub struct RoopertAttribute {
    //ident: Ident,
    pub attr: RoopertAttributeType,
}

impl Parse for RoopertAttribute {
    fn parse(input: ParseStream) -> Result<Self> {
        let ident: Ident = input.parse()?;
        // ignore comma -- just a separator
        if input.peek(Token![,]) {
            let _: Token![,] = input.parse()?;
        }
        match &ident.to_string() as &str {
            "parent" => Ok(Self {
                    //ident: ident,
                    attr: RoopertAttributeType::Parent(ParentAttribute::parse(input)?),
                }),
            "extend" | "extends" => Ok(Self {
                    //ident: ident,
                    attr: RoopertAttributeType::Extends(ExtendsAttribute::parse(input)?),
                }),
            "accessors" => Ok(Self {
                //ident: ident,
                attr: RoopertAttributeType::Accessors(AccessorsAttribute::parse(input)?),
            }),
            "get" => Ok(Self {
                //ident: ident,
                attr: RoopertAttributeType::Get(GetterAttribute::parse(input)?),
            }),
            "set" => Ok(Self {
                //ident: ident,
                attr: RoopertAttributeType::Set(SetterAttribute::parse(input)?),
            }),
            _ => Err(input.error(format!("unexpected identifier {}", ident.to_string())))
        }
    }
}

impl Generate for RoopertAttribute {
    fn generate(&mut self, input: TokenStream) -> core::result::Result<TokenStream, String> {
        self.attr.generate(input)
    }
    
    fn auto_append(&self) -> bool {self.attr.auto_append()}
}