1#[allow(unused)]
2use alloc::{string::String, vec::Vec};
3#[allow(unused)]
4use core::{
5 fmt::{self, Formatter},
6 marker::PhantomData,
7};
8
9#[allow(unused)]
10use serde::de::{Deserializer, Error as DeError, Visitor};
11
12#[allow(unused)]
13use super::Result;
14#[allow(unused)]
15use crate::{errors::*, traits::*};
16
17#[cfg(feature = "base32")]
18impl<'de, T: ValidateString<Error = Base32Error> + ValidateBytes<Error = Base32Error>>
19 serde::Deserialize<'de> for Result<T, Base32Error>
20{
21 #[inline]
22 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
23 where
24 D: Deserializer<'de>, {
25 struct MyVisitor<T>(PhantomData<T>);
26
27 impl<'de, T: ValidateString<Error = Base32Error> + ValidateBytes<Error = Base32Error>>
28 Visitor<'de> for MyVisitor<T>
29 {
30 type Value = Result<T, Base32Error>;
31
32 #[inline]
33 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
34 f.write_str("Base32Error")
35 }
36
37 #[inline]
38 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
39 where
40 E: DeError, {
41 Ok(Result::new(T::parse_str(v)))
42 }
43
44 #[inline]
45 fn visit_string<E>(self, v: String) -> core::result::Result<Self::Value, E>
46 where
47 E: DeError, {
48 Ok(Result::new(T::parse_string(v)))
49 }
50
51 #[inline]
52 fn visit_bytes<E>(self, v: &[u8]) -> core::result::Result<Self::Value, E>
53 where
54 E: DeError, {
55 Ok(Result::new(T::parse_u8_slice(v)))
56 }
57
58 #[inline]
59 fn visit_byte_buf<E>(self, v: Vec<u8>) -> core::result::Result<Self::Value, E>
60 where
61 E: DeError, {
62 Ok(Result::new(T::parse_vec_u8(v)))
63 }
64 }
65
66 deserializer.deserialize_any(MyVisitor(PhantomData))
67 }
68}
69
70#[cfg(feature = "base32_decoded")]
71impl<
72 'de,
73 T: ValidateString<Error = Base32DecodedError> + ValidateBytes<Error = Base32DecodedError>,
74 > serde::Deserialize<'de> for Result<T, Base32DecodedError>
75{
76 #[inline]
77 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
78 where
79 D: Deserializer<'de>, {
80 struct MyVisitor<T>(PhantomData<T>);
81
82 impl<
83 'de,
84 T: ValidateString<Error = Base32DecodedError>
85 + ValidateBytes<Error = Base32DecodedError>,
86 > Visitor<'de> for MyVisitor<T>
87 {
88 type Value = Result<T, Base32DecodedError>;
89
90 #[inline]
91 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
92 f.write_str("Base32DecodedError")
93 }
94
95 #[inline]
96 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
97 where
98 E: DeError, {
99 Ok(Result::new(T::parse_str(v)))
100 }
101
102 #[inline]
103 fn visit_string<E>(self, v: String) -> core::result::Result<Self::Value, E>
104 where
105 E: DeError, {
106 Ok(Result::new(T::parse_string(v)))
107 }
108
109 #[inline]
110 fn visit_bytes<E>(self, v: &[u8]) -> core::result::Result<Self::Value, E>
111 where
112 E: DeError, {
113 Ok(Result::new(T::parse_u8_slice(v)))
114 }
115
116 #[inline]
117 fn visit_byte_buf<E>(self, v: Vec<u8>) -> core::result::Result<Self::Value, E>
118 where
119 E: DeError, {
120 Ok(Result::new(T::parse_vec_u8(v)))
121 }
122 }
123
124 deserializer.deserialize_any(MyVisitor(PhantomData))
125 }
126}
127
128#[cfg(feature = "base64")]
129impl<'de, T: ValidateString<Error = Base64Error> + ValidateBytes<Error = Base64Error>>
130 serde::Deserialize<'de> for Result<T, Base64Error>
131{
132 #[inline]
133 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
134 where
135 D: Deserializer<'de>, {
136 struct MyVisitor<T>(PhantomData<T>);
137
138 impl<'de, T: ValidateString<Error = Base64Error> + ValidateBytes<Error = Base64Error>>
139 Visitor<'de> for MyVisitor<T>
140 {
141 type Value = Result<T, Base64Error>;
142
143 #[inline]
144 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
145 f.write_str("Base64Error")
146 }
147
148 #[inline]
149 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
150 where
151 E: DeError, {
152 Ok(Result::new(T::parse_str(v)))
153 }
154
155 #[inline]
156 fn visit_string<E>(self, v: String) -> core::result::Result<Self::Value, E>
157 where
158 E: DeError, {
159 Ok(Result::new(T::parse_string(v)))
160 }
161
162 #[inline]
163 fn visit_bytes<E>(self, v: &[u8]) -> core::result::Result<Self::Value, E>
164 where
165 E: DeError, {
166 Ok(Result::new(T::parse_u8_slice(v)))
167 }
168
169 #[inline]
170 fn visit_byte_buf<E>(self, v: Vec<u8>) -> core::result::Result<Self::Value, E>
171 where
172 E: DeError, {
173 Ok(Result::new(T::parse_vec_u8(v)))
174 }
175 }
176
177 deserializer.deserialize_any(MyVisitor(PhantomData))
178 }
179}
180
181#[cfg(feature = "base64_decoded")]
182impl<
183 'de,
184 T: ValidateString<Error = Base64DecodedError> + ValidateBytes<Error = Base64DecodedError>,
185 > serde::Deserialize<'de> for Result<T, Base64DecodedError>
186{
187 #[inline]
188 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
189 where
190 D: Deserializer<'de>, {
191 struct MyVisitor<T>(PhantomData<T>);
192
193 impl<
194 'de,
195 T: ValidateString<Error = Base64DecodedError>
196 + ValidateBytes<Error = Base64DecodedError>,
197 > Visitor<'de> for MyVisitor<T>
198 {
199 type Value = Result<T, Base64DecodedError>;
200
201 #[inline]
202 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
203 f.write_str("Base64DecodedError")
204 }
205
206 #[inline]
207 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
208 where
209 E: DeError, {
210 Ok(Result::new(T::parse_str(v)))
211 }
212
213 #[inline]
214 fn visit_string<E>(self, v: String) -> core::result::Result<Self::Value, E>
215 where
216 E: DeError, {
217 Ok(Result::new(T::parse_string(v)))
218 }
219
220 #[inline]
221 fn visit_bytes<E>(self, v: &[u8]) -> core::result::Result<Self::Value, E>
222 where
223 E: DeError, {
224 Ok(Result::new(T::parse_u8_slice(v)))
225 }
226
227 #[inline]
228 fn visit_byte_buf<E>(self, v: Vec<u8>) -> core::result::Result<Self::Value, E>
229 where
230 E: DeError, {
231 Ok(Result::new(T::parse_vec_u8(v)))
232 }
233 }
234
235 deserializer.deserialize_any(MyVisitor(PhantomData))
236 }
237}
238
239#[cfg(feature = "base64_url")]
240impl<'de, T: ValidateString<Error = Base64UrlError> + ValidateBytes<Error = Base64UrlError>>
241 serde::Deserialize<'de> for Result<T, Base64UrlError>
242{
243 #[inline]
244 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
245 where
246 D: Deserializer<'de>, {
247 struct MyVisitor<T>(PhantomData<T>);
248
249 impl<
250 'de,
251 T: ValidateString<Error = Base64UrlError> + ValidateBytes<Error = Base64UrlError>,
252 > Visitor<'de> for MyVisitor<T>
253 {
254 type Value = Result<T, Base64UrlError>;
255
256 #[inline]
257 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
258 f.write_str("Base64UrlError")
259 }
260
261 #[inline]
262 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
263 where
264 E: DeError, {
265 Ok(Result::new(T::parse_str(v)))
266 }
267
268 #[inline]
269 fn visit_string<E>(self, v: String) -> core::result::Result<Self::Value, E>
270 where
271 E: DeError, {
272 Ok(Result::new(T::parse_string(v)))
273 }
274
275 #[inline]
276 fn visit_bytes<E>(self, v: &[u8]) -> core::result::Result<Self::Value, E>
277 where
278 E: DeError, {
279 Ok(Result::new(T::parse_u8_slice(v)))
280 }
281
282 #[inline]
283 fn visit_byte_buf<E>(self, v: Vec<u8>) -> core::result::Result<Self::Value, E>
284 where
285 E: DeError, {
286 Ok(Result::new(T::parse_vec_u8(v)))
287 }
288 }
289
290 deserializer.deserialize_any(MyVisitor(PhantomData))
291 }
292}
293
294#[cfg(feature = "base64_url_decoded")]
295impl<
296 'de,
297 T: ValidateString<Error = Base64UrlDecodedError>
298 + ValidateBytes<Error = Base64UrlDecodedError>,
299 > serde::Deserialize<'de> for Result<T, Base64UrlDecodedError>
300{
301 #[inline]
302 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
303 where
304 D: Deserializer<'de>, {
305 struct MyVisitor<T>(PhantomData<T>);
306
307 impl<
308 'de,
309 T: ValidateString<Error = Base64UrlDecodedError>
310 + ValidateBytes<Error = Base64UrlDecodedError>,
311 > Visitor<'de> for MyVisitor<T>
312 {
313 type Value = Result<T, Base64UrlDecodedError>;
314
315 #[inline]
316 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
317 f.write_str("Base64UrlDecodedError")
318 }
319
320 #[inline]
321 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
322 where
323 E: DeError, {
324 Ok(Result::new(T::parse_str(v)))
325 }
326
327 #[inline]
328 fn visit_string<E>(self, v: String) -> core::result::Result<Self::Value, E>
329 where
330 E: DeError, {
331 Ok(Result::new(T::parse_string(v)))
332 }
333
334 #[inline]
335 fn visit_bytes<E>(self, v: &[u8]) -> core::result::Result<Self::Value, E>
336 where
337 E: DeError, {
338 Ok(Result::new(T::parse_u8_slice(v)))
339 }
340
341 #[inline]
342 fn visit_byte_buf<E>(self, v: Vec<u8>) -> core::result::Result<Self::Value, E>
343 where
344 E: DeError, {
345 Ok(Result::new(T::parse_vec_u8(v)))
346 }
347 }
348
349 deserializer.deserialize_any(MyVisitor(PhantomData))
350 }
351}
352
353#[cfg(feature = "bit")]
354impl<'de, T: ValidateString<Error = BitError> + ValidateUnsignedInteger<Error = BitError>>
355 serde::Deserialize<'de> for Result<T, BitError>
356{
357 #[inline]
358 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
359 where
360 D: Deserializer<'de>, {
361 if deserializer.is_human_readable() {
362 let s = String::deserialize(deserializer)?;
363
364 Ok(Result::new(T::parse_string(s)))
365 } else {
366 let s = u128::deserialize(deserializer)?;
367
368 Ok(Result::new(T::parse_u128(s)))
369 }
370 }
371}
372
373#[cfg(feature = "boolean")]
374impl<
375 'de,
376 T: ValidateString<Error = BooleanError>
377 + ValidateChar<Error = BooleanError>
378 + ValidateSignedInteger<Error = BooleanError>
379 + ValidateUnsignedInteger<Error = BooleanError>
380 + ValidateBoolean<Error = BooleanError>,
381 > serde::Deserialize<'de> for Result<T, BooleanError>
382{
383 #[inline]
384 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
385 where
386 D: serde::Deserializer<'de>, {
387 struct MyVisitor<T>(PhantomData<T>);
388
389 impl<
390 'de,
391 T: ValidateString<Error = BooleanError>
392 + ValidateChar<Error = BooleanError>
393 + ValidateSignedInteger<Error = BooleanError>
394 + ValidateUnsignedInteger<Error = BooleanError>
395 + ValidateBoolean<Error = BooleanError>,
396 > Visitor<'de> for MyVisitor<T>
397 {
398 type Value = Result<T, BooleanError>;
399
400 #[inline]
401 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
402 f.write_str("BooleanError")
403 }
404
405 fn visit_bool<E>(self, v: bool) -> core::result::Result<Self::Value, E>
406 where
407 E: DeError, {
408 Ok(Result::new(T::parse_bool(v)))
409 }
410
411 #[inline]
412 fn visit_i64<E>(self, v: i64) -> core::result::Result<Self::Value, E>
413 where
414 E: DeError, {
415 Ok(Result::new(T::parse_i64(v)))
416 }
417
418 #[inline]
419 fn visit_i128<E>(self, v: i128) -> core::result::Result<Self::Value, E>
420 where
421 E: DeError, {
422 Ok(Result::new(T::parse_i128(v)))
423 }
424
425 #[inline]
426 fn visit_u64<E>(self, v: u64) -> core::result::Result<Self::Value, E>
427 where
428 E: DeError, {
429 Ok(Result::new(T::parse_u64(v)))
430 }
431
432 #[inline]
433 fn visit_u128<E>(self, v: u128) -> core::result::Result<Self::Value, E>
434 where
435 E: DeError, {
436 Ok(Result::new(T::parse_u128(v)))
437 }
438
439 #[inline]
440 fn visit_char<E>(self, v: char) -> core::result::Result<Self::Value, E>
441 where
442 E: DeError, {
443 Ok(Result::new(T::parse_char(v)))
444 }
445
446 #[inline]
447 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
448 where
449 E: DeError, {
450 Ok(Result::new(T::parse_str(v)))
451 }
452
453 #[inline]
454 fn visit_string<E>(self, v: String) -> core::result::Result<Self::Value, E>
455 where
456 E: DeError, {
457 Ok(Result::new(T::parse_string(v)))
458 }
459 }
460
461 deserializer.deserialize_any(MyVisitor(PhantomData))
462 }
463}
464
465#[cfg(feature = "byte")]
466impl<'de, T: ValidateString<Error = ByteError> + ValidateUnsignedInteger<Error = ByteError>>
467 serde::Deserialize<'de> for Result<T, ByteError>
468{
469 #[inline]
470 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
471 where
472 D: Deserializer<'de>, {
473 if deserializer.is_human_readable() {
474 let s = String::deserialize(deserializer)?;
475
476 Ok(Result::new(T::parse_string(s)))
477 } else {
478 let s = u128::deserialize(deserializer)?;
479
480 Ok(Result::new(T::parse_u128(s)))
481 }
482 }
483}
484
485#[cfg(feature = "domain")]
486impl<'de, T: ValidateString<Error = DomainError>> serde::Deserialize<'de>
487 for Result<T, DomainError>
488{
489 #[inline]
490 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
491 where
492 D: Deserializer<'de>, {
493 struct MyVisitor<T>(PhantomData<T>);
494
495 impl<'de, T: ValidateString<Error = DomainError>> Visitor<'de> for MyVisitor<T> {
496 type Value = Result<T, DomainError>;
497
498 #[inline]
499 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
500 f.write_str("DomainError")
501 }
502
503 #[inline]
504 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
505 where
506 E: DeError, {
507 Ok(Result::new(T::parse_str(v)))
508 }
509
510 #[inline]
511 fn visit_string<E>(self, v: String) -> core::result::Result<Self::Value, E>
512 where
513 E: DeError, {
514 Ok(Result::new(T::parse_string(v)))
515 }
516 }
517
518 deserializer.deserialize_any(MyVisitor(PhantomData))
519 }
520}
521
522#[cfg(feature = "email")]
523impl<'de, T: ValidateString<Error = EmailError>> serde::Deserialize<'de> for Result<T, EmailError> {
524 #[inline]
525 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
526 where
527 D: Deserializer<'de>, {
528 struct MyVisitor<T>(PhantomData<T>);
529
530 impl<'de, T: ValidateString<Error = EmailError>> Visitor<'de> for MyVisitor<T> {
531 type Value = Result<T, EmailError>;
532
533 #[inline]
534 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
535 f.write_str("EmailError")
536 }
537
538 #[inline]
539 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
540 where
541 E: DeError, {
542 Ok(Result::new(T::parse_str(v)))
543 }
544 }
545
546 deserializer.deserialize_str(MyVisitor(PhantomData))
547 }
548}
549
550#[cfg(feature = "host")]
551impl<'de, T: ValidateString<Error = HostError>> serde::Deserialize<'de> for Result<T, HostError> {
552 #[inline]
553 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
554 where
555 D: Deserializer<'de>, {
556 struct MyVisitor<T>(PhantomData<T>);
557
558 impl<'de, T: ValidateString<Error = HostError>> Visitor<'de> for MyVisitor<T> {
559 type Value = Result<T, HostError>;
560
561 #[inline]
562 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
563 f.write_str("HostError")
564 }
565
566 #[inline]
567 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
568 where
569 E: DeError, {
570 Ok(Result::new(T::parse_str(v)))
571 }
572 }
573
574 deserializer.deserialize_str(MyVisitor(PhantomData))
575 }
576}
577
578#[cfg(feature = "http_url")]
579impl<'de, T: ValidateString<Error = HttpURLError>> serde::Deserialize<'de>
580 for Result<T, HttpURLError>
581{
582 #[inline]
583 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
584 where
585 D: Deserializer<'de>, {
586 struct MyVisitor<T>(PhantomData<T>);
587
588 impl<'de, T: ValidateString<Error = HttpURLError>> Visitor<'de> for MyVisitor<T> {
589 type Value = Result<T, HttpURLError>;
590
591 #[inline]
592 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
593 f.write_str("HttpURLError")
594 }
595
596 #[inline]
597 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
598 where
599 E: DeError, {
600 Ok(Result::new(T::parse_str(v)))
601 }
602 }
603
604 deserializer.deserialize_str(MyVisitor(PhantomData))
605 }
606}
607
608#[cfg(feature = "http_ftp_url")]
609impl<'de, T: ValidateString<Error = HttpFtpURLError>> serde::Deserialize<'de>
610 for Result<T, HttpFtpURLError>
611{
612 #[inline]
613 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
614 where
615 D: Deserializer<'de>, {
616 struct MyVisitor<T>(PhantomData<T>);
617
618 impl<'de, T: ValidateString<Error = HttpFtpURLError>> Visitor<'de> for MyVisitor<T> {
619 type Value = Result<T, HttpFtpURLError>;
620
621 #[inline]
622 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
623 f.write_str("HttpFtpURLError")
624 }
625
626 #[inline]
627 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
628 where
629 E: DeError, {
630 Ok(Result::new(T::parse_str(v)))
631 }
632 }
633
634 deserializer.deserialize_str(MyVisitor(PhantomData))
635 }
636}
637
638#[cfg(feature = "ip")]
639impl<'de, T: ValidateString<Error = IpError>> serde::Deserialize<'de> for Result<T, IpError> {
640 #[inline]
641 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
642 where
643 D: Deserializer<'de>, {
644 struct MyVisitor<T>(PhantomData<T>);
645
646 impl<'de, T: ValidateString<Error = IpError>> Visitor<'de> for MyVisitor<T> {
647 type Value = Result<T, IpError>;
648
649 #[inline]
650 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
651 f.write_str("IpError")
652 }
653
654 #[inline]
655 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
656 where
657 E: DeError, {
658 Ok(Result::new(T::parse_str(v)))
659 }
660 }
661
662 deserializer.deserialize_str(MyVisitor(PhantomData))
663 }
664}
665
666#[cfg(feature = "ipv4")]
667impl<'de, T: ValidateString<Error = Ipv4Error>> serde::Deserialize<'de> for Result<T, Ipv4Error> {
668 #[inline]
669 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
670 where
671 D: Deserializer<'de>, {
672 struct MyVisitor<T>(PhantomData<T>);
673
674 impl<'de, T: ValidateString<Error = Ipv4Error>> Visitor<'de> for MyVisitor<T> {
675 type Value = Result<T, Ipv4Error>;
676
677 #[inline]
678 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
679 f.write_str("Ipv4Error")
680 }
681
682 #[inline]
683 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
684 where
685 E: DeError, {
686 Ok(Result::new(T::parse_str(v)))
687 }
688 }
689
690 deserializer.deserialize_str(MyVisitor(PhantomData))
691 }
692}
693
694#[cfg(feature = "ipv6")]
695impl<'de, T: ValidateString<Error = Ipv6Error>> serde::Deserialize<'de> for Result<T, Ipv6Error> {
696 #[inline]
697 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
698 where
699 D: Deserializer<'de>, {
700 struct MyVisitor<T>(PhantomData<T>);
701
702 impl<'de, T: ValidateString<Error = Ipv6Error>> Visitor<'de> for MyVisitor<T> {
703 type Value = Result<T, Ipv6Error>;
704
705 #[inline]
706 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
707 f.write_str("Ipv6Error")
708 }
709
710 #[inline]
711 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
712 where
713 E: DeError, {
714 Ok(Result::new(T::parse_str(v)))
715 }
716 }
717
718 deserializer.deserialize_str(MyVisitor(PhantomData))
719 }
720}
721
722#[cfg(feature = "json")]
723impl<
724 'de,
725 T: ValidateString<Error = JsonError>
726 + ValidateSignedInteger<Error = JsonError>
727 + ValidateUnsignedInteger<Error = JsonError>
728 + ValidateNumber<Error = JsonError>
729 + ValidateBoolean<Error = JsonError>
730 + ValidateJsonValue<Error = JsonError>,
731 > serde::Deserialize<'de> for Result<T, JsonError>
732{
733 #[inline]
734 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
735 where
736 D: Deserializer<'de>, {
737 match serde_json::Value::deserialize(deserializer) {
738 Ok(value) => Ok(Result::new(T::parse_json_value(value))),
739 Err(_) => Ok(Result::new(Err(JsonError::InvalidJsonValueError))),
740 }
741 }
742}
743
744#[cfg(feature = "length")]
745impl<
746 'de,
747 C: CollectionLength + serde::Deserialize<'de>,
748 T: ValidateLength<C, Error = LengthError>,
749 > serde::Deserialize<'de> for Result<T, LengthError, C>
750{
751 #[inline]
752 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
753 where
754 D: Deserializer<'de>, {
755 Ok(Result::new(T::parse_collection(serde::Deserialize::deserialize(deserializer)?)))
756 }
757}
758
759#[cfg(feature = "line")]
760impl<'de, T: ValidateString<Error = LineError>> serde::Deserialize<'de> for Result<T, LineError> {
761 #[inline]
762 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
763 where
764 D: Deserializer<'de>, {
765 struct MyVisitor<T>(PhantomData<T>);
766
767 impl<'de, T: ValidateString<Error = LineError>> Visitor<'de> for MyVisitor<T> {
768 type Value = Result<T, LineError>;
769
770 #[inline]
771 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
772 f.write_str("LineError")
773 }
774
775 #[inline]
776 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
777 where
778 E: DeError, {
779 Ok(Result::new(T::parse_str(v)))
780 }
781
782 #[inline]
783 fn visit_string<E>(self, v: String) -> core::result::Result<Self::Value, E>
784 where
785 E: DeError, {
786 Ok(Result::new(T::parse_string(v)))
787 }
788 }
789
790 deserializer.deserialize_string(MyVisitor(PhantomData))
791 }
792}
793
794#[cfg(feature = "mac_address")]
795impl<'de, T: ValidateString<Error = MacAddressError>> serde::Deserialize<'de>
796 for Result<T, MacAddressError>
797{
798 #[inline]
799 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
800 where
801 D: Deserializer<'de>, {
802 struct MyVisitor<T>(PhantomData<T>);
803
804 impl<'de, T: ValidateString<Error = MacAddressError>> Visitor<'de> for MyVisitor<T> {
805 type Value = Result<T, MacAddressError>;
806
807 #[inline]
808 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
809 f.write_str("MacAddressError")
810 }
811
812 #[inline]
813 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
814 where
815 E: DeError, {
816 Ok(Result::new(T::parse_str(v)))
817 }
818 }
819
820 deserializer.deserialize_str(MyVisitor(PhantomData))
821 }
822}
823
824#[cfg(feature = "number")]
825impl<'de, T: ValidateString<Error = NumberError> + ValidateNumber<Error = NumberError>>
826 serde::Deserialize<'de> for Result<T, NumberError>
827{
828 #[inline]
829 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
830 where
831 D: Deserializer<'de>, {
832 struct MyVisitor<T>(PhantomData<T>);
833
834 impl<'de, T: ValidateString<Error = NumberError> + ValidateNumber<Error = NumberError>>
835 Visitor<'de> for MyVisitor<T>
836 {
837 type Value = Result<T, NumberError>;
838
839 #[inline]
840 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
841 f.write_str("NumberError")
842 }
843
844 #[inline]
845 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
846 where
847 E: DeError, {
848 Ok(Result::new(T::parse_str(v)))
849 }
850
851 #[inline]
852 fn visit_string<E>(self, v: String) -> core::result::Result<Self::Value, E>
853 where
854 E: DeError, {
855 Ok(Result::new(T::parse_string(v)))
856 }
857
858 #[inline]
859 fn visit_f32<E>(self, v: f32) -> core::result::Result<Self::Value, E>
860 where
861 E: DeError, {
862 Ok(Result::new(T::parse_f32(v)))
863 }
864
865 #[inline]
866 fn visit_f64<E>(self, v: f64) -> core::result::Result<Self::Value, E>
867 where
868 E: DeError, {
869 Ok(Result::new(T::parse_f64(v)))
870 }
871 }
872
873 deserializer.deserialize_any(MyVisitor(PhantomData))
874 }
875}
876
877#[cfg(feature = "phone")]
878impl<'de, T: ValidateString<Error = PhoneError>> serde::Deserialize<'de> for Result<T, PhoneError> {
879 #[inline]
880 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
881 where
882 D: Deserializer<'de>, {
883 struct MyVisitor<T>(PhantomData<T>);
884
885 impl<'de, T: ValidateString<Error = PhoneError>> Visitor<'de> for MyVisitor<T> {
886 type Value = Result<T, PhoneError>;
887
888 #[inline]
889 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
890 f.write_str("PhoneError")
891 }
892
893 #[inline]
894 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
895 where
896 E: DeError, {
897 Ok(Result::new(T::parse_str(v)))
898 }
899 }
900
901 deserializer.deserialize_str(MyVisitor(PhantomData))
902 }
903}
904
905#[cfg(feature = "regex")]
906impl<'de, T: ValidateString<Error = RegexError>> serde::Deserialize<'de> for Result<T, RegexError> {
907 #[inline]
908 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
909 where
910 D: Deserializer<'de>, {
911 struct MyVisitor<T>(PhantomData<T>);
912
913 impl<'de, T: ValidateString<Error = RegexError>> Visitor<'de> for MyVisitor<T> {
914 type Value = Result<T, RegexError>;
915
916 #[inline]
917 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
918 f.write_str("RegexError")
919 }
920
921 #[inline]
922 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
923 where
924 E: DeError, {
925 Ok(Result::new(T::parse_str(v)))
926 }
927
928 #[inline]
929 fn visit_string<E>(self, v: String) -> core::result::Result<Self::Value, E>
930 where
931 E: DeError, {
932 Ok(Result::new(T::parse_string(v)))
933 }
934 }
935
936 deserializer.deserialize_string(MyVisitor(PhantomData))
937 }
938}
939
940#[cfg(any(feature = "semver", feature = "semver_req"))]
941impl<'de, T: ValidateString<Error = SemverError>> serde::Deserialize<'de>
942 for Result<T, SemverError>
943{
944 #[inline]
945 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
946 where
947 D: Deserializer<'de>, {
948 struct MyVisitor<T>(PhantomData<T>);
949
950 impl<'de, T: ValidateString<Error = SemverError>> Visitor<'de> for MyVisitor<T> {
951 type Value = Result<T, SemverError>;
952
953 #[inline]
954 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
955 f.write_str("SemverError")
956 }
957
958 #[inline]
959 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
960 where
961 E: DeError, {
962 Ok(Result::new(T::parse_str(v)))
963 }
964 }
965
966 deserializer.deserialize_str(MyVisitor(PhantomData))
967 }
968}
969
970#[cfg(feature = "signed_integer")]
971impl<
972 'de,
973 T: ValidateString<Error = SignedIntegerError>
974 + ValidateSignedInteger<Error = SignedIntegerError>,
975 > serde::Deserialize<'de> for Result<T, SignedIntegerError>
976{
977 #[inline]
978 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
979 where
980 D: Deserializer<'de>, {
981 struct MyVisitor<T>(PhantomData<T>);
982
983 impl<
984 'de,
985 T: ValidateString<Error = SignedIntegerError>
986 + ValidateSignedInteger<Error = SignedIntegerError>,
987 > Visitor<'de> for MyVisitor<T>
988 {
989 type Value = Result<T, SignedIntegerError>;
990
991 #[inline]
992 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
993 f.write_str("SignedIntegerError")
994 }
995
996 #[inline]
997 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
998 where
999 E: DeError, {
1000 Ok(Result::new(T::parse_str(v)))
1001 }
1002
1003 #[inline]
1004 fn visit_string<E>(self, v: String) -> core::result::Result<Self::Value, E>
1005 where
1006 E: DeError, {
1007 Ok(Result::new(T::parse_string(v)))
1008 }
1009
1010 #[inline]
1011 fn visit_i8<E>(self, v: i8) -> core::result::Result<Self::Value, E>
1012 where
1013 E: DeError, {
1014 Ok(Result::new(T::parse_i8(v)))
1015 }
1016
1017 #[inline]
1018 fn visit_i16<E>(self, v: i16) -> core::result::Result<Self::Value, E>
1019 where
1020 E: DeError, {
1021 Ok(Result::new(T::parse_i16(v)))
1022 }
1023
1024 #[inline]
1025 fn visit_i32<E>(self, v: i32) -> core::result::Result<Self::Value, E>
1026 where
1027 E: DeError, {
1028 Ok(Result::new(T::parse_i32(v)))
1029 }
1030
1031 #[inline]
1032 fn visit_i64<E>(self, v: i64) -> core::result::Result<Self::Value, E>
1033 where
1034 E: DeError, {
1035 Ok(Result::new(T::parse_i64(v)))
1036 }
1037
1038 #[inline]
1039 fn visit_i128<E>(self, v: i128) -> core::result::Result<Self::Value, E>
1040 where
1041 E: DeError, {
1042 Ok(Result::new(T::parse_i128(v)))
1043 }
1044 }
1045
1046 deserializer.deserialize_any(MyVisitor(PhantomData))
1047 }
1048}
1049
1050#[cfg(feature = "text")]
1051impl<'de, T: ValidateString<Error = TextError>> serde::Deserialize<'de> for Result<T, TextError> {
1052 #[inline]
1053 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
1054 where
1055 D: Deserializer<'de>, {
1056 struct MyVisitor<T>(PhantomData<T>);
1057
1058 impl<'de, T: ValidateString<Error = TextError>> Visitor<'de> for MyVisitor<T> {
1059 type Value = Result<T, TextError>;
1060
1061 #[inline]
1062 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
1063 f.write_str("TextError")
1064 }
1065
1066 #[inline]
1067 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
1068 where
1069 E: DeError, {
1070 Ok(Result::new(T::parse_str(v)))
1071 }
1072
1073 #[inline]
1074 fn visit_string<E>(self, v: String) -> core::result::Result<Self::Value, E>
1075 where
1076 E: DeError, {
1077 Ok(Result::new(T::parse_string(v)))
1078 }
1079 }
1080
1081 deserializer.deserialize_string(MyVisitor(PhantomData))
1082 }
1083}
1084
1085#[cfg(feature = "unsigned_integer")]
1086impl<
1087 'de,
1088 T: ValidateString<Error = UnsignedIntegerError>
1089 + ValidateUnsignedInteger<Error = UnsignedIntegerError>,
1090 > serde::Deserialize<'de> for Result<T, UnsignedIntegerError>
1091{
1092 #[inline]
1093 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
1094 where
1095 D: Deserializer<'de>, {
1096 struct MyVisitor<T>(PhantomData<T>);
1097
1098 impl<
1099 'de,
1100 T: ValidateString<Error = UnsignedIntegerError>
1101 + ValidateUnsignedInteger<Error = UnsignedIntegerError>,
1102 > Visitor<'de> for MyVisitor<T>
1103 {
1104 type Value = Result<T, UnsignedIntegerError>;
1105
1106 #[inline]
1107 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
1108 f.write_str("UnsignedIntegerError")
1109 }
1110
1111 #[inline]
1112 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
1113 where
1114 E: DeError, {
1115 Ok(Result::new(T::parse_str(v)))
1116 }
1117
1118 #[inline]
1119 fn visit_string<E>(self, v: String) -> core::result::Result<Self::Value, E>
1120 where
1121 E: DeError, {
1122 Ok(Result::new(T::parse_string(v)))
1123 }
1124
1125 #[inline]
1126 fn visit_u8<E>(self, v: u8) -> core::result::Result<Self::Value, E>
1127 where
1128 E: DeError, {
1129 Ok(Result::new(T::parse_u8(v)))
1130 }
1131
1132 #[inline]
1133 fn visit_u16<E>(self, v: u16) -> core::result::Result<Self::Value, E>
1134 where
1135 E: DeError, {
1136 Ok(Result::new(T::parse_u16(v)))
1137 }
1138
1139 #[inline]
1140 fn visit_u32<E>(self, v: u32) -> core::result::Result<Self::Value, E>
1141 where
1142 E: DeError, {
1143 Ok(Result::new(T::parse_u32(v)))
1144 }
1145
1146 #[inline]
1147 fn visit_u64<E>(self, v: u64) -> core::result::Result<Self::Value, E>
1148 where
1149 E: DeError, {
1150 Ok(Result::new(T::parse_u64(v)))
1151 }
1152
1153 #[inline]
1154 fn visit_u128<E>(self, v: u128) -> core::result::Result<Self::Value, E>
1155 where
1156 E: DeError, {
1157 Ok(Result::new(T::parse_u128(v)))
1158 }
1159 }
1160
1161 deserializer.deserialize_any(MyVisitor(PhantomData))
1162 }
1163}
1164
1165#[cfg(feature = "url")]
1166impl<'de, T: ValidateString<Error = UrlError>> serde::Deserialize<'de> for Result<T, UrlError> {
1167 #[inline]
1168 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
1169 where
1170 D: Deserializer<'de>, {
1171 struct MyVisitor<T>(PhantomData<T>);
1172
1173 impl<'de, T: ValidateString<Error = UrlError>> Visitor<'de> for MyVisitor<T> {
1174 type Value = Result<T, UrlError>;
1175
1176 #[inline]
1177 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
1178 f.write_str("UrlError")
1179 }
1180
1181 #[inline]
1182 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
1183 where
1184 E: DeError, {
1185 Ok(Result::new(T::parse_str(v)))
1186 }
1187 }
1188
1189 deserializer.deserialize_str(MyVisitor(PhantomData))
1190 }
1191}
1192
1193#[cfg(feature = "uuid")]
1194impl<'de, T: ValidateString<Error = UuidError>> serde::Deserialize<'de> for Result<T, UuidError> {
1195 #[inline]
1196 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
1197 where
1198 D: Deserializer<'de>, {
1199 struct MyVisitor<T>(PhantomData<T>);
1200
1201 impl<'de, T: ValidateString<Error = UuidError>> Visitor<'de> for MyVisitor<T> {
1202 type Value = Result<T, UuidError>;
1203
1204 #[inline]
1205 fn expecting(&self, f: &mut Formatter) -> fmt::Result {
1206 f.write_str("UuidError")
1207 }
1208
1209 #[inline]
1210 fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
1211 where
1212 E: DeError, {
1213 Ok(Result::new(T::parse_str(v)))
1214 }
1215 }
1216
1217 deserializer.deserialize_str(MyVisitor(PhantomData))
1218 }
1219}