Struct linear_map::LinearMap
[−]
[src]
pub struct LinearMap<K, V> {
// some fields omitted
}A very simple map implementation backed by a vector.
Use it like any map, as long as the number of elements that it stores is very small.
Example (like std's HashMap)
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.iter() { match book_reviews.get(book) { Some(review) => println!("{}: {}", *book, *review), None => println!("{} is unreviewed.", *book) } } // iterate over everything. for (book, review) in book_reviews.iter() { println!("{}: \"{}\"", *book, *review); }
Methods
impl<K: Eq, V> LinearMap<K, V>
fn new() -> LinearMap<K, V>
Creates an empty map. This method does not allocate.
fn with_capacity(capacity: usize) -> LinearMap<K, V>
Creates an empty map with the given initial capacity.
fn capacity(&self) -> usize
Returns the number of elements the map can hold without reallocating.
fn reserve(&mut self, additional: usize)
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.
fn reserve_exact(&mut self, additional: 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.
fn shrink_to_fit(&mut self)
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.
fn len(&self) -> usize
Returns the number of elements in the map.
fn is_empty(&self) -> bool
Returns true if the map contains no elements.
fn clear(&mut self)
Clears the map, removing all elements. Keeps the allocated memory for reuse.
fn iter<'a>(&'a self) -> Iter<'a, K, V>
An iterator visiting all key-value pairs in arbitrary order. Iterator
element type is (&'a K, &'a V).
fn iter_mut<'a>(&'a mut self) -> IterMut<'a, K, V>
An iterator visiting all key-value pairs in arbitrary order with
mutable references to the values. Iterator element type is (&'a K, &'a mut V).
fn keys<'a>(&'a self) -> Keys<'a, K, V>
An iterator visiting all keys in arbitrary order. Iterator element type
is &'a K.
fn values<'a>(&'a self) -> Values<'a, K, V>
An iterator visiting all values in arbitrary order. Iterator element
type is &'a V.
fn get<Q: ?Sized>(&self, key: &Q) -> Option<&V> where K: Borrow<Q>, Q: Eq
Returns a reference to the value corresponding to the key.
fn get_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<&mut V> where K: Borrow<Q>, Q: Eq
Returns a mutable reference to the value corresponding to the key.
fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool where K: Borrow<Q>, Q: Eq
Returns true if the map contains a value to the specified key.
fn insert(&mut self, key: K, value: V) -> Option<V>
Inserts a key-value pair into the map. If the key already had a value
present in the map, it is returned. Otherwise, None is returned.
fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<V> where K: Borrow<Q>, Q: Eq
Removes a key-value pair from the map. If the key had a value present
in the map, it is returned. Otherwise, None is returned.
fn entry(&mut self, key: K) -> Entry<K, V>
Gets the given key's corresponding entry in the map for in-place manipulation.