Struct gimli::read::PubNamesEntryIter

pub struct PubNamesEntryIter<R: Reader>(_);

An iterator over the pubnames from a .debug_pubnames section.

Can be used with FallibleIterator.

Implementations

impl<R: Reader> PubNamesEntryIter<R>

pub fn next(&mut self) -> Result<Option<PubNamesEntry<R>>>

Advance the iterator and return the next pubname.

Returns the newly parsed pubname as Ok(Some(pubname)). Returns Ok(None) when iteration is complete and all pubnames have already been parsed and yielded. If an error occurs while parsing the next pubname, then this error is returned as Err(e), and all subsequent calls return Ok(None).

Trait Implementations

impl<R: Clone + Reader> Clone for PubNamesEntryIter<R>

fn clone(&self) -> PubNamesEntryIter<R>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R: Debug + Reader> Debug for PubNamesEntryIter<R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: Reader> FallibleIterator for PubNamesEntryIter<R>

type Item = PubNamesEntry<R>

The type being iterated over.

type Error = Error

The error type.

fn next(&mut self) -> Result<Option<Self::Item>, Self::Error>

Advances the iterator and returns the next value.

fn size_hint(&self) -> (usize, Option<usize>)

Returns bounds on the remaining length of the iterator.

fn count(self) -> Result<usize, Self::Error>where
    Self: Sized,

Consumes the iterator, returning the number of remaining items.

fn last(self) -> Result<Option<Self::Item>, Self::Error>where
    Self: Sized,

Returns the last element of the iterator.

fn nth(&mut self, n: usize) -> Result<Option<Self::Item>, Self::Error>

Returns the nth element of the iterator.

fn step_by(self, step: usize) -> StepBy<Self>where
    Self: Sized,

Returns an iterator starting at the same point, but stepping by the given amount at each iteration.

fn chain<I>(self, it: I) -> Chain<Self, I>where
    I: IntoFallibleIterator<Item = Self::Item, Error = Self::Error>,
    Self: Sized,

Returns an iterator which yields the elements of this iterator followed by another.

fn zip<I>(self, o: I) -> Zip<Self, <I as IntoFallibleIterator>::IntoFallibleIter>where
    Self: Sized,
    I: IntoFallibleIterator<Error = Self::Error>,

Returns an iterator that yields pairs of this iterator’s and another iterator’s values.

fn map<F, B>(self, f: F) -> Map<Self, F>where
    Self: Sized,
    F: FnMut(Self::Item) -> Result<B, Self::Error>,

Returns an iterator which applies a fallible transform to the elements of the underlying iterator.

fn for_each<F>(self, f: F) -> Result<(), Self::Error>where
    Self: Sized,
    F: FnMut(Self::Item) -> Result<(), Self::Error>,

Calls a fallible closure on each element of an iterator.

fn filter<F>(self, f: F) -> Filter<Self, F>where
    Self: Sized,
    F: FnMut(&Self::Item) -> Result<bool, Self::Error>,

Returns an iterator which uses a predicate to determine which values should be yielded. The predicate may fail; such failures are passed to the caller.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where
    Self: Sized,
    F: FnMut(Self::Item) -> Result<Option<B>, Self::Error>,

Returns an iterator which both filters and maps. The closure may fail; such failures are passed along to the consumer.

fn enumerate(self) -> Enumerate<Self>where
    Self: Sized,

Returns an iterator which yields the current iteration count as well as the value.

fn peekable(self) -> Peekable<Self>where
    Self: Sized,

Returns an iterator that can peek at the next element without consuming it.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
    Self: Sized,
    P: FnMut(&Self::Item) -> Result<bool, Self::Error>,

Returns an iterator that skips elements based on a predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
    Self: Sized,
    P: FnMut(&Self::Item) -> Result<bool, Self::Error>,

Returns an iterator that yields elements based on a predicate.

fn skip(self, n: usize) -> Skip<Self>where
    Self: Sized,

Returns an iterator which skips the first n values of this iterator.

fn take(self, n: usize) -> Take<Self>where
    Self: Sized,

Returns an iterator that yields only the first n values of this iterator.

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where
    Self: Sized,
    F: FnMut(&mut St, Self::Item) -> Result<Option<B>, Self::Error>,

Returns an iterator which applies a stateful map to values of this iterator.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
    Self: Sized,
    U: IntoFallibleIterator<Error = Self::Error>,
    F: FnMut(Self::Item) -> Result<U, Self::Error>,

Returns an iterator which maps this iterator’s elements to iterators, yielding those iterators’ values.

fn fuse(self) -> Fuse<Self>where
    Self: Sized,

Returns an iterator which yields this iterator’s elements and ends after the first Ok(None).

fn inspect<F>(self, f: F) -> Inspect<Self, F>where
    Self: Sized,
    F: FnMut(&Self::Item) -> Result<(), Self::Error>,

Returns an iterator which passes each element to a closure before returning it.

fn by_ref(&mut self) -> &mut Selfwhere
    Self: Sized,

Borrow an iterator rather than consuming it.

fn collect<T>(self) -> Result<T, Self::Error>where
    T: FromFallibleIterator<Self::Item>,
    Self: Sized,

Transforms the iterator into a collection.

fn partition<B, F>(self, f: F) -> Result<(B, B), Self::Error>where
    Self: Sized,
    B: Default + Extend<Self::Item>,
    F: FnMut(&Self::Item) -> Result<bool, Self::Error>,

Transforms the iterator into two collections, partitioning elements by a closure.

fn fold<B, F>(self, init: B, f: F) -> Result<B, Self::Error>where
    Self: Sized,
    F: FnMut(B, Self::Item) -> Result<B, Self::Error>,

Applies a function over the elements of the iterator, producing a single final value.

fn try_fold<B, E, F>(&mut self, init: B, f: F) -> Result<B, E>where
    Self: Sized,
    E: From<Self::Error>,
    F: FnMut(B, Self::Item) -> Result<B, E>,

Applies a function over the elements of the iterator, producing a single final value.

fn all<F>(&mut self, f: F) -> Result<bool, Self::Error>where
    Self: Sized,
    F: FnMut(Self::Item) -> Result<bool, Self::Error>,

Determines if all elements of this iterator match a predicate.

fn any<F>(&mut self, f: F) -> Result<bool, Self::Error>where
    Self: Sized,
    F: FnMut(Self::Item) -> Result<bool, Self::Error>,

Determines if any element of this iterator matches a predicate.

fn find<F>(&mut self, f: F) -> Result<Option<Self::Item>, Self::Error>where
    Self: Sized,
    F: FnMut(&Self::Item) -> Result<bool, Self::Error>,

Returns the first element of the iterator that matches a predicate.

fn find_map<B, F>(&mut self, f: F) -> Result<Option<B>, Self::Error>where
    Self: Sized,
    F: FnMut(Self::Item) -> Result<Option<B>, Self::Error>,

Applies a function to the elements of the iterator, returning the first non-None result.

fn position<F>(&mut self, f: F) -> Result<Option<usize>, Self::Error>where
    Self: Sized,
    F: FnMut(Self::Item) -> Result<bool, Self::Error>,

Returns the position of the first element of this iterator that matches a predicate. The predicate may fail; such failures are returned to the caller.

fn max_by_key<B, F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>where
    Self: Sized,
    B: Ord,
    F: FnMut(&Self::Item) -> Result<B, Self::Error>,

Returns the element of the iterator which gives the maximum value from the function.

fn max_by<F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Result<Ordering, Self::Error>,

Returns the element that gives the maximum value with respect to the function.

fn min_by_key<B, F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>where
    Self: Sized,
    B: Ord,
    F: FnMut(&Self::Item) -> Result<B, Self::Error>,

Returns the element of the iterator which gives the minimum value from the function.

fn min_by<F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Result<Ordering, Self::Error>,

Returns the element that gives the minimum value with respect to the function.

fn unzip<A, B, FromA, FromB>(self) -> Result<(FromA, FromB), Self::Error>where
    Self: Sized + FallibleIterator<Item = (A, B)>,
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,

Converts an iterator of pairs into a pair of containers.

fn cloned<'a, T>(self) -> Cloned<Self>where
    Self: Sized + FallibleIterator<Item = &'a T>,
    T: 'a + Clone,

Returns an iterator which clones all of its elements.

fn cycle(self) -> Cycle<Self>where
    Self: Sized + Clone,

Returns an iterator which repeas this iterator endlessly.

fn partial_cmp<I>(self, other: I) -> Result<Option<Ordering>, Self::Error>where
    Self: Sized,
    I: IntoFallibleIterator<Error = Self::Error>,
    Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,

Lexicographically compares the elements of this iterator to that of another.

fn eq<I>(self, other: I) -> Result<bool, Self::Error>where
    Self: Sized,
    I: IntoFallibleIterator<Error = Self::Error>,
    Self::Item: PartialEq<<I as IntoFallibleIterator>::Item>,

Determines if the elements of this iterator are equal to those of another.

fn ne<I>(self, other: I) -> Result<bool, Self::Error>where
    Self: Sized,
    I: IntoFallibleIterator<Error = Self::Error>,
    Self::Item: PartialEq<<I as IntoFallibleIterator>::Item>,

Determines if the elements of this iterator are not equal to those of another.

fn lt<I>(self, other: I) -> Result<bool, Self::Error>where
    Self: Sized,
    I: IntoFallibleIterator<Error = Self::Error>,
    Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,

Determines if the elements of this iterator are lexicographically less than those of another.

fn le<I>(self, other: I) -> Result<bool, Self::Error>where
    Self: Sized,
    I: IntoFallibleIterator<Error = Self::Error>,
    Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,

Determines if the elements of this iterator are lexicographically less than or equal to those of another.

fn gt<I>(self, other: I) -> Result<bool, Self::Error>where
    Self: Sized,
    I: IntoFallibleIterator<Error = Self::Error>,
    Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,

Determines if the elements of this iterator are lexicographically greater than those of another.

fn ge<I>(self, other: I) -> Result<bool, Self::Error>where
    Self: Sized,
    I: IntoFallibleIterator<Error = Self::Error>,
    Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,

Determines if the elements of this iterator are lexicographically greater than or equal to those of another.

fn iterator(self) -> Iterator<Self>where
    Self: Sized,

Returns a normal (non-fallible) iterator over Result<Item, Error>.

fn map_err<B, F>(self, f: F) -> MapErr<Self, F>where
    F: FnMut(Self::Error) -> B,
    Self: Sized,

Returns an iterator which applies a transform to the errors of the underlying iterator.