Struct maglev::Maglev

pub struct Maglev<N, S = BuildHasherDefault<DefaultHasher>> { /* fields omitted */ }

Maglev lookup table

Implementations

impl<N: Hash + Eq> Maglev<N, BuildHasherDefault<DefaultHasher>>

pub fn new<I: IntoIterator<Item = N>>(nodes: I) -> Self

Creates a Maglev lookup table.

pub fn with_capacity<I: IntoIterator<Item = N>>(
    nodes: I,
    capacity: usize
) -> Self

Creates a Maglev lookup table with the specified capacity.

impl<N: Hash + Eq, S: BuildHasher> Maglev<N, S>

pub fn with_hasher<I: IntoIterator<Item = N>>(nodes: I, hash_builder: S) -> Self

Creates a Maglev lookup table which will use the given hash builder to hash keys.

pub fn with_capacity_and_hasher<I: IntoIterator<Item = N>>(
    nodes: I,
    capacity: usize,
    hash_builder: S
) -> Self

Creates a Maglev lookup table with the specified capacity, using hasher to hash the keys.

Trait Implementations

impl<N: Clone, S: Clone> Clone for Maglev<N, S>

fn clone(&self) -> Maglev<N, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N, S> ConsistentHasher<N> for Maglev<N, S> where
    N: Hash + Eq,
    S: BuildHasher, 

fn nodes(&self) -> &[N]

Returns all nodes in arbitrary order.

fn capacity(&self) -> usize

Returns the number of slots in the lookup table.

fn get<Q: ?Sized>(&self, key: &Q) -> Option<&N> where
    Q: Hash + Eq, 

Returns a reference to the node corresponding to the key.

impl<N: Debug, S: Debug> Debug for Maglev<N, S>

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

Formats the value using the given formatter.

impl<N: Hash + Eq> FromIterator<N> for Maglev<N, BuildHasherDefault<DefaultHasher>>

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

Creates a value from an iterator.

impl<N, S, Q> Index<&'_ Q> for Maglev<N, S> where
    N: Hash + Eq,
    S: BuildHasher,
    Q: Hash + Eq + ?Sized, 

type Output = N

The returned type after indexing.

fn index(&self, index: &Q) -> &Self::Output

Performs the indexing (container[index]) operation.