serde_aux/field_attributes.rs
1use std::fmt::Display;
2use std::str::FromStr;
3
4#[cfg(feature = "chrono")]
5use serde::de::Error;
6use serde::{Deserialize, Deserializer};
7
8/// Allows a `bool` field to be defaulted to `true`, rather than the normal
9/// default of `false`. Useful for fields where the default value should be `true`.
10///
11/// Example:
12///
13/// ```rust
14/// use serde_aux::prelude::*;
15///
16/// #[derive(serde::Deserialize, Debug)]
17/// struct MyStruct {
18/// #[serde(default)]
19/// default_false: bool,
20/// #[serde(default = "bool_true")]
21/// default_true: bool,
22/// }
23///
24/// let s = r#" { } "#;
25/// let a: MyStruct = serde_json::from_str(s).unwrap();
26/// assert!(!a.default_false);
27/// assert!(a.default_true);
28/// ```
29#[inline]
30pub fn bool_true() -> bool {
31 true
32}
33
34/// Allows compact setting `u16` field default value.
35///
36/// # Example
37/// ```rust
38/// use serde_aux::prelude::*;
39///
40/// #[derive(serde::Deserialize, Debug)]
41/// struct MyStruct {
42/// #[serde(default = "default_u16::<30>")]
43/// default_30: u16,
44/// #[serde(default)]
45/// default_zero: u16,
46/// }
47///
48/// let s = r#"{}"#;
49/// let a: MyStruct = serde_json::from_str(s).unwrap();
50/// assert_eq!(a.default_30, 30);
51/// assert_eq!(a.default_zero, 0);
52/// ```
53#[inline]
54pub const fn default_u16<const V: u16>() -> u16 {
55 V
56}
57
58/// Allows compact setting `u32` field default value.
59///
60/// # Example
61/// ```rust
62/// use serde_aux::prelude::*;
63///
64/// #[derive(serde::Deserialize, Debug)]
65/// struct MyStruct {
66/// #[serde(default = "default_u32::<30>")]
67/// default_30: u32,
68/// #[serde(default)]
69/// default_zero: u32,
70/// }
71///
72/// let s = r#"{}"#;
73/// let a: MyStruct = serde_json::from_str(s).unwrap();
74/// assert_eq!(a.default_30, 30);
75/// assert_eq!(a.default_zero, 0);
76/// ```
77#[inline]
78pub const fn default_u32<const V: u32>() -> u32 {
79 V
80}
81
82/// Allows compact setting `u64` field default value.
83///
84/// # Example
85/// ```rust
86/// use serde_aux::prelude::*;
87///
88/// #[derive(serde::Deserialize, Debug)]
89/// struct MyStruct {
90/// #[serde(default = "default_u64::<30>")]
91/// default_30: u64,
92/// #[serde(default)]
93/// default_zero: u64,
94/// }
95///
96/// let s = r#"{}"#;
97/// let a: MyStruct = serde_json::from_str(s).unwrap();
98/// assert_eq!(a.default_30, 30);
99/// assert_eq!(a.default_zero, 0);
100/// ```
101#[inline]
102pub const fn default_u64<const V: u64>() -> u64 {
103 V
104}
105
106/// Allows compact setting `i16` field default value.
107///
108/// # Example
109/// ```rust
110/// use serde_aux::prelude::*;
111///
112/// #[derive(serde::Deserialize, Debug)]
113/// struct MyStruct {
114/// #[serde(default = "default_i16::<-30>")]
115/// default_30: i16,
116/// #[serde(default)]
117/// default_zero: i16,
118/// }
119///
120/// let s = r#"{}"#;
121/// let a: MyStruct = serde_json::from_str(s).unwrap();
122/// assert_eq!(a.default_30, -30);
123/// assert_eq!(a.default_zero, 0);
124/// ```
125#[inline]
126pub const fn default_i16<const V: i16>() -> i16 {
127 V
128}
129
130/// Allows compact setting `i32` field default value.
131///
132/// # Example
133/// ```rust
134/// use serde_aux::prelude::*;
135///
136/// #[derive(serde::Deserialize, Debug)]
137/// struct MyStruct {
138/// #[serde(default = "default_i32::<-30>")]
139/// default_30: i32,
140/// #[serde(default)]
141/// default_zero: i32,
142/// }
143///
144/// let s = r#"{}"#;
145/// let a: MyStruct = serde_json::from_str(s).unwrap();
146/// assert_eq!(a.default_30, -30);
147/// assert_eq!(a.default_zero, 0);
148/// ```
149#[inline]
150pub const fn default_i32<const V: i32>() -> i32 {
151 V
152}
153
154/// Allows compact setting `i64` field default value.
155///
156/// # Example
157/// ```rust
158/// use serde_aux::prelude::*;
159///
160/// #[derive(serde::Deserialize, Debug)]
161/// struct MyStruct {
162/// #[serde(default = "default_i64::<-30>")]
163/// default_30: i64,
164/// #[serde(default)]
165/// default_zero: i64,
166/// }
167///
168/// let s = r#"{}"#;
169/// let a: MyStruct = serde_json::from_str(s).unwrap();
170/// assert_eq!(a.default_30, -30);
171/// assert_eq!(a.default_zero, 0);
172/// ```
173#[inline]
174pub const fn default_i64<const V: i64>() -> i64 {
175 V
176}
177
178/// Deserializes a `chrono::DateTime<Utc>` from a milliseconds time stamp. Useful when the data is coming from a number
179/// which is not a seconds time stamp but milliseconds one. It also handles the string to number conversion if the
180/// data was passed as a string with number inside like **"1519927261900"**.
181///
182/// # Example:
183///
184/// ```rust
185/// use chrono::prelude::*;
186/// use serde_aux::prelude::*;
187///
188/// #[derive(serde::Deserialize, Debug)]
189/// struct MyStruct {
190/// #[serde(deserialize_with = "deserialize_datetime_utc_from_milliseconds")]
191/// time: DateTime<Utc>,
192/// }
193///
194/// let s = r#" { "time": "1519927261900" } "#;
195/// let a: MyStruct = serde_json::from_str(s).unwrap();
196/// assert_eq!(a.time.timestamp(), 1519927261);
197/// assert_eq!(a.time.timestamp_subsec_millis(), 900);
198/// ```
199#[cfg(feature = "chrono")]
200pub fn deserialize_datetime_utc_from_milliseconds<'de, D>(
201 deserializer: D,
202) -> Result<chrono::DateTime<chrono::Utc>, D::Error>
203where
204 D: Deserializer<'de>,
205{
206 use chrono::prelude::*;
207
208 let millis = deserialize_number_from_string::<i64, D>(deserializer)?;
209 DateTime::<Utc>::from_timestamp_millis(millis)
210 .ok_or_else(|| D::Error::custom("Couldn't parse the timestamp"))
211}
212
213/// Deserializes a `chrono::DateTime<Utc>` from a seconds time stamp.
214/// It also handles the string to number conversion if the
215/// data was passed as a string with number inside like **"1519927261"**.
216///
217/// # Example:
218///
219/// ```rust
220/// use chrono::prelude::*;
221/// use serde_aux::prelude::*;
222///
223/// #[derive(serde::Deserialize, Debug)]
224/// struct MyStruct {
225/// #[serde(deserialize_with = "deserialize_datetime_utc_from_seconds")]
226/// time: DateTime<Utc>,
227/// }
228///
229/// let s = r#" { "time": "1519927261" } "#;
230/// let a: MyStruct = serde_json::from_str(s).unwrap();
231/// assert_eq!(a.time.timestamp(), 1519927261);
232/// assert_eq!(a.time.timestamp_subsec_millis(), 0);
233/// ```
234#[cfg(feature = "chrono")]
235pub fn deserialize_datetime_utc_from_seconds<'de, D>(
236 deserializer: D,
237) -> Result<chrono::DateTime<chrono::Utc>, D::Error>
238where
239 D: Deserializer<'de>,
240{
241 use chrono::prelude::*;
242
243 let seconds = deserialize_number_from_string::<i64, D>(deserializer)?;
244 DateTime::<Utc>::from_timestamp(seconds, 0)
245 .ok_or_else(|| D::Error::custom("Couldn't parse the timestamp"))
246}
247
248/// Deserializes a number from string or a number.
249///
250/// # Example:
251///
252/// ```rust
253/// use serde_aux::prelude::*;
254///
255/// #[derive(serde::Deserialize, Debug)]
256/// struct MyStruct {
257/// #[serde(deserialize_with = "deserialize_number_from_string")]
258/// number_from_string: u64,
259/// }
260///
261/// let s = r#" { "number_from_string": "123" } "#;
262/// let a: MyStruct = serde_json::from_str(s).unwrap();
263/// assert_eq!(a.number_from_string, 123);
264///
265/// let s = r#" { "number_from_string": 444 } "#;
266/// let a: MyStruct = serde_json::from_str(s).unwrap();
267/// assert_eq!(a.number_from_string, 444);
268/// ```
269///
270/// For making it work with strong types you must implement `FromStr` trait. It is quite simple.
271///
272/// # Example
273///
274/// ```rust
275/// use std::str::FromStr;
276/// use std::num::{ParseIntError, ParseFloatError};
277///
278/// use serde_aux::prelude::*;
279///
280/// #[derive(serde::Deserialize, Debug, PartialEq)]
281/// struct IntId(u64);
282///
283/// impl FromStr for IntId {
284/// type Err = ParseIntError;
285///
286/// fn from_str(s: &str) -> Result<IntId, Self::Err> {
287/// Ok(IntId(u64::from_str(s)?))
288/// }
289/// }
290///
291/// #[derive(serde::Deserialize, Debug)]
292/// struct MyStruct {
293/// #[serde(deserialize_with = "deserialize_number_from_string")]
294/// int_id: IntId,
295/// }
296///
297/// let s = r#"{ "int_id": "123" }"#;
298/// let a: MyStruct = serde_json::from_str(s).unwrap();
299/// assert_eq!(a.int_id.0, 123);
300///
301/// let s = r#"{ "int_id": 444 }"#;
302/// let a: MyStruct = serde_json::from_str(s).unwrap();
303/// assert_eq!(a.int_id.0, 444);
304/// ```
305pub fn deserialize_number_from_string<'de, T, D>(deserializer: D) -> Result<T, D::Error>
306where
307 D: Deserializer<'de>,
308 T: FromStr + Deserialize<'de>,
309 <T as FromStr>::Err: Display,
310{
311 #[derive(Deserialize)]
312 #[serde(untagged)]
313 enum StringOrInt<T> {
314 String(String),
315 Number(T),
316 }
317
318 match StringOrInt::<T>::deserialize(deserializer)? {
319 StringOrInt::String(s) => s.parse::<T>().map_err(serde::de::Error::custom),
320 StringOrInt::Number(i) => Ok(i),
321 }
322}
323
324/// Deserializes an option number from string or a number.
325///
326/// # Example:
327///
328/// ```rust
329/// use serde_aux::prelude::*;
330///
331/// #[derive(serde::Deserialize, Debug)]
332/// struct MyStruct {
333/// #[serde(deserialize_with = "deserialize_option_number_from_string")]
334/// option_num: Option<f32>,
335/// #[serde(default, deserialize_with = "deserialize_option_number_from_string")]
336/// missing: Option<i32>
337/// }
338/// fn serde_qs_eq(s: &str, result: Option<f32>) {
339/// let a: MyStruct = serde_qs::from_str(s).unwrap();
340/// assert_eq!(a.option_num, result);
341/// assert_eq!(a.missing, None);
342/// }
343/// fn serde_qs_err(s: &str) {
344/// assert!(serde_qs::from_str::<MyStruct>(s).is_err());
345/// }
346/// fn serde_json_eq(s: &str, result: Option<f32>) {
347/// let a: MyStruct = serde_json::from_str(s).unwrap();
348/// assert_eq!(a.option_num, result);
349/// assert_eq!(a.missing, None);
350/// }
351/// fn serde_json_err(s: &str) {
352/// assert!(serde_json::from_str::<MyStruct>(s).is_err());
353/// }
354///
355/// serde_qs_eq("option_num=1", Some(1.0));
356/// serde_qs_eq("option_num=-1", Some(-1.0));
357/// serde_qs_eq("option_num=0.1", Some(0.1));
358/// serde_qs_eq("option_num=-0.1", Some(-0.1));
359/// serde_qs_eq("option_num=", None);
360/// serde_qs_eq("option_num", None);
361///
362/// serde_qs_err("option_num=true");
363/// serde_qs_err("option_num=a");
364/// serde_qs_err("option_num[a]=");
365/// serde_qs_err("option_num[]=");
366///
367/// serde_json_eq(r#" { "option_num": "1" } "#, Some(1.0));
368/// serde_json_eq(r#" { "option_num": "-1" } "#, Some(-1.0));
369/// serde_json_eq(r#" { "option_num": "0.1" } "#, Some(0.1));
370/// serde_json_eq(r#" { "option_num": "-0.1" } "#, Some(-0.1));
371/// serde_json_eq(r#" { "option_num": 1 } "#, Some(1.0));
372/// serde_json_eq(r#" { "option_num": -1 } "#, Some(-1.0));
373/// serde_json_eq(r#" { "option_num": 0.1 } "#, Some(0.1));
374/// serde_json_eq(r#" { "option_num": -0.1 } "#, Some(-0.1));
375/// serde_json_eq(r#" { "option_num": "" } "#, None);
376/// serde_json_eq(r#" { "option_num": null } "#, None);
377///
378/// serde_json_err(r#" { "option_num": true } "#);
379/// serde_json_err(r#" { "option_num": "a" } "#);
380/// serde_json_err(r#" { "option_num": {} } "#);
381/// serde_json_err(r#" { "option_num": [] } "#);
382/// ```
383pub fn deserialize_option_number_from_string<'de, T, D>(
384 deserializer: D,
385) -> Result<Option<T>, D::Error>
386where
387 D: Deserializer<'de>,
388 T: FromStr + Deserialize<'de>,
389 <T as FromStr>::Err: Display,
390{
391 #[derive(Deserialize)]
392 #[serde(untagged)]
393 enum NumericOrNull<'a, T> {
394 Str(&'a str),
395 String(String),
396 FromStr(T),
397 Null,
398 }
399
400 match NumericOrNull::<T>::deserialize(deserializer)? {
401 NumericOrNull::Str(s) => match s {
402 "" => Ok(None),
403 _ => T::from_str(s).map(Some).map_err(serde::de::Error::custom),
404 },
405 NumericOrNull::String(s) => match s.as_str() {
406 "" => Ok(None),
407 _ => T::from_str(&s).map(Some).map_err(serde::de::Error::custom),
408 },
409 NumericOrNull::FromStr(i) => Ok(Some(i)),
410 NumericOrNull::Null => Ok(None),
411 }
412}
413
414macro_rules! wrap_option_number_from_string_fn {
415 (
416 $(#[doc = $doc:tt])*
417 $func:ident,
418 $res:ty
419 ) => {
420 $(#[doc = $doc])*
421 pub fn $func<'de, T, D>(deserializer: D) -> Result<$res, D::Error>
422 where
423 D: Deserializer<'de>,
424 T: FromStr + Deserialize<'de>,
425 <T as FromStr>::Err: Display,
426 {
427 #[derive(Deserialize)]
428 #[serde(untagged)]
429 enum NumericOrNull<'a, T> {
430 Str(&'a str),
431 String(String),
432 FromStr(T),
433 Null,
434 }
435
436 match NumericOrNull::<T>::deserialize(deserializer)? {
437 NumericOrNull::Str(s) => match s {
438 "" => Ok(None.into()),
439 _ => T::from_str(s)
440 .map(|i| Some(i).into())
441 .map_err(serde::de::Error::custom),
442 },
443 NumericOrNull::String(s) => match s.as_str() {
444 "" => Ok(None.into()),
445 _ => T::from_str(&s)
446 .map(|i| Some(i).into())
447 .map_err(serde::de::Error::custom),
448 },
449 NumericOrNull::FromStr(i) => Ok(Some(i).into()),
450 NumericOrNull::Null => Ok(None.into()),
451 }
452 }
453 };
454}
455wrap_option_number_from_string_fn!(
456 /// Deserializes a `Cell` option number from string or a number. Same logic as [`"deserialize_option_number_from_string"`](https://docs.rs/serde-aux/latest/serde_aux/field_attributes/fn.deserialize_option_number_from_string.html).
457 ///
458 /// # Example:
459 ///
460 /// ```rust
461 /// use serde_aux::prelude::*;
462 /// use std::cell::Cell;
463 ///
464 /// #[derive(serde::Deserialize, Debug)]
465 /// struct MyStruct {
466 /// #[serde(deserialize_with = "deserialize_cell_option_number_from_string")]
467 /// v: Cell<Option<f32>>
468 /// }
469 ///
470 /// let a = serde_qs::from_str::<MyStruct>("v=-0.1").unwrap();
471 /// assert_eq!(a.v, Cell::new(Some(-0.1)));
472 /// ```
473 deserialize_cell_option_number_from_string,
474 std::cell::Cell<Option<T>>
475);
476wrap_option_number_from_string_fn!(
477 /// Deserializes a `RefCell` option number from string or a number. Same logic as [`"deserialize_option_number_from_string"`](https://docs.rs/serde-aux/latest/serde_aux/field_attributes/fn.deserialize_option_number_from_string.html).
478 ///
479 /// # Example:
480 ///
481 /// ```rust
482 /// use serde_aux::prelude::*;
483 /// use std::cell::RefCell;
484 ///
485 /// #[derive(serde::Deserialize, Debug)]
486 /// struct MyStruct {
487 /// #[serde(default, deserialize_with = "deserialize_ref_cell_option_number_from_string")]
488 /// v: RefCell<Option<f32>>
489 /// }
490 ///
491 /// let a = serde_qs::from_str::<MyStruct>("v=-0.1").unwrap();
492 /// assert_eq!(a.v, RefCell::new(Some(-0.1)));
493 /// ```
494 deserialize_ref_cell_option_number_from_string,
495 std::cell::RefCell<Option<T>>
496);
497wrap_option_number_from_string_fn!(
498 /// Deserializes a `Mutex` option number from string or a number. Same logic as [`"deserialize_option_number_from_string"`](https://docs.rs/serde-aux/latest/serde_aux/field_attributes/fn.deserialize_option_number_from_string.html).
499 ///
500 /// # Example:
501 ///
502 /// ```rust
503 /// use serde_aux::prelude::*;
504 /// use std::sync::Mutex;
505 ///
506 /// #[derive(serde::Deserialize, Debug)]
507 /// struct MyStruct {
508 /// #[serde(default, deserialize_with = "deserialize_mutex_option_number_from_string")]
509 /// v: Mutex<Option<f32>>
510 /// }
511 ///
512 /// let a = serde_qs::from_str::<MyStruct>("v=-0.1").unwrap();
513 /// assert_eq!(*a.v.lock().unwrap(), Some(-0.1));
514 /// ```
515 deserialize_mutex_option_number_from_string,
516 std::sync::Mutex<Option<T>>
517);
518wrap_option_number_from_string_fn!(
519 /// Deserializes a `RwLock` option number from string or a number. Same logic as [`"deserialize_option_number_from_string"`](https://docs.rs/serde-aux/latest/serde_aux/field_attributes/fn.deserialize_option_number_from_string.html).
520 ///
521 /// # Example:
522 ///
523 /// ```rust
524 /// use serde_aux::prelude::*;
525 /// use std::sync::RwLock;
526 ///
527 /// #[derive(serde::Deserialize, Debug)]
528 /// struct MyStruct {
529 /// #[serde(default, deserialize_with = "deserialize_rw_lock_option_number_from_string")]
530 /// v: RwLock<Option<f32>>
531 /// }
532 ///
533 /// let a = serde_qs::from_str::<MyStruct>("v=-0.1").unwrap();
534 /// assert_eq!(*a.v.read().unwrap(), Some(-0.1));
535 /// ```
536 deserialize_rw_lock_option_number_from_string,
537 std::sync::RwLock<Option<T>>
538);
539
540/// Deserializes boolean from anything (string, number, boolean). If input is a string,
541/// it is expected, that it is possible to convert it to a number. The return boolean is
542/// `true` if the number was either `1` or `1.0` after parsing.
543///
544/// # Example
545///
546/// ```rust
547/// use serde_aux::prelude::*;
548///
549/// #[derive(serde::Deserialize, Debug)]
550/// struct MyStruct {
551/// #[serde(deserialize_with = "deserialize_bool_from_anything")]
552/// boolean: bool,
553/// }
554///
555/// let s = r#"{ "boolean": 1.0 }"#;
556/// let a: MyStruct = serde_json::from_str(s).unwrap();
557/// assert!(a.boolean);
558///
559/// let s = r#"{ "boolean": 0.0 }"#;
560/// let a: MyStruct = serde_json::from_str(s).unwrap();
561/// assert!(!a.boolean);
562///
563/// let s = r#"{ "boolean": 2.3 }"#;
564/// assert!(serde_json::from_str::<MyStruct>(s).is_err());
565///
566/// let s = r#"{ "boolean": 1 }"#;
567/// let a: MyStruct = serde_json::from_str(s).unwrap();
568/// assert!(a.boolean);
569///
570/// let s = r#"{ "boolean": 0 }"#;
571/// let a: MyStruct = serde_json::from_str(s).unwrap();
572/// assert!(!a.boolean);
573///
574/// let s = r#"{ "boolean": 2 }"#;
575/// assert!(serde_json::from_str::<MyStruct>(s).is_err());
576///
577/// let s = r#"{ "boolean": "1.0" }"#;
578/// let a: MyStruct = serde_json::from_str(s).unwrap();
579/// assert!(a.boolean);
580///
581/// let s = r#"{ "boolean": "0.0" }"#;
582/// let a: MyStruct = serde_json::from_str(s).unwrap();
583/// assert!(!a.boolean);
584///
585/// let s = r#"{ "boolean": "2.3" }"#;
586/// assert!(serde_json::from_str::<MyStruct>(s).is_err());
587///
588/// let s = r#"{ "boolean": "1" }"#;
589/// let a: MyStruct = serde_json::from_str(s).unwrap();
590/// assert!(a.boolean);
591///
592/// let s = r#"{ "boolean": "0" }"#;
593/// let a: MyStruct = serde_json::from_str(s).unwrap();
594/// assert!(!a.boolean);
595///
596/// let s = r#"{ "boolean": "2" }"#;
597/// assert!(serde_json::from_str::<MyStruct>(s).is_err());
598///
599/// let s = r#"{ "boolean": "foo" }"#;
600/// assert!(serde_json::from_str::<MyStruct>(s).is_err());
601/// ```
602pub fn deserialize_bool_from_anything<'de, D>(deserializer: D) -> Result<bool, D::Error>
603where
604 D: Deserializer<'de>,
605{
606 #[derive(Deserialize)]
607 #[serde(untagged)]
608 enum AnythingOrBool {
609 String(String),
610 Int(i64),
611 Float(f64),
612 Boolean(bool),
613 }
614
615 match AnythingOrBool::deserialize(deserializer)? {
616 AnythingOrBool::Boolean(b) => Ok(b),
617 AnythingOrBool::Int(i) => match i {
618 1 => Ok(true),
619 0 => Ok(false),
620 _ => Err(serde::de::Error::custom("The number is neither 1 nor 0")),
621 },
622 AnythingOrBool::Float(f) => {
623 if (f - 1.0f64).abs() < f64::EPSILON {
624 Ok(true)
625 } else if f == 0.0f64 {
626 Ok(false)
627 } else {
628 Err(serde::de::Error::custom(
629 "The number is neither 1.0 nor 0.0",
630 ))
631 }
632 }
633 AnythingOrBool::String(string) => {
634 if let Ok(b) = string.parse::<bool>() {
635 Ok(b)
636 } else if let Ok(i) = string.parse::<i64>() {
637 match i {
638 1 => Ok(true),
639 0 => Ok(false),
640 _ => Err(serde::de::Error::custom("The number is neither 1 nor 0")),
641 }
642 } else if let Ok(f) = string.parse::<f64>() {
643 if (f - 1.0f64).abs() < f64::EPSILON {
644 Ok(true)
645 } else if f == 0.0f64 {
646 Ok(false)
647 } else {
648 Err(serde::de::Error::custom(
649 "The number is neither 1.0 nor 0.0",
650 ))
651 }
652 } else {
653 Err(serde::de::Error::custom(format!(
654 "Could not parse boolean from a string: {}",
655 string
656 )))
657 }
658 }
659 }
660}
661
662/// Deserializes string from a number. If the original value is a number value,
663/// it will be converted to a string.
664///
665/// # Example:
666///
667/// ```rust
668/// use serde_aux::prelude::*;
669///
670/// #[derive(serde::Deserialize, Debug)]
671/// struct MyStruct {
672/// #[serde(deserialize_with = "deserialize_string_from_number")]
673/// number_as_string: String,
674/// }
675///
676/// let s = r#" { "number_as_string": "foo" } "#;
677/// let a: MyStruct = serde_json::from_str(s).unwrap();
678/// assert_eq!(a.number_as_string, "foo");
679///
680/// let s = r#" { "number_as_string": -13 } "#;
681/// let a: MyStruct = serde_json::from_str(s).unwrap();
682/// assert_eq!(a.number_as_string, "-13");
683///
684/// let s = r#" { "number_as_string": 24.0034 } "#;
685/// let a: MyStruct = serde_json::from_str(s).unwrap();
686/// assert_eq!(a.number_as_string, "24.0034");
687/// ```
688pub fn deserialize_string_from_number<'de, D>(deserializer: D) -> Result<String, D::Error>
689where
690 D: Deserializer<'de>,
691{
692 #[derive(Deserialize)]
693 #[serde(untagged)]
694 enum StringOrNumber {
695 String(String),
696 Number(i64),
697 Float(f64),
698 }
699
700 match StringOrNumber::deserialize(deserializer)? {
701 StringOrNumber::String(s) => Ok(s),
702 StringOrNumber::Number(i) => Ok(i.to_string()),
703 StringOrNumber::Float(f) => Ok(f.to_string()),
704 }
705}
706
707/// Deserializes default value from nullable value. If the original value is `null`,
708/// `Default::default()` is used.
709///
710/// # Example:
711///
712/// ```rust
713/// use serde_aux::prelude::*;
714///
715/// #[derive(serde::Deserialize, Debug)]
716/// struct MyStruct {
717/// #[serde(deserialize_with = "deserialize_default_from_null")]
718/// null_as_default: u64,
719/// }
720///
721/// let s = r#" { "null_as_default": 42 } "#;
722/// let a: MyStruct = serde_json::from_str(s).unwrap();
723/// assert_eq!(a.null_as_default, 42);
724///
725/// let s = r#" { "null_as_default": null } "#;
726/// let a: MyStruct = serde_json::from_str(s).unwrap();
727/// assert_eq!(a.null_as_default, 0);
728///
729/// let s = r#" { "null_as_default": "wrong_type" } "#;
730/// assert!(serde_json::from_str::<MyStruct>(s).is_err());
731/// ```
732pub fn deserialize_default_from_null<'de, D, T>(deserializer: D) -> Result<T, D::Error>
733where
734 D: Deserializer<'de>,
735 T: Deserialize<'de> + Default,
736{
737 Ok(Option::deserialize(deserializer)?.unwrap_or_default())
738}
739
740/// Deserializes default value from nullable value or empty object. If the original value is `null` or `{}`,
741/// `Default::default()` is used.
742///
743/// # Example:
744///
745/// ```rust
746/// use serde_aux::prelude::*;
747///
748/// #[derive(serde::Deserialize, Debug)]
749/// struct MyStruct {
750/// #[serde(deserialize_with = "deserialize_default_from_empty_object")]
751/// empty_as_default: Option<MyInnerStruct>,
752/// }
753///
754/// #[derive(serde::Deserialize, Debug)]
755/// struct MyInnerStruct {
756/// mandatory: u64,
757/// }
758///
759/// let s = r#" { "empty_as_default": { "mandatory": 42 } } "#;
760/// let a: MyStruct = serde_json::from_str(s).unwrap();
761/// assert_eq!(a.empty_as_default.unwrap().mandatory, 42);
762///
763/// let s = r#" { "empty_as_default": null } "#;
764/// let a: MyStruct = serde_json::from_str(s).unwrap();
765/// assert!(a.empty_as_default.is_none());
766///
767/// let s = r#" { "empty_as_default": {} } "#;
768/// let a: MyStruct = serde_json::from_str(s).unwrap();
769/// assert!(a.empty_as_default.is_none());
770///
771/// let s = r#" { "empty_as_default": { "unknown": 42 } } "#;
772/// assert!(serde_json::from_str::<MyStruct>(s).is_err());
773/// ```
774pub fn deserialize_default_from_empty_object<'de, D, T>(deserializer: D) -> Result<T, D::Error>
775where
776 D: Deserializer<'de>,
777 T: Deserialize<'de> + Default,
778{
779 #[derive(Debug, Deserialize)]
780 #[serde(deny_unknown_fields)]
781 struct EmptyObject {}
782
783 #[derive(Debug, Deserialize)]
784 #[serde(untagged)]
785 enum EmptyOrNot<Y> {
786 NonEmpty(Y),
787 Empty(EmptyObject),
788 Null,
789 }
790
791 let empty_or_not: EmptyOrNot<T> = EmptyOrNot::deserialize(deserializer)?;
792
793 match empty_or_not {
794 EmptyOrNot::NonEmpty(e) => Ok(e),
795 _ => Ok(T::default()),
796 }
797}
798
799/// Deserializes a comma separated string into a `Vec<T>`.
800///
801/// # Example:
802///
803/// ```rust
804/// use serde_aux::prelude::*;
805///
806/// #[derive(serde::Deserialize, Debug)]
807/// struct MyStruct {
808/// #[serde(deserialize_with = "deserialize_vec_from_string_or_vec")]
809/// list: Vec<i32>,
810/// }
811///
812/// let s = r#" { "list": "1,2,3,4" } "#;
813/// let a: MyStruct = serde_json::from_str(s).unwrap();
814/// assert_eq!(&a.list, &[1, 2, 3, 4]);
815///
816/// let s = r#" { "list": [1,2,3,4] } "#;
817/// let a: MyStruct = serde_json::from_str(s).unwrap();
818/// assert_eq!(&a.list, &[1, 2, 3, 4]);
819/// ```
820pub fn deserialize_vec_from_string_or_vec<'de, T, D>(deserializer: D) -> Result<Vec<T>, D::Error>
821where
822 D: Deserializer<'de>,
823 T: FromStr + Deserialize<'de> + 'static,
824 <T as FromStr>::Err: std::fmt::Display,
825{
826 StringOrVecToVec::default().into_deserializer()(deserializer)
827}
828
829/// Deserialize to primary or fallback type.
830///
831/// This helper function will attempt to deserialize to the primary type first,
832/// and if that fails it will attempt to deserialize to the fallback type. If
833/// both fail, it will return an error.
834///
835/// # Example:
836///
837/// ```rust
838/// use serde_aux::prelude::*;
839///
840/// #[derive(serde::Deserialize, Debug)]
841/// struct MyStruct {
842/// #[serde(deserialize_with = "deserialize_to_type_or_fallback")]
843/// i64_or_f64: Result<i64, f64>,
844/// #[serde(deserialize_with = "deserialize_to_type_or_fallback")]
845/// f64_or_string: Result<f64, String>,
846/// }
847///
848/// let s = r#" { "i64_or_f64": 1, "f64_or_string": 1 } "#;
849/// let a: MyStruct = serde_json::from_str(s).unwrap();
850/// assert_eq!(a.i64_or_f64, Ok(1));
851/// assert_eq!(a.f64_or_string, Ok(1.0));
852///
853/// let s = r#" { "i64_or_f64": 1.0, "f64_or_string": 1.0 } "#;
854/// let a: MyStruct = serde_json::from_str(s).unwrap();
855/// assert_eq!(a.i64_or_f64, Err(1.0));
856/// assert_eq!(a.f64_or_string, Ok(1.0));
857///
858/// let s = r#" { "i64_or_f64": 1.0, "f64_or_string": "foo" } "#;
859/// let a: MyStruct = serde_json::from_str(s).unwrap();
860/// assert_eq!(a.i64_or_f64, Err(1.0));
861/// assert_eq!(a.f64_or_string, Err(String::from("foo")));
862///
863/// let s = r#" { "i64_or_f64": "foo", "f64_or_string": "foo" } "#;
864/// assert!(serde_json::from_str::<MyStruct>(s).is_err());
865/// ```
866pub fn deserialize_to_type_or_fallback<'de, D, T, F>(
867 deserializer: D,
868) -> Result<Result<T, F>, D::Error>
869where
870 D: Deserializer<'de>,
871 T: Deserialize<'de>,
872 F: Deserialize<'de>,
873{
874 #[derive(Deserialize)]
875 #[serde(untagged)]
876 enum DeEither<T, F> {
877 Type(T),
878 Fallback(F),
879 }
880
881 DeEither::<T, F>::deserialize(deserializer).map(|de| match de {
882 DeEither::Type(t) => Ok(t),
883 DeEither::Fallback(f) => Err(f),
884 })
885}
886
887/// Deserialize to a given type, while ignoring any invalid fields.
888///
889/// This helper function will attempt to deserialize to the given type, and if
890/// it fails it will return `None`, therefore never failing. This is different
891/// from deserializing directly to `Option<T>`, because this would return `None`
892/// only for empty fields, while it would return an error for invalid fields.
893///
894/// # Example:
895///
896/// ```rust
897/// use serde_aux::prelude::*;
898///
899/// #[derive(serde::Deserialize, Debug)]
900/// struct MyStruct {
901/// #[serde(deserialize_with = "deserialize_to_type_or_none")]
902/// opt_f64: Option<f64>,
903/// }
904///
905/// let s = r#" { "opt_f64": 1 } "#;
906/// let a: MyStruct = serde_json::from_str(s).unwrap();
907/// assert_eq!(a.opt_f64, Some(1.0));
908///
909/// let s = r#" { "opt_f64": 1.0 } "#;
910/// let a: MyStruct = serde_json::from_str(s).unwrap();
911/// assert_eq!(a.opt_f64, Some(1.0));
912///
913/// let s = r#" { "opt_f64": "foo" } "#;
914/// let a: MyStruct = serde_json::from_str(s).unwrap();
915/// assert_eq!(a.opt_f64, None);
916/// ```
917pub fn deserialize_to_type_or_none<'de, D, T>(deserializer: D) -> Result<Option<T>, D::Error>
918where
919 D: Deserializer<'de>,
920 Option<T>: Deserialize<'de>,
921{
922 Option::<T>::deserialize(deserializer).or_else(|_| Ok(None))
923}
924
925/// Deserialize to a given type, while returning invalid fields as `String`.
926///
927/// This helper function will attempt to deserialize to the given type, and if
928/// it fails it will return the invalid field lossily converted to `String`,
929/// therefore never failing.
930///
931/// # Example:
932///
933/// ```rust
934/// use serde_aux::prelude::*;
935///
936/// #[derive(serde::Deserialize, Debug)]
937/// struct MyStruct {
938/// #[serde(deserialize_with = "deserialize_to_type_or_string_lossy")]
939/// f64_or_string_lossy: Result<f64, String>,
940/// }
941///
942/// let s = r#" { "f64_or_string_lossy": 1 } "#;
943/// let a: MyStruct = serde_json::from_str(s).unwrap();
944/// assert_eq!(a.f64_or_string_lossy, Ok(1.0));
945///
946/// let s = r#" { "f64_or_string_lossy": 1.0 } "#;
947/// let a: MyStruct = serde_json::from_str(s).unwrap();
948/// assert_eq!(a.f64_or_string_lossy, Ok(1.0));
949///
950/// let s = r#" { "f64_or_string_lossy": "foo" } "#;
951/// let a: MyStruct = serde_json::from_str(s).unwrap();
952/// assert_eq!(a.f64_or_string_lossy, Err(String::from("foo")));
953/// ```
954pub fn deserialize_to_type_or_string_lossy<'de, D, T>(
955 deserializer: D,
956) -> Result<Result<T, String>, D::Error>
957where
958 D: Deserializer<'de>,
959 T: Deserialize<'de>,
960{
961 let value = serde_value::Value::deserialize(deserializer)?;
962 Ok(T::deserialize(value.clone()).map_err(|_| match value {
963 serde_value::Value::Bool(b) => b.to_string(),
964 serde_value::Value::U8(u) => u.to_string(),
965 serde_value::Value::U16(u) => u.to_string(),
966 serde_value::Value::U32(u) => u.to_string(),
967 serde_value::Value::U64(u) => u.to_string(),
968 serde_value::Value::I8(i) => i.to_string(),
969 serde_value::Value::I16(i) => i.to_string(),
970 serde_value::Value::I32(i) => i.to_string(),
971 serde_value::Value::I64(i) => i.to_string(),
972 serde_value::Value::F32(f) => f.to_string(),
973 serde_value::Value::F64(f) => f.to_string(),
974 serde_value::Value::Char(c) => c.to_string(),
975 serde_value::Value::String(s) => s,
976 serde_value::Value::Unit => String::new(),
977 serde_value::Value::Option(opt) => {
978 format!("{:?}", opt)
979 }
980 serde_value::Value::Newtype(nt) => {
981 format!("{:?}", nt)
982 }
983 serde_value::Value::Seq(seq) => format!("{:?}", seq),
984 serde_value::Value::Map(map) => format!("{:?}", map),
985 serde_value::Value::Bytes(v) => String::from_utf8_lossy(&v).into_owned(),
986 }))
987}
988
989/// Create a parser quickly.
990///
991/// ```
992/// use serde_aux::prelude::*;
993/// use std::str::FromStr;
994///
995/// serde_aux::StringOrVecToVecParser!(parse_between_commas, |c| { c == ',' }, true);
996///
997/// #[derive(serde::Deserialize, Debug)]
998/// struct MyStruct {
999/// #[serde(deserialize_with = "parse_between_commas")]
1000/// list: Vec<i32>,
1001/// }
1002///
1003/// let s = r#" { "list": "1,2,3,4" } "#;
1004/// let a: MyStruct = serde_json::from_str(s).unwrap();
1005/// assert_eq!(&a.list, &[1, 2, 3, 4]);
1006///
1007/// let s = r#" { "list": [1,2,3,4] } "#;
1008/// let a: MyStruct = serde_json::from_str(s).unwrap();
1009/// assert_eq!(&a.list, &[1, 2, 3, 4]);
1010///
1011///
1012/// serde_aux::StringOrVecToVecParser!(u8, parse_hex_with_spaces, ' ', |s| { u8::from_str_radix(s, 16) }, true);
1013///
1014/// #[derive(serde::Deserialize, Debug)]
1015/// struct MyStructHex {
1016/// #[serde(deserialize_with = "parse_hex_with_spaces")]
1017/// list: Vec<u8>,
1018/// }
1019///
1020/// let s = r#" { "list": "a1 b2 c3 d4 " } "#;
1021/// let a: MyStructHex = serde_json::from_str(s).unwrap();
1022/// assert_eq!(&a.list, &[0xa1, 0xb2, 0xc3, 0xd4]);
1023///
1024/// let s = r#" { "list": "a1 b2 c3 d4 " } "#;
1025/// let a: MyStructHex = serde_json::from_str(s).unwrap();
1026/// assert_eq!(&a.list, &[0xa1, 0xb2, 0xc3, 0xd4]);
1027/// ```
1028#[macro_export]
1029macro_rules! StringOrVecToVecParser {
1030 ($name:ident, $separator:expr, $skip_empty:expr) => {
1031 fn $name<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
1032 where
1033 D: serde::Deserializer<'de>,
1034 T: FromStr + serde::Deserialize<'de> + 'static,
1035 <T as FromStr>::Err: std::fmt::Display,
1036 {
1037 let mut parser = $crate::field_attributes::StringOrVecToVec::with_separator($separator);
1038 parser.skip_empty($skip_empty);
1039 parser.into_deserializer()(deserializer)
1040 }
1041 };
1042
1043 ($t:ty, $name:ident, $pattern:expr, $converter:expr, $skip_empty:expr) => {
1044 fn $name<'de, D>(deserializer: D) -> Result<Vec<$t>, D::Error>
1045 where
1046 D: serde::Deserializer<'de>,
1047 {
1048 $crate::field_attributes::StringOrVecToVec::new($pattern, $converter, $skip_empty)
1049 .into_deserializer()(deserializer)
1050 }
1051 };
1052}
1053
1054/// Builder to create a parser, that parses a separated string or a vec into a vec.
1055///
1056/// # Example:
1057///
1058/// ```rust
1059/// use serde_aux::prelude::*;
1060/// use std::str::FromStr;
1061///
1062/// fn parser<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
1063/// where
1064/// D: serde::Deserializer<'de>,
1065/// T: FromStr + serde::Deserialize<'de> + 'static,
1066/// <T as FromStr>::Err: std::fmt::Display,
1067/// {
1068/// StringOrVecToVec::default().into_deserializer()(deserializer)
1069/// }
1070///
1071/// #[derive(serde::Deserialize, Debug)]
1072/// struct MyStruct {
1073/// #[serde(deserialize_with = "parser")]
1074/// list: Vec<i32>,
1075/// }
1076///
1077/// let s = r#" { "list": "1,2,3,4" } "#;
1078/// let a: MyStruct = serde_json::from_str(s).unwrap();
1079/// assert_eq!(&a.list, &[1, 2, 3, 4]);
1080///
1081/// let s = r#" { "list": [1,2,3,4] } "#;
1082/// let a: MyStruct = serde_json::from_str(s).unwrap();
1083/// assert_eq!(&a.list, &[1, 2, 3, 4]);
1084pub struct StringOrVecToVec<'a, T, E> {
1085 separator: Pattern<'a>,
1086 parser: Box<StringOrVecParser<T, E>>,
1087 skip_empty: bool,
1088}
1089
1090/// A functor returning a [`Result`] of parsing a string into a vector
1091/// of objects of type `T`.
1092pub type StringOrVecParser<T, E> = dyn FnMut(&str) -> Result<T, E>;
1093
1094/// Pattern on which a string can be split.
1095pub enum Pattern<'a> {
1096 /// Split on a matching char
1097 Char(char),
1098 /// Split on a matching str
1099 Str(&'a str),
1100 /// Split if a char matches the predicate
1101 Pred(Box<dyn Fn(char) -> bool>),
1102 /// Multiple patterns
1103 ///
1104 /// # Example
1105 ///
1106 /// ```rust
1107 /// use serde_aux::prelude::*;
1108 /// use std::str::FromStr;
1109 ///
1110 /// fn parser<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
1111 /// where
1112 /// D: serde::Deserializer<'de>,
1113 /// T: FromStr + serde::Deserialize<'de> + 'static,
1114 /// <T as FromStr>::Err: std::fmt::Display,
1115 /// {
1116 /// StringOrVecToVec::with_separator(vec![Pattern::Char('+'), Pattern::Char('-')]).into_deserializer()(deserializer)
1117 /// }
1118 ///
1119 /// #[derive(serde::Deserialize, Debug)]
1120 /// struct MyStruct {
1121 /// #[serde(deserialize_with = "parser")]
1122 /// list: Vec<i32>,
1123 /// }
1124 ///
1125 /// let s = r#" { "list": "1-2+3-4" } "#;
1126 /// let a: MyStruct = serde_json::from_str(s).unwrap();
1127 /// assert_eq!(&a.list, &[1, 2, 3, 4]);
1128 ///
1129 /// let s = r#" { "list": [1,2,3,4] } "#;
1130 /// let a: MyStruct = serde_json::from_str(s).unwrap();
1131 /// assert_eq!(&a.list, &[1, 2, 3, 4]);
1132 /// ```
1133 Multiple(Vec<Pattern<'a>>),
1134}
1135
1136impl From<char> for Pattern<'_> {
1137 fn from(c: char) -> Self {
1138 Pattern::Char(c)
1139 }
1140}
1141
1142impl<'a> From<&'a str> for Pattern<'a> {
1143 fn from(s: &'a str) -> Self {
1144 Pattern::Str(s)
1145 }
1146}
1147
1148impl<'a> From<Vec<Pattern<'a>>> for Pattern<'a> {
1149 fn from(patterns: Vec<Pattern<'a>>) -> Self {
1150 Pattern::Multiple(patterns)
1151 }
1152}
1153
1154/// # Example
1155///
1156/// ```rust
1157/// use serde_aux::prelude::*;
1158/// use std::str::FromStr;
1159///
1160/// fn parser<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
1161/// where
1162/// D: serde::Deserializer<'de>,
1163/// T: FromStr + serde::Deserialize<'de> + 'static,
1164/// <T as FromStr>::Err: std::fmt::Display,
1165/// {
1166/// StringOrVecToVec::with_separator(vec!['-', '+'].into_iter().collect::<Pattern>()).into_deserializer()(deserializer)
1167/// }
1168///
1169/// #[derive(serde::Deserialize, Debug)]
1170/// struct MyStruct {
1171/// #[serde(deserialize_with = "parser")]
1172/// list: Vec<i32>,
1173/// }
1174///
1175/// let s = r#" { "list": "1-2+3-4" } "#;
1176/// let a: MyStruct = serde_json::from_str(s).unwrap();
1177/// assert_eq!(&a.list, &[1, 2, 3, 4]);
1178///
1179/// let s = r#" { "list": [1,2,3,4] } "#;
1180/// let a: MyStruct = serde_json::from_str(s).unwrap();
1181/// assert_eq!(&a.list, &[1, 2, 3, 4]);
1182/// ```
1183impl<'a> std::iter::FromIterator<Pattern<'a>> for Pattern<'a> {
1184 fn from_iter<I>(iter: I) -> Self
1185 where
1186 I: IntoIterator<Item = Pattern<'a>>,
1187 {
1188 Pattern::Multiple(iter.into_iter().collect())
1189 }
1190}
1191
1192impl std::iter::FromIterator<char> for Pattern<'_> {
1193 fn from_iter<I>(iter: I) -> Self
1194 where
1195 I: IntoIterator<Item = char>,
1196 {
1197 Pattern::Multiple(iter.into_iter().map(Pattern::from).collect())
1198 }
1199}
1200
1201impl<'a> std::iter::FromIterator<&'a str> for Pattern<'a> {
1202 fn from_iter<I>(iter: I) -> Self
1203 where
1204 I: IntoIterator<Item = &'a str>,
1205 {
1206 Pattern::Multiple(iter.into_iter().map(Pattern::from).collect())
1207 }
1208}
1209
1210impl<P> From<P> for Pattern<'_>
1211where
1212 P: Fn(char) -> bool + 'static,
1213{
1214 fn from(pred: P) -> Self {
1215 Pattern::Pred(Box::new(pred))
1216 }
1217}
1218
1219impl<'de, T> Default for StringOrVecToVec<'_, T, T::Err>
1220where
1221 T: FromStr + Deserialize<'de> + 'static,
1222 <T as FromStr>::Err: std::fmt::Display,
1223{
1224 fn default() -> Self {
1225 Self::new(|c| c == ',', T::from_str, false)
1226 }
1227}
1228
1229impl<'a, 'de, T> StringOrVecToVec<'a, T, T::Err>
1230where
1231 T: FromStr + Deserialize<'de> + 'static,
1232 <T as FromStr>::Err: std::fmt::Display,
1233{
1234 /// Create a `StringOrVecToVec` builder with a custom separator. `T::from_str` is used to parse
1235 /// the elements of the list.
1236 ///
1237 /// # Example:
1238 ///
1239 /// ```rust
1240 /// use serde_aux::prelude::*;
1241 /// use std::str::FromStr;
1242 ///
1243 /// fn parser<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
1244 /// where
1245 /// D: serde::Deserializer<'de>,
1246 /// T: FromStr + serde::Deserialize<'de> + 'static,
1247 /// <T as FromStr>::Err: std::fmt::Display,
1248 /// {
1249 /// StringOrVecToVec::with_separator(|c| c == '-' || c == '+').into_deserializer()(deserializer)
1250 /// }
1251 ///
1252 /// #[derive(serde::Deserialize, Debug)]
1253 /// struct MyStruct {
1254 /// #[serde(deserialize_with = "parser")]
1255 /// list: Vec<i32>,
1256 /// }
1257 ///
1258 /// let s = r#" { "list": "1-2+3-4" } "#;
1259 /// let a: MyStruct = serde_json::from_str(s).unwrap();
1260 /// assert_eq!(&a.list, &[1, 2, 3, 4]);
1261 ///
1262 /// let s = r#" { "list": [1,2,3,4] } "#;
1263 /// let a: MyStruct = serde_json::from_str(s).unwrap();
1264 /// assert_eq!(&a.list, &[1, 2, 3, 4]);
1265 /// ```
1266 pub fn with_separator(separator: impl Into<Pattern<'a>>) -> Self {
1267 Self::new(separator, T::from_str, false)
1268 }
1269
1270 /// Sets the flag to skip empty separations.
1271 ///
1272 /// ```rust
1273 /// use serde_aux::prelude::*;
1274 /// use std::str::FromStr;
1275 ///
1276 /// fn parser_skip_empty<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
1277 /// where
1278 /// D: serde::Deserializer<'de>,
1279 /// T: FromStr + serde::Deserialize<'de> + 'static,
1280 /// <T as FromStr>::Err: std::fmt::Display,
1281 /// {
1282 /// let mut parser = StringOrVecToVec::with_separator(|c| c == '-' || c == '+');
1283 /// parser.skip_empty(true);
1284 /// parser.into_deserializer()(deserializer)
1285 /// }
1286 ///
1287 /// #[derive(serde::Deserialize, Debug)]
1288 /// struct MyStructSkipEmpty {
1289 /// #[serde(deserialize_with = "parser_skip_empty")]
1290 /// list: Vec<i32>,
1291 /// }
1292 ///
1293 /// let s = r#" { "list": "1-2+3-4--++--" } "#;
1294 /// let a: MyStructSkipEmpty = serde_json::from_str(s).unwrap();
1295 /// assert_eq!(&a.list, &[1, 2, 3, 4]);
1296 /// ```
1297 pub fn skip_empty(&mut self, skip_empty: bool) -> &mut Self {
1298 self.skip_empty = skip_empty;
1299 self
1300 }
1301}
1302
1303impl<'a, T, E> StringOrVecToVec<'a, T, E> {
1304 /// Create a deserializer with a custom separator and parsing function.
1305 ///
1306 /// # Example:
1307 ///
1308 /// ```rust
1309 /// use serde_aux::prelude::*;
1310 /// use std::str::FromStr;
1311 ///
1312 /// fn parser<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
1313 /// where
1314 /// D: serde::Deserializer<'de>,
1315 /// T: FromStr + serde::Deserialize<'de> + 'static,
1316 /// <T as FromStr>::Err: std::fmt::Display,
1317 /// {
1318 /// StringOrVecToVec::new('-', |s| s.trim().parse(), false).into_deserializer()(deserializer)
1319 /// }
1320 ///
1321 /// #[derive(serde::Deserialize, Debug)]
1322 /// struct MyStruct {
1323 /// #[serde(deserialize_with = "parser")]
1324 /// list: Vec<i32>,
1325 /// }
1326 ///
1327 /// let s = r#" { "list": "1 - 2 - 3- 4 " } "#;
1328 /// let a: MyStruct = serde_json::from_str(s).unwrap();
1329 /// assert_eq!(&a.list, &[1, 2, 3, 4]);
1330 ///
1331 /// let s = r#" { "list": [1,2,3,4] } "#;
1332 /// let a: MyStruct = serde_json::from_str(s).unwrap();
1333 /// assert_eq!(&a.list, &[1, 2, 3, 4]);
1334 /// ```
1335 pub fn new(
1336 separator: impl Into<Pattern<'a>>,
1337 parser: impl FnMut(&str) -> Result<T, E> + 'static,
1338 skip_empty: bool,
1339 ) -> Self {
1340 Self {
1341 separator: separator.into(),
1342 parser: Box::new(parser),
1343 skip_empty,
1344 }
1345 }
1346
1347 /// Create a deserializer with a custom parsing function. The input string will be separated on
1348 /// `,`.
1349 ///
1350 /// # Example:
1351 ///
1352 /// ```rust
1353 /// use serde_aux::prelude::*;
1354 /// use std::str::FromStr;
1355 ///
1356 /// fn parser<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
1357 /// where
1358 /// D: serde::Deserializer<'de>,
1359 /// T: FromStr + serde::Deserialize<'de> + 'static,
1360 /// <T as FromStr>::Err: std::fmt::Display,
1361 /// {
1362 /// StringOrVecToVec::with_parser(|s| s.trim().parse()).into_deserializer()(deserializer)
1363 /// }
1364 ///
1365 /// #[derive(serde::Deserialize, Debug)]
1366 /// struct MyStruct {
1367 /// #[serde(deserialize_with = "parser")]
1368 /// list: Vec<i32>,
1369 /// }
1370 ///
1371 /// let s = r#" { "list": "1 , 2 , 3, 4 " } "#;
1372 /// let a: MyStruct = serde_json::from_str(s).unwrap();
1373 /// assert_eq!(&a.list, &[1, 2, 3, 4]);
1374 ///
1375 /// let s = r#" { "list": [1,2,3,4] } "#;
1376 /// let a: MyStruct = serde_json::from_str(s).unwrap();
1377 /// assert_eq!(&a.list, &[1, 2, 3, 4]);
1378 /// ```
1379 pub fn with_parser(parser: impl FnMut(&str) -> Result<T, E> + 'static) -> Self {
1380 Self::new(|c| c == ',', parser, false)
1381 }
1382
1383 /// Creates the actual deserializer from this builder.
1384 pub fn into_deserializer<'de, D>(
1385 self,
1386 ) -> impl FnMut(D) -> Result<Vec<T>, <D as Deserializer<'de>>::Error>
1387 where
1388 'a: 'de,
1389 D: Deserializer<'de>,
1390 T: Deserialize<'de>,
1391 E: std::fmt::Display,
1392 {
1393 #[derive(Deserialize)]
1394 #[serde(untagged)]
1395 enum StringOrVec<T> {
1396 String(String),
1397 Vec(Vec<T>),
1398 }
1399
1400 let StringOrVecToVec {
1401 mut parser,
1402 separator,
1403 skip_empty,
1404 } = self;
1405
1406 move |deserializer| match StringOrVec::<T>::deserialize(deserializer)? {
1407 StringOrVec::String(s) => Ok(separator
1408 .split(&s)
1409 .into_iter()
1410 .filter(|s| {
1411 if skip_empty && s.is_empty() {
1412 return false;
1413 }
1414 true
1415 })
1416 .map(&mut parser)
1417 .collect::<Result<Vec<_>, _>>()
1418 .map_err(serde::de::Error::custom)?),
1419 StringOrVec::Vec(v) => Ok(v),
1420 }
1421 }
1422}
1423
1424impl Pattern<'_> {
1425 fn split<'b>(&self, input: &'b str) -> Vec<&'b str> {
1426 match self {
1427 Pattern::Char(c) => input.split(*c).collect(),
1428 Pattern::Str(s) => input.split(s).collect(),
1429 Pattern::Pred(p) => input.split(p).collect(),
1430 Pattern::Multiple(patterns) => {
1431 let mut split = vec![input];
1432 for pattern in patterns {
1433 let delete_until = split.len();
1434 let mut new_split = Vec::new();
1435 for s in &split {
1436 new_split.append(&mut pattern.split(s));
1437 }
1438
1439 if !new_split.is_empty() {
1440 split = split.split_off(delete_until);
1441 }
1442
1443 split.append(&mut new_split);
1444 }
1445 split
1446 }
1447 }
1448 }
1449}
1450
1451#[cfg(test)]
1452mod tests {
1453 use crate::prelude::*;
1454 use std::{
1455 cell::{Cell, RefCell},
1456 sync::{Mutex, RwLock},
1457 };
1458 #[derive(Debug, serde::Deserialize)]
1459 struct MyStruct {
1460 #[serde(
1461 default,
1462 deserialize_with = "deserialize_cell_option_number_from_string"
1463 )]
1464 cell: Cell<Option<f32>>,
1465 #[serde(
1466 default,
1467 deserialize_with = "deserialize_ref_cell_option_number_from_string"
1468 )]
1469 ref_cell: RefCell<Option<f32>>,
1470 #[serde(
1471 default,
1472 deserialize_with = "deserialize_mutex_option_number_from_string"
1473 )]
1474 mutex: Mutex<Option<f32>>,
1475 #[serde(
1476 default,
1477 deserialize_with = "deserialize_rw_lock_option_number_from_string"
1478 )]
1479 rw_lock: RwLock<Option<f32>>,
1480 }
1481 macro_rules! serde_qs_eq {
1482 ($s:literal, $result:expr) => {
1483 let a: MyStruct = serde_qs::from_str($s).unwrap();
1484 assert_eq!(a.cell, Cell::new($result));
1485 assert_eq!(a.ref_cell, RefCell::new($result));
1486 assert_eq!(*a.mutex.lock().unwrap(), $result);
1487 assert_eq!(*a.rw_lock.read().unwrap(), $result);
1488 };
1489 }
1490 macro_rules! serde_qs_err {
1491 ($rest:literal) => {
1492 assert!(serde_qs::from_str::<MyStruct>(concat!("cell", $rest)).is_err());
1493 assert!(serde_qs::from_str::<MyStruct>(concat!("ref_cell", $rest)).is_err());
1494 assert!(serde_qs::from_str::<MyStruct>(concat!("mutex", $rest)).is_err());
1495 assert!(serde_qs::from_str::<MyStruct>(concat!("rw_lock", $rest)).is_err());
1496 };
1497 }
1498 macro_rules! serde_json_eq {
1499 ($s:literal, $result:expr) => {
1500 let a: MyStruct = serde_json::from_str($s).unwrap();
1501 assert_eq!(a.cell, Cell::new($result));
1502 assert_eq!(a.ref_cell, RefCell::new($result));
1503 assert_eq!(*a.mutex.lock().unwrap(), $result);
1504 assert_eq!(*a.rw_lock.read().unwrap(), $result);
1505 };
1506 }
1507 macro_rules! serde_json_err {
1508 ($v:tt) => {
1509 assert!(serde_json::from_str::<MyStruct>(r#" { "cell": $v } "#).is_err());
1510 assert!(serde_json::from_str::<MyStruct>(r#" { "ref_cell": $v } "#).is_err());
1511 assert!(serde_json::from_str::<MyStruct>(r#" { "mutex": $v } "#).is_err());
1512 assert!(serde_json::from_str::<MyStruct>(r#" { "rw_lock": $v } "#).is_err());
1513 };
1514 }
1515 #[test]
1516 fn test_deserialize_wrap_option_number_from_string() {
1517 serde_qs_eq!("cell=1&ref_cell=1&mutex=1&rw_lock=1", Some(1.0));
1518 serde_qs_eq!("cell=-1&ref_cell=-1&mutex=-1&rw_lock=-1", Some(-1.0));
1519 serde_qs_eq!("cell=0.1&ref_cell=0.1&mutex=0.1&rw_lock=0.1", Some(0.1));
1520 serde_qs_eq!(
1521 "cell=-0.1&ref_cell=-0.1&mutex=-0.1&rw_lock=-0.1",
1522 Some(-0.1)
1523 );
1524 serde_qs_eq!("cell=&ref_cell=&mutex=&rw_lock=", None);
1525 serde_qs_eq!("cell&ref_cell&mutex&rw_lock", None);
1526
1527 serde_qs_err!("=true");
1528 serde_qs_err!("=a");
1529 serde_qs_err!("[a]=");
1530 serde_qs_err!("[]=");
1531
1532 serde_json_eq!(
1533 r#" { "cell":"1","ref_cell":"1","mutex":"1","rw_lock":"1" } "#,
1534 Some(1.0)
1535 );
1536 serde_json_eq!(
1537 r#" { "cell":"-1","ref_cell":"-1","mutex":"-1","rw_lock":"-1" } "#,
1538 Some(-1.0)
1539 );
1540 serde_json_eq!(
1541 r#" { "cell":"0.1","ref_cell":"0.1","mutex":"0.1","rw_lock":"0.1" } "#,
1542 Some(0.1)
1543 );
1544 serde_json_eq!(
1545 r#" { "cell":"-0.1","ref_cell":"-0.1","mutex":"-0.1","rw_lock":"-0.1" } "#,
1546 Some(-0.1)
1547 );
1548 serde_json_eq!(
1549 r#" { "cell":1,"ref_cell":1,"mutex":1,"rw_lock":1 } "#,
1550 Some(1.0)
1551 );
1552 serde_json_eq!(
1553 r#" { "cell":-1,"ref_cell":-1,"mutex":-1,"rw_lock":-1 } "#,
1554 Some(-1.0)
1555 );
1556 serde_json_eq!(
1557 r#" { "cell":0.1,"ref_cell":0.1,"mutex":0.1,"rw_lock":0.1 } "#,
1558 Some(0.1)
1559 );
1560 serde_json_eq!(
1561 r#" { "cell":-0.1,"ref_cell":-0.1,"mutex":-0.1,"rw_lock":-0.1 } "#,
1562 Some(-0.1)
1563 );
1564 serde_json_eq!(
1565 r#" { "cell":"","ref_cell":"","mutex":"","rw_lock":"" } "#,
1566 None
1567 );
1568 serde_json_eq!(
1569 r#" { "cell":null,"ref_cell":null,"mutex":null,"rw_lock":null } "#,
1570 None
1571 );
1572
1573 serde_json_err!(true);
1574 serde_json_err!("a");
1575 serde_json_err!({});
1576 serde_json_err!([]);
1577 }
1578
1579 #[derive(Debug, serde::Deserialize)]
1580 struct TestStruct {
1581 #[serde(default, deserialize_with = "deserialize_option_number_from_string")]
1582 value: Option<f32>,
1583 }
1584
1585 #[test]
1586 fn deserialize_string_variant_valid_number() {
1587 let json = r#"{"value": "4\u0032.5"}"#;
1588 let result: TestStruct = serde_json::from_str(json).unwrap();
1589 assert_eq!(result.value, Some(42.5));
1590 }
1591}