Struct case_insensitive_hashmap::CaseInsensitiveHashMap

pub struct CaseInsensitiveHashMap<V, S = RandomState>
where
    S: BuildHasher,
{ /* private fields */ }

Implementations

impl<V> CaseInsensitiveHashMap<V, RandomState>

pub fn new() -> Self

Creates a new CaseInsensitiveHashMap with the default hasher and capacity.

Examples found in repository

examples/ex1.rs (line 4)

fn main() {
    let mut map = CaseInsensitiveHashMap::new();
    map.insert("A", 1);
    map.insert("B", 2);
    map.insert("a", 10);

    for (k,v) in &map {
        println!("Key = {}, Value = {}", k, v);
    }

    if map.contains_key("c") {
        println!("c is in the map");
    } else {
        println!("c is NOT in the map");
    }

    for (k,v) in &mut map {
        *v *= 10;
        println!("Key = {}, Value = {}", k, v);
    }

    let keys = map.keys().collect::<Vec<_>>();
    println!("keys = {:?}", keys);

    let values = map.values().collect::<Vec<_>>();
    println!("values = {:?}", values);

}

pub fn with_capacity(capacity: usize) -> CaseInsensitiveHashMap<V, RandomState>

Creates a new CaseInsensitiveHashMap with the default hasher and specified capacity.

impl<V, S> CaseInsensitiveHashMap<V, S>

where S: BuildHasher,

pub fn with_hasher(hash_builder: S) -> Self

Creates a new CaseInsensitiveHashMap with the specified hasher and default capacity.

pub fn with_capacity_and_hasher( capacity: usize, hash_builder: S, ) -> CaseInsensitiveHashMap<V, S>

Creates a new CaseInsensitiveHashMap with the specified capacity and hasher.

pub fn capacity(&self) -> usize

Returns the number of elements the map can hold without reallocating.

This number is a lower bound; the HashMap might be able to hold more, but is guaranteed to be able to hold at least this many.

pub fn clear(&mut self)

Clears the map, removing all key-value pairs. Keeps the allocated memory for reuse.

pub fn contains_key<K: Into<UniCase<String>>>(&self, k: K) -> bool

Returns true if the map contains a value for the specified key. The key may be a String, str or UniCase value.

Examples found in repository

examples/ex1.rs (line 13)

fn main() {
    let mut map = CaseInsensitiveHashMap::new();
    map.insert("A", 1);
    map.insert("B", 2);
    map.insert("a", 10);

    for (k,v) in &map {
        println!("Key = {}, Value = {}", k, v);
    }

    if map.contains_key("c") {
        println!("c is in the map");
    } else {
        println!("c is NOT in the map");
    }

    for (k,v) in &mut map {
        *v *= 10;
        println!("Key = {}, Value = {}", k, v);
    }

    let keys = map.keys().collect::<Vec<_>>();
    println!("keys = {:?}", keys);

    let values = map.values().collect::<Vec<_>>();
    println!("values = {:?}", values);

}

pub fn drain(&mut self) -> Drain<'_, UniCase<String>, V>

Clears the map, returning all key-value pairs as an iterator. Keeps the allocated memory for reuse.

pub fn entry<K: Into<UniCase<String>>>( &mut self, k: K, ) -> Entry<'_, UniCase<String>, V>

Gets the given key’s corresponding entry in the map for in-place manipulation.

pub fn get<K: Into<UniCase<String>>>(&self, k: K) -> Option<&V>

Returns a reference to the value corresponding to the key. The key may be a String, str or UniCase value.

pub fn get_key_value<K: Into<UniCase<String>>>( &self, k: K, ) -> Option<(&UniCase<String>, &V)>

Returns the key-value pair corresponding to the supplied key. The key may be a String, str or UniCase value.

pub fn get_mut<K: Into<UniCase<String>>>(&mut self, k: K) -> Option<&mut V>

Returns a mutable reference to the value corresponding to the key. The key may be a String, str or UniCase value.

pub fn hasher(&self) -> &S

Returns a reference to the map’s BuildHasher.

pub fn insert<K: Into<UniCase<String>>>(&mut self, k: K, v: V) -> Option<V>

Inserts a key-value pair into the map. If the map did not have this key present, None is returned. If the map did have this key present, the value is updated, and the old value is returned. The key is not updated, though; this matters for types that can be == without being identical. See the module-level documentation of HashMap

Examples found in repository

examples/ex1.rs (line 5)

fn main() {
    let mut map = CaseInsensitiveHashMap::new();
    map.insert("A", 1);
    map.insert("B", 2);
    map.insert("a", 10);

    for (k,v) in &map {
        println!("Key = {}, Value = {}", k, v);
    }

    if map.contains_key("c") {
        println!("c is in the map");
    } else {
        println!("c is NOT in the map");
    }

    for (k,v) in &mut map {
        *v *= 10;
        println!("Key = {}, Value = {}", k, v);
    }

    let keys = map.keys().collect::<Vec<_>>();
    println!("keys = {:?}", keys);

    let values = map.values().collect::<Vec<_>>();
    println!("values = {:?}", values);

}

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

pub fn iter(&self) -> Iter<'_, UniCase<String>, V>

An iterator visiting all key-value pairs in arbitrary order. The iterator element type is (&’a UniCase, &’a V).

pub fn iter_mut(&mut self) -> IterMut<'_, UniCase<String>, V>

An iterator visiting all key-value pairs in arbitrary order, with mutable references to the values. The iterator element type is (&’a UniCase, &’a mut V).

pub fn keys(&self) -> Keys<'_, UniCase<String>, V>

An iterator visiting all keys in arbitrary order. The iterator element type is &’a UniCase.

Examples found in repository

examples/ex1.rs (line 24)

fn main() {
    let mut map = CaseInsensitiveHashMap::new();
    map.insert("A", 1);
    map.insert("B", 2);
    map.insert("a", 10);

    for (k,v) in &map {
        println!("Key = {}, Value = {}", k, v);
    }

    if map.contains_key("c") {
        println!("c is in the map");
    } else {
        println!("c is NOT in the map");
    }

    for (k,v) in &mut map {
        *v *= 10;
        println!("Key = {}, Value = {}", k, v);
    }

    let keys = map.keys().collect::<Vec<_>>();
    println!("keys = {:?}", keys);

    let values = map.values().collect::<Vec<_>>();
    println!("values = {:?}", values);

}

pub fn len(&self) -> usize

Returns the number of elements in the map.

pub fn remove<K: Into<UniCase<String>>>(&mut self, k: K) -> Option<V>

Removes a key from the map, returning the value at the key if the key was previously in the map. The key may be a String, str or UniCase value.

pub fn remove_entry<K: Into<UniCase<String>>>( &mut self, k: K, ) -> Option<(UniCase<String>, V)>

Removes a key from the map, returning the stored key and value if the key was previously in the map. The key may be a String, str or UniCase value.

pub fn reserve(&mut self, additional: usize)

in the HashMap. The collection may reserve more space to avoid frequent reallocations.

Panics

Panics if the new allocation size overflows usize.

pub fn retain<F>(&mut self, f: F)

where F: FnMut(&UniCase<String>, &mut V) -> bool,

Retains only the elements specified by the predicate. In other words, remove all pairs (k, v) such that f(&k,&mut v) returns false.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the map as much as possible. It will drop down as much as possible while maintaining the internal rules and possibly leaving some space in accordance with the resize policy.

pub fn values(&self) -> Values<'_, UniCase<String>, V>

An iterator visiting all values in arbitrary order. The iterator element type is &’a V.

Examples found in repository

examples/ex1.rs (line 27)

fn main() {
    let mut map = CaseInsensitiveHashMap::new();
    map.insert("A", 1);
    map.insert("B", 2);
    map.insert("a", 10);

    for (k,v) in &map {
        println!("Key = {}, Value = {}", k, v);
    }

    if map.contains_key("c") {
        println!("c is in the map");
    } else {
        println!("c is NOT in the map");
    }

    for (k,v) in &mut map {
        *v *= 10;
        println!("Key = {}, Value = {}", k, v);
    }

    let keys = map.keys().collect::<Vec<_>>();
    println!("keys = {:?}", keys);

    let values = map.values().collect::<Vec<_>>();
    println!("values = {:?}", values);

}

pub fn values_mut(&mut self) -> ValuesMut<'_, UniCase<String>, V>

An iterator visiting all values mutably in arbitrary order. The iterator element type is &’a mut V.

Trait Implementations

impl<V: Clone, S> Clone for CaseInsensitiveHashMap<V, S>

where S: BuildHasher + Clone,

fn clone(&self) -> CaseInsensitiveHashMap<V, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Debug, S> Debug for CaseInsensitiveHashMap<V, S>

where S: BuildHasher + Debug,

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

Formats the value using the given formatter.

impl<V: Default, S> Default for CaseInsensitiveHashMap<V, S>

where S: BuildHasher + Default,

fn default() -> CaseInsensitiveHashMap<V, S>

Returns the “default value” for a type.

impl<'a, K, V, S> Extend<(K, &'a V)> for CaseInsensitiveHashMap<V, S>

where K: Into<UniCase<String>>, S: BuildHasher, V: Copy,

fn extend<T: IntoIterator<Item = (K, &'a V)>>(&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<K, V, S> Extend<(K, V)> for CaseInsensitiveHashMap<V, S>

where K: Into<UniCase<String>>, S: BuildHasher,

fn extend<T: IntoIterator<Item = (K, V)>>(&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<K, V> FromIterator<(K, V)> for CaseInsensitiveHashMap<V>

where K: Into<UniCase<String>>,

fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self

Creates a value from an iterator.

impl<K, V, S> Index<K> for CaseInsensitiveHashMap<V, S>

where K: Into<UniCase<String>>, S: BuildHasher,

type Output = V

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, V, S> IntoIterator for &'a CaseInsensitiveHashMap<V, S>

where S: BuildHasher,

type Item = (&'a UniCase<String>, &'a V)

The type of the elements being iterated over.

type IntoIter = Iter<'a, UniCase<String>, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, V, S> IntoIterator for &'a mut CaseInsensitiveHashMap<V, S>

where S: BuildHasher,

type Item = (&'a UniCase<String>, &'a mut V)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, UniCase<String>, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<V, S> IntoIterator for CaseInsensitiveHashMap<V, S>

where S: BuildHasher,

type Item = (UniCase<String>, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<UniCase<String>, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<V, S> PartialEq for CaseInsensitiveHashMap<V, S>

where V: PartialEq, S: BuildHasher,

fn eq(&self, other: &CaseInsensitiveHashMap<V, S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V, S> Eq for CaseInsensitiveHashMap<V, S>

where V: Eq, S: BuildHasher,