fastnum2 0.3.5

fork of 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

use byteorder::{NetworkEndian, ReadBytesExt, WriteBytesExt};
use core::error::Error;

use crate::{decimal::extras::utils::db::postgres::NBase, utils::err_msg};

impl NBase {
    // https://github.com/postgres/postgres/blob/bcd1c3630095e48bc3b1eb0fc8e8c8a7c851eba1/src/backend/utils/adt/numeric.c#L167-L170
    const SIGN_POS: u16 = 0x0000;
    const SIGN_NEG: u16 = 0x4000;
    const SIGN_NAN: u16 = 0xC000;

    pub(crate) fn decode<T: ReadBytesExt>(
        mut buf: T,
    ) -> Result<Self, Box<dyn Error + Sync + Send>> {
        let digit_count = buf.read_u16::<NetworkEndian>()?;
        let weight = buf.read_i16::<NetworkEndian>()?;
        let sign = buf.read_u16::<NetworkEndian>()?;
        let scale = buf.read_u16::<NetworkEndian>()?;

        if sign == Self::SIGN_NAN {
            Ok(NBase::NaN)
        } else {
            let digits = (0..digit_count)
                .map(|_| buf.read_i16::<NetworkEndian>())
                .collect::<Result<Vec<_>, _>>()?;

            match sign {
                Self::SIGN_POS => Ok(NBase::Positive {
                    weight,
                    scale,
                    digits,
                }),
                Self::SIGN_NEG => Ok(NBase::Negative {
                    weight,
                    scale,
                    digits,
                }),
                _ => {
                    Err(err_msg!("sign for numeric field was not one of 0, 0x4000, 0xC000").into())
                }
            }
        }
    }

    pub(crate) fn encode<T: WriteBytesExt>(
        self,
        buf: &mut T,
    ) -> Result<(), Box<dyn Error + Sync + Send>> {
        let sign = match self {
            Self::Positive { .. } => Self::SIGN_POS,
            Self::Negative { .. } => Self::SIGN_NEG,
            Self::NaN => Self::SIGN_NAN,
        };

        let empty_vec = Vec::new();
        let digits = match self {
            NBase::Positive { ref digits, .. } | NBase::Negative { ref digits, .. } => digits,
            NBase::NaN => &empty_vec,
        };

        let weight = match self {
            NBase::Positive { weight, .. } | NBase::Negative { weight, .. } => weight,
            NBase::NaN => 0,
        };

        let scale = match self {
            NBase::Positive { scale, .. } | NBase::Negative { scale, .. } => scale,
            NBase::NaN => 0,
        };

        let digits_len = u16::try_from(digits.len())
            .map_err(|_| err_msg!("numeric digits count should not overflow u16"))?;

        buf.write_u16::<NetworkEndian>(digits_len)?;
        buf.write_i16::<NetworkEndian>(weight)?;
        buf.write_u16::<NetworkEndian>(sign)?;
        buf.write_u16::<NetworkEndian>(scale)?;

        for digit in digits.iter() {
            buf.write_i16::<NetworkEndian>(*digit)?;
        }

        Ok(())
    }
}