decstr 0.2.0

IEEE 754 decimal floating point bitstrings
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use crate::{
    text::{
        ParsedInfinity,
        TextWriter,
    },
    ParseError,
};
use core::{
    fmt::{
        self,
        Write,
    },
    str,
};

#[derive(Debug)]
pub struct InfinityParser<B> {
    expecting: &'static [u8],
    infinity: ParsedInfinity,
    buf: B,
    error: Option<ParseError>,
}

const INFINITY_BUF_EXPECTING: &[u8] = b"infinity";

impl<B: TextWriter> InfinityParser<B> {
    pub fn begin(buf: B) -> Self {
        InfinityParser {
            buf,
            error: None,
            expecting: INFINITY_BUF_EXPECTING,
            infinity: ParsedInfinity {
                is_infinity_negative: false,
            },
        }
    }

    pub(in crate::text) fn advance(&mut self, b: u8) {
        self.expecting = &self.expecting[1..];

        self.buf.advance_significand(b);
    }

    pub(in crate::text) fn infinity_is_positive(&mut self) {
        self.infinity.is_infinity_negative = false;
    }

    pub(in crate::text) fn infinity_is_negative(&mut self) {
        self.infinity.is_infinity_negative = true;
    }

    pub fn parse_ascii(&mut self, ascii: &[u8]) -> Result<(), ParseError> {
        if let Some(remaining_capacity) = self.buf.remaining_capacity() {
            if remaining_capacity < ascii.len() {
                return Err(ParseError::buffer_too_small());
            }
        }

        for b in ascii {
            match b {
                // Mark the infinity as negative
                b'-' if self.is_at_start() => {
                    self.infinity.is_infinity_negative = true;
                    self.buf.advance_significand(*b);
                }
                // Uncommon: mark the infinity as positive
                b'+' if self.is_at_start() => {
                    self.infinity.is_infinity_negative = false;
                    self.buf.advance_significand(*b);
                }
                // Advance through the set of expected characters
                c if !self.expecting.is_empty() && self.expecting[0].eq_ignore_ascii_case(c) => {
                    self.expecting = &self.expecting[1..];
                    self.buf.advance_significand(*b);
                }
                // Any other character is invalid
                c => {
                    return Err(ParseError::unexpected_char(
                        *c,
                        str::from_utf8(self.expecting.get(0..1).unwrap_or(b"")).unwrap(),
                    ))
                }
            }
        }

        Ok(())
    }

    pub fn end(self) -> Result<ParsedInfinity, ParseError> {
        debug_assert!(
            self.error.is_none(),
            "attempt to complete a parser with an error context"
        );

        match self.expecting {
            // If we just encounter `inf` then we still have a valid infinity
            b"" | b"inity" => Ok(self.infinity),
            _ => Err(ParseError::unexpected_end(
                str::from_utf8(self.expecting.get(0..1).unwrap_or(b"")).unwrap(),
            )),
        }
    }

    pub fn context(&mut self, err: ParseError) -> fmt::Error {
        self.error = Some(err);
        fmt::Error
    }

    pub fn unwrap_context(&mut self, _: fmt::Error) -> ParseError {
        self.error.take().unwrap_or_else(ParseError::source)
    }

    fn is_at_start(&self) -> bool {
        self.expecting.len() == INFINITY_BUF_EXPECTING.len()
    }
}

impl<B: TextWriter> Write for InfinityParser<B> {
    fn write_str(&mut self, s: &str) -> fmt::Result {
        self.parse_ascii(s.as_bytes())
            .map_err(|err| self.context(err))
    }
}