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