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