Struct core_io::Take

pub struct Take<T> { /* fields omitted */ }

Reader adaptor 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.

Methods

impl<T> Take<T>

fn limit(&self) -> u64

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

Note

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

Examples

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

let f = try!(File::open("foo.txt"));

// read at most five bytes
let handle = f.take(5);

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

fn into_inner(self) -> T

Consumes the Take, returning the wrapped reader.

Examples

#![feature(io_take_into_inner)]

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

let mut file = try!(File::open("foo.txt"));

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

let file = handle.into_inner();

Trait Implementations

impl<T: Read> Read for Take<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_exact(&mut self, buf: &mut [u8]) -> Result<()>

Read the exact number of bytes required to fill buf.

fn by_ref(&mut self) -> &mut Self where 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 chars(self) -> Chars<Self> where Self: Sized

Transforms this Read instance to an Iterator over chars.

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

Creates an adaptor which will chain this stream with another.

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

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