darling_core 0.1.0

Helper crate for proc-macro library for reading attributes into structs when implementing custom derives. Use `darling` to get library functionality.
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

use syn;

use {FromField, Result};

/// A generic container which holds the body of a struct or enum variant.
/// This is an exact match of `syn::VariantData`, but it allows for arbitrary
/// types to support parsing scenarios.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum VariantData<T> {
    Tuple(Vec<T>),
    Struct(Vec<T>),
    Unit,
}

impl<T> VariantData<T> {
    /// Creates a new `VariantData` instance of the same shape as the one passed in,
    /// but containing no values.
    pub fn empty_from(src: &syn::VariantData) -> Self {
        match *src {
            syn::VariantData::Struct(_) => VariantData::Struct(vec![]),
            syn::VariantData::Tuple(_) => VariantData::Tuple(vec![]),
            syn::VariantData::Unit => VariantData::Unit,
        }
    }

    /// Gets all field declarations. Returns an empty `Vec` for `VariantData::Unit`.
    pub fn fields<'a>(&'a self) -> Vec<&'a T> {
        match *self {
            VariantData::Tuple(ref fields) |
            VariantData::Struct(ref fields) => fields.iter().collect(),
            VariantData::Unit => Vec::new(),
        }
    }

    /// Transforms the fields of the variant by applying `FnMut(T) -> U` to each one.
    pub fn map<F, U>(self, map: F) -> VariantData<U>
        where F: FnMut(T) -> U
    {
        match self {
            VariantData::Tuple(fields) => VariantData::Tuple(fields.into_iter().map(map).collect()),
            VariantData::Struct(fields) => {
                VariantData::Struct(fields.into_iter().map(map).collect())
            }
            VariantData::Unit => VariantData::Unit,
        }
    }

    pub fn as_ref<'a>(&'a self) -> VariantData<&'a T> {
        match *self {
            VariantData::Tuple(ref fields) => VariantData::Tuple(fields.iter().collect()),
            VariantData::Struct(ref fields) => VariantData::Struct(fields.iter().collect()),
            VariantData::Unit => VariantData::Unit,
        }
    }

    /// Returns `true` if this is a unit variant.
    pub fn is_unit(&self) -> bool {
        match *self {
            VariantData::Unit => true,
            _ => false,
        }
    }

    /// Returns `true` if this is a struct-style variant with named fields.
    pub fn is_struct(&self) -> bool {
        match *self {
            VariantData::Struct(_) => true,
            _ => false,
        }
    }

    /// Returns `true` if this is a tuple-style variant with unnamed fields.
    pub fn is_tuple(&self) -> bool {
        match *self {
            VariantData::Tuple(_) => true,
            _ => false,
        }
    }
}

impl<F: FromField> VariantData<F> {
    pub fn from(vd: &syn::VariantData) -> Result<Self> {
        match *vd {
            syn::VariantData::Unit => Ok(VariantData::Unit),
            syn::VariantData::Tuple(ref fields) => {
                let mut f = Vec::with_capacity(fields.len());
                for field in fields {
                    f.push(FromField::from_field(field)?);
                }

                Ok(VariantData::Tuple(f))
            }
            syn::VariantData::Struct(ref fields) => {
                let mut f = Vec::with_capacity(fields.len());
                for field in fields {
                    f.push(FromField::from_field(field)?);
                }

                Ok(VariantData::Struct(f))
            }
        }
    }
}

impl<T> Into<Vec<T>> for VariantData<T> {
    fn into(self) -> Vec<T> {
        match self {
            VariantData::Struct(fields) | VariantData::Tuple(fields) => fields,
            VariantData::Unit => Vec::new(),
        }
    }
}