-
Notifications
You must be signed in to change notification settings - Fork 528
/
core.rs
88 lines (73 loc) · 1.99 KB
/
core.rs
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
//! Reimplements core logic and types from `std::io` in an `alloc`-friendly
//! fashion.
use alloc::vec::Vec;
use core::fmt::{self, Display};
use core::result;
/// see [`std::io::ErrorKind`]
pub enum ErrorKind {
/// see [`std::io::ErrorKind::Other`]
Other,
}
/// see [`std::io::Error`]
// I/O errors can never occur in no-std mode. All our no-std I/O implementations
// are infallible.
pub struct Error;
impl Display for Error {
fn fmt(&self, _formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
unreachable!()
}
}
impl Error {
/// see [`std::io::Error::new`]
pub fn new(_kind: ErrorKind, _error: &'static str) -> Error {
Error
}
}
/// see [`std::io::Result`]
pub type Result<T> = result::Result<T, Error>;
/// see [`std::io::Write`]
pub trait Write {
/// see [`std::io::Write::write`]
fn write(&mut self, buf: &[u8]) -> Result<usize>;
/// see [`std::io::Write::write_all`]
fn write_all(&mut self, buf: &[u8]) -> Result<()> {
// All our Write impls in no_std mode always write the whole buffer in
// one call infallibly.
let result = self.write(buf);
debug_assert!(result.is_ok());
debug_assert_eq!(result.unwrap_or(0), buf.len());
Ok(())
}
/// see [`std::io::Write::flush`]
fn flush(&mut self) -> Result<()>;
}
impl<W: Write> Write for &mut W {
#[inline]
fn write(&mut self, buf: &[u8]) -> Result<usize> {
(*self).write(buf)
}
#[inline]
fn write_all(&mut self, buf: &[u8]) -> Result<()> {
(*self).write_all(buf)
}
#[inline]
fn flush(&mut self) -> Result<()> {
(*self).flush()
}
}
impl Write for Vec<u8> {
#[inline]
fn write(&mut self, buf: &[u8]) -> Result<usize> {
self.extend_from_slice(buf);
Ok(buf.len())
}
#[inline]
fn write_all(&mut self, buf: &[u8]) -> Result<()> {
self.extend_from_slice(buf);
Ok(())
}
#[inline]
fn flush(&mut self) -> Result<()> {
Ok(())
}
}