nanoserde_derive/
lib.rs

1#![no_std]
2
3extern crate alloc;
4extern crate proc_macro;
5
6#[cfg(any(feature = "json", feature = "ron", feature = "binary"))]
7#[macro_use]
8mod shared;
9
10#[cfg(feature = "binary")]
11mod serde_bin;
12#[cfg(feature = "binary")]
13use crate::serde_bin::*;
14
15#[cfg(feature = "ron")]
16mod serde_ron;
17#[cfg(feature = "ron")]
18use crate::serde_ron::*;
19
20#[cfg(feature = "json")]
21mod serde_json;
22#[cfg(feature = "json")]
23use crate::serde_json::*;
24
25#[cfg(any(feature = "json", feature = "ron", feature = "binary"))]
26mod parse;
27
28#[cfg(feature = "binary")]
29#[proc_macro_derive(SerBin, attributes(nserde))]
30pub fn derive_ser_bin(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
31    let input = parse::parse_data(input);
32
33    let crate_name = shared::attrs_crate(input.attributes()).unwrap_or("nanoserde");
34
35    if let Some(proxy) = shared::attrs_proxy(input.attributes()) {
36        return derive_ser_bin_proxy(&proxy, input.name(), crate_name);
37    }
38
39    // ok we have an ident, its either a struct or a enum
40    match &input {
41        parse::Data::Struct(struct_) if struct_.named => derive_ser_bin_struct(struct_, crate_name),
42        parse::Data::Struct(struct_) => derive_ser_bin_struct_unnamed(struct_, crate_name),
43        parse::Data::Enum(enum_) => derive_ser_bin_enum(enum_, crate_name),
44        _ => unimplemented!("Only structs and enums are supported"),
45    }
46}
47
48#[cfg(feature = "binary")]
49#[proc_macro_derive(DeBin, attributes(nserde))]
50pub fn derive_de_bin(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
51    let input = parse::parse_data(input);
52
53    let crate_name = shared::attrs_crate(input.attributes()).unwrap_or("nanoserde");
54
55    if let Some(proxy) = shared::attrs_proxy(input.attributes()) {
56        return derive_de_bin_proxy(&proxy, input.name(), crate_name);
57    }
58
59    // ok we have an ident, its either a struct or a enum
60    match &input {
61        parse::Data::Struct(struct_) if struct_.named => derive_de_bin_struct(struct_, crate_name),
62        parse::Data::Struct(struct_) => derive_de_bin_struct_unnamed(struct_, crate_name),
63        parse::Data::Enum(enum_) => derive_de_bin_enum(enum_, crate_name),
64
65        _ => unimplemented!("Only structs and enums are supported"),
66    }
67}
68
69#[cfg(feature = "ron")]
70#[proc_macro_derive(SerRon, attributes(nserde))]
71pub fn derive_ser_ron(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
72    let input = parse::parse_data(input);
73
74    let crate_name = shared::attrs_crate(input.attributes()).unwrap_or("nanoserde");
75
76    if let Some(proxy) = shared::attrs_proxy(input.attributes()) {
77        return derive_ser_ron_proxy(&proxy, input.name(), crate_name);
78    }
79
80    // ok we have an ident, its either a struct or a enum
81    match &input {
82        parse::Data::Struct(struct_) if struct_.named => derive_ser_ron_struct(struct_, crate_name),
83        parse::Data::Struct(struct_) => derive_ser_ron_struct_unnamed(struct_, crate_name),
84        parse::Data::Enum(enum_) => derive_ser_ron_enum(enum_, crate_name),
85        _ => unimplemented!("Only structs and enums are supported"),
86    }
87}
88
89#[cfg(feature = "ron")]
90#[proc_macro_derive(DeRon, attributes(nserde))]
91pub fn derive_de_ron(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
92    let input = parse::parse_data(input);
93
94    let crate_name = shared::attrs_crate(input.attributes()).unwrap_or("nanoserde");
95
96    if let Some(proxy) = shared::attrs_proxy(input.attributes()) {
97        return derive_de_ron_proxy(&proxy, input.name(), crate_name);
98    }
99
100    // ok we have an ident, its either a struct or a enum
101    match &input {
102        parse::Data::Struct(struct_) if struct_.named => derive_de_ron_struct(struct_, crate_name),
103        parse::Data::Struct(struct_) => derive_de_ron_struct_unnamed(struct_, crate_name),
104        parse::Data::Enum(enum_) => derive_de_ron_enum(enum_, crate_name),
105        _ => unimplemented!("Only structs and enums are supported"),
106    }
107}
108
109#[cfg(feature = "json")]
110#[proc_macro_derive(SerJson, attributes(nserde))]
111pub fn derive_ser_json(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
112    let input = parse::parse_data(input);
113
114    let crate_name = shared::attrs_crate(input.attributes()).unwrap_or("nanoserde");
115
116    if let Some(proxy) = shared::attrs_proxy(input.attributes()) {
117        return derive_ser_json_proxy(&proxy, input.name(), crate_name);
118    }
119
120    // ok we have an ident, its either a struct or a enum
121    match &input {
122        parse::Data::Struct(struct_) if struct_.named => {
123            derive_ser_json_struct(struct_, crate_name)
124        }
125        parse::Data::Struct(struct_) => derive_ser_json_struct_unnamed(struct_, crate_name),
126        parse::Data::Enum(enum_) => derive_ser_json_enum(enum_, crate_name),
127        _ => unimplemented!(""),
128    }
129}
130
131#[cfg(feature = "json")]
132#[proc_macro_derive(DeJson, attributes(nserde))]
133pub fn derive_de_json(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
134    let input = parse::parse_data(input);
135
136    let crate_name = shared::attrs_crate(input.attributes()).unwrap_or("nanoserde");
137
138    if let Some(proxy) = shared::attrs_proxy(input.attributes()) {
139        return derive_de_json_proxy(&proxy, input.name(), crate_name);
140    }
141
142    // ok we have an ident, its either a struct or a enum
143    match &input {
144        parse::Data::Struct(struct_) if struct_.named => derive_de_json_struct(struct_, crate_name),
145        parse::Data::Struct(struct_) => derive_de_json_struct_unnamed(struct_, crate_name),
146        parse::Data::Enum(enum_) => derive_de_json_enum(enum_, crate_name),
147        parse::Data::Union(_) => unimplemented!("Unions are not supported"),
148    }
149}
nanoserde_derive/lib.rs

nanoserde_derive/
lib.rs
