Skip to main content

grain_id/
serde.rs

1use core::fmt;
2
3use ::serde::{
4    Deserialize, Deserializer, Serialize, Serializer,
5    de::{self, Visitor},
6};
7
8use crate::{GrainId, GrainIdPrefix, alphabet};
9
10/// Serializes as a 7-character string in human-readable formats and as a [`u64`] otherwise.
11impl Serialize for GrainId {
12    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
13        if serializer.is_human_readable() {
14            serializer.serialize_str(alphabet::as_str(&self.encode()))
15        } else {
16            serializer.serialize_u64(self.to_u64())
17        }
18    }
19}
20
21impl<'de> Deserialize<'de> for GrainId {
22    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
23        struct GrainIdVisitor;
24
25        impl Visitor<'_> for GrainIdVisitor {
26            type Value = GrainId;
27
28            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
29                f.write_str("a 7-character grain-id string or an integer below 2^35")
30            }
31
32            fn visit_str<E: de::Error>(self, v: &str) -> Result<GrainId, E> {
33                v.parse().map_err(E::custom)
34            }
35
36            fn visit_u64<E: de::Error>(self, v: u64) -> Result<GrainId, E> {
37                GrainId::from_u64(v).map_err(E::custom)
38            }
39        }
40
41        if deserializer.is_human_readable() {
42            deserializer.deserialize_str(GrainIdVisitor)
43        } else {
44            deserializer.deserialize_u64(GrainIdVisitor)
45        }
46    }
47}
48
49/// Serializes as a string of up to 7 characters in human-readable formats and as a
50/// `(value, len)` tuple otherwise.
51impl Serialize for GrainIdPrefix {
52    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
53        if serializer.is_human_readable() {
54            let (buf, len) = self.encode();
55            serializer.serialize_str(alphabet::as_str(&buf[..len]))
56        } else {
57            (self.value(), self.len()).serialize(serializer)
58        }
59    }
60}
61
62impl<'de> Deserialize<'de> for GrainIdPrefix {
63    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
64        if deserializer.is_human_readable() {
65            struct PrefixVisitor;
66
67            impl Visitor<'_> for PrefixVisitor {
68                type Value = GrainIdPrefix;
69
70                fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
71                    f.write_str("a grain-id prefix string of at most 7 characters")
72                }
73
74                fn visit_str<E: de::Error>(self, v: &str) -> Result<GrainIdPrefix, E> {
75                    v.parse().map_err(E::custom)
76                }
77            }
78
79            deserializer.deserialize_str(PrefixVisitor)
80        } else {
81            let (value, len) = <(u64, u8)>::deserialize(deserializer)?;
82            GrainIdPrefix::from_parts(value, len).map_err(de::Error::custom)
83        }
84    }
85}