Allow lax decoding for invalid bson types about bson-rust HOT 7 CLOSED

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Test {
    #[serde(rename = "_id")]
    test_id : i32,
    #[serde(with = "bson::compat::i2f")]
    amount : i32
}

#[allow(non_snake_case)]
pub mod LaxNumber {
    use serde::{Serialize, Deserialize, Deserializer};
    use serde::de::DeserializeOwned;
    use bson::Bson;

    pub trait LaxFromF64 {
        fn from(v : f64) -> Self;
    }

    macro_rules! impl_laxfrom64 {
        ($to:ident) => (
            impl LaxFromF64 for $to {
                fn from(v : f64) -> $to {
                    v as $to
                }
            }
        )
    }

    impl_laxfrom64!(i8);
    impl_laxfrom64!(i16);
    impl_laxfrom64!(i32);
    impl_laxfrom64!(i64);
    impl_laxfrom64!(f32);
    impl_laxfrom64!(f64);
    
    pub fn deserialize<'de, T, D>(d: D) -> Result<T, D::Error>
        where D: Deserializer<'de>,
              T: LaxFromF64
    {
        f64::deserialize(d).map(T::from)
    }

     pub fn deserialize_nullable<'de, T, D>(d: D) -> Result<Option<T>, D::Error>
        where D: Deserializer<'de>,
              T: LaxFromF64
    {
        Option::<f64>::deserialize(d)
            .map(|x| {
                match x {
                    None => None,
                    Some(v) => Some(T::from(v))
                }
            })
    }
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Test {
    #[serde(rename = "_id")]
    test_id : i32,

    #[serde(deserialize_with = "LaxNumber::deserialize")]
    amount : i32

    #[serde(deserialize_with = "LaxNumber::deserialize_nullable")]
    amount_nullable : Option<i32>
}

#[inline]
pub fn deserialize<D>(deserializer: D) -> Result<D::Ok, D::Error>
    where D: Deserializer<'de>
{
    deserializer.deserialize_i32(LaxI32Visitor)
}

use std::marker::PhantomData;

pub struct LaxI32Visitor<T: From<i32>>(PhantomData<T>);

impl<'de, T> Visitor<'de> for LaxI32Visitor<T> where T: From<i32> {
    type Value = T;

    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "expecting an integer or floating point")
    }

    #[inline]
    fn visit_i8<E>(self, value: i8) -> Result<T, E>
        where E: Error
    {
        Ok(T::from(value as i32))
    }

    #[inline]
    fn visit_i16<E>(self, value: i16) -> Result<T, E>
        where E: Error
    {
        Ok(T::from(value as i32))
    }

    #[inline]
    fn visit_i32<E>(self, value: i32) -> Result<T, E>
        where E: Error
    {
        Ok(T::from(value))
    }

    #[inline]
    fn visit_i64<E>(self, value: i64) -> Result<T, E>
        where E: Error
    {
        Ok(T::from(value as i32))
    }

    #[inline]
    fn visit_f32<E>(self, value: f32) -> Result<T, E> {
        Ok(T::from(value as i32))
    }

    #[inline]
    fn visit_f64<E>(self, value: f64) -> Result<T, E> {
        Ok(T::from(value as i32))
    }
}