Trait streaming_decompression::FallibleStreamingIterator

source · [−]
pub trait FallibleStreamingIterator {
    type Item: ?Sized;
    type Error;


Show 21 methods    fn advance(&mut self) -> Result<(), Self::Error>;
    fn get(&self) -> Option<&Self::Item>;

    fn next(&mut self) -> Result<Option<&Self::Item>, Self::Error> { ... }
    fn size_hint(&self) -> (usize, Option<usize>) { ... }
    fn all<F>(&mut self, f: F) -> Result<bool, Self::Error>
    where
        F: FnMut(&Self::Item) -> bool,
    { ... }
    fn any<F>(&mut self, f: F) -> Result<bool, Self::Error>
    where
        F: FnMut(&Self::Item) -> bool,
    { ... }
    fn by_ref(&mut self) -> &mut Self { ... }
    fn count(self) -> Result<usize, Self::Error> { ... }
    fn filter<F>(self, f: F) -> Filter<Self, F>
    where
        F: FnMut(&Self::Item) -> bool,
    { ... }
    fn find<F>(&mut self, f: F) -> Result<Option<&Self::Item>, Self::Error>
    where
        F: FnMut(&Self::Item) -> bool,
    { ... }
    fn for_each<F>(self, f: F) -> Result<(), Self::Error>
    where
        F: FnMut(&Self::Item),
    { ... }
    fn fuse(self) -> Fuse<Self> { ... }
    fn map<F, B>(self, f: F) -> Map<Self, F, B>
    where
        F: FnMut(&Self::Item) -> B,
    { ... }
    fn map_ref<F, B>(self, f: F) -> MapRef<Self, F>
    where
        F: Fn(&Self::Item) -> &B,
        B: ?Sized,
    { ... }
    fn map_err<F, B>(self, f: F) -> MapErr<Self, F>
    where
        F: Fn(Self::Error) -> B,
    { ... }
    fn nth(&mut self, n: usize) -> Result<Option<&Self::Item>, Self::Error> { ... }
    fn position<F>(&mut self, f: F) -> Result<Option<usize>, Self::Error>
    where
        F: FnMut(&Self::Item) -> bool,
    { ... }
    fn skip(self, n: usize) -> Skip<Self> { ... }
    fn skip_while<F>(self, f: F) -> SkipWhile<Self, F>
    where
        F: FnMut(&Self::Item) -> bool,
    { ... }
    fn take(self, n: usize) -> Take<Self> { ... }
    fn take_while<F>(self, f: F) -> TakeWhile<Self, F>
    where
        F: FnMut(&Self::Item) -> bool,
    { ... }

}
Expand description

A fallible, streaming iterator.

Required Associated Types

The type being iterated over.

The error type of iteration.

Required Methods

Advances the iterator to the next position.

Iterators start just before the first item, so this method should be called before get when iterating.

The behavior of calling this method after get has returned None, or after this method has returned an error is unspecified.

Returns the current element.

The behavior of calling this method before any calls to advance is unspecified.

Provided Methods

Advances the iterator, returning the next element.

The default implementation simply calls advance followed by get.

Returns bounds on the number of remaining elements in the iterator.

Determines if all elements of the iterator satisfy a predicate.

Determines if any elements of the iterator satisfy a predicate.

Borrows an iterator, rather than consuming it.

This is useful to allow the application of iterator adaptors while still retaining ownership of the original adaptor.

Returns the number of remaining elements in the iterator.

Returns an iterator which filters elements by a predicate.

Returns the first element of the iterator which satisfies a predicate.

Calls a closure on each element of an iterator.

Returns an iterator which is well-behaved at the beginning and end of iteration.

Returns an iterator which applies a transform to elements.

Returns an iterator which applies a transform to elements.

Unlike map, the the closure provided to this method returns a reference into the original value.

Returns an iterator that applies a transform to errors.

Returns the nth element of the iterator.

Returns the position of the first element matching a predicate.

Returns an iterator which skips the first n elements.

Returns an iterator which skips the first sequence of elements matching a predicate.

Returns an iterator which only returns the first n elements.

Returns an iterator which only returns the first sequence of elements matching a predicate.

Implementations on Foreign Types

Implementors