custom_attrs 1.6.1

A library that allows you to configure values specific to each variants of an 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
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

use proc_macro2::TokenStream;
use quote::ToTokens;
use syn::{parse::Parse, token::CustomToken, Expr, Ident, Path, Token};

use crate::reference::ReferenceTokens;

pub type AttributeValueAssignment = IdentValueAssignmentGeneric<Ident, Expr>;
pub type AttributeValueAssignmentTokens = IdentValueAssignmentGeneric<Ident, ReferenceTokens>;
pub type AttributeValueAssignmentTokenStream = IdentValueAssignmentGeneric<Ident, TokenStream>;
pub type ConfigValueAssignment = IdentOptionalValueAssignmentGeneric<Path, Expr>;

pub struct IdentValueAssignmentGeneric<I, V> {
    ident: I,
    value: ValueAssignmentGeneric<V>,
}

impl<I, V> IdentValueAssignmentGeneric<I, V> {
    pub fn into_value(self) -> V {
        self.value.value
    }

    pub fn from_parts(ident: I, equal: Token!(=), value: V) -> Self {
        Self {
            ident,
            value: ValueAssignmentGeneric::from_parts(equal, value),
        }
    }

    pub fn into_parts(self) -> (I, Token!(=), V) {
        (self.ident, self.value._equal, self.value.value)
    }

    pub fn ident(&self) -> &I {
        &self.ident
    }
}

impl<I: Parse, V: Parse> Parse for IdentValueAssignmentGeneric<I, V> {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        Ok(Self {
            ident: input.parse()?,
            value: input.parse()?,
        })
    }
}

impl<I: ToTokens, V: ToTokens> ToTokens for IdentValueAssignmentGeneric<I, V> {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        self.ident.to_tokens(tokens);
        self.value.to_tokens(tokens);
    }
}

pub struct IdentOptionalValueAssignmentGeneric<I, V> {
    ident: I,
    value: Option<ValueAssignmentGeneric<V>>,
}

impl<I, V> IdentOptionalValueAssignmentGeneric<I, V> {
    pub fn value(&self) -> Option<&V> {
        self.value.as_ref().map(|v| &v.value)
    }

    pub fn ident(&self) -> &I {
        &self.ident
    }
}

impl<I: Parse, V: Parse> Parse for IdentOptionalValueAssignmentGeneric<I, V> {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        Ok(Self {
            ident: input.parse()?,
            value: input.parse()?,
        })
    }
}

impl<I: ToTokens, V: ToTokens> ToTokens for IdentOptionalValueAssignmentGeneric<I, V> {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        self.ident.to_tokens(tokens);
        self.value.to_tokens(tokens);
    }
}

pub type ValueAssignment = ValueAssignmentGeneric<Expr>;

pub struct ValueAssignmentGeneric<V> {
    _equal: Token!(=),
    value: V,
}

impl<V> ValueAssignmentGeneric<V> {
    pub fn from_parts(equal: Token!(=), value: V) -> Self {
        Self {
            _equal: equal,
            value,
        }
    }

    pub fn into_value(self) -> V {
        self.value
    }
}

impl<V: Parse> Parse for ValueAssignmentGeneric<V> {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        Ok(Self {
            _equal: input.parse()?,
            value: input.parse()?,
        })
    }
}

impl<V> CustomToken for ValueAssignmentGeneric<V> {
    fn peek(cursor: syn::buffer::Cursor) -> bool {
        if let Some((punct, _)) = cursor.punct() {
            if punct.as_char() == '=' {
                return true;
            }
        }
        false
    }

    fn display() -> &'static str {
        todo!()
    }
}

impl<V: ToTokens> ToTokens for ValueAssignmentGeneric<V> {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        self._equal.to_tokens(tokens);
        self.value.to_tokens(tokens);
    }
}