serbia 0.4.3

No-fuss big arrays for Serde
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use proc_macro2::TokenStream;
use quote::ToTokens;
use syn::{Expr, ExprLit, Field, Ident, Lit, Meta, MetaList, NestedMeta, Type};

enum Arg {
    Flag(String),
    KeyValueArg(KeyValueArg),
}

struct KeyValueArg {
    key: String,
    value: Lit,
}

fn parse_arg(meta: NestedMeta) -> Result<Arg, ()> {
    if let NestedMeta::Meta(Meta::NameValue(meta)) = meta {
        let key = meta
            .path
            .get_ident()
            .expect("expected serbia argument to be an ident")
            .to_string();
        let value = meta.lit;

        return Ok(Arg::KeyValueArg(KeyValueArg { key, value }));
    } else if let NestedMeta::Meta(Meta::Path(path)) = meta {
        let key = path
            .get_ident()
            .expect("expected serbia flag to be an ident")
            .to_string();
        return Ok(Arg::Flag(key));
    }

    Err(())
}

/// A field that is a (potentially) big array, with convenient metadata
/// for generating custom serialization/deserialization code.
pub struct BigArrayField<'f> {
    pub field: &'f mut Field,
    pub len: TokenStream,
    pub serialize: bool,
    pub deserialize: bool,
    pub element_type: Option<Type>,
}

impl<'f> BigArrayField<'f> {
    // TODO: This begs for a cleanup. Convoluted logic.
    pub fn parse_field(field: &'f mut Field) -> Option<Self> {
        let mut len = None;
        let mut serialize = true;
        let mut deserialize = true;
        let mut element_type = None;

        // TODO: replace with drain_filter once stabilized.
        let (serbia_attrs, other_attrs): (Vec<_>, Vec<_>) =
            field.attrs.iter().cloned().partition(|a| {
                if let Some(ident) = a.path.get_ident() {
                    return ident == "serbia";
                }

                false
            });

        field.attrs = other_attrs;

        let serde_attrs = field.attrs.iter().filter(|a| {
            if let Some(ident) = a.path.get_ident() {
                return ident == "serde";
            }

            false
        });

        for attr in serbia_attrs {
            if let Meta::List(MetaList { nested: meta, .. }) = attr.parse_meta().unwrap() {
                for arg in meta {
                    let arg = parse_arg(arg).unwrap();

                    match arg {
                        Arg::Flag(flag) => match flag.as_str() {
                            "skip" => return None,
                            "skip_serializing" => serialize = false,
                            "skip_deserializing" => deserialize = false,
                            unknown => panic!("unknown serbia flag: {}", unknown),
                        },
                        Arg::KeyValueArg(key_value) => match key_value.key.as_str() {
                            "bufsize" => {
                                len = Some(if let Lit::Str(const_name) = key_value.value {
                                    Ident::new(&const_name.value(), const_name.span())
                                        .to_token_stream()
                                } else {
                                    key_value.value.into_token_stream()
                                });
                            }
                            unknown => panic!("unknown serbia key-value option: {}", unknown),
                        },
                    }
                }
            }
        }

        for attr in serde_attrs {
            if let Meta::List(MetaList { nested: meta, .. }) = attr.parse_meta().unwrap() {
                for arg in meta {
                    if let NestedMeta::Meta(meta) = arg {
                        match meta.path().get_ident().unwrap().to_string().as_str() {
                            "serialize_with" | "skip_serializing" => serialize = false,
                            "deserialize_with" | "skip_deserializing" => deserialize = false,
                            "skip" | "with" => {
                                serialize = false;
                                deserialize = false;
                            }
                            _ => {}
                        }
                    }
                }
            }
        }

        if let Type::Array(array_type) = &field.ty {
            element_type = Some(*array_type.elem.clone());

            if len.is_none() {
                if let Expr::Lit(ExprLit {
                    lit: Lit::Int(len_literal),
                    ..
                }) = &array_type.len
                {
                    let len_literal: usize = len_literal.base10_parse().unwrap();

                    if len_literal > 32 {
                        len = Some(array_type.len.clone().into_token_stream());
                    }
                } else if let Expr::Path(len_expr) = &array_type.len {
                    len = Some(len_expr.into_token_stream());
                }
            }
        }

        if let Some(len) = len {
            return Some(BigArrayField {
                field,
                len,
                serialize,
                deserialize,
                element_type,
            });
        }

        None
    }
}