Struct topset::TopSet

pub struct TopSet<X, C>where
    C: FnMut(&X, &X) -> bool,{ /* private fields */ }

A top N set of items.

This set contains no more than N items. When this limit is reached, the smallest (according to the specified comparison) is thrown.

Comparing two elements is done by a duel, resolved by a provided closure: if true is returned, the first item wins, if false the second.

By the way, using PartialOrd::gt will select the top elements and PartialOrd::lt will select the lowest.

Of course, any closure could be used but it should satisfy the transitivity. In other words, if a beats b and b beats c then a should beat c too. If it is not the case, the results are unpredictable.

Implementations

impl<X, C> TopSet<X, C>where
    C: FnMut(&X, &X) -> bool,

pub fn new(n: usize, beat: C) -> Self

Creates a new top set with a selecting closure.

pub fn with_init<I: IntoIterator<Item = X>>(n: usize, init: I, beat: C) -> Self

Creates a new top set with a selecting closure and an initial set of items.

If the initial set contains more than n elements, only the n greatest ones (according to beat selector) are stored.

pub fn is_empty(&self) -> bool

Check if the top set is empty

pub fn len(&self) -> usize

Get the number of stored items.

It never exceeds the predefined capacity.

pub fn capacity(&self) -> usize

Get the capacity of this top set

This capacity could only change by calling [resize].

pub fn peek(&self) -> Option<&X>

Read access to the lowest item of the top set

Notice that it actually returned the lowest one and so all the others are better (or equal) this one.

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

Iterate over all the top selected items.

The iterator is not sorted. A sorted iteration could be obtained by iterative call to Self::pop or by using Self::into_iter_sorted.

pub fn into_vec(self) -> Vec<X>

Gets all the top set elements in a vector.

This vector is not sorted. See Self::into_sorted_vec if a sorted result is expected.

pub fn insert(&mut self, x: X) -> Option<X>

Insert a new item.

If the top set is not filled, the item is simply added and None is returned.

If there is no more room, then one item should be rejected:

• if the new item is better than some already stored ones, it is added and the removed item is returned
• if the new item is worse than all the stored ones, it is returned

pub fn into_iter_sorted(self) -> IntoIterSorted<X, C>

Converts this topset into a sorted iterator

Notice that the lowest item of the top set is the first one. The greatest item is the last one.

pub fn into_sorted_vec(self) -> Vec<X>where
    X: PartialEq,

Returns the topset in a sorted vector.

The first element of the vector is the lowest item of the top set and the last one is the greatest one.

pub fn resize(&mut self, n: usize)

Resize the top set

If the size decreases, then the lowest items are removed. If the size increases, nothing else happens but there is still more room for next insertions.

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

Pop the lowest item of the top set

Remove and return the lowest item of the top set. After this call, there is one more room for a item.

This method is the only way to get the top elements in a sorted way (from the lowest to the best).

Trait Implementations

impl<X: Clone, C: Clone> Clone for TopSet<X, C>where
    C: FnMut(&X, &X) -> bool,

fn clone(&self) -> TopSet<X, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<X, C> Debug for TopSet<X, C>where
    X: Debug,
    C: FnMut(&X, &X) -> bool,

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

Formats the value using the given formatter.

impl<X, C> Extend<X> for TopSet<X, C>where
    C: FnMut(&X, &X) -> bool,

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

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<X, C> From<TopSet<X, C>> for IntoIterSorted<X, C>where
    C: FnMut(&X, &X) -> bool,

fn from(topset: TopSet<X, C>) -> Self

Converts to this type from the input type.

impl<'a, X, C> IntoIterator for &'a TopSet<X, C>where
    C: FnMut(&X, &X) -> bool,

type Item = &'a X

The type of the elements being iterated over.

type IntoIter = <&'a Vec<X, Global> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<X, C> IntoIterator for TopSet<X, C>where
    C: FnMut(&X, &X) -> bool,

type Item = X

The type of the elements being iterated over.

type IntoIter = <Vec<X, Global> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.