fastnum 0.7.5

Fast decimal numbers library
Documentation 
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

//! # Decimal number serialization and deserialization utils for serde

#[cfg(feature = "serde-arbitrary-precision")]
mod details;

#[cfg(feature = "serde-arbitrary-precision")]
type D<const N: usize> = crate::decimal::Decimal<N>;

/// Serialize/deserialize [crate::decimal::Decimal] as arbitrary precision
/// numbers in JSON using the `arbitrary_precision` feature within `serde_json`.
///
/// ```
/// # use serde::Deserialize;
/// # use fastnum::*;
///
/// #[derive(Deserialize)]
/// pub struct Arbitrary {
///     #[serde(with = "decimal::serde::dec::arbitrary_precision")]
///     value: D128,
/// }
///
/// let data: Arbitrary = serde_json::from_str(r#"{"value": -1.09861228866810969139524523692252570465}"#).unwrap();
/// assert_eq!(dec128!(-1.09861228866810969139524523692252570465), data.value);
/// ```
#[cfg(feature = "serde-arbitrary-precision")]
pub mod arbitrary_precision {

    use super::*;

    use serde::{de, Serialize};
    use std::str::FromStr;

    /// Deserializer for [`#[serde(with = "...")]`](<https://serde.rs/field-attrs.html#with>).
    pub fn deserialize<'de, Ds, const N: usize>(deserializer: Ds) -> Result<D<N>, Ds::Error>
    where
        Ds: de::Deserializer<'de>,
    {
        deserializer.deserialize_any(details::Visitor)
    }

    /// Serializer for [`#[serde(with = "...")]`](<https://serde.rs/field-attrs.html#with>).
    pub fn serialize<S, const N: usize>(value: &D<N>, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serde_json::Number::from_str(&value.to_string())
            .map_err(serde::ser::Error::custom)?
            .serialize(serializer)
    }
}

/// Serialize/deserialize optional [crate::decimal::Decimal] as arbitrary
/// precision numbers in JSON using the `arbitrary_precision` feature within
/// `serde_json`.
///
/// ```
/// # use serde::Deserialize;
/// # use fastnum::*;
///
/// #[derive(Deserialize)]
/// pub struct Arbitrary {
///     #[serde(with = "decimal::serde::dec::arbitrary_precision_option")]
///     value: Option<D128>,
/// }
///
/// let data: Arbitrary = serde_json::from_str(r#"{"value": -1.09861228866810969139524523692252570465}"#).unwrap();
/// assert_eq!(Some(dec128!(-1.09861228866810969139524523692252570465)), data.value);
///
/// let data: Arbitrary = serde_json::from_str(r#"{"value": null}"#).unwrap();
/// assert_eq!(None, data.value);
/// ```
#[cfg(feature = "serde-arbitrary-precision")]
pub mod arbitrary_precision_option {
    use super::*;

    use serde::{de, Serialize};

    /// Deserializer for [`#[serde(with = "...")]`](<https://serde.rs/field-attrs.html#with>).
    pub fn deserialize<'de, Ds, const N: usize>(deserializer: Ds) -> Result<Option<D<N>>, Ds::Error>
    where
        Ds: de::Deserializer<'de>,
    {
        deserializer.deserialize_option(details::OptionVisitor)
    }

    /// Serializer for [`#[serde(with = "...")]`](<https://serde.rs/field-attrs.html#with>).
    pub fn serialize<S, const N: usize>(
        value: &Option<D<N>>,
        serializer: S,
    ) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match value {
            Some(decimal) => {
                serde_json::Number::from_string_unchecked(decimal.to_string()).serialize(serializer)
            }
            None => serializer.serialize_none(),
        }
    }
}