1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use serde;
use std::str::FromStr;
use std::fmt;

use super::pure_decimal::Decimal;


// Copied from https://github.com/paupino/rust-decimal/blob/master/src/serde_types.rs
// MIT LICENSE

#[cfg(feature = "serde")]
impl serde::ser::Serialize for Decimal {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: serde::ser::Serializer,
    {
        serializer.serialize_str(&self.0.to_string())
    }
}

#[cfg(feature = "serde")]
impl<'de> serde::de::Deserialize<'de> for Decimal {
    fn deserialize<D>(deserializer: D) -> Result<Decimal, D::Error>
        where
            D: serde::de::Deserializer<'de>,
    {
        deserializer.deserialize_any(SerdeDecimalVisitor)
    }
}

#[cfg(feature = "serde")]
#[allow(non_camel_case_types)]
struct SerdeDecimalVisitor;

#[cfg(feature = "serde")]
impl<'de> serde::de::Visitor<'de> for SerdeDecimalVisitor {
    type Value = Decimal;

    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "a Decimal value")
    }

    fn visit_str<E>(self, s: &str) -> Result<Decimal, E>
        where
            E: serde::de::Error,
    {
        use serde::de::Unexpected;
        Decimal::from_str(s).map_err(|_| E::invalid_value(Unexpected::Str(s), &self))
    }


    fn visit_f64<E>(self, value: f64) -> Result<Decimal, E>
        where
            E: serde::de::Error,
    {
        use serde::de::Unexpected;
        Decimal::from_str(&value.to_string()).map_err(|_| E::invalid_value(Unexpected::Float(value), &self))
    }

    fn visit_i64<E>(self, value: i64) -> Result<Decimal, E>
        where
            E: serde::de::Error,
    {
        Ok(Decimal::from(value))
    }

    fn visit_u64<E>(self, value: u64) -> Result<Decimal, E>
        where
            E: serde::de::Error,
    {
        Ok(Decimal::from(value))
    }
}

#[cfg(test)]
mod tests {


    extern crate serde_json;
    use super::*;

    #[derive(Serialize, Deserialize, Debug)]
    struct Record {
        amount: Decimal,
    }

    #[test]
    fn deserialize_valid_decimal() {
        let data = [
            ("{\"amount\":\"1.234\"}", "1.234"),
            ("{\"amount\":1234}", "1234"),
            ("{\"amount\":1234.56}", "1234.56"),
        ];
        for &(serialized, value) in data.iter() {
            let result = serde_json::from_str(serialized);
            assert_eq!(
                true,
                result.is_ok(),
                "expected successful deserialization for {}. Error: {:?}",
                serialized,
                result.err().unwrap()
            );
            let record: Record = result.unwrap();
            assert_eq!(
                value,
                record.amount.to_string(),
                "expected: {}, actual: {}",
                value,
                record.amount.to_string()
            );
        }
    }

    #[test]
    #[should_panic]
    fn deserialize_invalid_decimal() {
        let serialized = "{\"amount\":\"foo\"}";
        let _: Record = serde_json::from_str(serialized).unwrap();
    }

    #[test]
    fn serialize_decimal() {
        let record = Record { amount: dec!(1.234) };
        let serialized = serde_json::to_string(&record).unwrap();
        assert_eq!("{\"amount\":\"1.234\"}", serialized);
    }
}