Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://doc.rust-lang.org/std/io/struct.Cursor.html below:

Cursor in std::io - Rust

pub struct Cursor<T> {  }

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

Cursors are used with in-memory buffers, anything implementing AsRef<[u8]>, to allow them to implement Read and/or Write, allowing these buffers to be used anywhere you might use a reader or writer that does actual I/O.

The standard library implements some I/O traits on various types which are commonly used as a buffer, like Cursor<Vec<u8>> and Cursor<&[u8]>.

We may want to write bytes to a File in our production code, but use an in-memory buffer in our tests. We can do this with Cursor:

use std::io::prelude::*;
use std::io::{self, SeekFrom};
use std::fs::File;

fn write_ten_bytes_at_end<W: Write + Seek>(mut writer: W) -> io::Result<()> {
    writer.seek(SeekFrom::End(-10))?;

    for i in 0..10 {
        writer.write(&[i])?;
    }

    Ok(())
}

let mut file = File::create("foo.txt")?;
file.set_len(10)?;

write_ten_bytes_at_end(&mut file)?;

#[test]
fn test_writes_bytes() {
    use std::io::Cursor;
    let mut buff = Cursor::new(vec![0; 15]);

    write_ten_bytes_at_end(&mut buff).unwrap();

    assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
}

Creates a new cursor wrapping the provided underlying in-memory buffer.

Cursor initial position is 0 even if underlying buffer (e.g., Vec) is not empty. So writing to cursor starts with overwriting Vec content, not with appending to it.

use std::io::Cursor;

let buff = Cursor::new(Vec::new());

Consumes this cursor, returning the underlying value.

use std::io::Cursor;

let buff = Cursor::new(Vec::new());

let vec = buff.into_inner();

Gets a reference to the underlying value in this cursor.

use std::io::Cursor;

let buff = Cursor::new(Vec::new());

let reference = buff.get_ref();

Gets a mutable reference to the underlying value in this cursor.

Care should be taken to avoid modifying the internal I/O state of the underlying value as it may corrupt this cursor’s position.

use std::io::Cursor;

let mut buff = Cursor::new(Vec::new());

let reference = buff.get_mut();

Returns the current position of this cursor.

use std::io::Cursor;
use std::io::prelude::*;
use std::io::SeekFrom;

let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);

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

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

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

Sets the position of this cursor.

use std::io::Cursor;

let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);

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

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

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

Splits the underlying slice at the cursor position and returns them.

#![feature(cursor_split)]
use std::io::Cursor;

let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);

assert_eq!(buff.split(), ([].as_slice(), [1, 2, 3, 4, 5].as_slice()));

buff.set_position(2);
assert_eq!(buff.split(), ([1, 2].as_slice(), [3, 4, 5].as_slice()));

buff.set_position(6);
assert_eq!(buff.split(), ([1, 2, 3, 4, 5].as_slice(), [].as_slice()));

Splits the underlying slice at the cursor position and returns them mutably.

#![feature(cursor_split)]
use std::io::Cursor;

let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);

assert_eq!(buff.split_mut(), ([].as_mut_slice(), [1, 2, 3, 4, 5].as_mut_slice()));

buff.set_position(2);
assert_eq!(buff.split_mut(), ([1, 2].as_mut_slice(), [3, 4, 5].as_mut_slice()));

buff.set_position(6);
assert_eq!(buff.split_mut(), ([1, 2, 3, 4, 5].as_mut_slice(), [].as_mut_slice()));

Returns the contents of the internal buffer, filling it with more data, via

methods, if empty.

Marks the given

of additional bytes from the internal buffer as having been read. Subsequent calls to

only return bytes that have not been marked as read.

Checks if there is any data left to be

.

Reads all bytes into

until the delimiter

or EOF is reached.

Skips all bytes until the delimiter

or EOF is reached.

Reads all bytes until a newline (the

byte) is reached, and append them to the provided

buffer.

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

.

Returns an iterator over the lines of this reader.

Tests for self and other values to be equal, and is used by ==.

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Pull some bytes from this source into the specified buffer.

Like

, except that it reads into a slice of buffers.

Determines if this

er has an efficient

implementation.

Reads the exact number of bytes required to fill

.

Reads the exact number of bytes required to fill

.

Reads all bytes until EOF in this source, placing them into

.

Reads all bytes until EOF in this source, appending them to

.

Creates a “by reference” adaptor for this instance of

.

Creates an adapter which will chain this stream with another.

Creates an adapter which will read at most

bytes from it.

Writes a buffer into this writer, returning how many bytes were written.

Attempts to write an entire buffer into this writer.

Attempts to write multiple buffers into this writer.

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

Writes a formatted string into this writer, returning any error encountered.

Creates a “by reference” adapter for this instance of

.

Writes a buffer into this writer, returning how many bytes were written.

Attempts to write an entire buffer into this writer.

Attempts to write multiple buffers into this writer.

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

Writes a formatted string into this writer, returning any error encountered.

Creates a “by reference” adapter for this instance of

.

Writes a buffer into this writer, returning how many bytes were written.

Attempts to write an entire buffer into this writer.

Attempts to write multiple buffers into this writer.

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

Writes a formatted string into this writer, returning any error encountered.

Creates a “by reference” adapter for this instance of

.

Writes a buffer into this writer, returning how many bytes were written.

Attempts to write an entire buffer into this writer.

Attempts to write multiple buffers into this writer.

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

Writes a formatted string into this writer, returning any error encountered.

Creates a “by reference” adapter for this instance of

.

Writes a buffer into this writer, returning how many bytes were written.

Attempts to write an entire buffer into this writer.

Attempts to write multiple buffers into this writer.

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

Writes a formatted string into this writer, returning any error encountered.

Creates a “by reference” adapter for this instance of

.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4