1use core::marker::PhantomData;
13
14use crate::{
15 error::*,
16 fmt::{Braced, Hyphenated, Simple, Urn},
17 non_nil::NonNilUuid,
18 std::fmt,
19 Bytes, Uuid,
20};
21use serde_core::{
22 de::{self, Error as _},
23 Deserialize, Deserializer, Serialize, Serializer,
24};
25
26impl Serialize for Uuid {
27 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
28 if serializer.is_human_readable() {
29 serializer.serialize_str(self.hyphenated().encode_lower(&mut Uuid::encode_buffer()))
30 } else {
31 serializer.serialize_bytes(self.as_bytes())
32 }
33 }
34}
35
36impl Serialize for NonNilUuid {
37 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
38 where
39 S: serde_core::Serializer,
40 {
41 Uuid::from(*self).serialize(serializer)
42 }
43}
44
45impl Serialize for Hyphenated {
46 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
47 serializer.serialize_str(self.encode_lower(&mut Uuid::encode_buffer()))
48 }
49}
50
51impl Serialize for Simple {
52 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
53 serializer.serialize_str(self.encode_lower(&mut Uuid::encode_buffer()))
54 }
55}
56
57impl Serialize for Urn {
58 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
59 serializer.serialize_str(self.encode_lower(&mut Uuid::encode_buffer()))
60 }
61}
62
63impl Serialize for Braced {
64 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
65 serializer.serialize_str(self.encode_lower(&mut Uuid::encode_buffer()))
66 }
67}
68
69impl UuidDeserialize for Uuid {
70 fn expecting() -> &'static str {
71 "a formatted UUID string"
72 }
73
74 fn from_str<E: de::Error>(formatted: &str) -> Result<Self, E> {
75 formatted.parse().map_err(de_error)
76 }
77
78 fn from_slice<E: de::Error>(bytes: &[u8]) -> Result<Self, E> {
79 Uuid::from_slice(bytes).map_err(de_error)
80 }
81
82 fn from_bytes<E: de::Error>(bytes: Bytes) -> Result<Self, E> {
83 Ok(Uuid::from_bytes(bytes))
84 }
85}
86
87impl<'de> Deserialize<'de> for Uuid {
88 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
89 if deserializer.is_human_readable() {
90 deserializer.deserialize_str(UuidReadableVisitor {
91 _marker: PhantomData::<Uuid>,
92 })
93 } else {
94 deserializer.deserialize_bytes(UuidBytesVisitor {
95 _marker: PhantomData::<Uuid>,
96 })
97 }
98 }
99}
100
101impl UuidDeserialize for Braced {
102 fn expecting() -> &'static str {
103 "a UUID string in the braced format"
104 }
105
106 fn from_str<E: de::Error>(formatted: &str) -> Result<Self, E> {
107 formatted.parse().map_err(de_error)
108 }
109}
110
111impl<'de> Deserialize<'de> for Braced {
112 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
113 deserializer.deserialize_str(UuidReadableVisitor {
114 _marker: PhantomData::<Braced>,
115 })
116 }
117}
118
119impl UuidDeserialize for Hyphenated {
120 fn expecting() -> &'static str {
121 "a UUID string in the hyphenated format"
122 }
123
124 fn from_str<E: de::Error>(formatted: &str) -> Result<Self, E> {
125 formatted.parse().map_err(de_error)
126 }
127}
128
129impl<'de> Deserialize<'de> for Hyphenated {
130 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
131 deserializer.deserialize_str(UuidReadableVisitor {
132 _marker: PhantomData::<Hyphenated>,
133 })
134 }
135}
136
137impl UuidDeserialize for Simple {
138 fn expecting() -> &'static str {
139 "a UUID string in the simple format"
140 }
141
142 fn from_str<E: de::Error>(formatted: &str) -> Result<Self, E> {
143 formatted.parse().map_err(de_error)
144 }
145}
146
147impl<'de> Deserialize<'de> for Simple {
148 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
149 deserializer.deserialize_str(UuidReadableVisitor {
150 _marker: PhantomData::<Simple>,
151 })
152 }
153}
154
155impl UuidDeserialize for Urn {
156 fn expecting() -> &'static str {
157 "a UUID string in the URN format"
158 }
159
160 fn from_str<E: de::Error>(formatted: &str) -> Result<Self, E> {
161 formatted.parse().map_err(de_error)
162 }
163}
164
165impl<'de> Deserialize<'de> for Urn {
166 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
167 deserializer.deserialize_str(UuidReadableVisitor {
168 _marker: PhantomData::<Urn>,
169 })
170 }
171}
172
173impl<'de> Deserialize<'de> for NonNilUuid {
174 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
175 where
176 D: Deserializer<'de>,
177 {
178 let uuid = Uuid::deserialize(deserializer)?;
179
180 NonNilUuid::try_from(uuid).map_err(|_| {
181 de::Error::invalid_value(de::Unexpected::Other("nil UUID"), &"a non-nil UUID")
182 })
183 }
184}
185
186struct UuidReadableVisitor<T> {
187 _marker: PhantomData<T>,
188}
189
190impl<'vi, T: UuidDeserialize> de::Visitor<'vi> for UuidReadableVisitor<T> {
191 type Value = T;
192
193 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
194 formatter.write_str(T::expecting())
195 }
196
197 fn visit_str<E: de::Error>(self, value: &str) -> Result<T, E> {
198 T::from_str(value)
199 }
200
201 fn visit_bytes<E: de::Error>(self, value: &[u8]) -> Result<T, E> {
202 T::from_slice(value)
203 }
204
205 fn visit_seq<A>(self, seq: A) -> Result<T, A::Error>
206 where
207 A: de::SeqAccess<'vi>,
208 {
209 UuidBytesVisitor {
210 _marker: PhantomData,
211 }
212 .visit_seq(seq)
213 }
214}
215
216struct UuidBytesVisitor<T> {
217 _marker: PhantomData<T>,
218}
219
220impl<'vi, T: UuidDeserialize> de::Visitor<'vi> for UuidBytesVisitor<T> {
221 type Value = T;
222
223 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
224 write!(formatter, "a 16 byte array")
225 }
226
227 fn visit_bytes<E: de::Error>(self, value: &[u8]) -> Result<T, E> {
228 T::from_slice(value)
229 }
230
231 fn visit_seq<A>(self, mut seq: A) -> Result<T, A::Error>
232 where
233 A: de::SeqAccess<'vi>,
234 {
235 let mut bytes = [0; 16];
236
237 let mut i = 0;
238 for byte in bytes.iter_mut() {
239 let Some(e) = seq.next_element()? else {
240 break;
241 };
242
243 *byte = e;
244
245 i += 1;
246 }
247
248 while seq.next_element::<de::IgnoredAny>()?.is_some() {
249 i += 1;
250 }
251
252 if i != 16 {
253 return Err(A::Error::invalid_length(i, &self));
254 }
255
256 T::from_bytes(bytes)
257 }
258}
259
260fn de_error<E: de::Error>(e: Error) -> E {
261 E::custom(format_args!("UUID parsing failed: {}", e))
262}
263
264trait UuidDeserialize {
265 fn expecting() -> &'static str;
266
267 fn from_str<E: de::Error>(formatted: &str) -> Result<Self, E>
268 where
269 Self: Sized,
270 {
271 Err(E::invalid_type(
272 de::Unexpected::Str(formatted),
273 &Self::expecting(),
274 ))
275 }
276
277 fn from_slice<E: de::Error>(bytes: &[u8]) -> Result<Self, E>
278 where
279 Self: Sized,
280 {
281 Err(E::invalid_type(
282 de::Unexpected::Bytes(bytes),
283 &Self::expecting(),
284 ))
285 }
286
287 fn from_bytes<E: de::Error>(bytes: Bytes) -> Result<Self, E>
288 where
289 Self: Sized,
290 {
291 Self::from_slice(bytes.as_ref())
292 }
293}
294
295pub mod compact {
296 pub fn serialize<S>(u: &crate::Uuid, serializer: S) -> Result<S::Ok, S::Error>
304 where
305 S: serde_core::Serializer,
306 {
307 serde_core::Serialize::serialize(u.as_bytes(), serializer)
308 }
309
310 pub fn deserialize<'de, D>(deserializer: D) -> Result<crate::Uuid, D::Error>
314 where
315 D: serde_core::Deserializer<'de>,
316 {
317 let bytes: [u8; 16] = serde_core::Deserialize::deserialize(deserializer)?;
318
319 Ok(crate::Uuid::from_bytes(bytes))
320 }
321
322 pub mod option {
324 pub fn serialize<S>(u: &Option<crate::Uuid>, serializer: S) -> Result<S::Ok, S::Error>
326 where
327 S: serde_core::Serializer,
328 {
329 match u {
330 Some(u) => serializer.serialize_some(u.as_bytes()),
331 None => serializer.serialize_none(),
332 }
333 }
334
335 pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<crate::Uuid>, D::Error>
337 where
338 D: serde_core::Deserializer<'de>,
339 {
340 <Option<[u8; 16]> as serde_core::Deserialize>::deserialize(deserializer)
341 .map(|bytes| bytes.map(crate::Uuid::from_bytes))
342 }
343 }
344
345 #[cfg(test)]
346 mod tests {
347 use serde_derive::*;
348 use serde_test::{Configure, Token};
349
350 use crate::Uuid;
351
352 const BYTES: [u8; 16] = [
353 0xf9, 0x16, 0x8c, 0x5e, 0xce, 0xb2, 0x4f, 0xaa, 0xb6, 0xbf, 0x32, 0x9b, 0xf3, 0x9f,
354 0xa1, 0xe4,
355 ];
356
357 #[test]
358 fn test_compact_option() {
359 #[derive(Debug, PartialEq, Serialize, Deserialize)]
360 struct Field {
361 #[serde(with = "crate::serde::compact::option")]
362 id: Option<Uuid>,
363 }
364
365 let present = Field {
366 id: Some(Uuid::from_bytes(BYTES)),
367 };
368 let absent = Field { id: None };
369 let tokens = [
370 Token::Struct {
371 name: "Field",
372 len: 1,
373 },
374 Token::Str("id"),
375 Token::Some,
376 Token::Tuple { len: 16 },
377 Token::U8(BYTES[0]),
378 Token::U8(BYTES[1]),
379 Token::U8(BYTES[2]),
380 Token::U8(BYTES[3]),
381 Token::U8(BYTES[4]),
382 Token::U8(BYTES[5]),
383 Token::U8(BYTES[6]),
384 Token::U8(BYTES[7]),
385 Token::U8(BYTES[8]),
386 Token::U8(BYTES[9]),
387 Token::U8(BYTES[10]),
388 Token::U8(BYTES[11]),
389 Token::U8(BYTES[12]),
390 Token::U8(BYTES[13]),
391 Token::U8(BYTES[14]),
392 Token::U8(BYTES[15]),
393 Token::TupleEnd,
394 Token::StructEnd,
395 ];
396 serde_test::assert_tokens(&present, &tokens);
397 let none_tokens = [
398 Token::Struct {
399 name: "Field",
400 len: 1,
401 },
402 Token::Str("id"),
403 Token::None,
404 Token::StructEnd,
405 ];
406 serde_test::assert_tokens(&absent, &none_tokens);
407 }
408
409 #[test]
410 fn test_serialize_compact() {
411 #[derive(Serialize, Debug, Deserialize, PartialEq)]
412 struct UuidContainer {
413 #[serde(with = "crate::serde::compact")]
414 u: crate::Uuid,
415 }
416
417 let uuid_bytes = b"F9168C5E-CEB2-4F";
418 let container = UuidContainer {
419 u: crate::Uuid::from_slice(uuid_bytes).unwrap(),
420 };
421
422 serde_test::assert_tokens(
425 &container.compact(),
426 &[
427 Token::Struct {
428 name: "UuidContainer",
429 len: 1,
430 },
431 Token::Str("u"),
432 Token::Tuple { len: 16 },
433 Token::U8(uuid_bytes[0]),
434 Token::U8(uuid_bytes[1]),
435 Token::U8(uuid_bytes[2]),
436 Token::U8(uuid_bytes[3]),
437 Token::U8(uuid_bytes[4]),
438 Token::U8(uuid_bytes[5]),
439 Token::U8(uuid_bytes[6]),
440 Token::U8(uuid_bytes[7]),
441 Token::U8(uuid_bytes[8]),
442 Token::U8(uuid_bytes[9]),
443 Token::U8(uuid_bytes[10]),
444 Token::U8(uuid_bytes[11]),
445 Token::U8(uuid_bytes[12]),
446 Token::U8(uuid_bytes[13]),
447 Token::U8(uuid_bytes[14]),
448 Token::U8(uuid_bytes[15]),
449 Token::TupleEnd,
450 Token::StructEnd,
451 ],
452 )
453 }
454 }
455}
456
457pub mod bytes {
480 use super::*;
481
482 struct ByteUuid(crate::Uuid);
483
484 impl serde_core::Serialize for ByteUuid {
485 fn serialize<S: serde_core::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
486 serializer.serialize_bytes(self.0.as_bytes())
487 }
488 }
489
490 impl<'de> serde_core::Deserialize<'de> for ByteUuid {
491 fn deserialize<D: serde_core::Deserializer<'de>>(
492 deserializer: D,
493 ) -> Result<Self, D::Error> {
494 deserializer
495 .deserialize_bytes(UuidBytesVisitor {
496 _marker: PhantomData::<crate::Uuid>,
497 })
498 .map(Self)
499 }
500 }
501
502 pub fn serialize<S>(u: &crate::Uuid, serializer: S) -> Result<S::Ok, S::Error>
506 where
507 S: serde_core::Serializer,
508 {
509 ByteUuid(*u).serialize(serializer)
510 }
511
512 pub fn deserialize<'de, D>(deserializer: D) -> Result<crate::Uuid, D::Error>
516 where
517 D: serde_core::Deserializer<'de>,
518 {
519 ByteUuid::deserialize(deserializer).map(|u| u.0)
520 }
521
522 pub mod option {
524 use super::*;
525
526 pub fn serialize<S>(u: &Option<crate::Uuid>, serializer: S) -> Result<S::Ok, S::Error>
528 where
529 S: serde_core::Serializer,
530 {
531 match u {
532 Some(u) => serializer.serialize_some(&ByteUuid(*u)),
533 None => serializer.serialize_none(),
534 }
535 }
536
537 pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<crate::Uuid>, D::Error>
539 where
540 D: serde_core::Deserializer<'de>,
541 {
542 Option::<ByteUuid>::deserialize(deserializer).map(|u| u.map(|u| u.0))
543 }
544 }
545
546 #[cfg(test)]
547 mod tests {
548 use serde_derive::*;
549
550 use crate::Uuid;
551 use serde_test::Token;
552
553 const BYTES: [u8; 16] = [
554 0xf9, 0x16, 0x8c, 0x5e, 0xce, 0xb2, 0x4f, 0xaa, 0xb6, 0xbf, 0x32, 0x9b, 0xf3, 0x9f,
555 0xa1, 0xe4,
556 ];
557
558 #[test]
559 fn test_bytes_option() {
560 #[derive(Debug, PartialEq, Serialize, Deserialize)]
561 struct Field {
562 #[serde(with = "crate::serde::bytes::option")]
563 id: Option<Uuid>,
564 }
565
566 let present = Field {
567 id: Some(Uuid::from_bytes(BYTES)),
568 };
569 let absent = Field { id: None };
570 let present_tokens = [
571 Token::Struct {
572 name: "Field",
573 len: 1,
574 },
575 Token::Str("id"),
576 Token::Some,
577 Token::Bytes(&BYTES),
578 Token::StructEnd,
579 ];
580 let none_tokens = [
581 Token::Struct {
582 name: "Field",
583 len: 1,
584 },
585 Token::Str("id"),
586 Token::None,
587 Token::StructEnd,
588 ];
589 serde_test::assert_tokens(&present, &present_tokens);
590 serde_test::assert_tokens(&absent, &none_tokens);
591 }
592
593 #[test]
594 fn test_serialize_bytes() {
595 #[derive(Serialize, Debug, Deserialize, PartialEq)]
596 struct UuidContainer {
597 #[serde(with = "crate::serde::bytes")]
598 u: crate::Uuid,
599 }
600
601 let uuid_bytes = b"F9168C5E-CEB2-4F";
602 let container = UuidContainer {
603 u: crate::Uuid::from_slice(uuid_bytes).unwrap(),
604 };
605
606 serde_test::assert_tokens(
607 &container,
608 &[
609 serde_test::Token::Struct {
610 name: "UuidContainer",
611 len: 1,
612 },
613 serde_test::Token::Str("u"),
614 serde_test::Token::Bytes(uuid_bytes),
615 serde_test::Token::StructEnd,
616 ],
617 )
618 }
619
620 #[test]
621 fn test_de_bytes_from_seq() {
622 #[derive(Serialize, Debug, Deserialize, PartialEq)]
623 struct UuidContainer {
624 #[serde(with = "crate::serde::bytes")]
625 u: crate::Uuid,
626 }
627
628 let container = UuidContainer {
629 u: Uuid::from_bytes(BYTES),
630 };
631
632 let json = serde_json::to_string(&container).unwrap();
634 assert_eq!(container, serde_json::from_str(&json).unwrap());
635
636 serde_test::assert_de_tokens_error::<UuidContainer>(
637 &[
638 Token::Struct {
639 name: "UuidContainer",
640 len: 1,
641 },
642 Token::Str("u"),
643 Token::Seq { len: Some(1) },
644 Token::U8(BYTES[0]),
645 Token::SeqEnd,
646 ],
647 "invalid length 1, expected a 16 byte array",
648 );
649 }
650 }
651}
652
653pub mod simple {
680 use super::*;
681
682 pub fn serialize<S>(u: &crate::Uuid, serializer: S) -> Result<S::Ok, S::Error>
697 where
698 S: serde_core::Serializer,
699 {
700 serde_core::Serialize::serialize(u.as_simple(), serializer)
701 }
702
703 pub fn deserialize<'de, D>(deserializer: D) -> Result<Uuid, D::Error>
707 where
708 D: serde_core::Deserializer<'de>,
709 {
710 Ok(Simple::deserialize(deserializer)?.into())
711 }
712
713 pub mod option {
715 use super::*;
716
717 pub fn serialize<S>(u: &Option<Uuid>, serializer: S) -> Result<S::Ok, S::Error>
719 where
720 S: serde_core::Serializer,
721 {
722 match u {
723 Some(u) => serializer.serialize_some(u.as_simple()),
724 None => serializer.serialize_none(),
725 }
726 }
727
728 pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Uuid>, D::Error>
730 where
731 D: serde_core::Deserializer<'de>,
732 {
733 Option::<Simple>::deserialize(deserializer).map(|u| u.map(Into::into))
734 }
735 }
736
737 #[cfg(test)]
738 mod tests {
739 use serde::de::{self, Error};
740 use serde_test::{Readable, Token};
741
742 use super::*;
743
744 const HYPHENATED_UUID_STR: &str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
745 const SIMPLE_UUID_STR: &str = "f9168c5eceb24faab6bf329bf39fa1e4";
746
747 #[test]
748 fn test_simple_option() {
749 #[derive(Debug, PartialEq, serde_derive::Serialize, serde_derive::Deserialize)]
750 struct Field {
751 #[serde(with = "crate::serde::simple::option")]
752 id: Option<Uuid>,
753 }
754
755 let present = Field {
756 id: Some(HYPHENATED_UUID_STR.parse().unwrap()),
757 };
758 let absent = Field { id: None };
759 let present_tokens = [
760 Token::Struct {
761 name: "Field",
762 len: 1,
763 },
764 Token::Str("id"),
765 Token::Some,
766 Token::Str(SIMPLE_UUID_STR),
767 Token::StructEnd,
768 ];
769 let absent_tokens = [
770 Token::Struct {
771 name: "Field",
772 len: 1,
773 },
774 Token::Str("id"),
775 Token::None,
776 Token::StructEnd,
777 ];
778
779 serde_test::assert_tokens(&present, &present_tokens);
780 serde_test::assert_tokens(&absent, &absent_tokens);
781 }
782
783 #[test]
784 fn test_serialize_as_simple() {
785 #[derive(serde_derive::Serialize)]
786 struct Struct(#[serde(with = "super")] crate::Uuid);
787
788 let u = Struct(Uuid::parse_str(HYPHENATED_UUID_STR).unwrap());
789 serde_test::assert_ser_tokens(
790 &u,
791 &[
792 Token::NewtypeStruct { name: "Struct" },
793 Token::Str(SIMPLE_UUID_STR),
794 ],
795 );
796 }
797
798 #[test]
799 fn test_de_from_simple() {
800 #[derive(PartialEq, Debug, serde_derive::Deserialize)]
801 struct Struct(#[serde(with = "super")] crate::Uuid);
802 let s = Struct(HYPHENATED_UUID_STR.parse().unwrap());
803 serde_test::assert_de_tokens::<Struct>(
804 &s,
805 &[
806 Token::TupleStruct {
807 name: "Struct",
808 len: 1,
809 },
810 Token::BorrowedStr(SIMPLE_UUID_STR),
811 Token::TupleStructEnd,
812 ],
813 );
814 }
815
816 #[test]
817 fn test_de_reject_hyphenated() {
818 #[derive(PartialEq, Debug, serde_derive::Deserialize)]
819 struct Struct(#[serde(with = "super")] crate::Uuid);
820 serde_test::assert_de_tokens_error::<Readable<Struct>>(
821 &[
822 Token::TupleStruct {
823 name: "Struct",
824 len: 1,
825 },
826 Token::BorrowedStr(HYPHENATED_UUID_STR),
827 Token::TupleStructEnd,
828 ],
829 &format!(
830 "{}",
831 de::value::Error::custom(
832 "UUID parsing failed: invalid character: found `-` at 8"
833 )
834 ),
835 );
836 }
837
838 #[test]
839 fn test_de_reject_seq() {
840 let uuid_bytes = b"F9168C5E-CEB2-4F";
841
842 #[derive(PartialEq, Debug, serde_derive::Deserialize)]
843 struct Struct(#[serde(with = "super")] crate::Uuid);
844 serde_test::assert_de_tokens_error::<Readable<Struct>>(
845 &[
846 Token::TupleStruct {
847 name: "Struct",
848 len: 1,
849 },
850 Token::Bytes(uuid_bytes),
851 Token::TupleStructEnd,
852 ],
853 &format!(
854 "{}",
855 de::value::Error::custom(
856 "invalid type: byte array, expected a UUID string in the simple format"
857 )
858 ),
859 );
860 }
861 }
862}
863
864pub mod braced {
891 use super::*;
892
893 pub fn serialize<S>(u: &crate::Uuid, serializer: S) -> Result<S::Ok, S::Error>
908 where
909 S: serde_core::Serializer,
910 {
911 serde_core::Serialize::serialize(u.as_braced(), serializer)
912 }
913
914 pub fn deserialize<'de, D>(deserializer: D) -> Result<crate::Uuid, D::Error>
918 where
919 D: serde_core::Deserializer<'de>,
920 {
921 Ok(Braced::deserialize(deserializer)?.into())
922 }
923
924 pub mod option {
926 use super::*;
927
928 pub fn serialize<S>(u: &Option<Uuid>, serializer: S) -> Result<S::Ok, S::Error>
930 where
931 S: serde_core::Serializer,
932 {
933 match u {
934 Some(u) => serializer.serialize_some(u.as_braced()),
935 None => serializer.serialize_none(),
936 }
937 }
938
939 pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Uuid>, D::Error>
941 where
942 D: serde_core::Deserializer<'de>,
943 {
944 Option::<Braced>::deserialize(deserializer).map(|u| u.map(Into::into))
945 }
946 }
947
948 #[cfg(test)]
949 mod tests {
950
951 use super::*;
952 use serde::de::{self, Error};
953 use serde_test::{Readable, Token};
954
955 const HYPHENATED_UUID_STR: &str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
956 const BRACED_UUID_STR: &str = "{f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4}";
957
958 #[test]
959 fn test_braced_option() {
960 #[derive(Debug, PartialEq, serde_derive::Serialize, serde_derive::Deserialize)]
961 struct Field {
962 #[serde(with = "crate::serde::braced::option")]
963 id: Option<Uuid>,
964 }
965
966 let present = Field {
967 id: Some(HYPHENATED_UUID_STR.parse().unwrap()),
968 };
969 let absent = Field { id: None };
970 let present_tokens = [
971 Token::Struct {
972 name: "Field",
973 len: 1,
974 },
975 Token::Str("id"),
976 Token::Some,
977 Token::Str(BRACED_UUID_STR),
978 Token::StructEnd,
979 ];
980 let absent_tokens = [
981 Token::Struct {
982 name: "Field",
983 len: 1,
984 },
985 Token::Str("id"),
986 Token::None,
987 Token::StructEnd,
988 ];
989
990 serde_test::assert_tokens(&present, &present_tokens);
991 serde_test::assert_tokens(&absent, &absent_tokens);
992 }
993
994 #[test]
995 fn test_serialize_as_braced() {
996 #[derive(serde_derive::Serialize)]
997 struct Struct(#[serde(with = "super")] crate::Uuid);
998
999 let u = Struct(Uuid::parse_str(HYPHENATED_UUID_STR).unwrap());
1000 serde_test::assert_ser_tokens(
1001 &u,
1002 &[
1003 Token::NewtypeStruct { name: "Struct" },
1004 Token::Str(BRACED_UUID_STR),
1005 ],
1006 );
1007 }
1008
1009 #[test]
1010 fn test_de_from_braced() {
1011 #[derive(PartialEq, Debug, serde_derive::Deserialize)]
1012 struct Struct(#[serde(with = "super")] crate::Uuid);
1013 let s = Struct(HYPHENATED_UUID_STR.parse().unwrap());
1014 serde_test::assert_de_tokens::<Struct>(
1015 &s,
1016 &[
1017 Token::TupleStruct {
1018 name: "Struct",
1019 len: 1,
1020 },
1021 Token::BorrowedStr(BRACED_UUID_STR),
1022 Token::TupleStructEnd,
1023 ],
1024 );
1025 }
1026
1027 #[test]
1028 fn test_de_reject_hyphenated() {
1029 #[derive(PartialEq, Debug, serde_derive::Deserialize)]
1030 struct Struct(#[serde(with = "super")] crate::Uuid);
1031 serde_test::assert_de_tokens_error::<Readable<Struct>>(
1032 &[
1033 Token::TupleStruct {
1034 name: "Struct",
1035 len: 1,
1036 },
1037 Token::BorrowedStr(HYPHENATED_UUID_STR),
1038 Token::TupleStructEnd,
1039 ],
1040 &format!(
1041 "{}",
1042 de::value::Error::custom(
1043 "UUID parsing failed: invalid character: found `f` at 0"
1044 )
1045 ),
1046 );
1047 }
1048
1049 #[test]
1050 fn test_de_reject_seq() {
1051 let uuid_bytes = b"F9168C5E-CEB2-4F";
1052
1053 #[derive(PartialEq, Debug, serde_derive::Deserialize)]
1054 struct Struct(#[serde(with = "super")] crate::Uuid);
1055 serde_test::assert_de_tokens_error::<Readable<Struct>>(
1056 &[
1057 Token::TupleStruct {
1058 name: "Struct",
1059 len: 1,
1060 },
1061 Token::Bytes(uuid_bytes),
1062 Token::TupleStructEnd,
1063 ],
1064 &format!(
1065 "{}",
1066 de::value::Error::custom(
1067 "invalid type: byte array, expected a UUID string in the braced format"
1068 )
1069 ),
1070 );
1071 }
1072 }
1073}
1074
1075pub mod hyphenated {
1102
1103 use super::*;
1104
1105 pub fn serialize<S>(u: &crate::Uuid, serializer: S) -> Result<S::Ok, S::Error>
1120 where
1121 S: serde_core::Serializer,
1122 {
1123 serde_core::Serialize::serialize(u.as_hyphenated(), serializer)
1124 }
1125
1126 pub fn deserialize<'de, D>(deserializer: D) -> Result<crate::Uuid, D::Error>
1130 where
1131 D: serde_core::Deserializer<'de>,
1132 {
1133 Ok(Hyphenated::deserialize(deserializer)?.into())
1134 }
1135
1136 pub mod option {
1138 use super::*;
1139
1140 pub fn serialize<S>(u: &Option<Uuid>, serializer: S) -> Result<S::Ok, S::Error>
1142 where
1143 S: serde_core::Serializer,
1144 {
1145 match u {
1146 Some(u) => serializer.serialize_some(u.as_hyphenated()),
1147 None => serializer.serialize_none(),
1148 }
1149 }
1150
1151 pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Uuid>, D::Error>
1153 where
1154 D: serde_core::Deserializer<'de>,
1155 {
1156 Option::<Hyphenated>::deserialize(deserializer).map(|u| u.map(Into::into))
1157 }
1158 }
1159
1160 #[cfg(test)]
1161 mod tests {
1162
1163 use serde::de::{self, Error};
1164 use serde_test::{Readable, Token};
1165
1166 use super::*;
1167
1168 const HYPHENATED_UUID_STR: &str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
1169 const BRACED_UUID_STR: &str = "{f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4}";
1170
1171 #[test]
1172 fn test_hyphenated_option() {
1173 #[derive(Debug, PartialEq, serde_derive::Serialize, serde_derive::Deserialize)]
1174 struct Field {
1175 #[serde(with = "crate::serde::hyphenated::option")]
1176 id: Option<Uuid>,
1177 }
1178
1179 let present = Field {
1180 id: Some(HYPHENATED_UUID_STR.parse().unwrap()),
1181 };
1182 let absent = Field { id: None };
1183 let present_tokens = [
1184 Token::Struct {
1185 name: "Field",
1186 len: 1,
1187 },
1188 Token::Str("id"),
1189 Token::Some,
1190 Token::Str(HYPHENATED_UUID_STR),
1191 Token::StructEnd,
1192 ];
1193 let absent_tokens = [
1194 Token::Struct {
1195 name: "Field",
1196 len: 1,
1197 },
1198 Token::Str("id"),
1199 Token::None,
1200 Token::StructEnd,
1201 ];
1202
1203 serde_test::assert_tokens(&present, &present_tokens);
1204 serde_test::assert_tokens(&absent, &absent_tokens);
1205 }
1206
1207 #[test]
1208 fn test_serialize_as_hyphenated() {
1209 #[derive(serde_derive::Serialize)]
1210 struct Struct(#[serde(with = "super")] crate::Uuid);
1211
1212 let u = Struct(Uuid::parse_str(HYPHENATED_UUID_STR).unwrap());
1213 serde_test::assert_ser_tokens(
1214 &u,
1215 &[
1216 Token::NewtypeStruct { name: "Struct" },
1217 Token::Str(HYPHENATED_UUID_STR),
1218 ],
1219 );
1220 }
1221
1222 #[test]
1223 fn test_de_from_hyphenated() {
1224 #[derive(PartialEq, Debug, serde_derive::Deserialize)]
1225 struct Struct(#[serde(with = "super")] crate::Uuid);
1226 let s = Struct(HYPHENATED_UUID_STR.parse().unwrap());
1227 serde_test::assert_de_tokens::<Struct>(
1228 &s,
1229 &[
1230 Token::TupleStruct {
1231 name: "Struct",
1232 len: 1,
1233 },
1234 Token::BorrowedStr(HYPHENATED_UUID_STR),
1235 Token::TupleStructEnd,
1236 ],
1237 );
1238 }
1239
1240 #[test]
1241 fn test_de_reject_braced() {
1242 #[derive(PartialEq, Debug, serde_derive::Deserialize)]
1243 struct Struct(#[serde(with = "super")] crate::Uuid);
1244 serde_test::assert_de_tokens_error::<Readable<Struct>>(
1245 &[
1246 Token::TupleStruct {
1247 name: "Struct",
1248 len: 1,
1249 },
1250 Token::BorrowedStr(BRACED_UUID_STR),
1251 Token::TupleStructEnd,
1252 ],
1253 &format!(
1254 "{}",
1255 de::value::Error::custom(
1256 "UUID parsing failed: invalid character: found `{` at 0"
1257 )
1258 ),
1259 );
1260 }
1261
1262 #[test]
1263 fn test_de_reject_seq() {
1264 let uuid_bytes = b"F9168C5E-CEB2-4F";
1265
1266 #[derive(PartialEq, Debug, serde_derive::Deserialize)]
1267 struct Struct(#[serde(with = "super")] crate::Uuid);
1268 serde_test::assert_de_tokens_error::<Readable<Struct>>(
1269 &[
1270 Token::TupleStruct {
1271 name: "Struct",
1272 len: 1,
1273 },
1274 Token::Bytes(uuid_bytes),
1275 Token::TupleStructEnd,
1276 ],
1277 &format!(
1278 "{}",
1279 de::value::Error::custom(
1280 "invalid type: byte array, expected a UUID string in the hyphenated format"
1281 )
1282 ),
1283 );
1284 }
1285 }
1286}
1287
1288pub mod urn {
1315 use super::*;
1316
1317 pub fn serialize<S>(u: &crate::Uuid, serializer: S) -> Result<S::Ok, S::Error>
1332 where
1333 S: serde_core::Serializer,
1334 {
1335 serde_core::Serialize::serialize(u.as_urn(), serializer)
1336 }
1337
1338 pub fn deserialize<'de, D>(deserializer: D) -> Result<crate::Uuid, D::Error>
1342 where
1343 D: serde_core::Deserializer<'de>,
1344 {
1345 Ok(Urn::deserialize(deserializer)?.into())
1346 }
1347
1348 pub mod option {
1350 use super::*;
1351
1352 pub fn serialize<S>(u: &Option<Uuid>, serializer: S) -> Result<S::Ok, S::Error>
1354 where
1355 S: serde_core::Serializer,
1356 {
1357 match u {
1358 Some(u) => serializer.serialize_some(u.as_urn()),
1359 None => serializer.serialize_none(),
1360 }
1361 }
1362
1363 pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Uuid>, D::Error>
1365 where
1366 D: serde_core::Deserializer<'de>,
1367 {
1368 Option::<Urn>::deserialize(deserializer).map(|u| u.map(Into::into))
1369 }
1370 }
1371
1372 #[cfg(test)]
1373 mod tests {
1374 use serde::de::{self, Error};
1375 use serde_test::{Readable, Token};
1376
1377 use super::*;
1378
1379 const HYPHENATED_UUID_STR: &str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
1380 const URN_UUID_STR: &str = "urn:uuid:f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
1381
1382 #[test]
1383 fn test_urn_option() {
1384 #[derive(Debug, PartialEq, serde_derive::Serialize, serde_derive::Deserialize)]
1385 struct Field {
1386 #[serde(with = "crate::serde::urn::option")]
1387 id: Option<Uuid>,
1388 }
1389
1390 let present = Field {
1391 id: Some(HYPHENATED_UUID_STR.parse().unwrap()),
1392 };
1393 let absent = Field { id: None };
1394 let present_tokens = [
1395 Token::Struct {
1396 name: "Field",
1397 len: 1,
1398 },
1399 Token::Str("id"),
1400 Token::Some,
1401 Token::Str(URN_UUID_STR),
1402 Token::StructEnd,
1403 ];
1404 let absent_tokens = [
1405 Token::Struct {
1406 name: "Field",
1407 len: 1,
1408 },
1409 Token::Str("id"),
1410 Token::None,
1411 Token::StructEnd,
1412 ];
1413
1414 serde_test::assert_tokens(&present, &present_tokens);
1415 serde_test::assert_tokens(&absent, &absent_tokens);
1416 }
1417
1418 #[test]
1419 fn test_serialize_as_urn() {
1420 #[derive(serde_derive::Serialize)]
1421 struct Struct(#[serde(with = "super")] crate::Uuid);
1422
1423 let u = Struct(Uuid::parse_str(HYPHENATED_UUID_STR).unwrap());
1424 serde_test::assert_ser_tokens(
1425 &u,
1426 &[
1427 Token::NewtypeStruct { name: "Struct" },
1428 Token::Str(URN_UUID_STR),
1429 ],
1430 );
1431 }
1432
1433 #[test]
1434 fn test_de_from_urn() {
1435 #[derive(PartialEq, Debug, serde_derive::Deserialize)]
1436 struct Struct(#[serde(with = "super")] crate::Uuid);
1437 let s = Struct(HYPHENATED_UUID_STR.parse().unwrap());
1438 serde_test::assert_de_tokens::<Struct>(
1439 &s,
1440 &[
1441 Token::TupleStruct {
1442 name: "Struct",
1443 len: 1,
1444 },
1445 Token::BorrowedStr(URN_UUID_STR),
1446 Token::TupleStructEnd,
1447 ],
1448 );
1449 }
1450
1451 #[test]
1452 fn test_de_reject_hyphenated() {
1453 #[derive(PartialEq, Debug, serde_derive::Deserialize)]
1454 struct Struct(#[serde(with = "super")] crate::Uuid);
1455 serde_test::assert_de_tokens_error::<Readable<Struct>>(
1456 &[
1457 Token::TupleStruct {
1458 name: "Struct",
1459 len: 1,
1460 },
1461 Token::BorrowedStr(HYPHENATED_UUID_STR),
1462 Token::TupleStructEnd,
1463 ],
1464 &format!(
1465 "{}",
1466 de::value::Error::custom(
1467 "UUID parsing failed: invalid character: found `f` at 0"
1468 )
1469 ),
1470 );
1471 }
1472
1473 #[test]
1474 fn test_de_reject_seq() {
1475 let uuid_bytes = b"F9168C5E-CEB2-4F";
1476
1477 #[derive(PartialEq, Debug, serde_derive::Deserialize)]
1478 struct Struct(#[serde(with = "super")] crate::Uuid);
1479 serde_test::assert_de_tokens_error::<Readable<Struct>>(
1480 &[
1481 Token::TupleStruct {
1482 name: "Struct",
1483 len: 1,
1484 },
1485 Token::Bytes(uuid_bytes),
1486 Token::TupleStructEnd,
1487 ],
1488 &format!(
1489 "{}",
1490 de::value::Error::custom(
1491 "invalid type: byte array, expected a UUID string in the URN format"
1492 )
1493 ),
1494 );
1495 }
1496 }
1497}
1498
1499#[cfg(test)]
1500mod serde_tests {
1501 use super::*;
1502
1503 use serde_test::{Compact, Configure, Readable, Token};
1504
1505 #[test]
1506 fn test_serialize_readable_string() {
1507 let uuid_str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
1508 let u = Uuid::parse_str(uuid_str).unwrap();
1509 serde_test::assert_tokens(&u.readable(), &[Token::Str(uuid_str)]);
1510 }
1511
1512 #[test]
1513 fn test_deserialize_readable_compact() {
1514 let uuid_bytes = b"F9168C5E-CEB2-4F";
1515 let u = Uuid::from_slice(uuid_bytes).unwrap();
1516
1517 serde_test::assert_de_tokens(
1518 &u.readable(),
1519 &[
1520 Token::Tuple { len: 16 },
1521 Token::U8(uuid_bytes[0]),
1522 Token::U8(uuid_bytes[1]),
1523 Token::U8(uuid_bytes[2]),
1524 Token::U8(uuid_bytes[3]),
1525 Token::U8(uuid_bytes[4]),
1526 Token::U8(uuid_bytes[5]),
1527 Token::U8(uuid_bytes[6]),
1528 Token::U8(uuid_bytes[7]),
1529 Token::U8(uuid_bytes[8]),
1530 Token::U8(uuid_bytes[9]),
1531 Token::U8(uuid_bytes[10]),
1532 Token::U8(uuid_bytes[11]),
1533 Token::U8(uuid_bytes[12]),
1534 Token::U8(uuid_bytes[13]),
1535 Token::U8(uuid_bytes[14]),
1536 Token::U8(uuid_bytes[15]),
1537 Token::TupleEnd,
1538 ],
1539 );
1540 }
1541
1542 #[test]
1543 fn test_deserialize_readable_bytes() {
1544 let uuid_bytes = b"F9168C5E-CEB2-4F";
1545 let u = Uuid::from_slice(uuid_bytes).unwrap();
1546
1547 serde_test::assert_de_tokens(&u.readable(), &[serde_test::Token::Bytes(uuid_bytes)]);
1548 }
1549
1550 #[test]
1551 fn test_serialize_hyphenated() {
1552 let uuid_str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
1553 let u = Uuid::parse_str(uuid_str).unwrap();
1554 serde_test::assert_ser_tokens(&u.hyphenated(), &[Token::Str(uuid_str)]);
1555 serde_test::assert_de_tokens(&u.hyphenated(), &[Token::Str(uuid_str)]);
1556 }
1557
1558 #[test]
1559 fn test_serialize_simple() {
1560 let uuid_str = "f9168c5eceb24faab6bf329bf39fa1e4";
1561 let u = Uuid::parse_str(uuid_str).unwrap();
1562 serde_test::assert_ser_tokens(&u.simple(), &[Token::Str(uuid_str)]);
1563 serde_test::assert_de_tokens(&u.simple(), &[Token::Str(uuid_str)]);
1564 }
1565
1566 #[test]
1567 fn test_serialize_urn() {
1568 let uuid_str = "urn:uuid:f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
1569 let u = Uuid::parse_str(uuid_str).unwrap();
1570 serde_test::assert_ser_tokens(&u.urn(), &[Token::Str(uuid_str)]);
1571 serde_test::assert_de_tokens(&u.urn(), &[Token::Str(uuid_str)]);
1572 }
1573
1574 #[test]
1575 fn test_serialize_braced() {
1576 let uuid_str = "{f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4}";
1577 let u = Uuid::parse_str(uuid_str).unwrap();
1578 serde_test::assert_ser_tokens(&u.braced(), &[Token::Str(uuid_str)]);
1579 serde_test::assert_de_tokens(&u.braced(), &[Token::Str(uuid_str)]);
1580 }
1581
1582 #[test]
1583 fn test_serialize_non_human_readable() {
1584 let uuid_bytes = b"F9168C5E-CEB2-4F";
1585 let u = Uuid::from_slice(uuid_bytes).unwrap();
1586 serde_test::assert_tokens(
1587 &u.compact(),
1588 &[serde_test::Token::Bytes(&[
1589 70, 57, 49, 54, 56, 67, 53, 69, 45, 67, 69, 66, 50, 45, 52, 70,
1590 ])],
1591 );
1592 }
1593
1594 #[test]
1595 fn test_de_failure() {
1596 serde_test::assert_de_tokens_error::<Readable<Uuid>>(
1597 &[Token::Str("hello_world")],
1598 "UUID parsing failed: invalid character: found `h` at 0",
1599 );
1600
1601 serde_test::assert_de_tokens_error::<Compact<Uuid>>(
1602 &[Token::Bytes(b"hello_world")],
1603 "UUID parsing failed: invalid length: expected 16 bytes, found 11",
1604 );
1605
1606 serde_test::assert_de_tokens_error::<Readable<Uuid>>(
1607 &[
1608 Token::Tuple { len: 2 },
1609 Token::U8(70),
1610 Token::U8(57),
1611 Token::TupleEnd,
1612 ],
1613 "invalid length 2, expected a 16 byte array",
1614 );
1615
1616 serde_test::assert_de_tokens_error::<Compact<Uuid>>(
1617 &[
1618 Token::Tuple { len: 2 },
1619 Token::U8(70),
1620 Token::U8(57),
1621 Token::TupleEnd,
1622 ],
1623 "invalid length 2, expected a 16 byte array",
1624 );
1625
1626 serde_test::assert_de_tokens_error::<Readable<Uuid>>(
1627 &[
1628 Token::Tuple { len: 17 },
1629 Token::U8(70),
1630 Token::U8(57),
1631 Token::U8(49),
1632 Token::U8(54),
1633 Token::U8(56),
1634 Token::U8(67),
1635 Token::U8(53),
1636 Token::U8(69),
1637 Token::U8(45),
1638 Token::U8(67),
1639 Token::U8(69),
1640 Token::U8(66),
1641 Token::U8(50),
1642 Token::U8(45),
1643 Token::U8(52),
1644 Token::U8(70),
1645 Token::U8(70),
1646 Token::TupleEnd,
1647 ],
1648 "invalid length 17, expected a 16 byte array",
1649 );
1650
1651 serde_test::assert_de_tokens_error::<Compact<Uuid>>(
1652 &[
1653 Token::Tuple { len: 17 },
1654 Token::U8(70),
1655 Token::U8(57),
1656 Token::U8(49),
1657 Token::U8(54),
1658 Token::U8(56),
1659 Token::U8(67),
1660 Token::U8(53),
1661 Token::U8(69),
1662 Token::U8(45),
1663 Token::U8(67),
1664 Token::U8(69),
1665 Token::U8(66),
1666 Token::U8(50),
1667 Token::U8(45),
1668 Token::U8(52),
1669 Token::U8(70),
1670 Token::U8(70),
1671 Token::TupleEnd,
1672 ],
1673 "invalid length 17, expected a 16 byte array",
1674 );
1675 }
1676
1677 #[test]
1678 fn test_serde_non_nil_uuid() {
1679 let uuid_str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
1680 let uuid = Uuid::parse_str(uuid_str).unwrap();
1681 let non_nil_uuid = NonNilUuid::try_from(uuid).unwrap();
1682
1683 serde_test::assert_ser_tokens(&non_nil_uuid.readable(), &[Token::Str(uuid_str)]);
1684 serde_test::assert_de_tokens(&non_nil_uuid.readable(), &[Token::Str(uuid_str)]);
1685 }
1686}