TLA  Line data    Source code

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