Struct NBest 

pub struct NBest<T, F = ()>
where
    Self: NBestWrapper<T, F>,
{ /* private fields */ }

Collection to keep the N highest elements, and discard the others

Implementations

impl<T: Ord> NBest<T, ()>

pub fn new(n: usize) -> Self

Returns a new NBest with the specified capacity, for items implementing the Ord trait

pub fn with_iter<I>(n: usize, iter: I) -> Self

where I: IntoIterator<Item = T>,

Returns a new NBest, built from the contents of an iterator

impl<T, F: Fn(&T, &T) -> Ordering + Clone> NBest<T, F>

pub fn with_cmp_fn(n: usize, func: F) -> Self

where F: Fn(&T, &T) -> Ordering,

Returns a new NBest, using the supplied function to perform comparisons

pub fn with_cmp_fn_and_iter<I>(n: usize, func: F, iter: I) -> Self

where F: Fn(&T, &T) -> Ordering, I: IntoIterator<Item = T>,

Returns a new NBest, built from the contents of an iterator, using the supplied function

impl<T, F> NBest<T, F>

where Self: NBestWrapper<T, F>,

pub fn push(&mut self, item: T)

Adds a new element, discarding the lowest element if the collection is at capacity

pub fn pop(&mut self) -> Option<T>

Returns the least element contained within the collection, or None if the collection is empty

pub fn len(&self) -> usize

Returns the number of elements contained within the collection

len() will always be less than capacity.

pub fn capacity(&self) -> usize

Returns the maximum number of elements the collection will collect

pub fn iter(&self) -> impl Iterator<Item = &T>

Returns an iterator over the elements contained within the collection, in an unspecified order

pub fn drain<'a>(&'a mut self) -> impl Iterator<Item = T> + 'a

Empties the collection and returns an iterator over all contained elements, in an unspecified order

pub fn into_sorted_vec(self) -> Vec<T>

Consumes the collection, and returns all elements in a sorted Vec

Trait Implementations

impl<T, F> Extend<T> for NBest<T, F>

where Self: NBestWrapper<T, F>,

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T, F> IntoIterator for NBest<T, F>

where Self: NBestWrapper<T, F>,

fn into_iter(self) -> Self::IntoIter

Consumes the collection and returns an iterator over the elements, in an unspecified order

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, F>

Which kind of iterator are we turning this into?