Line data Source code
1 : use utils::lsn::Lsn;
2 :
3 : use crate::keyspace::SparseKeySpace;
4 :
5 : #[derive(Debug, PartialEq, Eq)]
6 : pub struct Partitioning {
7 : pub keys: crate::keyspace::KeySpace,
8 : pub sparse_keys: crate::keyspace::SparseKeySpace,
9 : pub at_lsn: Lsn,
10 : }
11 :
12 : impl serde::Serialize for Partitioning {
13 6 : fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14 6 : where
15 6 : S: serde::Serializer,
16 6 : {
17 : pub struct KeySpace<'a>(&'a crate::keyspace::KeySpace);
18 :
19 : impl<'a> serde::Serialize for KeySpace<'a> {
20 12 : fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
21 12 : where
22 12 : S: serde::Serializer,
23 12 : {
24 : use serde::ser::SerializeSeq;
25 12 : let mut seq = serializer.serialize_seq(Some(self.0.ranges.len()))?;
26 36 : for kr in &self.0.ranges {
27 24 : seq.serialize_element(&KeyRange(kr))?;
28 : }
29 12 : seq.end()
30 12 : }
31 : }
32 :
33 : use serde::ser::SerializeMap;
34 6 : let mut map = serializer.serialize_map(Some(2))?;
35 6 : map.serialize_key("keys")?;
36 6 : map.serialize_value(&KeySpace(&self.keys))?;
37 6 : map.serialize_key("sparse_keys")?;
38 6 : map.serialize_value(&KeySpace(&self.sparse_keys.0))?;
39 6 : map.serialize_key("at_lsn")?;
40 6 : map.serialize_value(&WithDisplay(&self.at_lsn))?;
41 6 : map.end()
42 6 : }
43 : }
44 :
45 : pub struct WithDisplay<'a, T>(&'a T);
46 :
47 : impl<'a, T: std::fmt::Display> serde::Serialize for WithDisplay<'a, T> {
48 54 : fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
49 54 : where
50 54 : S: serde::Serializer,
51 54 : {
52 54 : serializer.collect_str(&self.0)
53 54 : }
54 : }
55 :
56 : pub struct KeyRange<'a>(&'a std::ops::Range<crate::key::Key>);
57 :
58 : impl<'a> serde::Serialize for KeyRange<'a> {
59 24 : fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
60 24 : where
61 24 : S: serde::Serializer,
62 24 : {
63 : use serde::ser::SerializeTuple;
64 24 : let mut t = serializer.serialize_tuple(2)?;
65 24 : t.serialize_element(&WithDisplay(&self.0.start))?;
66 24 : t.serialize_element(&WithDisplay(&self.0.end))?;
67 24 : t.end()
68 24 : }
69 : }
70 :
71 : impl<'a> serde::Deserialize<'a> for Partitioning {
72 6 : fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
73 6 : where
74 6 : D: serde::Deserializer<'a>,
75 6 : {
76 : pub struct KeySpace(crate::keyspace::KeySpace);
77 :
78 : impl<'de> serde::Deserialize<'de> for KeySpace {
79 12 : fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
80 12 : where
81 12 : D: serde::Deserializer<'de>,
82 12 : {
83 : #[serde_with::serde_as]
84 48 : #[derive(serde::Deserialize)]
85 : #[serde(transparent)]
86 : struct Key(#[serde_as(as = "serde_with::DisplayFromStr")] crate::key::Key);
87 :
88 : #[serde_with::serde_as]
89 24 : #[derive(serde::Deserialize)]
90 : struct Range(Key, Key);
91 :
92 12 : let ranges: Vec<Range> = serde::Deserialize::deserialize(deserializer)?;
93 12 : Ok(Self(crate::keyspace::KeySpace {
94 12 : ranges: ranges
95 12 : .into_iter()
96 24 : .map(|Range(start, end)| (start.0..end.0))
97 12 : .collect(),
98 12 : }))
99 12 : }
100 : }
101 :
102 : #[serde_with::serde_as]
103 30 : #[derive(serde::Deserialize)]
104 : struct De {
105 : keys: KeySpace,
106 : sparse_keys: KeySpace,
107 : #[serde_as(as = "serde_with::DisplayFromStr")]
108 : at_lsn: Lsn,
109 : }
110 :
111 6 : let de: De = serde::Deserialize::deserialize(deserializer)?;
112 6 : Ok(Self {
113 6 : at_lsn: de.at_lsn,
114 6 : keys: de.keys.0,
115 6 : sparse_keys: SparseKeySpace(de.sparse_keys.0),
116 6 : })
117 6 : }
118 : }
119 :
120 : #[cfg(test)]
121 : mod tests {
122 : use super::*;
123 :
124 : #[test]
125 6 : fn test_serialization_roundtrip() {
126 6 : let reference = r#"
127 6 : {
128 6 : "keys": [
129 6 : [
130 6 : "000000000000000000000000000000000000",
131 6 : "000000000000000000000000000000000001"
132 6 : ],
133 6 : [
134 6 : "000000067F00000001000000000000000000",
135 6 : "000000067F00000001000000000000000002"
136 6 : ],
137 6 : [
138 6 : "030000000000000000000000000000000000",
139 6 : "030000000000000000000000000000000003"
140 6 : ]
141 6 : ],
142 6 : "sparse_keys": [
143 6 : [
144 6 : "620000000000000000000000000000000000",
145 6 : "620000000000000000000000000000000003"
146 6 : ]
147 6 : ],
148 6 : "at_lsn": "0/2240160"
149 6 : }
150 6 : "#;
151 6 :
152 6 : let de: Partitioning = serde_json::from_str(reference).unwrap();
153 6 :
154 6 : let ser = serde_json::to_string(&de).unwrap();
155 6 :
156 6 : let ser_de: serde_json::Value = serde_json::from_str(&ser).unwrap();
157 6 :
158 6 : assert_eq!(
159 6 : ser_de,
160 6 : serde_json::from_str::<'_, serde_json::Value>(reference).unwrap()
161 6 : );
162 6 : }
163 : }
|
