Struct buf_list::Cursor

pub struct Cursor<T> { /* private fields */ }

A Cursor wraps an in-memory BufList and provides it with a Seek implementation.

Cursors allow BufLists to implement Read and BufRead, allowing a BufList to be used anywhere you might use a reader or writer that does actual I/O.

The cursor may either own or borrow a BufList: both Cursor<BufList> and Cursor<&BufList> are supported.

Optional features

• tokio1: With this feature enabled, Cursor implements the tokio crate’s AsyncSeek, AsyncRead and AsyncBufRead.
• futures03: With this feature enabled, Cursor implements the futures crate’s AsyncSeek, AsyncRead and AsyncBufRead.

Implementations

impl<T: AsRef<BufList>> Cursor<T>

pub fn new(inner: T) -> Cursor<T>

Creates a new cursor wrapping the provided BufList.

Examples

use buf_list::{BufList, Cursor};

let cursor = Cursor::new(BufList::new());

pub fn into_inner(self) -> T

Consumes this cursor, returning the underlying value.

Examples

use buf_list::{BufList, Cursor};

let cursor = Cursor::new(BufList::new());

let vec = cursor.into_inner();

pub const fn get_ref(&self) -> &T

Gets a reference to the underlying value in this cursor.

Examples

use buf_list::{BufList, Cursor};

let cursor = Cursor::new(BufList::new());

let reference = cursor.get_ref();

pub const fn position(&self) -> u64

Returns the current position of this cursor.

Examples

use buf_list::{BufList, Cursor};
use std::io::prelude::*;
use std::io::SeekFrom;

let mut cursor = Cursor::new(BufList::from(&[1, 2, 3, 4, 5][..]));

assert_eq!(cursor.position(), 0);

cursor.seek(SeekFrom::Current(2)).unwrap();
assert_eq!(cursor.position(), 2);

cursor.seek(SeekFrom::Current(-1)).unwrap();
assert_eq!(cursor.position(), 1);

pub fn set_position(&mut self, pos: u64)

Sets the position of this cursor.

Examples

use buf_list::{BufList, Cursor};

let mut cursor = Cursor::new(BufList::from(&[1, 2, 3, 4, 5][..]));

assert_eq!(cursor.position(), 0);

cursor.set_position(2);
assert_eq!(cursor.position(), 2);

cursor.set_position(4);
assert_eq!(cursor.position(), 4);

Trait Implementations

impl<T: AsRef<BufList> + Unpin> AsyncBufRead for Cursor<T>

Available on crate feature futures03 only.

fn poll_fill_buf(
    self: Pin<&mut Self>,
    _: &mut Context<'_>
) -> Poll<Result<&[u8]>>

Attempt to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(self: Pin<&mut Self>, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to poll_read.

impl<T: AsRef<BufList> + Unpin> AsyncBufRead for Cursor<T>

Available on crate feature tokio1 only.

fn poll_fill_buf(
    self: Pin<&mut Self>,
    _: &mut Context<'_>
) -> Poll<Result<&[u8]>>

Attempts to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(self: Pin<&mut Self>, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to poll_read.

impl<T: AsRef<BufList> + Unpin> AsyncRead for Cursor<T>

Available on crate feature futures03 only.

fn poll_read(
    self: Pin<&mut Self>,
    _cx: &mut Context<'_>,
    buf: &mut [u8]
) -> Poll<Result<usize>>

Attempt to read from the AsyncRead into buf.

fn poll_read_vectored(
    self: Pin<&mut Self>,
    _: &mut Context<'_>,
    bufs: &mut [IoSliceMut<'_>]
) -> Poll<Result<usize>>

Attempt to read from the AsyncRead into bufs using vectored IO operations.

impl<T: AsRef<BufList> + Unpin> AsyncRead for Cursor<T>

Available on crate feature tokio1 only.

fn poll_read(
    self: Pin<&mut Self>,
    _: &mut Context<'_>,
    buf: &mut ReadBuf<'_>
) -> Poll<Result<()>>

Attempts to read from the AsyncRead into buf.

impl<T: AsRef<BufList> + Unpin> AsyncSeek for Cursor<T>

Available on crate feature futures03 only.

fn poll_seek(
    self: Pin<&mut Self>,
    _: &mut Context<'_>,
    pos: SeekFrom
) -> Poll<Result<u64>>

Attempt to seek to an offset, in bytes, in a stream.

impl<T: AsRef<BufList> + Unpin> AsyncSeek for Cursor<T>

Available on crate feature tokio1 only.

fn start_seek(self: Pin<&mut Self>, pos: SeekFrom) -> Result<()>

Attempts to seek to an offset, in bytes, in a stream.

fn poll_complete(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<u64>>

Waits for a seek operation to complete.

impl<T: AsRef<BufList>> BufRead for Cursor<T>

fn fill_buf(&mut self) -> Result<&[u8]>

Returns the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(&mut self, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to read.

fn has_data_left(&mut self) -> Result<bool, Error>

🔬This is a nightly-only experimental API. (buf_read_has_data_left)

Check if the underlying Read has any data left to be read.

fn read_until(
    &mut self,
    byte: u8,
    buf: &mut Vec<u8, Global>
) -> Result<usize, Error>

Read all bytes into buf until the delimiter byte or EOF is reached.

fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until a newline (the 0xA byte) is reached, and append them to the provided String buffer.

fn split(self, byte: u8) -> Split<Self>where
    Self: Sized,

Returns an iterator over the contents of this reader split on the byte byte.

fn lines(self) -> Lines<Self>where
    Self: Sized,

Returns an iterator over the lines of this reader.

impl<T> Clone for Cursor<T>where
    T: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, other: &Self)

Performs copy-assignment from source.

impl<T: AsRef<BufList>> Read for Cursor<T>

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

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

Like read, except that it reads into a slice of buffers.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<()>

Read the exact number of bytes required to fill buf.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Read the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Selfwhere
    Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>where
    Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>where
    R: Read,
    Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>where
    Self: Sized,

Creates an adapter which will read at most limit bytes from it.

impl<T: AsRef<BufList>> Seek for Cursor<T>

fn seek(&mut self, style: SeekFrom) -> Result<u64>

Seek to an offset, in bytes, in a stream.

fn stream_position(&mut self) -> Result<u64>

Returns the current seek position from the start of the stream.

fn rewind(&mut self) -> Result<(), Error>

Rewind to the beginning of a stream.

fn stream_len(&mut self) -> Result<u64, Error>

🔬This is a nightly-only experimental API. (seek_stream_len)

Returns the length of this stream (in bytes).