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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use super::fmt::Default;
use crate::{stream, unwrap, BufReadExt, ReadOneFrom, ReadOneFromError};

/// The opposite of [ReadOneFrom].
pub trait ReadOneInto<T> {
    /// Errors that come from [ReadOneFrom].
    ///
    /// This is usually [ReadError].
    ///
    /// [ReadError]: crate::ReadError
    type Error: std::error::Error + From<stream::error::StreamError>;

    /// Read one from `self` and parse into `T`.
    fn try_read_one(&mut self) -> Result<T, Self::Error>;

    /// Read an element in a single non-whitespace character from `self`, parse into `T`.
    fn try_read_in_char(&mut self) -> Result<T, Self::Error>;

    /// Read an element in the remained line from `self`, parse into `T`.
    fn try_read_in_line_trimmed(&mut self) -> Result<T, Self::Error>;

    /// Read an element in a single trimmed line that is not empty from `self`, parse into `T`.
    fn try_read_in_line_some_trimmed(&mut self) -> Result<T, Self::Error>;

    /// Read all remaining elements from `stream`.
    fn try_read_all(&mut self) -> Result<Vec<T>, Self::Error>;

    /// Read all elements in current line from `self`.
    fn try_read_any_in_line(&mut self) -> Result<Vec<T>, Self::Error>;

    /// Read all elements in a non-empty line from `self`.
    fn try_read_some_in_line(&mut self) -> Result<Vec<T>, Self::Error>;

    /// Unwrap the result of [ReadOneInto::try_read_one].
    #[inline]
    #[track_caller]
    fn read_one(&mut self) -> T {
        unwrap!(self.try_read_one())
    }

    /// Unwrap the result of [ReadOneInto::try_read_in_char].
    #[inline]
    #[track_caller]
    fn read_in_char(&mut self) -> T {
        unwrap!(self.try_read_in_char())
    }

    /// Unwrap the result of [ReadOneInto::try_read_in_line_trimmed].
    #[inline]
    #[track_caller]
    fn read_in_line_trimmed(&mut self) -> T {
        unwrap!(self.try_read_in_line_trimmed())
    }

    /// Unwrap the result of [ReadOneInto::try_read_in_line_some_trimmed].
    #[inline]
    #[track_caller]
    fn read_in_line_some_trimmed(&mut self) -> T {
        unwrap!(self.try_read_in_line_some_trimmed())
    }

    /// Unwrap the result of [ReadOneInto::try_read_all].
    #[inline]
    #[track_caller]
    fn read_all(&mut self) -> Vec<T> {
        unwrap!(self.try_read_all())
    }

    /// Unwrap the result of [ReadOneInto::try_read_any_in_line].
    #[inline]
    #[track_caller]
    fn read_any_in_line(&mut self) -> Vec<T> {
        unwrap!(self.try_read_any_in_line())
    }

    /// Unwrap the result of [ReadOneInto::try_read_some_in_line].
    #[inline]
    #[track_caller]
    fn read_some_in_line(&mut self) -> Vec<T> {
        unwrap!(self.try_read_some_in_line())
    }
}

impl<T: ReadOneFrom, U: BufReadExt> ReadOneInto<T> for U {
    type Error = ReadOneFromError<T>;

    #[inline]
    fn try_read_one(&mut self) -> Result<T, Self::Error> {
        T::try_read_one_from(self, Default::new())
    }

    #[inline]
    fn try_read_in_char(&mut self) -> Result<T, Self::Error> {
        T::try_read_in_char_from(self, Default::new())
    }

    #[inline]
    fn try_read_in_line_trimmed(&mut self) -> Result<T, Self::Error> {
        T::try_read_in_line_trimmed_from(self, Default::new())
    }

    #[inline]
    fn try_read_in_line_some_trimmed(&mut self) -> Result<T, Self::Error> {
        T::try_read_in_line_some_trimmed_from(self, Default::new())
    }

    #[inline]
    fn try_read_all(&mut self) -> Result<Vec<T>, Self::Error> {
        T::try_read_all_from(self, Default::new())
    }

    #[inline]
    fn try_read_any_in_line(&mut self) -> Result<Vec<T>, Self::Error> {
        T::try_read_any_in_line_from(self, Default::new())
    }

    #[inline]
    fn try_read_some_in_line(&mut self) -> Result<Vec<T>, Self::Error> {
        T::try_read_some_in_line_from(self, Default::new())
    }
}