roaring 0.10.11

use serde::de::SeqAccess;
use serde::de::Visitor;
use serde::Deserialize;
use serde::Deserializer;
use serde::Serialize;

use crate::RoaringTreemap;

impl<'de> Deserialize<'de> for RoaringTreemap {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct TreemapVisitor;

        impl<'de> Visitor<'de> for TreemapVisitor {
            type Value = RoaringTreemap;

            fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
                formatter.write_str("roaring bitmap")
            }

            fn visit_bytes<E>(self, bytes: &[u8]) -> Result<RoaringTreemap, E>
            where
                E: serde::de::Error,
            {
                RoaringTreemap::deserialize_from(bytes).map_err(serde::de::Error::custom)
            }

            // in some case bytes will be serialized as a sequence thus we need to accept both
            // even if it means non optimal performance
            fn visit_seq<A>(self, mut seq: A) -> Result<RoaringTreemap, A::Error>
            where
                A: SeqAccess<'de>,
            {
                let mut bytes: Vec<u8> = Vec::new();
                while let Some(el) = seq.next_element()? {
                    bytes.push(el);
                }
                RoaringTreemap::deserialize_from(&*bytes).map_err(serde::de::Error::custom)
            }
        }

        deserializer.deserialize_bytes(TreemapVisitor)
    }
}

impl Serialize for RoaringTreemap {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        let mut buf = Vec::new();
        self.serialize_into(&mut buf).map_err(serde::ser::Error::custom)?;

        serializer.serialize_bytes(&buf)
    }
}

#[cfg(test)]
mod test {
    use crate::RoaringTreemap;
    use proptest::prelude::*;

    proptest! {
        #[test]
        fn test_serde_json(
            treemap in RoaringTreemap::arbitrary(),
        ) {
            let json = serde_json::to_vec(&treemap).unwrap();
            prop_assert_eq!(treemap, serde_json::from_slice(&json).unwrap());
        }

        #[test]
        fn test_postcard(
            treemap in RoaringTreemap::arbitrary(),
        ) {
            let buffer = postcard::to_allocvec(&treemap).unwrap();
            prop_assert_eq!(treemap, postcard::from_bytes(&buffer).unwrap());
        }
    }
}