Remove BufReader::poll_seek_relative

futures-util/src/io/buf_reader.rs

@@ -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>,
@@ -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)`

futures/tests/io_buf_reader.rs

@@ -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];
@@ -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