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

use Decimal;
use num::{FromPrimitive, Zero};
use serde;
use std::fmt;
use std::str::FromStr;

impl<'de> serde::Deserialize<'de> for Decimal {
    fn deserialize<D>(deserializer: D) -> Result<Decimal, D::Error>
    where
        D: serde::de::Deserializer<'de>, {
        deserializer.deserialize_any(DecimalVisitor)
    }
}

struct DecimalVisitor;

impl<'de> serde::de::Visitor<'de> for DecimalVisitor {
    type Value = Decimal;

    fn visit_i16<E>(self, value: i16) -> Result<Decimal, E> {
        match Decimal::from_i32(value as i32) {
            Some(s) => Ok(s),
            None => Ok(Decimal::zero()),
        }
    }

    fn visit_i32<E>(self, value: i32) -> Result<Decimal, E> {
        match Decimal::from_i32(value) {
            Some(s) => Ok(s),
            None => Ok(Decimal::zero()),
        }
    }

    fn visit_str<E>(self, value: &str) -> Result<Decimal, E> {
        match Decimal::from_str(value) {
            Ok(s) => Ok(s),
            Err(_) => Ok(Decimal::zero()),
        }
    }

    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        write!(
            formatter,
            "a Decimal type representing a fixed-point number"
        )
    }
}

impl serde::Serialize for Decimal {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer, {
        serializer.serialize_str(&self.to_string())
    }
}