1use crate::{Comparator, Version, VersionReq};
2use core::fmt;
3use serde::de::{Deserialize, Deserializer, Error, Visitor};
4use serde::ser::{Serialize, Serializer};
5
6impl Serialize for Version {
7 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
8 where
9 S: Serializer,
10 {
11 serializer.collect_str(self)
12 }
13}
14
15impl Serialize for VersionReq {
16 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
17 where
18 S: Serializer,
19 {
20 serializer.collect_str(self)
21 }
22}
23
24impl Serialize for Comparator {
25 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
26 where
27 S: Serializer,
28 {
29 serializer.collect_str(self)
30 }
31}
32
33impl<'de> Deserialize<'de> for Version {
34 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
35 where
36 D: Deserializer<'de>,
37 {
38 struct VersionVisitor;
39
40 impl<'de> Visitor<'de> for VersionVisitor {
41 type Value = Version;
42
43 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
44 formatter.write_str("semver version")
45 }
46
47 fn visit_str<E>(self, string: &str) -> Result<Self::Value, E>
48 where
49 E: Error,
50 {
51 string.parse().map_err(Error::custom)
52 }
53 }
54
55 deserializer.deserialize_str(VersionVisitor)
56 }
57}
58
59impl<'de> Deserialize<'de> for VersionReq {
60 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
61 where
62 D: Deserializer<'de>,
63 {
64 struct VersionReqVisitor;
65
66 impl<'de> Visitor<'de> for VersionReqVisitor {
67 type Value = VersionReq;
68
69 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
70 formatter.write_str("semver version")
71 }
72
73 fn visit_str<E>(self, string: &str) -> Result<Self::Value, E>
74 where
75 E: Error,
76 {
77 string.parse().map_err(Error::custom)
78 }
79 }
80
81 deserializer.deserialize_str(VersionReqVisitor)
82 }
83}
84
85impl<'de> Deserialize<'de> for Comparator {
86 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
87 where
88 D: Deserializer<'de>,
89 {
90 struct ComparatorVisitor;
91
92 impl<'de> Visitor<'de> for ComparatorVisitor {
93 type Value = Comparator;
94
95 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
96 formatter.write_str("semver comparator")
97 }
98
99 fn visit_str<E>(self, string: &str) -> Result<Self::Value, E>
100 where
101 E: Error,
102 {
103 string.parse().map_err(Error::custom)
104 }
105 }
106
107 deserializer.deserialize_str(ComparatorVisitor)
108 }
109}
110