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

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

Take in std::io - Rust

pub struct Take<T> {  }

Reader adapter which limits the bytes read from an underlying reader.

This struct is generally created by calling take on a reader. Please see the documentation of take for more details.

Returns the number of bytes that can be read before this instance will return EOF.

This instance may reach EOF after reading fewer bytes than indicated by this method if the underlying Read instance reaches EOF.

use std::io;
use std::io::prelude::*;
use std::fs::File;

fn main() -> io::Result<()> {
    let f = File::open("foo.txt")?;

    let handle = f.take(5);

    println!("limit: {}", handle.limit());
    Ok(())
}

Returns the number of bytes read so far.

Sets the number of bytes that can be read before this instance will return EOF. This is the same as constructing a new Take instance, so the amount of bytes read and the previous limit value don’t matter when calling this method.

use std::io;
use std::io::prelude::*;
use std::fs::File;

fn main() -> io::Result<()> {
    let f = File::open("foo.txt")?;

    let mut handle = f.take(5);
    handle.set_limit(10);

    assert_eq!(handle.limit(), 10);
    Ok(())
}

Consumes the Take, returning the wrapped reader.

use std::io;
use std::io::prelude::*;
use std::fs::File;

fn main() -> io::Result<()> {
    let mut file = File::open("foo.txt")?;

    let mut buffer = [0; 5];
    let mut handle = file.take(5);
    handle.read(&mut buffer)?;

    let file = handle.into_inner();
    Ok(())
}

Gets a reference to the underlying reader.

Care should be taken to avoid modifying the internal I/O state of the underlying reader as doing so may corrupt the internal limit of this Take.

use std::io;
use std::io::prelude::*;
use std::fs::File;

fn main() -> io::Result<()> {
    let mut file = File::open("foo.txt")?;

    let mut buffer = [0; 5];
    let mut handle = file.take(5);
    handle.read(&mut buffer)?;

    let file = handle.get_ref();
    Ok(())
}

Gets a mutable reference to the underlying reader.

Care should be taken to avoid modifying the internal I/O state of the underlying reader as doing so may corrupt the internal limit of this Take.

use std::io;
use std::io::prelude::*;
use std::fs::File;

fn main() -> io::Result<()> {
    let mut file = File::open("foo.txt")?;

    let mut buffer = [0; 5];
    let mut handle = file.take(5);
    handle.read(&mut buffer)?;

    let file = handle.get_mut();
    Ok(())
}

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.

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 all bytes until EOF in this source, placing them into

.

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

.

Reads the exact number of bytes required to fill

.

Reads the exact number of bytes required to fill

.

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.

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