std​::io​::extensions

Structs

Bytes

Functions

u64_from_be_bytesu64_to_be_bytesu64_to_le_bytes

Struct std::io::extensions::Bytes[src]

pub struct Bytes<'r, T> {
    // some fields omitted
}

An iterator that reads a single byte on each iteration, until .read_byte() returns EndOfFile.

Notes about the Iteration Protocol

The Bytes may yield None and thus terminate an iteration, but continue to yield elements if iteration is attempted again.

Error

Any error other than EndOfFile that is produced by the underlying Reader is returned by the iterator and should be handled by the caller.

Methods

impl<'r, R: Reader> Bytes<'r, R>

fn new(r: &'r mut R) -> Bytes<'r, R>

Constructs a new byte iterator from the given Reader instance.

Trait Implementations

impl<'r, R: Reader> Iterator<IoResult<u8>> for Bytes<'r, R>

fn next(&mut self) -> Option<IoResult<u8>>

fn size_hint<A>(&self) -> (uint, Option<uint>)

fn chain<U: Iterator<A>>(self, other: U) -> Chain<Self, U>

fn zip<B, U: Iterator<B>>(self, other: U) -> Zip<Self, U>

fn map<B>(self, f: |A|: 'r -> B) -> Map<'r, A, B, Self>

fn filter<A>(self, predicate: |&A|: 'r -> bool) -> Filter<'r, A, Self>

fn filter_map<B>(self, f: |A|: 'r -> Option<B>) -> FilterMap<'r, A, B, Self>

fn enumerate<A>(self) -> Enumerate<Self>

fn peekable<A>(self) -> Peekable<A, Self>

fn skip_while<A>(self, predicate: |&A|: 'r -> bool) -> SkipWhile<'r, A, Self>

fn take_while<A>(self, predicate: |&A|: 'r -> bool) -> TakeWhile<'r, A, Self>

fn skip<A>(self, n: uint) -> Skip<Self>

fn take<A>(self, n: uint) -> Take<Self>

fn scan<St, B>(self, initial_state: St, f: |&mut St, A|: 'r -> Option<B>) -> Scan<'r, A, B, Self, St>

fn flat_map<B, U: Iterator<B>>(self, f: |A|: 'r -> U) -> FlatMap<'r, A, Self, U>

fn fuse<A>(self) -> Fuse<Self>

fn inspect<A>(self, f: |&A|: 'r) -> Inspect<'r, A, Self>

fn by_ref<A>(&'r mut self) -> ByRef<'r, Self>

fn advance<A>(&mut self, f: |A| -> bool) -> bool

fn collect<B: FromIterator<A>>(&mut self) -> B

fn nth<A>(&mut self, n: uint) -> Option<A>

fn last<A>(&mut self) -> Option<A>

fn fold<B>(&mut self, init: B, f: |B, A| -> B) -> B

fn count<A>(&mut self) -> uint

fn all<A>(&mut self, f: |A| -> bool) -> bool

fn any<A>(&mut self, f: |A| -> bool) -> bool

fn find<A>(&mut self, predicate: |&A| -> bool) -> Option<A>

fn position<A>(&mut self, predicate: |A| -> bool) -> Option<uint>

fn max_by<B: Ord>(&mut self, f: |&A| -> B) -> Option<A>

fn min_by<B: Ord>(&mut self, f: |&A| -> B) -> Option<A>