Struct frequency_ordermap::OrderMapFrequency

pub struct OrderMapFrequency<T, N = usize, S = FnvBuildHasher> where
    T: Hash + Eq,
    N: Num,
    S: BuildHasher,  { /* fields omitted */ }

A frequency counter backed by an OrderMap

Methods

impl<T, N, S> OrderMapFrequency<T, N, S> where
    T: Eq + Hash,
    N: Num,
    S: BuildHasher + Default, 

fn new() -> OrderMapFrequency<T, N, S>

Creates an empty OrderMapFrequency, a frequency counter backed by a OrderMap. Does not allocate.

fn with_capacity(capacity: usize) -> OrderMapFrequency<T, N, S>

Creates an empty OrderMapFrequency, a frequency counter backed by a OrderMap with the specified capacity.

The hash map will be able to hold at least capacity elements without reallocating. If capacity is 0, the hash map will not allocate. ```

impl<T, N, S> OrderMapFrequency<T, N, S> where
    T: Eq + Hash,
    N: Num,
    S: BuildHasher, 

fn with_capacity_and_hasher(
    capacity: usize,
    hash_builder: S
) -> OrderMapFrequency<T, N, S>

Creates an empty OrderMapFrequency, a frequency counter backed by a OrderMap with the specified capacity, using hasher to hash the keys.

The hash map will be able to hold at least capacity elements without reallocating. If capacity is 0, the hash map will not allocate.

fn len(&self) -> usize

Returns the number of elements that have been counted.

fn is_empty(&self) -> bool

Returns true if the counter contains no elements.

fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more elements to be inserted in the OrderMap backing this frequency counter. The collection may reserve more space to avoid frequent reallocations.

Panics

Panics if the new allocation size overflows usize.

Trait Implementations

impl<'t, T, N, S> Frequency<'t, T> for OrderMapFrequency<T, N, S> where
    T: 't + Eq + Hash,
    N: 't + Num + Clone,
    S: 't + BuildHasher, 

type N = N

The type used to record counts.

type Iter = Iter<'t, T, Self::N>

The type of an iterator over item-count pairs.

type Items = Keys<'t, T, Self::N>

The type of an iterator over items.

type Counts = Values<'t, T, Self::N>

The type of an iterator over counts.

fn count(&self, key: &T) -> Self::N

Returns the count of an item.

fn increment(&mut self, value: T)

Increments the count for an item.

fn iter(&'t self) -> Self::Iter

An iterator visiting all key-value pairs. Iterator element type is (&'t T, &'t usize).

fn items(&'t self) -> Self::Items

An iterator visiting all keys in arbitrary order. Iterator element type is &'t T.

fn counts(&'t self) -> Self::Counts

An iterator visiting all counts in arbitrary order. Iterator element type is &'t usize.

impl<T, N, S> Default for OrderMapFrequency<T, N, S> where
    T: Eq + Hash,
    N: Num,
    S: BuildHasher + Default, 

fn default() -> OrderMapFrequency<T, N, S>

Creates an empty OrderMapFrequency<T, V, S>, a frequency counter backed by a OrderMap with the Default value for the hasher.

impl<T, N, S> Extend<T> for OrderMapFrequency<T, N, S> where
    T: Eq + Hash,
    N: Num + Clone,
    S: BuildHasher, 

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

Extends a collection with the contents of an iterator.

impl<T, N, S> FromIterator<T> for OrderMapFrequency<T, N, S> where
    T: Eq + Hash,
    N: Num + Clone,
    S: BuildHasher + Default, 

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<'t, T, N, S> IntoIterator for &'t OrderMapFrequency<T, N, S> where
    T: 't + Eq + Hash,
    N: 't + Num + Clone,
    S: 't + BuildHasher, 

type Item = <<OrderMapFrequency<T, N, S> as Frequency<'t, T>>::Iter as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = <OrderMapFrequency<T, N, S> as Frequency<'t, T>>::Iter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, N, S> AsRef<OrderMap<T, N, S>> for OrderMapFrequency<T, N, S> where
    T: Eq + Hash,
    N: Num,
    S: BuildHasher, 

fn as_ref(&self) -> &OrderMap<T, N, S>

Performs the conversion.

impl<T, N, S> AsMut<OrderMap<T, N, S>> for OrderMapFrequency<T, N, S> where
    T: Eq + Hash,
    N: Num,
    S: BuildHasher, 

fn as_mut(&mut self) -> &mut OrderMap<T, N, S>

Performs the conversion.