iof 0.5.0

Read from and write data to console or file in simple formats.
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

use crate::impl_read_one_from_for_from_str;
use std::num::*;

#[cfg(feature = "c-compatible")]
mod inner {
    use crate::ext::{Pattern, State};

    #[derive(Debug, Clone, Copy)]
    pub(super) enum Unsigned {
        Initial,
        Sign,
        Digits,
        // Overrun,
    }

    impl Pattern for Unsigned {
        type Item = char;

        #[inline]
        fn step(&mut self, c: <Self as Pattern>::Item) -> bool {
            match self {
                Self::Initial => {
                    match c {
                        '+' => *self = Self::Sign,
                        _ if c.is_ascii_digit() => *self = Self::Digits,
                        _ => return false,
                    }
                    // if c == '+' {
                    //     *self = Self::Sign;
                    //     Ok(true)
                    // } else if c.is_ascii_digit() {
                    //     *self = Self::Digits;
                    //     Ok(false)
                    // } else {
                    //     Err(PatternError::UnexpectedChar(c))
                    // }
                }
                Self::Sign => {
                    match c {
                        _ if c.is_ascii_digit() => *self = Self::Digits,
                        _ => return false,
                    }
                    // if c.is_ascii_digit() {
                    //     *self = Self::Digits;
                    //     Ok(false)
                    // } else {
                    //     Err(PatternError::UnexpectedChar(c))
                    // }
                }
                Self::Digits => return c.is_ascii_digit(),
                // Self::Overrun => {}
            }
            true
        }

        #[inline]
        fn state(&self) -> State {
            match self {
                Self::Digits => State::Stoppable,
                // Self::Overrun => State::Overrun,
                Self::Initial | Self::Sign => State::Unfulfilled,
            }
        }
    }
}

#[cfg(feature = "c-compatible")]
impl_read_one_from_for_from_str!(
    u8
    u16
    u32
    u64
    u128
    usize

    NonZeroU8
    NonZeroU16
    NonZeroU32
    NonZeroU64
    NonZeroU128
    NonZeroUsize

    => inner::Unsigned::Initial
);

#[cfg(not(feature = "c-compatible"))]
impl_read_one_from_for_from_str!(
    u8
    u16
    u32
    u64
    u128
    usize

    NonZeroU8
    NonZeroU16
    NonZeroU32
    NonZeroU64
    NonZeroU128
    NonZeroUsize
);