manger 0.1.1

A performant, low-level, lightweight and intuitive combinatoric parser 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

use crate::chars;
use crate::common::{Digit, OneOrMore, Sign};
use crate::error::ConsumeError;
use crate::error::ConsumeErrorType::*;
use crate::{consume_enum, Consumable};
use std::str::FromStr;

enum FloatNumberStruct {
    NoPeriod,
    PeriodStart,
    PeriodMiddle,
}

consume_enum!(
    FloatNumberStruct {
        PeriodStart => [
            : chars::Period,
            : OneOrMore<Digit>;
        ],
        PeriodMiddle => [
            : OneOrMore<Digit>,
            : chars::Period,
            : OneOrMore<Digit>;
        ],
        NoPeriod => [
            : OneOrMore<Digit>;
        ]
    }
);

enum FloatStructure {
    Float,
    Infinity,
    NaN,
}

use crate::chars::alpha;
consume_enum!(
    FloatStructure {
        Float => [
            : Sign,
            : FloatNumberStruct,
            : Option<(alpha::E, OneOrMore<Digit>)>;
        ],
        Infinity => [
            : Sign,
            : alpha::I,
            : alpha::N,
            : alpha::F,
            : alpha::I,
            : alpha::N,
            : alpha::I,
            : alpha::T,
            : alpha::Y;
        ],
        NaN => [
            : alpha::N,
            : alpha::A,
            : alpha::N;
        ]
    }
);

impl Consumable for f32 {
    fn consume_from(source: &str) -> Result<(Self, &str), ConsumeError> {
        let (_, unconsumed) = FloatNumberStruct::consume_from(source)?;

        Ok((
            <f32>::from_str(utf8_slice::till(
                source,
                utf8_slice::len(source) - utf8_slice::len(unconsumed),
            ))
            .map_err(|_| ConsumeError::new_with(InvalidValue { index: 0 }))?,
            unconsumed,
        ))
    }
}