buni-rs 1.1.0

Reference Buni serializer / deserializer in Rust
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

use crate::deserialize::Item;
use alloc::str::FromStr;
use alloc::string::ToString;
use core::cell::Cell;
use nom::character::streaming::{char, digit1};
use nom::error::{ErrorKind, ParseError};
use nom::sequence::preceded;
use nom::Parser;
use nom::{AsChar, IResult, Input};

pub fn int<'a, I: Input + ToString, E: ParseError<I>>(input: I) -> IResult<I, Item, E>
where <I as Input>::Item: AsChar {
    let string_int = preceded(char('-'), digit1).parse(input)?;
    Ok((string_int.0, Item::Int(0 - i64::from_str(string_int.1.to_string().as_str()).map_err(|_| {
        nom::Err::Error(E::from_error_kind(string_int.1, ErrorKind::Digit))
    })?)))
}

#[test]
pub fn test_int() {
    use nom::Finish;
    use crate::DeserializeError;
    assert_eq!(int::<&str, DeserializeError<&str>>("-727nya").finish().unwrap(), ("nya", Item::Int(-727)))
}

pub fn uint<'a, I: Input + ToString, E: ParseError<I>>(input: I) -> IResult<I, Item, E>
where <I as Input>::Item: AsChar {
    let string_int = digit1.parse(input)?;
    Ok((string_int.0, Item::UInt(u64::from_str(string_int.1.to_string().as_str()).map_err(|_| {
        nom::Err::Error(E::from_error_kind(string_int.1, ErrorKind::Digit))
    })?)))
}

#[test]
pub fn test_uint() {
    use nom::Finish;
    use crate::DeserializeError;
    assert_eq!(uint::<&str, DeserializeError<&str>>("727nya").finish().unwrap(), ("nya", Item::UInt(727)))
}

fn float_matcher<I: Input, E: ParseError<I>>(input: I) -> IResult<I, I, E>
where <I as Input>::Item: AsChar {
    let float_found = Cell::new(false);
    let dot_found = Cell::new(false);
    let e_found = Cell::new(false);
    let must_be_digit = Cell::new(false);
    let result = input.split_at_position1(|c| {
        let dot = c.as_char() == '.';
        let e = c.as_char() == 'e';
        let is_digit = matches!(c.as_char(), '0'..='9');
        if dot | e {
            if dot {
                if dot_found.get() {
                    float_found.set(false);
                    return true;
                } else {
                    dot_found.set(true);
                }
            }
            if e {
                if e_found.get() {
                    float_found.set(false);
                    return true;
                } else {
                    e_found.set(true);
                }
            }
            float_found.replace(true);
            must_be_digit.replace(true);
        } else {
            if must_be_digit.get() {
                if is_digit {
                    must_be_digit.set(false);
                } else {
                    float_found.set(false);
                    return true;
                }
            }
        }
        !(dot | e | is_digit)
    }, ErrorKind::Digit);
    if !float_found.get() {
        Err(nom::Err::Error(E::from_error_kind(input, ErrorKind::IsNot)))
    } else {
        result
    }
}

pub fn float<I: Input + ToString, E: ParseError<I>>(input: I) -> IResult<I, Item, E>
where <I as Input>::Item: AsChar {
    let string_float = float_matcher.parse(input)?;
    Ok((string_float.0, Item::Float(f64::from_str(string_float.1.to_string().as_str()).map_err(|_| {
        nom::Err::Error(E::from_error_kind(string_float.1, ErrorKind::Digit))
    })?)))
}

#[test]
pub fn test_float() {
    use nom::Finish;
    use crate::DeserializeError;
    assert_eq!(float::<&str, DeserializeError<&str>>("7.27nya").finish().unwrap(), ("nya", Item::Float(7.27)));
    match float::<&str, DeserializeError<&str>>("727nya").finish().unwrap_err() {
        DeserializeError::ParseError(_, kind) => {
            assert_eq!(kind, ErrorKind::IsNot);
        }
        _ => assert!(false),
    }
    match float::<&str, DeserializeError<&str>>("727.nya").finish().unwrap_err() {
        DeserializeError::ParseError(_, kind) => {
            assert_eq!(kind, ErrorKind::IsNot);
        }
        _ => assert!(false),
    }
    match float::<&str, DeserializeError<&str>>("72..7nya").finish().unwrap_err(){
        DeserializeError::ParseError(_, kind) => {
            assert_eq!(kind, ErrorKind::IsNot);
        }
        _ => assert!(false),
    }
    assert_eq!(float::<&str, DeserializeError<&str>>("7e27nya").finish().unwrap(), ("nya", Item::Float(7e27)))
}