Skip to content

Commit c1aae4d

Browse files
nrcnrc
committed
std::io: migrate ReadBuf to BorrowBuf/BorrowCursor
Signed-off-by: Nick Cameron <[email protected]>
1 parent 6f18f0a commit c1aae4d

File tree

14 files changed

+324
-390
lines changed

14 files changed

+324
-390
lines changed

‎library/std/src/fs.rs

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ mod tests;
1313

1414
use crate::ffi::OsString;
1515
use crate::fmt;
16-
use crate::io::{self, IoSlice, IoSliceMut, Read, ReadBuf, Seek, SeekFrom, Write};
16+
use crate::io::{self, BorrowCursor, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write};
1717
use crate::path::{Path, PathBuf};
1818
use crate::sys::fs as fs_imp;
1919
use crate::sys_common::{AsInner, AsInnerMut, FromInner, IntoInner};
@@ -703,8 +703,8 @@ impl Read for File {
703703
self.inner.read_vectored(bufs)
704704
}
705705

706-
fn read_buf(&mut self, buf: &mut ReadBuf<'_>) -> io::Result<()> {
707-
self.inner.read_buf(buf)
706+
fn read_buf(&mut self, cursor: BorrowCursor<'_, '_>) -> io::Result<()> {
707+
self.inner.read_buf(cursor)
708708
}
709709

710710
#[inline]
@@ -755,8 +755,8 @@ impl Read for &File {
755755
self.inner.read(buf)
756756
}
757757

758-
fn read_buf(&mut self, buf: &mut ReadBuf<'_>) -> io::Result<()> {
759-
self.inner.read_buf(buf)
758+
fn read_buf(&mut self, cursor: BorrowCursor<'_, '_>) -> io::Result<()> {
759+
self.inner.read_buf(cursor)
760760
}
761761

762762
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {

‎library/std/src/io/buffered/bufreader.rs

Lines changed: 8 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,8 @@ mod buffer;
22

33
use crate::fmt;
44
use crate::io::{
5-
self, BufRead, IoSliceMut, Read, ReadBuf, Seek, SeekFrom, SizeHint, DEFAULT_BUF_SIZE,
5+
self, BorrowBuf, BorrowCursor, BufRead, IoSliceMut, Read, Seek, SeekFrom, SizeHint,
6+
DEFAULT_BUF_SIZE,
67
};
78
use buffer::Buffer;
89

@@ -266,21 +267,21 @@ impl<R: Read> Read for BufReader<R> {
266267
Ok(nread)
267268
}
268269

269-
fn read_buf(&mut self, buf: &mut ReadBuf<'_>) -> io::Result<()> {
270+
fn read_buf(&mut self, mut cursor: BorrowCursor<'_, '_>) -> io::Result<()> {
270271
// If we don't have any buffered data and we're doing a massive read
271272
// (larger than our internal buffer), bypass our internal buffer
272273
// entirely.
273-
if self.buf.pos() == self.buf.filled() && buf.remaining() >= self.capacity() {
274+
if self.buf.pos() == self.buf.filled() && cursor.capacity() >= self.capacity() {
274275
self.discard_buffer();
275-
return self.inner.read_buf(buf);
276+
return self.inner.read_buf(cursor);
276277
}
277278

278-
let prev = buf.filled_len();
279+
let prev = cursor.written();
279280

280281
let mut rem = self.fill_buf()?;
281-
rem.read_buf(buf)?;
282+
rem.read_buf(cursor.clone())?;
282283

283-
self.consume(buf.filled_len() - prev); //slice impl of read_buf known to never unfill buf
284+
self.consume(cursor.written() - prev); //slice impl of read_buf known to never unfill buf
284285

285286
Ok(())
286287
}

‎library/std/src/io/buffered/tests.rs

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
use crate::io::prelude::*;
2-
use crate::io::{self, BufReader, BufWriter, ErrorKind, IoSlice, LineWriter, ReadBuf, SeekFrom};
2+
use crate::io::{self, BorrowBuf, BufReader, BufWriter, ErrorKind, IoSlice, LineWriter, SeekFrom};
33
use crate::mem::MaybeUninit;
44
use crate::panic;
55
use crate::sync::atomic::{AtomicUsize, Ordering};
@@ -61,48 +61,48 @@ fn test_buffered_reader_read_buf() {
6161
let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
6262
let mut reader = BufReader::with_capacity(2, inner);
6363

64-
let mut buf = [MaybeUninit::uninit(); 3];
65-
let mut buf = ReadBuf::uninit(&mut buf);
64+
let buf: &mut [_] = &mut [MaybeUninit::uninit(); 3];
65+
let mut buf: BorrowBuf<'_> = buf.into();
6666

67-
reader.read_buf(&mut buf).unwrap();
67+
reader.read_buf(buf.unfilled()).unwrap();
6868

6969
assert_eq!(buf.filled(), [5, 6, 7]);
7070
assert_eq!(reader.buffer(), []);
7171

72-
let mut buf = [MaybeUninit::uninit(); 2];
73-
let mut buf = ReadBuf::uninit(&mut buf);
72+
let buf: &mut [_] = &mut [MaybeUninit::uninit(); 2];
73+
let mut buf: BorrowBuf<'_> = buf.into();
7474

75-
reader.read_buf(&mut buf).unwrap();
75+
reader.read_buf(buf.unfilled()).unwrap();
7676

7777
assert_eq!(buf.filled(), [0, 1]);
7878
assert_eq!(reader.buffer(), []);
7979

80-
let mut buf = [MaybeUninit::uninit(); 1];
81-
let mut buf = ReadBuf::uninit(&mut buf);
80+
let buf: &mut [_] = &mut [MaybeUninit::uninit(); 1];
81+
let mut buf: BorrowBuf<'_> = buf.into();
8282

83-
reader.read_buf(&mut buf).unwrap();
83+
reader.read_buf(buf.unfilled()).unwrap();
8484

8585
assert_eq!(buf.filled(), [2]);
8686
assert_eq!(reader.buffer(), [3]);
8787

88-
let mut buf = [MaybeUninit::uninit(); 3];
89-
let mut buf = ReadBuf::uninit(&mut buf);
88+
let buf: &mut [_] = &mut [MaybeUninit::uninit(); 3];
89+
let mut buf: BorrowBuf<'_> = buf.into();
9090

91-
reader.read_buf(&mut buf).unwrap();
91+
reader.read_buf(buf.unfilled()).unwrap();
9292

9393
assert_eq!(buf.filled(), [3]);
9494
assert_eq!(reader.buffer(), []);
9595

96-
reader.read_buf(&mut buf).unwrap();
96+
reader.read_buf(buf.unfilled()).unwrap();
9797

9898
assert_eq!(buf.filled(), [3, 4]);
9999
assert_eq!(reader.buffer(), []);
100100

101101
buf.clear();
102102

103-
reader.read_buf(&mut buf).unwrap();
103+
reader.read_buf(buf.unfilled()).unwrap();
104104

105-
assert_eq!(buf.filled_len(), 0);
105+
assert!(buf.filled().is_empty());
106106
}
107107

108108
#[test]

‎library/std/src/io/copy.rs

Lines changed: 18 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
use super::{BufWriter, ErrorKind, Read, ReadBuf, Result, Write, DEFAULT_BUF_SIZE};
1+
use super::{BorrowBuf, BufWriter, ErrorKind, Read, Result, Write, DEFAULT_BUF_SIZE};
22
use crate::mem::MaybeUninit;
33

44
/// Copies the entire contents of a reader into a writer.
@@ -97,37 +97,39 @@ impl<I: Write> BufferedCopySpec for BufWriter<I> {
9797

9898
loop {
9999
let buf = writer.buffer_mut();
100-
let mut read_buf = ReadBuf::uninit(buf.spare_capacity_mut());
100+
let mut read_buf: BorrowBuf<'_> = buf.spare_capacity_mut().into();
101101

102-
// SAFETY: init is either 0 or the initialized_len of the previous iteration
103102
unsafe {
104-
read_buf.assume_init(init);
103+
// SAFETY: init is either 0 or the init_len from the previous iteration.
104+
read_buf.set_init(init);
105105
}
106106

107107
if read_buf.capacity() >= DEFAULT_BUF_SIZE {
108-
match reader.read_buf(&mut read_buf) {
108+
let mut cursor = read_buf.unfilled();
109+
match reader.read_buf(cursor.clone()) {
109110
Ok(()) => {
110-
let bytes_read = read_buf.filled_len();
111+
let bytes_read = cursor.written();
111112

112113
if bytes_read == 0 {
113114
return Ok(len);
114115
}
115116

116-
init = read_buf.initialized_len() - bytes_read;
117+
init = read_buf.init_len() - bytes_read;
118+
len += bytes_read as u64;
117119

118-
// SAFETY: ReadBuf guarantees all of its filled bytes are init
120+
// SAFETY: BorrowBuf guarantees all of its filled bytes are init
119121
unsafe { buf.set_len(buf.len() + bytes_read) };
120-
len += bytes_read as u64;
122+
121123
// Read again if the buffer still has enough capacity, as BufWriter itself would do
122124
// This will occur if the reader returns short reads
123-
continue;
124125
}
125-
Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
126+
Err(ref e) if e.kind() == ErrorKind::Interrupted => {}
126127
Err(e) => return Err(e),
127128
}
129+
} else {
130+
writer.flush_buf()?;
131+
init = 0;
128132
}
129-
130-
writer.flush_buf()?;
131133
}
132134
}
133135
}
@@ -136,13 +138,13 @@ fn stack_buffer_copy<R: Read + ?Sized, W: Write + ?Sized>(
136138
reader: &mut R,
137139
writer: &mut W,
138140
) -> Result<u64> {
139-
let mut buf = [MaybeUninit::uninit(); DEFAULT_BUF_SIZE];
140-
let mut buf = ReadBuf::uninit(&mut buf);
141+
let buf: &mut [_] = &mut [MaybeUninit::uninit(); DEFAULT_BUF_SIZE];
142+
let mut buf: BorrowBuf<'_> = buf.into();
141143

142144
let mut len = 0;
143145

144146
loop {
145-
match reader.read_buf(&mut buf) {
147+
match reader.read_buf(buf.unfilled()) {
146148
Ok(()) => {}
147149
Err(e) if e.kind() == ErrorKind::Interrupted => continue,
148150
Err(e) => return Err(e),

‎library/std/src/io/cursor.rs

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ use crate::io::prelude::*;
55

66
use crate::alloc::Allocator;
77
use crate::cmp;
8-
use crate::io::{self, ErrorKind, IoSlice, IoSliceMut, ReadBuf, SeekFrom};
8+
use crate::io::{self, BorrowCursor, ErrorKind, IoSlice, IoSliceMut, SeekFrom};
99

1010
/// A `Cursor` wraps an in-memory buffer and provides it with a
1111
/// [`Seek`] implementation.
@@ -323,12 +323,12 @@ where
323323
Ok(n)
324324
}
325325

326-
fn read_buf(&mut self, buf: &mut ReadBuf<'_>) -> io::Result<()> {
327-
let prev_filled = buf.filled_len();
326+
fn read_buf(&mut self, mut cursor: BorrowCursor<'_, '_>) -> io::Result<()> {
327+
let prev_written = cursor.written();
328328

329-
Read::read_buf(&mut self.fill_buf()?, buf)?;
329+
Read::read_buf(&mut self.fill_buf()?, cursor.clone())?;
330330

331-
self.pos += (buf.filled_len() - prev_filled) as u64;
331+
self.pos += (cursor.written() - prev_written) as u64;
332332

333333
Ok(())
334334
}

‎library/std/src/io/impls.rs

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ use crate::cmp;
66
use crate::collections::VecDeque;
77
use crate::fmt;
88
use crate::io::{
9-
self, BufRead, ErrorKind, IoSlice, IoSliceMut, Read, ReadBuf, Seek, SeekFrom, Write,
9+
self, BorrowCursor, BufRead, ErrorKind, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write,
1010
};
1111
use crate::mem;
1212

@@ -21,8 +21,8 @@ impl<R: Read + ?Sized> Read for &mut R {
2121
}
2222

2323
#[inline]
24-
fn read_buf(&mut self, buf: &mut ReadBuf<'_>) -> io::Result<()> {
25-
(**self).read_buf(buf)
24+
fn read_buf(&mut self, cursor: BorrowCursor<'_, '_>) -> io::Result<()> {
25+
(**self).read_buf(cursor)
2626
}
2727

2828
#[inline]
@@ -125,8 +125,8 @@ impl<R: Read + ?Sized> Read for Box<R> {
125125
}
126126

127127
#[inline]
128-
fn read_buf(&mut self, buf: &mut ReadBuf<'_>) -> io::Result<()> {
129-
(**self).read_buf(buf)
128+
fn read_buf(&mut self, cursor: BorrowCursor<'_, '_>) -> io::Result<()> {
129+
(**self).read_buf(cursor)
130130
}
131131

132132
#[inline]
@@ -249,11 +249,11 @@ impl Read for &[u8] {
249249
}
250250

251251
#[inline]
252-
fn read_buf(&mut self, buf: &mut ReadBuf<'_>) -> io::Result<()> {
253-
let amt = cmp::min(buf.remaining(), self.len());
252+
fn read_buf(&mut self, mut cursor: BorrowCursor<'_, '_>) -> io::Result<()> {
253+
let amt = cmp::min(cursor.capacity(), self.len());
254254
let (a, b) = self.split_at(amt);
255255

256-
buf.append(a);
256+
cursor.append(a);
257257

258258
*self = b;
259259
Ok(())

0 commit comments

Comments
 (0)