Line data    Source code

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