1pub(crate) fn generate(
2 mut writer: impl std::io::Write,
3 type_name: &str,
4 generics: super::Generics<'_>,
5 fields: &[super::Property<'_>],
6 map_namespace: &impl crate::MapNamespace,
7 resource_metadata: Option<&super::ResourceMetadata<'_>>,
8) -> Result<(), crate::Error> {
9 use std::fmt::Write;
10
11 let local = crate::map_namespace_local_to_string(map_namespace)?;
12
13 let type_generics_impl = generics.type_part.map(|part| format!("<{part}>")).unwrap_or_default();
14 let type_generics_type = generics.type_part.map(|part| format!("<{part}>")).unwrap_or_default();
15 let type_generics_where = generics.where_part.map(|part| format!(" where {part}")).unwrap_or_default();
16
17 let mut fields_string = String::new();
18 let mut required_fields_num = 0_usize;
19 let mut fields_num = vec![];
20 let mut has_flattened_field = false;
21
22 if resource_metadata.is_some() {
23 writeln!(fields_string,
24 r#" {local}serde::ser::SerializeStruct::serialize_field(&mut state, "apiVersion", <Self as {local}Resource>::API_VERSION)?;"#)?;
25 writeln!(fields_string,
26 r#" {local}serde::ser::SerializeStruct::serialize_field(&mut state, "kind", <Self as {local}Resource>::KIND)?;"#)?;
27
28 required_fields_num += 2;
29 }
30
31 for super::Property { name, field_name, required, is_flattened, .. } in fields {
32 if *is_flattened {
33 writeln!(fields_string, " {local}serde::Serialize::serialize(&self.{field_name}, SerializerWrapper(&mut state))?;")?;
34
35 has_flattened_field = true;
36 }
37 else {
38 match required {
39 super::PropertyRequired::Required { is_default: _ } => {
40 writeln!(fields_string, " {local}serde::ser::SerializeStruct::serialize_field(&mut state, {name:?}, &self.{field_name})?;")?;
41
42 required_fields_num += 1;
43 },
44
45 super::PropertyRequired::Optional => {
46 writeln!(fields_string, " if let Some(value) = &self.{field_name} {{")?;
47 writeln!(fields_string, " {local}serde::ser::SerializeStruct::serialize_field(&mut state, {name:?}, value)?;")?;
48 writeln!(fields_string, " }}")?;
49
50 fields_num.push(format!("self.{field_name}.as_ref().map_or(0, |_| 1)"));
51 },
52
53 super::PropertyRequired::OptionalDefault => {
54 writeln!(fields_string, " if !self.{field_name}.is_empty() {{")?;
55 writeln!(fields_string, " {local}serde::ser::SerializeStruct::serialize_field(&mut state, {name:?}, &self.{field_name})?;")?;
56 writeln!(fields_string, " }}")?;
57
58 fields_num.push(format!("usize::from(!self.{field_name}.is_empty())"));
59 },
60 }
61 }
62 }
63
64 let fields_num: std::borrow::Cow<'_, str> = match (required_fields_num, fields_num.is_empty()) {
65 (0, true) => " 0".into(),
66
67 (0, false) => {
68 let mut fields_num_str = String::new();
69 let mut first = true;
70 for field_num in fields_num {
71 if first {
72 first = false;
73 }
74 else {
75 writeln!(fields_num_str, " +")?;
76 }
77
78 write!(fields_num_str, " {field_num}")?;
79 }
80
81 fields_num_str.into()
82 },
83
84 (required_fields_num, true) => format!(" {required_fields_num}").into(),
85
86 (required_fields_num, false) => {
87 let mut fields_num_str = format!(" {required_fields_num}");
88 for field_num in fields_num {
89 writeln!(fields_num_str, " +")?;
90 write!(fields_num_str, " {field_num}")?;
91 }
92
93 fields_num_str.into()
94 },
95 };
96
97 let serialize_type_name =
98 if resource_metadata.is_some() {
99 format!("<Self as {local}Resource>::KIND")
100 }
101 else {
102 format!("{type_name:?}")
103 };
104
105 let struct_serializer: std::borrow::Cow<'_, str> =
106 if has_flattened_field {
107 let mut out = String::new();
108
109 writeln!(out, " struct SerializerWrapper<'a, S>(&'a mut S);")?;
110 writeln!(out)?;
111 writeln!(out, " impl<'a, S> {local}serde::Serializer for SerializerWrapper<'a, S> where S: {local}serde::ser::SerializeStruct {{")?;
112 writeln!(out, " type Ok = ();")?;
113 writeln!(out, " type Error = <S as {local}serde::ser::SerializeStruct>::Error;")?;
114 writeln!(out)?;
115 writeln!(out, " type SerializeSeq = {local}serde::ser::Impossible<Self::Ok, Self::Error>;")?;
116 writeln!(out, " type SerializeTuple = {local}serde::ser::Impossible<Self::Ok, Self::Error>;")?;
117 writeln!(out, " type SerializeTupleStruct = {local}serde::ser::Impossible<Self::Ok, Self::Error>;")?;
118 writeln!(out, " type SerializeTupleVariant = {local}serde::ser::Impossible<Self::Ok, Self::Error>;")?;
119 writeln!(out, " type SerializeMap = {local}serde::ser::Impossible<Self::Ok, Self::Error>;")?;
120 writeln!(out, " type SerializeStruct = SerializerStructWrapper<'a, S>;")?;
121 writeln!(out, " type SerializeStructVariant = {local}serde::ser::Impossible<Self::Ok, Self::Error>;")?;
122 writeln!(out)?;
123 writeln!(out, " fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {{")?;
124 writeln!(out, r#" Err({local}serde::ser::Error::custom("bool is not supported"))"#)?;
125 writeln!(out, " }}")?;
126 writeln!(out)?;
127 writeln!(out, " fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {{")?;
128 writeln!(out, r#" Err({local}serde::ser::Error::custom("i8 is not supported"))"#)?;
129 writeln!(out, " }}")?;
130 writeln!(out)?;
131 writeln!(out, " fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {{")?;
132 writeln!(out, r#" Err({local}serde::ser::Error::custom(" is not supported"))"#)?;
133 writeln!(out, " }}")?;
134 writeln!(out)?;
135 writeln!(out, " fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {{")?;
136 writeln!(out, r#" Err({local}serde::ser::Error::custom("i32 is not supported"))"#)?;
137 writeln!(out, " }}")?;
138 writeln!(out)?;
139 writeln!(out, " fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {{")?;
140 writeln!(out, r#" Err({local}serde::ser::Error::custom("i64 is not supported"))"#)?;
141 writeln!(out, " }}")?;
142 writeln!(out)?;
143 writeln!(out, " fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {{")?;
144 writeln!(out, r#" Err({local}serde::ser::Error::custom("u8 is not supported"))"#)?;
145 writeln!(out, " }}")?;
146 writeln!(out)?;
147 writeln!(out, " fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {{")?;
148 writeln!(out, r#" Err({local}serde::ser::Error::custom("u16 is not supported"))"#)?;
149 writeln!(out, " }}")?;
150 writeln!(out)?;
151 writeln!(out, " fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {{")?;
152 writeln!(out, r#" Err({local}serde::ser::Error::custom("u32 is not supported"))"#)?;
153 writeln!(out, " }}")?;
154 writeln!(out)?;
155 writeln!(out, " fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {{")?;
156 writeln!(out, r#" Err({local}serde::ser::Error::custom("u64 is not supported"))"#)?;
157 writeln!(out, " }}")?;
158 writeln!(out)?;
159 writeln!(out, " fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {{")?;
160 writeln!(out, r#" Err({local}serde::ser::Error::custom("f32 is not supported"))"#)?;
161 writeln!(out, " }}")?;
162 writeln!(out)?;
163 writeln!(out, " fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {{")?;
164 writeln!(out, r#" Err({local}serde::ser::Error::custom("f64 is not supported"))"#)?;
165 writeln!(out, " }}")?;
166 writeln!(out)?;
167 writeln!(out, " fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {{")?;
168 writeln!(out, r#" Err({local}serde::ser::Error::custom("char is not supported"))"#)?;
169 writeln!(out, " }}")?;
170 writeln!(out)?;
171 writeln!(out, " fn serialize_str(self, _: &str) -> Result<Self::Ok, Self::Error> {{")?;
172 writeln!(out, r#" Err({local}serde::ser::Error::custom("str is not supported"))"#)?;
173 writeln!(out, " }}")?;
174 writeln!(out)?;
175 writeln!(out, " fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {{")?;
176 writeln!(out, r#" Err({local}serde::ser::Error::custom("bytes is not supported"))"#)?;
177 writeln!(out, " }}")?;
178 writeln!(out)?;
179 writeln!(out, " fn serialize_none(self) -> Result<Self::Ok, Self::Error> {{")?;
180 writeln!(out, r#" Err({local}serde::ser::Error::custom("none is not supported"))"#)?;
181 writeln!(out, " }}")?;
182 writeln!(out)?;
183 writeln!(out, " fn serialize_some<T>(self, _: &T) -> Result<Self::Ok, Self::Error> where T: {local}serde::Serialize + ?Sized {{")?;
184 writeln!(out, r#" Err({local}serde::ser::Error::custom("some is not supported"))"#)?;
185 writeln!(out, " }}")?;
186 writeln!(out)?;
187 writeln!(out, " fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {{")?;
188 writeln!(out, r#" Err({local}serde::ser::Error::custom("unit is not supported"))"#)?;
189 writeln!(out, " }}")?;
190 writeln!(out)?;
191 writeln!(out, " fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {{")?;
192 writeln!(out, r#" Err({local}serde::ser::Error::custom("unit struct is not supported"))"#)?;
193 writeln!(out, " }}")?;
194 writeln!(out)?;
195 writeln!(out, " fn serialize_unit_variant(self, _: &'static str, _: u32, _: &'static str) -> Result<Self::Ok, Self::Error> {{")?;
196 writeln!(out, r#" Err({local}serde::ser::Error::custom("unit variant is not supported"))"#)?;
197 writeln!(out, " }}")?;
198 writeln!(out)?;
199 writeln!(out, " fn serialize_newtype_struct<T>(")?;
200 writeln!(out, " self,")?;
201 writeln!(out, " _: &'static str,")?;
202 writeln!(out, " _: &T,")?;
203 writeln!(out, " ) -> Result<Self::Ok, Self::Error> where T: {local}serde::Serialize + ?Sized {{")?;
204 writeln!(out, r#" Err({local}serde::ser::Error::custom("newtype struct is not supported"))"#)?;
205 writeln!(out, " }}")?;
206 writeln!(out)?;
207 writeln!(out, " fn serialize_newtype_variant<T>(")?;
208 writeln!(out, " self,")?;
209 writeln!(out, " _: &'static str,")?;
210 writeln!(out, " _: u32,")?;
211 writeln!(out, " _: &'static str,")?;
212 writeln!(out, " _: &T,")?;
213 writeln!(out, " ) -> Result<Self::Ok, Self::Error> where T: {local}serde::Serialize + ?Sized {{")?;
214 writeln!(out, r#" Err({local}serde::ser::Error::custom("newtype variant is not supported"))"#)?;
215 writeln!(out, " }}")?;
216 writeln!(out)?;
217 writeln!(out, " fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {{")?;
218 writeln!(out, r#" Err({local}serde::ser::Error::custom("seq is not supported"))"#)?;
219 writeln!(out, " }}")?;
220 writeln!(out)?;
221 writeln!(out, " fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {{")?;
222 writeln!(out, r#" Err({local}serde::ser::Error::custom("tuple is not supported"))"#)?;
223 writeln!(out, " }}")?;
224 writeln!(out)?;
225 writeln!(out, " fn serialize_tuple_struct(self, _: &'static str, _: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {{")?;
226 writeln!(out, r#" Err({local}serde::ser::Error::custom("tuple struct is not supported"))"#)?;
227 writeln!(out, " }}")?;
228 writeln!(out)?;
229 writeln!(out, " fn serialize_tuple_variant(")?;
230 writeln!(out, " self,")?;
231 writeln!(out, " _: &'static str,")?;
232 writeln!(out, " _: u32,")?;
233 writeln!(out, " _: &'static str,")?;
234 writeln!(out, " _: usize,")?;
235 writeln!(out, " ) -> Result<Self::SerializeTupleVariant, Self::Error> {{")?;
236 writeln!(out, r#" Err({local}serde::ser::Error::custom("tuple variant is not supported"))"#)?;
237 writeln!(out, " }}")?;
238 writeln!(out)?;
239 writeln!(out, " fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {{")?;
240 writeln!(out, r#" Err({local}serde::ser::Error::custom("map is not supported"))"#)?;
241 writeln!(out, " }}")?;
242 writeln!(out)?;
243 writeln!(out, " fn serialize_struct(self, _: &'static str, _: usize) -> Result<Self::SerializeStruct, Self::Error> {{")?;
244 writeln!(out, " Ok(SerializerStructWrapper(self.0))")?;
245 writeln!(out, " }}")?;
246 writeln!(out)?;
247 writeln!(out, " fn serialize_struct_variant(")?;
248 writeln!(out, " self,")?;
249 writeln!(out, " _: &'static str,")?;
250 writeln!(out, " _: u32,")?;
251 writeln!(out, " _: &'static str,")?;
252 writeln!(out, " _: usize,")?;
253 writeln!(out, " ) -> Result<Self::SerializeStructVariant, Self::Error> {{")?;
254 writeln!(out, r#" Err({local}serde::ser::Error::custom("struct variant is not supported"))"#)?;
255 writeln!(out, " }}")?;
256 writeln!(out, " }}")?;
257 writeln!(out)?;
258 writeln!(out, " struct SerializerStructWrapper<'a, S>(&'a mut S);")?;
259 writeln!(out)?;
260 writeln!(out, " impl<'a, S> {local}serde::ser::SerializeStruct for SerializerStructWrapper<'a, S> where S: {local}serde::ser::SerializeStruct {{")?;
261 writeln!(out, " type Ok = ();")?;
262 writeln!(out, " type Error = <S as {local}serde::ser::SerializeStruct>::Error;")?;
263 writeln!(out)?;
264 writeln!(out, " fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error> where T: {local}serde::Serialize + ?Sized {{")?;
265 writeln!(out, r#" self.0.serialize_field(key, value)"#)?;
266 writeln!(out, " }}")?;
267 writeln!(out)?;
268 writeln!(out, " fn end(self) -> Result<Self::Ok, Self::Error> {{")?;
269 writeln!(out, r#" Ok(())"#)?;
270 writeln!(out, " }}")?;
271 writeln!(out, " }}")?;
272 writeln!(out)?;
273
274 out.into()
275 }
276 else {
277 "".into()
278 };
279
280 writeln!(
281 writer,
282 include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/templates/impl_serialize.rs")),
283 local = local,
284 type_name = type_name,
285 type_generics_impl = type_generics_impl,
286 type_generics_type = type_generics_type,
287 type_generics_where = type_generics_where,
288 struct_serializer = struct_serializer,
289 fields_num = fields_num,
290 fields = fields_string,
291 serialize_type_name = serialize_type_name,
292 )?;
293
294 Ok(())
295}