Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Remove BufReader::poll_seek_relative #1938

Merged
merged 1 commit into from Nov 4, 2019
Merged

Remove BufReader::poll_seek_relative #1938

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
30 changes: 0 additions & 30 deletions futures-util/src/io/buf_reader.rs
View file
Open in desktop
Expand Up @@ -103,33 +103,6 @@ impl<R: AsyncRead> BufReader<R> {
}
}

impl<R: AsyncRead + AsyncSeek> BufReader<R> {
// https://github.com/rust-lang/rust/issues/31100
/// Seeks relative to the current position. If the new position lies within the buffer,
/// the buffer will not be flushed, allowing for more efficient seeks.
/// This method does not return the location of the underlying reader, so the caller
/// must track this information themselves if it is required.
pub fn poll_seek_relative(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>,
offset: i64,
) -> Poll<io::Result<()>> {
let pos = self.pos as u64;
if offset < 0 {
if let Some(new_pos) = pos.checked_sub((-offset) as u64) {
*self.as_mut().pos() = new_pos as usize;
return Poll::Ready(Ok(()));
}
} else if let Some(new_pos) = pos.checked_add(offset as u64) {
if new_pos <= self.cap as u64 {
*self.as_mut().pos() = new_pos as usize;
return Poll::Ready(Ok(()));
}
}
self.poll_seek(cx, SeekFrom::Current(offset)).map(|res| res.map(|_| ()))
}
}

impl<R: AsyncRead> AsyncRead for BufReader<R> {
fn poll_read(
mut self: Pin<&mut Self>,
Expand Down Expand Up @@ -220,9 +193,6 @@ impl<R: AsyncRead + AsyncSeek> AsyncSeek for BufReader<R> {
/// `.into_inner()` immediately after a seek yields the underlying reader
/// at the same position.
///
/// To seek without discarding the internal buffer, use
/// [`BufReader::poll_seek_relative`](BufReader::poll_seek_relative).
///
/// See [`AsyncSeek`](futures_io::AsyncSeek) for more details.
///
/// Note: In the edge case where you're seeking with `SeekFrom::Current(n)`
Expand Down
62 changes: 0 additions & 62 deletions futures/tests/io_buf_reader.rs
View file
Open in desktop
Expand Up @@ -36,17 +36,6 @@ macro_rules! run_fill_buf {
}};
}

macro_rules! run_seek_relative {
($reader:expr, $offset:expr) => {{
let mut cx = noop_context();
loop {
if let Poll::Ready(x) = Pin::new(&mut $reader).poll_seek_relative(&mut cx, $offset) {
break x;
}
}
}};
}

#[test]
fn test_buffered_reader() {
let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
Expand Down Expand Up @@ -99,57 +88,6 @@ fn test_buffered_reader_seek() {
assert_eq!(block_on(reader.seek(SeekFrom::Current(-2))).ok(), Some(3));
}

#[test]
fn test_buffered_reader_seek_relative() {
let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
let mut reader = BufReader::with_capacity(2, Cursor::new(inner));

assert!(run_seek_relative!(reader, 3).is_ok());
assert_eq!(run_fill_buf!(reader).ok(), Some(&[0, 1][..]));
assert!(run_seek_relative!(reader, 0).is_ok());
assert_eq!(run_fill_buf!(reader).ok(), Some(&[0, 1][..]));
assert!(run_seek_relative!(reader, 1).is_ok());
assert_eq!(run_fill_buf!(reader).ok(), Some(&[1][..]));
assert!(run_seek_relative!(reader, -1).is_ok());
assert_eq!(run_fill_buf!(reader).ok(), Some(&[0, 1][..]));
assert!(run_seek_relative!(reader, 2).is_ok());
assert_eq!(run_fill_buf!(reader).ok(), Some(&[2, 3][..]));
}

#[test]
fn test_buffered_reader_invalidated_after_read() {
let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
let mut reader = BufReader::with_capacity(3, Cursor::new(inner));

assert_eq!(run_fill_buf!(reader).ok(), Some(&[5, 6, 7][..]));
Pin::new(&mut reader).consume(3);

let mut buffer = [0, 0, 0, 0, 0];
assert_eq!(block_on(reader.read(&mut buffer)).ok(), Some(5));
assert_eq!(buffer, [0, 1, 2, 3, 4]);

assert!(run_seek_relative!(reader, -2).is_ok());
let mut buffer = [0, 0];
assert_eq!(block_on(reader.read(&mut buffer)).ok(), Some(2));
assert_eq!(buffer, [3, 4]);
}

#[test]
fn test_buffered_reader_invalidated_after_seek() {
let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
let mut reader = BufReader::with_capacity(3, Cursor::new(inner));

assert_eq!(run_fill_buf!(reader).ok(), Some(&[5, 6, 7][..]));
Pin::new(&mut reader).consume(3);

assert!(block_on(reader.seek(SeekFrom::Current(5))).is_ok());

assert!(run_seek_relative!(reader, -2).is_ok());
let mut buffer = [0, 0];
assert_eq!(block_on(reader.read(&mut buffer)).ok(), Some(2));
assert_eq!(buffer, [3, 4]);
}

#[test]
fn test_buffered_reader_seek_underflow() {
// gimmick reader that yields its position modulo 256 for each byte
Expand Down