Struct linear_map::LinearMap [] [src]

pub struct LinearMap<K, V> { /* fields omitted */ }

A map implemented by searching linearly in a vector.

LinearMap's keys are compared using the Eq trait. All search operations (contains_key, get, get_mut, insert, and remove) run in O(n) time, making this implementation suitable only for small numbers of keys. The ordering of the keys in the underlying vector is arbitrary.

It is a logic error for a key to be modified in such a way that the key's equality, as determined by the Eq trait, changes while it is in the map. This is normally only possible through Cell, RefCell, global state, I/O, or unsafe code.

Example

use linear_map::LinearMap;

// type inference lets us omit an explicit type signature (which
// would be `LinearMap<&str, &str>` in this example).
let mut book_reviews = LinearMap::new();

// review some books.
book_reviews.insert("Adventures of Huckleberry Finn",    "My favorite book.");
book_reviews.insert("Grimms' Fairy Tales",               "Masterpiece.");
book_reviews.insert("Pride and Prejudice",               "Very enjoyable.");
book_reviews.insert("The Adventures of Sherlock Holmes", "Eye lyked it alot.");

// check for a specific one.
if !book_reviews.contains_key("Les Misérables") {
    println!("We've got {} reviews, but Les Misérables ain't one.",
             book_reviews.len());
}

// oops, this review has a lot of spelling mistakes. let's delete it.
book_reviews.remove("The Adventures of Sherlock Holmes");

// look up the values associated with some keys.
let to_find = ["Pride and Prejudice", "Alice's Adventure in Wonderland"];
for book in &to_find {
    match book_reviews.get(book) {
        Some(review) => println!("{}: {}", book, review),
        None => println!("{} is unreviewed.", book)
    }
}

// iterate over everything.
for (book, review) in &book_reviews {
    println!("{}: \"{}\"", book, review);
}

Methods

impl<K: Eq, V> LinearMap<K, V>
[src]

Creates an empty map. This method does not allocate.

Creates an empty map with the given initial capacity.

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

Reserves capacity for at least additional more to be inserted in the map. The collection may reserve more space to avoid frequent reallocations.

Panics

Panics if the new allocation size overflows usize.

Reserves the minimum capacity for exactly additional more elemnnts to be inserted in the map.

Note that the allocator may give the collection more space than it requests. Therefore capacity cannot be relied upon to be precisely minimal. Prefer reserve if future insertions are expected.

Panics

Panics if the new capacity overflows usize.

Shrinks the capacity of the map as much as possible.

It will drop down as close as possible to the current length but the allocator may still inform the map that there is more space than necessary. Therefore capacity cannot be relid upon to be minimal.

Returns the number of elements in the map.

Returns true if the map contains no elements.

Clears the map, removing all elements. Keeps the allocated memory for reuse.

Removes all key-value pairs from the map and returns an iterator that yields them in arbitrary order.

All key-value pairs are removed even if the iterator is not exhausted. However, the behavior of this method is unspecified if the iterator is leaked.

The iterator's item type is (K, V).

Returns an iterator yielding references to the map's keys and their corresponding values in arbitrary order.

The iterator's item type is (&K, &V).

Returns an iterator yielding references to the map's keys and mutable references to their corresponding values in arbitrary order.

The iterator's item type is (&K, &mut V).

Returns an iterator yielding references to the map's keys in arbitrary order.

The iterator's item type is &K.

Returns an iterator yielding references to the map's values in arbitrary order.

The iterator's item type is &V.

Returns a reference to the value in the map whose key is equal to the given key.

Returns None if the map contains no such key.

The given key may be any borrowed form of the map's key type, but Eq on the borrowed form must match that of the key type.

Returns a mutable reference to the value in the map whose key is equal to the given key.

Returns None if the map contains no such key.

The given key may be any borrowed form of the map's key type, but Eq on the borrowed form must match that of the key type.

Checks if the map contains a key that is equal to the given key.

The given key may be any borrowed form of the map's key type, but Eq on the borrowed form must match that of the key type.

Inserts a key-value pair into the map.

Returns None if the map did not contain a key that is equal to the given key.

If the map did contain such a key, its corresponding value is replaced with the given value, and the old value is returned. The key is not updated, though. This matters for values that can be == without being identical. See the standard library's documentation for more details.

Removes the key in the map that is equal to the given key and returns its corresponding value.

Returns None if the map contained no such key.

The given key may be any borrowed form of the map's key type, but Eq on the borrowed form must match that of the key type.

Returns the given key's corresponding entry in the map for in-place manipulation.

Trait Implementations

impl<K: Clone, V: Clone> Clone for LinearMap<K, V>
[src]

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

impl<K: Eq + Debug, V: Debug> Debug for LinearMap<K, V>
[src]

Formats the value using the given formatter.

impl<K: Eq, V> Default for LinearMap<K, V>
[src]

Returns the "default value" for a type. Read more

impl<K: Eq, V> Extend<(K, V)> for LinearMap<K, V>
[src]

Extends a collection with the contents of an iterator. Read more

impl<K: Eq, V> FromIterator<(K, V)> for LinearMap<K, V>
[src]

Creates a value from an iterator. Read more

impl<'a, K: Eq + Borrow<Q>, V, Q: ?Sized + Eq> Index<&'a Q> for LinearMap<K, V>
[src]

The returned type after indexing

The method for the indexing (container[index]) operation

impl<K: Eq, V: PartialEq> PartialEq for LinearMap<K, V>
[src]

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

This method tests for !=.

impl<K: Eq, V: Eq> Eq for LinearMap<K, V>
[src]

impl<K: Eq, V> Into<Vec<(K, V)>> for LinearMap<K, V>
[src]

Performs the conversion.

impl<K: Eq, V> IntoIterator for LinearMap<K, V>
[src]

The type of the elements being iterated over.

Which kind of iterator are we turning this into?

Creates an iterator from a value. Read more

impl<'a, K: Eq, V> IntoIterator for &'a LinearMap<K, V>
[src]

The type of the elements being iterated over.

Which kind of iterator are we turning this into?

Creates an iterator from a value. Read more

impl<'a, K: Eq, V> IntoIterator for &'a mut LinearMap<K, V>
[src]

The type of the elements being iterated over.

Which kind of iterator are we turning this into?

Creates an iterator from a value. Read more