musli 0.1.6

Müsli is a flexible and efficient serialization framework.
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! Number parsing for JSON, which adapts the shared [`number`] parser to the
//! [`Parser`] interface and to reporting errors through a [`Context`].
//!
//! [`number`]: crate::number

use crate::Context;
use crate::json::parser::Parser;
use crate::number::{self, Json, Signed, Unsigned};

/// Parse a number out of `p`, advancing it past the number and anchoring any
/// diagnostic at the byte the number started on.
macro_rules! parse {
    (
        $(#[$meta:meta])*
        fn $name:ident<$bound:ident> = $parse:ident;
    ) => {
        $(#[$meta])*
        #[inline]
        pub(crate) fn $name<'de, T, C, P>(cx: C, mut p: P) -> Result<T, C::Error>
        where
            T: $bound,
            P: Parser<'de>,
            C: Context,
        {
            p.skip_whitespace(cx);

            let start = cx.mark();

            match number::$parse::<Json, T>(p.remaining()) {
                Ok((value, len)) => {
                    p.skip(cx, len)?;
                    Ok(value)
                }
                Err(error) => Err(report(cx, &mut p, &start, error)),
            }
        }
    };
}

parse! {
    /// Parse an unsigned integer, ignoring any fraction or exponent.
    #[cfg_attr(feature = "parse-full", allow(unused))]
    fn parse_unsigned_base<Unsigned> = parse_unsigned_base;
}

parse! {
    /// Parse an unsigned integer which may be written with a fraction or an
    /// exponent, as long as it denotes a whole number.
    #[cfg_attr(not(feature = "parse-full"), allow(unused))]
    fn parse_unsigned_full<Unsigned> = parse_unsigned;
}

parse! {
    /// Parse a signed integer, ignoring any fraction or exponent.
    #[cfg_attr(feature = "parse-full", allow(unused))]
    fn parse_signed_base<Signed> = parse_signed_base;
}

parse! {
    /// Parse a signed integer which may be written with a fraction or an
    /// exponent, as long as it denotes a whole number.
    #[cfg_attr(not(feature = "parse-full"), allow(unused))]
    fn parse_signed_full<Signed> = parse_signed;
}

/// Parse a number without being told which type it is wanted as.
#[inline]
pub(crate) fn parse_any<'de, C, P>(cx: C, p: &mut P) -> Result<number::Any, C::Error>
where
    C: Context,
    P: ?Sized + Parser<'de>,
{
    p.skip_whitespace(cx);

    let start = cx.mark();

    match number::parse_any::<Json>(p.remaining()) {
        Ok((any, len)) => {
            p.skip(cx, len)?;
            Ok(any)
        }
        Err(error) => Err(report(cx, p, &start, error)),
    }
}

/// Skip over a well-formed number.
#[inline]
pub(crate) fn skip_number<'de, P, C>(cx: C, mut p: P) -> Result<(), C::Error>
where
    P: Parser<'de>,
    C: Context,
{
    p.skip_whitespace(cx);

    let start = cx.mark();

    match number::skip::<Json>(p.remaining()) {
        Ok(len) => p.skip(cx, len),
        Err(error) => Err(report(cx, &mut p, &start, error)),
    }
}

/// Parse a floating point number.
#[inline]
pub(crate) fn parse_float<'de, F, C, P>(cx: C, p: &mut P) -> Result<F, C::Error>
where
    F: number::Float,
    C: Context,
    P: ?Sized + Parser<'de>,
{
    let start = cx.mark();

    match number::parse_float::<Json, F>(p.remaining()) {
        Ok((value, len)) => {
            p.skip(cx, len)?;
            Ok(value)
        }
        Err(error) => Err(report(cx, p, &start, error)),
    }
}

/// Report `error` against the number which begins at `start`.
///
/// The parser is first advanced past the byte which is at fault, so that the
/// span the diagnostic carries covers the offending part of the input rather
/// than collapsing onto the byte the number began on.
#[inline]
fn report<'de, C, P>(cx: C, p: &mut P, start: &C::Mark, error: number::Error) -> C::Error
where
    C: Context,
    P: ?Sized + Parser<'de>,
{
    let n = error.at().saturating_add(1).min(p.remaining().len());

    if let Err(error) = p.skip(cx, n) {
        return error;
    }

    cx.message_at(start, error)
}