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": "TRUE" }"#;
597/// let a: MyStruct = serde_json::from_str(s).unwrap();
598/// assert!(a.boolean);
599///
600/// let s = r#"{ "boolean": "FALSE" }"#;
601/// let a: MyStruct = serde_json::from_str(s).unwrap();
602/// assert!(!a.boolean);
603///
604/// let s = r#"{ "boolean": "TruE" }"#;
605/// let a: MyStruct = serde_json::from_str(s).unwrap();
606/// assert!(a.boolean);
607///
608/// let s = r#"{ "boolean": "fAlsE" }"#;
609/// let a: MyStruct = serde_json::from_str(s).unwrap();
610/// assert!(!a.boolean);
611///
612/// let s = r#"{ "boolean": "true" }"#;
613/// let a: MyStruct = serde_json::from_str(s).unwrap();
614/// assert!(a.boolean);
615///
616/// let s = r#"{ "boolean": "false" }"#;
617/// let a: MyStruct = serde_json::from_str(s).unwrap();
618/// assert!(!a.boolean);
619///
620/// let s = r#"{ "boolean": "2" }"#;
621/// assert!(serde_json::from_str::<MyStruct>(s).is_err());
622///
623/// let s = r#"{ "boolean": "foo" }"#;
624/// assert!(serde_json::from_str::<MyStruct>(s).is_err());
625/// ```
626pub fn deserialize_bool_from_anything<'de, D>(deserializer: D) -> Result<bool, D::Error>
627where
628 D: Deserializer<'de>,
629{
630 #[derive(Deserialize)]
631 #[serde(untagged)]
632 enum AnythingOrBool {
633 String(String),
634 Int(i64),
635 Float(f64),
636 Boolean(bool),
637 }
638
639 match AnythingOrBool::deserialize(deserializer)? {
640 AnythingOrBool::Boolean(b) => Ok(b),
641 AnythingOrBool::Int(i) => match i {
642 1 => Ok(true),
643 0 => Ok(false),
644 _ => Err(serde::de::Error::custom("The number is neither 1 nor 0")),
645 },
646 AnythingOrBool::Float(f) => {
647 if (f - 1.0f64).abs() < f64::EPSILON {
648 Ok(true)
649 } else if f == 0.0f64 {
650 Ok(false)
651 } else {
652 Err(serde::de::Error::custom(
653 "The number is neither 1.0 nor 0.0",
654 ))
655 }
656 }
657 AnythingOrBool::String(string) => {
658 if let Ok(b) = string.to_lowercase().parse::<bool>() {
659 Ok(b)
660 } else if let Ok(i) = string.parse::<i64>() {
661 match i {
662 1 => Ok(true),
663 0 => Ok(false),
664 _ => Err(serde::de::Error::custom("The number is neither 1 nor 0")),
665 }
666 } else if let Ok(f) = string.parse::<f64>() {
667 if (f - 1.0f64).abs() < f64::EPSILON {
668 Ok(true)
669 } else if f == 0.0f64 {
670 Ok(false)
671 } else {
672 Err(serde::de::Error::custom(
673 "The number is neither 1.0 nor 0.0",
674 ))
675 }
676 } else {
677 Err(serde::de::Error::custom(format!(
678 "Could not parse boolean from a string: {}",
679 string
680 )))
681 }
682 }
683 }
684}
685
686/// Deserializes string from a number. If the original value is a number value,
687/// it will be converted to a string.
688///
689/// # Example:
690///
691/// ```rust
692/// use serde_aux::prelude::*;
693///
694/// #[derive(serde::Deserialize, Debug)]
695/// struct MyStruct {
696/// #[serde(deserialize_with = "deserialize_string_from_number")]
697/// number_as_string: String,
698/// }
699///
700/// let s = r#" { "number_as_string": "foo" } "#;
701/// let a: MyStruct = serde_json::from_str(s).unwrap();
702/// assert_eq!(a.number_as_string, "foo");
703///
704/// let s = r#" { "number_as_string": -13 } "#;
705/// let a: MyStruct = serde_json::from_str(s).unwrap();
706/// assert_eq!(a.number_as_string, "-13");
707///
708/// let s = r#" { "number_as_string": 24.0034 } "#;
709/// let a: MyStruct = serde_json::from_str(s).unwrap();
710/// assert_eq!(a.number_as_string, "24.0034");
711/// ```
712pub fn deserialize_string_from_number<'de, D>(deserializer: D) -> Result<String, D::Error>
713where
714 D: Deserializer<'de>,
715{
716 #[derive(Deserialize)]
717 #[serde(untagged)]
718 enum StringOrNumber {
719 String(String),
720 Number(i64),
721 Float(f64),
722 }
723
724 match StringOrNumber::deserialize(deserializer)? {
725 StringOrNumber::String(s) => Ok(s),
726 StringOrNumber::Number(i) => Ok(i.to_string()),
727 StringOrNumber::Float(f) => Ok(f.to_string()),
728 }
729}
730
731/// Deserializes default value from nullable value. If the original value is `null`,
732/// `Default::default()` is used.
733///
734/// # Example:
735///
736/// ```rust
737/// use serde_aux::prelude::*;
738///
739/// #[derive(serde::Deserialize, Debug)]
740/// struct MyStruct {
741/// #[serde(deserialize_with = "deserialize_default_from_null")]
742/// null_as_default: u64,
743/// }
744///
745/// let s = r#" { "null_as_default": 42 } "#;
746/// let a: MyStruct = serde_json::from_str(s).unwrap();
747/// assert_eq!(a.null_as_default, 42);
748///
749/// let s = r#" { "null_as_default": null } "#;
750/// let a: MyStruct = serde_json::from_str(s).unwrap();
751/// assert_eq!(a.null_as_default, 0);
752///
753/// let s = r#" { "null_as_default": "wrong_type" } "#;
754/// assert!(serde_json::from_str::<MyStruct>(s).is_err());
755/// ```
756pub fn deserialize_default_from_null<'de, D, T>(deserializer: D) -> Result<T, D::Error>
757where
758 D: Deserializer<'de>,
759 T: Deserialize<'de> + Default,
760{
761 Ok(Option::deserialize(deserializer)?.unwrap_or_default())
762}
763
764/// Deserializes default value from nullable value or empty object. If the original value is `null` or `{}`,
765/// `Default::default()` is used.
766///
767/// # Example:
768///
769/// ```rust
770/// use serde_aux::prelude::*;
771///
772/// #[derive(serde::Deserialize, Debug)]
773/// struct MyStruct {
774/// #[serde(deserialize_with = "deserialize_default_from_empty_object")]
775/// empty_as_default: Option<MyInnerStruct>,
776/// }
777///
778/// #[derive(serde::Deserialize, Debug)]
779/// struct MyInnerStruct {
780/// mandatory: u64,
781/// }
782///
783/// let s = r#" { "empty_as_default": { "mandatory": 42 } } "#;
784/// let a: MyStruct = serde_json::from_str(s).unwrap();
785/// assert_eq!(a.empty_as_default.unwrap().mandatory, 42);
786///
787/// let s = r#" { "empty_as_default": null } "#;
788/// let a: MyStruct = serde_json::from_str(s).unwrap();
789/// assert!(a.empty_as_default.is_none());
790///
791/// let s = r#" { "empty_as_default": {} } "#;
792/// let a: MyStruct = serde_json::from_str(s).unwrap();
793/// assert!(a.empty_as_default.is_none());
794///
795/// let s = r#" { "empty_as_default": { "unknown": 42 } } "#;
796/// assert!(serde_json::from_str::<MyStruct>(s).is_err());
797/// ```
798pub fn deserialize_default_from_empty_object<'de, D, T>(deserializer: D) -> Result<T, D::Error>
799where
800 D: Deserializer<'de>,
801 T: Deserialize<'de> + Default,
802{
803 #[derive(Debug, Deserialize)]
804 #[serde(deny_unknown_fields)]
805 struct EmptyObject {}
806
807 #[derive(Debug, Deserialize)]
808 #[serde(untagged)]
809 enum EmptyOrNot<Y> {
810 NonEmpty(Y),
811 Empty(EmptyObject),
812 Null,
813 }
814
815 let empty_or_not: EmptyOrNot<T> = EmptyOrNot::deserialize(deserializer)?;
816
817 match empty_or_not {
818 EmptyOrNot::NonEmpty(e) => Ok(e),
819 _ => Ok(T::default()),
820 }
821}
822
823/// Deserializes a comma separated string into a `Vec<T>`.
824///
825/// # Example:
826///
827/// ```rust
828/// use serde_aux::prelude::*;
829///
830/// #[derive(serde::Deserialize, Debug)]
831/// struct MyStruct {
832/// #[serde(deserialize_with = "deserialize_vec_from_string_or_vec")]
833/// list: Vec<i32>,
834/// }
835///
836/// let s = r#" { "list": "1,2,3,4" } "#;
837/// let a: MyStruct = serde_json::from_str(s).unwrap();
838/// assert_eq!(&a.list, &[1, 2, 3, 4]);
839///
840/// let s = r#" { "list": [1,2,3,4] } "#;
841/// let a: MyStruct = serde_json::from_str(s).unwrap();
842/// assert_eq!(&a.list, &[1, 2, 3, 4]);
843/// ```
844pub fn deserialize_vec_from_string_or_vec<'de, T, D>(deserializer: D) -> Result<Vec<T>, D::Error>
845where
846 D: Deserializer<'de>,
847 T: FromStr + Deserialize<'de> + 'static,
848 <T as FromStr>::Err: std::fmt::Display,
849{
850 StringOrVecToVec::default().into_deserializer()(deserializer)
851}
852
853/// Deserialize to primary or fallback type.
854///
855/// This helper function will attempt to deserialize to the primary type first,
856/// and if that fails it will attempt to deserialize to the fallback type. If
857/// both fail, it will return an error.
858///
859/// # Example:
860///
861/// ```rust
862/// use serde_aux::prelude::*;
863///
864/// #[derive(serde::Deserialize, Debug)]
865/// struct MyStruct {
866/// #[serde(deserialize_with = "deserialize_to_type_or_fallback")]
867/// i64_or_f64: Result<i64, f64>,
868/// #[serde(deserialize_with = "deserialize_to_type_or_fallback")]
869/// f64_or_string: Result<f64, String>,
870/// }
871///
872/// let s = r#" { "i64_or_f64": 1, "f64_or_string": 1 } "#;
873/// let a: MyStruct = serde_json::from_str(s).unwrap();
874/// assert_eq!(a.i64_or_f64, Ok(1));
875/// assert_eq!(a.f64_or_string, Ok(1.0));
876///
877/// let s = r#" { "i64_or_f64": 1.0, "f64_or_string": 1.0 } "#;
878/// let a: MyStruct = serde_json::from_str(s).unwrap();
879/// assert_eq!(a.i64_or_f64, Err(1.0));
880/// assert_eq!(a.f64_or_string, Ok(1.0));
881///
882/// let s = r#" { "i64_or_f64": 1.0, "f64_or_string": "foo" } "#;
883/// let a: MyStruct = serde_json::from_str(s).unwrap();
884/// assert_eq!(a.i64_or_f64, Err(1.0));
885/// assert_eq!(a.f64_or_string, Err(String::from("foo")));
886///
887/// let s = r#" { "i64_or_f64": "foo", "f64_or_string": "foo" } "#;
888/// assert!(serde_json::from_str::<MyStruct>(s).is_err());
889/// ```
890pub fn deserialize_to_type_or_fallback<'de, D, T, F>(
891 deserializer: D,
892) -> Result<Result<T, F>, D::Error>
893where
894 D: Deserializer<'de>,
895 T: Deserialize<'de>,
896 F: Deserialize<'de>,
897{
898 #[derive(Deserialize)]
899 #[serde(untagged)]
900 enum DeEither<T, F> {
901 Type(T),
902 Fallback(F),
903 }
904
905 DeEither::<T, F>::deserialize(deserializer).map(|de| match de {
906 DeEither::Type(t) => Ok(t),
907 DeEither::Fallback(f) => Err(f),
908 })
909}
910
911/// Deserialize to a given type, while ignoring any invalid fields.
912///
913/// This helper function will attempt to deserialize to the given type, and if
914/// it fails it will return `None`, therefore never failing. This is different
915/// from deserializing directly to `Option<T>`, because this would return `None`
916/// only for empty fields, while it would return an error for invalid fields.
917///
918/// # Example:
919///
920/// ```rust
921/// use serde_aux::prelude::*;
922///
923/// #[derive(serde::Deserialize, Debug)]
924/// struct MyStruct {
925/// #[serde(deserialize_with = "deserialize_to_type_or_none")]
926/// opt_f64: Option<f64>,
927/// }
928///
929/// let s = r#" { "opt_f64": 1 } "#;
930/// let a: MyStruct = serde_json::from_str(s).unwrap();
931/// assert_eq!(a.opt_f64, Some(1.0));
932///
933/// let s = r#" { "opt_f64": 1.0 } "#;
934/// let a: MyStruct = serde_json::from_str(s).unwrap();
935/// assert_eq!(a.opt_f64, Some(1.0));
936///
937/// let s = r#" { "opt_f64": "foo" } "#;
938/// let a: MyStruct = serde_json::from_str(s).unwrap();
939/// assert_eq!(a.opt_f64, None);
940/// ```
941pub fn deserialize_to_type_or_none<'de, D, T>(deserializer: D) -> Result<Option<T>, D::Error>
942where
943 D: Deserializer<'de>,
944 Option<T>: Deserialize<'de>,
945{
946 Option::<T>::deserialize(deserializer).or_else(|_| Ok(None))
947}
948
949/// Deserialize to a given type, while returning invalid fields as `String`.
950///
951/// This helper function will attempt to deserialize to the given type, and if
952/// it fails it will return the invalid field lossily converted to `String`,
953/// therefore never failing.
954///
955/// # Example:
956///
957/// ```rust
958/// use serde_aux::prelude::*;
959///
960/// #[derive(serde::Deserialize, Debug)]
961/// struct MyStruct {
962/// #[serde(deserialize_with = "deserialize_to_type_or_string_lossy")]
963/// f64_or_string_lossy: Result<f64, String>,
964/// }
965///
966/// let s = r#" { "f64_or_string_lossy": 1 } "#;
967/// let a: MyStruct = serde_json::from_str(s).unwrap();
968/// assert_eq!(a.f64_or_string_lossy, Ok(1.0));
969///
970/// let s = r#" { "f64_or_string_lossy": 1.0 } "#;
971/// let a: MyStruct = serde_json::from_str(s).unwrap();
972/// assert_eq!(a.f64_or_string_lossy, Ok(1.0));
973///
974/// let s = r#" { "f64_or_string_lossy": "foo" } "#;
975/// let a: MyStruct = serde_json::from_str(s).unwrap();
976/// assert_eq!(a.f64_or_string_lossy, Err(String::from("foo")));
977/// ```
978pub fn deserialize_to_type_or_string_lossy<'de, D, T>(
979 deserializer: D,
980) -> Result<Result<T, String>, D::Error>
981where
982 D: Deserializer<'de>,
983 T: Deserialize<'de>,
984{
985 let value = serde_value::Value::deserialize(deserializer)?;
986 Ok(T::deserialize(value.clone()).map_err(|_| match value {
987 serde_value::Value::Bool(b) => b.to_string(),
988 serde_value::Value::U8(u) => u.to_string(),
989 serde_value::Value::U16(u) => u.to_string(),
990 serde_value::Value::U32(u) => u.to_string(),
991 serde_value::Value::U64(u) => u.to_string(),
992 serde_value::Value::I8(i) => i.to_string(),
993 serde_value::Value::I16(i) => i.to_string(),
994 serde_value::Value::I32(i) => i.to_string(),
995 serde_value::Value::I64(i) => i.to_string(),
996 serde_value::Value::F32(f) => f.to_string(),
997 serde_value::Value::F64(f) => f.to_string(),
998 serde_value::Value::Char(c) => c.to_string(),
999 serde_value::Value::String(s) => s,
1000 serde_value::Value::Unit => String::new(),
1001 serde_value::Value::Option(opt) => {
1002 format!("{:?}", opt)
1003 }
1004 serde_value::Value::Newtype(nt) => {
1005 format!("{:?}", nt)
1006 }
1007 serde_value::Value::Seq(seq) => format!("{:?}", seq),
1008 serde_value::Value::Map(map) => format!("{:?}", map),
1009 serde_value::Value::Bytes(v) => String::from_utf8_lossy(&v).into_owned(),
1010 }))
1011}
1012
1013/// Create a parser quickly.
1014///
1015/// ```
1016/// use serde_aux::prelude::*;
1017/// use std::str::FromStr;
1018///
1019/// serde_aux::StringOrVecToVecParser!(parse_between_commas, |c| { c == ',' }, true);
1020///
1021/// #[derive(serde::Deserialize, Debug)]
1022/// struct MyStruct {
1023/// #[serde(deserialize_with = "parse_between_commas")]
1024/// list: Vec<i32>,
1025/// }
1026///
1027/// let s = r#" { "list": "1,2,3,4" } "#;
1028/// let a: MyStruct = serde_json::from_str(s).unwrap();
1029/// assert_eq!(&a.list, &[1, 2, 3, 4]);
1030///
1031/// let s = r#" { "list": [1,2,3,4] } "#;
1032/// let a: MyStruct = serde_json::from_str(s).unwrap();
1033/// assert_eq!(&a.list, &[1, 2, 3, 4]);
1034///
1035///
1036/// serde_aux::StringOrVecToVecParser!(u8, parse_hex_with_spaces, ' ', |s| { u8::from_str_radix(s, 16) }, true);
1037///
1038/// #[derive(serde::Deserialize, Debug)]
1039/// struct MyStructHex {
1040/// #[serde(deserialize_with = "parse_hex_with_spaces")]
1041/// list: Vec<u8>,
1042/// }
1043///
1044/// let s = r#" { "list": "a1 b2 c3 d4 " } "#;
1045/// let a: MyStructHex = serde_json::from_str(s).unwrap();
1046/// assert_eq!(&a.list, &[0xa1, 0xb2, 0xc3, 0xd4]);
1047///
1048/// let s = r#" { "list": "a1 b2 c3 d4 " } "#;
1049/// let a: MyStructHex = serde_json::from_str(s).unwrap();
1050/// assert_eq!(&a.list, &[0xa1, 0xb2, 0xc3, 0xd4]);
1051/// ```
1052#[macro_export]
1053macro_rules! StringOrVecToVecParser {
1054 ($name:ident, $separator:expr, $skip_empty:expr) => {
1055 fn $name<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
1056 where
1057 D: serde::Deserializer<'de>,
1058 T: FromStr + serde::Deserialize<'de> + 'static,
1059 <T as FromStr>::Err: std::fmt::Display,
1060 {
1061 let mut parser = $crate::field_attributes::StringOrVecToVec::with_separator($separator);
1062 parser.skip_empty($skip_empty);
1063 parser.into_deserializer()(deserializer)
1064 }
1065 };
1066
1067 ($t:ty, $name:ident, $pattern:expr, $converter:expr, $skip_empty:expr) => {
1068 fn $name<'de, D>(deserializer: D) -> Result<Vec<$t>, D::Error>
1069 where
1070 D: serde::Deserializer<'de>,
1071 {
1072 $crate::field_attributes::StringOrVecToVec::new($pattern, $converter, $skip_empty)
1073 .into_deserializer()(deserializer)
1074 }
1075 };
1076}
1077
1078/// Builder to create a parser, that parses a separated string or a vec into a vec.
1079///
1080/// # Example:
1081///
1082/// ```rust
1083/// use serde_aux::prelude::*;
1084/// use std::str::FromStr;
1085///
1086/// fn parser<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
1087/// where
1088/// D: serde::Deserializer<'de>,
1089/// T: FromStr + serde::Deserialize<'de> + 'static,
1090/// <T as FromStr>::Err: std::fmt::Display,
1091/// {
1092/// StringOrVecToVec::default().into_deserializer()(deserializer)
1093/// }
1094///
1095/// #[derive(serde::Deserialize, Debug)]
1096/// struct MyStruct {
1097/// #[serde(deserialize_with = "parser")]
1098/// list: Vec<i32>,
1099/// }
1100///
1101/// let s = r#" { "list": "1,2,3,4" } "#;
1102/// let a: MyStruct = serde_json::from_str(s).unwrap();
1103/// assert_eq!(&a.list, &[1, 2, 3, 4]);
1104///
1105/// let s = r#" { "list": [1,2,3,4] } "#;
1106/// let a: MyStruct = serde_json::from_str(s).unwrap();
1107/// assert_eq!(&a.list, &[1, 2, 3, 4]);
1108pub struct StringOrVecToVec<'a, T, E> {
1109 separator: Pattern<'a>,
1110 parser: Box<StringOrVecParser<T, E>>,
1111 skip_empty: bool,
1112}
1113
1114/// A functor returning a [`Result`] of parsing a string into a vector
1115/// of objects of type `T`.
1116pub type StringOrVecParser<T, E> = dyn FnMut(&str) -> Result<T, E>;
1117
1118/// Pattern on which a string can be split.
1119pub enum Pattern<'a> {
1120 /// Split on a matching char
1121 Char(char),
1122 /// Split on a matching str
1123 Str(&'a str),
1124 /// Split if a char matches the predicate
1125 Pred(Box<dyn Fn(char) -> bool>),
1126 /// Multiple patterns
1127 ///
1128 /// # Example
1129 ///
1130 /// ```rust
1131 /// use serde_aux::prelude::*;
1132 /// use std::str::FromStr;
1133 ///
1134 /// fn parser<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
1135 /// where
1136 /// D: serde::Deserializer<'de>,
1137 /// T: FromStr + serde::Deserialize<'de> + 'static,
1138 /// <T as FromStr>::Err: std::fmt::Display,
1139 /// {
1140 /// StringOrVecToVec::with_separator(vec![Pattern::Char('+'), Pattern::Char('-')]).into_deserializer()(deserializer)
1141 /// }
1142 ///
1143 /// #[derive(serde::Deserialize, Debug)]
1144 /// struct MyStruct {
1145 /// #[serde(deserialize_with = "parser")]
1146 /// list: Vec<i32>,
1147 /// }
1148 ///
1149 /// let s = r#" { "list": "1-2+3-4" } "#;
1150 /// let a: MyStruct = serde_json::from_str(s).unwrap();
1151 /// assert_eq!(&a.list, &[1, 2, 3, 4]);
1152 ///
1153 /// let s = r#" { "list": [1,2,3,4] } "#;
1154 /// let a: MyStruct = serde_json::from_str(s).unwrap();
1155 /// assert_eq!(&a.list, &[1, 2, 3, 4]);
1156 /// ```
1157 Multiple(Vec<Pattern<'a>>),
1158}
1159
1160impl From<char> for Pattern<'_> {
1161 fn from(c: char) -> Self {
1162 Pattern::Char(c)
1163 }
1164}
1165
1166impl<'a> From<&'a str> for Pattern<'a> {
1167 fn from(s: &'a str) -> Self {
1168 Pattern::Str(s)
1169 }
1170}
1171
1172impl<'a> From<Vec<Pattern<'a>>> for Pattern<'a> {
1173 fn from(patterns: Vec<Pattern<'a>>) -> Self {
1174 Pattern::Multiple(patterns)
1175 }
1176}
1177
1178/// # Example
1179///
1180/// ```rust
1181/// use serde_aux::prelude::*;
1182/// use std::str::FromStr;
1183///
1184/// fn parser<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
1185/// where
1186/// D: serde::Deserializer<'de>,
1187/// T: FromStr + serde::Deserialize<'de> + 'static,
1188/// <T as FromStr>::Err: std::fmt::Display,
1189/// {
1190/// StringOrVecToVec::with_separator(vec!['-', '+'].into_iter().collect::<Pattern>()).into_deserializer()(deserializer)
1191/// }
1192///
1193/// #[derive(serde::Deserialize, Debug)]
1194/// struct MyStruct {
1195/// #[serde(deserialize_with = "parser")]
1196/// list: Vec<i32>,
1197/// }
1198///
1199/// let s = r#" { "list": "1-2+3-4" } "#;
1200/// let a: MyStruct = serde_json::from_str(s).unwrap();
1201/// assert_eq!(&a.list, &[1, 2, 3, 4]);
1202///
1203/// let s = r#" { "list": [1,2,3,4] } "#;
1204/// let a: MyStruct = serde_json::from_str(s).unwrap();
1205/// assert_eq!(&a.list, &[1, 2, 3, 4]);
1206/// ```
1207impl<'a> std::iter::FromIterator<Pattern<'a>> for Pattern<'a> {
1208 fn from_iter<I>(iter: I) -> Self
1209 where
1210 I: IntoIterator<Item = Pattern<'a>>,
1211 {
1212 Pattern::Multiple(iter.into_iter().collect())
1213 }
1214}
1215
1216impl std::iter::FromIterator<char> for Pattern<'_> {
1217 fn from_iter<I>(iter: I) -> Self
1218 where
1219 I: IntoIterator<Item = char>,
1220 {
1221 Pattern::Multiple(iter.into_iter().map(Pattern::from).collect())
1222 }
1223}
1224
1225impl<'a> std::iter::FromIterator<&'a str> for Pattern<'a> {
1226 fn from_iter<I>(iter: I) -> Self
1227 where
1228 I: IntoIterator<Item = &'a str>,
1229 {
1230 Pattern::Multiple(iter.into_iter().map(Pattern::from).collect())
1231 }
1232}
1233
1234impl<P> From<P> for Pattern<'_>
1235where
1236 P: Fn(char) -> bool + 'static,
1237{
1238 fn from(pred: P) -> Self {
1239 Pattern::Pred(Box::new(pred))
1240 }
1241}
1242
1243impl<'de, T> Default for StringOrVecToVec<'_, T, T::Err>
1244where
1245 T: FromStr + Deserialize<'de> + 'static,
1246 <T as FromStr>::Err: std::fmt::Display,
1247{
1248 fn default() -> Self {
1249 Self::new(|c| c == ',', T::from_str, false)
1250 }
1251}
1252
1253impl<'a, 'de, T> StringOrVecToVec<'a, T, T::Err>
1254where
1255 T: FromStr + Deserialize<'de> + 'static,
1256 <T as FromStr>::Err: std::fmt::Display,
1257{
1258 /// Create a `StringOrVecToVec` builder with a custom separator. `T::from_str` is used to parse
1259 /// the elements of the list.
1260 ///
1261 /// # Example:
1262 ///
1263 /// ```rust
1264 /// use serde_aux::prelude::*;
1265 /// use std::str::FromStr;
1266 ///
1267 /// fn parser<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
1268 /// where
1269 /// D: serde::Deserializer<'de>,
1270 /// T: FromStr + serde::Deserialize<'de> + 'static,
1271 /// <T as FromStr>::Err: std::fmt::Display,
1272 /// {
1273 /// StringOrVecToVec::with_separator(|c| c == '-' || c == '+').into_deserializer()(deserializer)
1274 /// }
1275 ///
1276 /// #[derive(serde::Deserialize, Debug)]
1277 /// struct MyStruct {
1278 /// #[serde(deserialize_with = "parser")]
1279 /// list: Vec<i32>,
1280 /// }
1281 ///
1282 /// let s = r#" { "list": "1-2+3-4" } "#;
1283 /// let a: MyStruct = serde_json::from_str(s).unwrap();
1284 /// assert_eq!(&a.list, &[1, 2, 3, 4]);
1285 ///
1286 /// let s = r#" { "list": [1,2,3,4] } "#;
1287 /// let a: MyStruct = serde_json::from_str(s).unwrap();
1288 /// assert_eq!(&a.list, &[1, 2, 3, 4]);
1289 /// ```
1290 pub fn with_separator(separator: impl Into<Pattern<'a>>) -> Self {
1291 Self::new(separator, T::from_str, false)
1292 }
1293
1294 /// Sets the flag to skip empty separations.
1295 ///
1296 /// ```rust
1297 /// use serde_aux::prelude::*;
1298 /// use std::str::FromStr;
1299 ///
1300 /// fn parser_skip_empty<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
1301 /// where
1302 /// D: serde::Deserializer<'de>,
1303 /// T: FromStr + serde::Deserialize<'de> + 'static,
1304 /// <T as FromStr>::Err: std::fmt::Display,
1305 /// {
1306 /// let mut parser = StringOrVecToVec::with_separator(|c| c == '-' || c == '+');
1307 /// parser.skip_empty(true);
1308 /// parser.into_deserializer()(deserializer)
1309 /// }
1310 ///
1311 /// #[derive(serde::Deserialize, Debug)]
1312 /// struct MyStructSkipEmpty {
1313 /// #[serde(deserialize_with = "parser_skip_empty")]
1314 /// list: Vec<i32>,
1315 /// }
1316 ///
1317 /// let s = r#" { "list": "1-2+3-4--++--" } "#;
1318 /// let a: MyStructSkipEmpty = serde_json::from_str(s).unwrap();
1319 /// assert_eq!(&a.list, &[1, 2, 3, 4]);
1320 /// ```
1321 pub fn skip_empty(&mut self, skip_empty: bool) -> &mut Self {
1322 self.skip_empty = skip_empty;
1323 self
1324 }
1325}
1326
1327impl<'a, T, E> StringOrVecToVec<'a, T, E> {
1328 /// Create a deserializer with a custom separator and parsing function.
1329 ///
1330 /// # Example:
1331 ///
1332 /// ```rust
1333 /// use serde_aux::prelude::*;
1334 /// use std::str::FromStr;
1335 ///
1336 /// fn parser<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
1337 /// where
1338 /// D: serde::Deserializer<'de>,
1339 /// T: FromStr + serde::Deserialize<'de> + 'static,
1340 /// <T as FromStr>::Err: std::fmt::Display,
1341 /// {
1342 /// StringOrVecToVec::new('-', |s| s.trim().parse(), false).into_deserializer()(deserializer)
1343 /// }
1344 ///
1345 /// #[derive(serde::Deserialize, Debug)]
1346 /// struct MyStruct {
1347 /// #[serde(deserialize_with = "parser")]
1348 /// list: Vec<i32>,
1349 /// }
1350 ///
1351 /// let s = r#" { "list": "1 - 2 - 3- 4 " } "#;
1352 /// let a: MyStruct = serde_json::from_str(s).unwrap();
1353 /// assert_eq!(&a.list, &[1, 2, 3, 4]);
1354 ///
1355 /// let s = r#" { "list": [1,2,3,4] } "#;
1356 /// let a: MyStruct = serde_json::from_str(s).unwrap();
1357 /// assert_eq!(&a.list, &[1, 2, 3, 4]);
1358 /// ```
1359 pub fn new(
1360 separator: impl Into<Pattern<'a>>,
1361 parser: impl FnMut(&str) -> Result<T, E> + 'static,
1362 skip_empty: bool,
1363 ) -> Self {
1364 Self {
1365 separator: separator.into(),
1366 parser: Box::new(parser),
1367 skip_empty,
1368 }
1369 }
1370
1371 /// Create a deserializer with a custom parsing function. The input string will be separated on
1372 /// `,`.
1373 ///
1374 /// # Example:
1375 ///
1376 /// ```rust
1377 /// use serde_aux::prelude::*;
1378 /// use std::str::FromStr;
1379 ///
1380 /// fn parser<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
1381 /// where
1382 /// D: serde::Deserializer<'de>,
1383 /// T: FromStr + serde::Deserialize<'de> + 'static,
1384 /// <T as FromStr>::Err: std::fmt::Display,
1385 /// {
1386 /// StringOrVecToVec::with_parser(|s| s.trim().parse()).into_deserializer()(deserializer)
1387 /// }
1388 ///
1389 /// #[derive(serde::Deserialize, Debug)]
1390 /// struct MyStruct {
1391 /// #[serde(deserialize_with = "parser")]
1392 /// list: Vec<i32>,
1393 /// }
1394 ///
1395 /// let s = r#" { "list": "1 , 2 , 3, 4 " } "#;
1396 /// let a: MyStruct = serde_json::from_str(s).unwrap();
1397 /// assert_eq!(&a.list, &[1, 2, 3, 4]);
1398 ///
1399 /// let s = r#" { "list": [1,2,3,4] } "#;
1400 /// let a: MyStruct = serde_json::from_str(s).unwrap();
1401 /// assert_eq!(&a.list, &[1, 2, 3, 4]);
1402 /// ```
1403 pub fn with_parser(parser: impl FnMut(&str) -> Result<T, E> + 'static) -> Self {
1404 Self::new(|c| c == ',', parser, false)
1405 }
1406
1407 /// Creates the actual deserializer from this builder.
1408 pub fn into_deserializer<'de, D>(
1409 self,
1410 ) -> impl FnMut(D) -> Result<Vec<T>, <D as Deserializer<'de>>::Error>
1411 where
1412 'a: 'de,
1413 D: Deserializer<'de>,
1414 T: Deserialize<'de>,
1415 E: std::fmt::Display,
1416 {
1417 #[derive(Deserialize)]
1418 #[serde(untagged)]
1419 enum StringOrVec<T> {
1420 String(String),
1421 Vec(Vec<T>),
1422 }
1423
1424 let StringOrVecToVec {
1425 mut parser,
1426 separator,
1427 skip_empty,
1428 } = self;
1429
1430 move |deserializer| match StringOrVec::<T>::deserialize(deserializer)? {
1431 StringOrVec::String(s) => Ok(separator
1432 .split(&s)
1433 .into_iter()
1434 .filter(|s| {
1435 if skip_empty && s.is_empty() {
1436 return false;
1437 }
1438 true
1439 })
1440 .map(&mut parser)
1441 .collect::<Result<Vec<_>, _>>()
1442 .map_err(serde::de::Error::custom)?),
1443 StringOrVec::Vec(v) => Ok(v),
1444 }
1445 }
1446}
1447
1448impl Pattern<'_> {
1449 fn split<'b>(&self, input: &'b str) -> Vec<&'b str> {
1450 match self {
1451 Pattern::Char(c) => input.split(*c).collect(),
1452 Pattern::Str(s) => input.split(s).collect(),
1453 Pattern::Pred(p) => input.split(p).collect(),
1454 Pattern::Multiple(patterns) => {
1455 let mut split = vec![input];
1456 for pattern in patterns {
1457 let delete_until = split.len();
1458 let mut new_split = Vec::new();
1459 for s in &split {
1460 new_split.append(&mut pattern.split(s));
1461 }
1462
1463 if !new_split.is_empty() {
1464 split = split.split_off(delete_until);
1465 }
1466
1467 split.append(&mut new_split);
1468 }
1469 split
1470 }
1471 }
1472 }
1473}
1474
1475#[cfg(test)]
1476mod tests {
1477 use crate::prelude::*;
1478 use std::{
1479 cell::{Cell, RefCell},
1480 sync::{Mutex, RwLock},
1481 };
1482 #[derive(Debug, serde::Deserialize)]
1483 struct MyStruct {
1484 #[serde(
1485 default,
1486 deserialize_with = "deserialize_cell_option_number_from_string"
1487 )]
1488 cell: Cell<Option<f32>>,
1489 #[serde(
1490 default,
1491 deserialize_with = "deserialize_ref_cell_option_number_from_string"
1492 )]
1493 ref_cell: RefCell<Option<f32>>,
1494 #[serde(
1495 default,
1496 deserialize_with = "deserialize_mutex_option_number_from_string"
1497 )]
1498 mutex: Mutex<Option<f32>>,
1499 #[serde(
1500 default,
1501 deserialize_with = "deserialize_rw_lock_option_number_from_string"
1502 )]
1503 rw_lock: RwLock<Option<f32>>,
1504 }
1505 macro_rules! serde_qs_eq {
1506 ($s:literal, $result:expr) => {
1507 let a: MyStruct = serde_qs::from_str($s).unwrap();
1508 assert_eq!(a.cell, Cell::new($result));
1509 assert_eq!(a.ref_cell, RefCell::new($result));
1510 assert_eq!(*a.mutex.lock().unwrap(), $result);
1511 assert_eq!(*a.rw_lock.read().unwrap(), $result);
1512 };
1513 }
1514 macro_rules! serde_qs_err {
1515 ($rest:literal) => {
1516 assert!(serde_qs::from_str::<MyStruct>(concat!("cell", $rest)).is_err());
1517 assert!(serde_qs::from_str::<MyStruct>(concat!("ref_cell", $rest)).is_err());
1518 assert!(serde_qs::from_str::<MyStruct>(concat!("mutex", $rest)).is_err());
1519 assert!(serde_qs::from_str::<MyStruct>(concat!("rw_lock", $rest)).is_err());
1520 };
1521 }
1522 macro_rules! serde_json_eq {
1523 ($s:literal, $result:expr) => {
1524 let a: MyStruct = serde_json::from_str($s).unwrap();
1525 assert_eq!(a.cell, Cell::new($result));
1526 assert_eq!(a.ref_cell, RefCell::new($result));
1527 assert_eq!(*a.mutex.lock().unwrap(), $result);
1528 assert_eq!(*a.rw_lock.read().unwrap(), $result);
1529 };
1530 }
1531 macro_rules! serde_json_err {
1532 ($v:tt) => {
1533 assert!(serde_json::from_str::<MyStruct>(r#" { "cell": $v } "#).is_err());
1534 assert!(serde_json::from_str::<MyStruct>(r#" { "ref_cell": $v } "#).is_err());
1535 assert!(serde_json::from_str::<MyStruct>(r#" { "mutex": $v } "#).is_err());
1536 assert!(serde_json::from_str::<MyStruct>(r#" { "rw_lock": $v } "#).is_err());
1537 };
1538 }
1539 #[test]
1540 fn test_deserialize_wrap_option_number_from_string() {
1541 serde_qs_eq!("cell=1&ref_cell=1&mutex=1&rw_lock=1", Some(1.0));
1542 serde_qs_eq!("cell=-1&ref_cell=-1&mutex=-1&rw_lock=-1", Some(-1.0));
1543 serde_qs_eq!("cell=0.1&ref_cell=0.1&mutex=0.1&rw_lock=0.1", Some(0.1));
1544 serde_qs_eq!(
1545 "cell=-0.1&ref_cell=-0.1&mutex=-0.1&rw_lock=-0.1",
1546 Some(-0.1)
1547 );
1548 serde_qs_eq!("cell=&ref_cell=&mutex=&rw_lock=", None);
1549 serde_qs_eq!("cell&ref_cell&mutex&rw_lock", None);
1550
1551 serde_qs_err!("=true");
1552 serde_qs_err!("=a");
1553 serde_qs_err!("[a]=");
1554 serde_qs_err!("[]=");
1555
1556 serde_json_eq!(
1557 r#" { "cell":"1","ref_cell":"1","mutex":"1","rw_lock":"1" } "#,
1558 Some(1.0)
1559 );
1560 serde_json_eq!(
1561 r#" { "cell":"-1","ref_cell":"-1","mutex":"-1","rw_lock":"-1" } "#,
1562 Some(-1.0)
1563 );
1564 serde_json_eq!(
1565 r#" { "cell":"0.1","ref_cell":"0.1","mutex":"0.1","rw_lock":"0.1" } "#,
1566 Some(0.1)
1567 );
1568 serde_json_eq!(
1569 r#" { "cell":"-0.1","ref_cell":"-0.1","mutex":"-0.1","rw_lock":"-0.1" } "#,
1570 Some(-0.1)
1571 );
1572 serde_json_eq!(
1573 r#" { "cell":1,"ref_cell":1,"mutex":1,"rw_lock":1 } "#,
1574 Some(1.0)
1575 );
1576 serde_json_eq!(
1577 r#" { "cell":-1,"ref_cell":-1,"mutex":-1,"rw_lock":-1 } "#,
1578 Some(-1.0)
1579 );
1580 serde_json_eq!(
1581 r#" { "cell":0.1,"ref_cell":0.1,"mutex":0.1,"rw_lock":0.1 } "#,
1582 Some(0.1)
1583 );
1584 serde_json_eq!(
1585 r#" { "cell":-0.1,"ref_cell":-0.1,"mutex":-0.1,"rw_lock":-0.1 } "#,
1586 Some(-0.1)
1587 );
1588 serde_json_eq!(
1589 r#" { "cell":"","ref_cell":"","mutex":"","rw_lock":"" } "#,
1590 None
1591 );
1592 serde_json_eq!(
1593 r#" { "cell":null,"ref_cell":null,"mutex":null,"rw_lock":null } "#,
1594 None
1595 );
1596
1597 serde_json_err!(true);
1598 serde_json_err!("a");
1599 serde_json_err!({});
1600 serde_json_err!([]);
1601 }
1602
1603 #[derive(Debug, serde::Deserialize)]
1604 struct TestStruct {
1605 #[serde(default, deserialize_with = "deserialize_option_number_from_string")]
1606 value: Option<f32>,
1607 }
1608
1609 #[test]
1610 fn deserialize_string_variant_valid_number() {
1611 let json = r#"{"value": "4\u0032.5"}"#;
1612 let result: TestStruct = serde_json::from_str(json).unwrap();
1613 assert_eq!(result.value, Some(42.5));
1614 }
1615}