Add and methods

Author: mnpw

.gitignore

@@ -0,0 +1,2 @@
+/target
+Cargo.lock

Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "hashmap-rs"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

examples/std-1.rs

@@ -0,0 +1,51 @@
+use hashmap::HashMap;
+
+// Type inference lets us omit an explicit type signature (which
+// would be `HashMap<String, String>` in this example).
+let mut book_reviews = HashMap::new();
+
+// Review some books.
+book_reviews.insert(
+    "Adventures of Huckleberry Finn".to_string(),
+    "My favorite book.".to_string(),
+);
+book_reviews.insert(
+    "Grimms' Fairy Tales".to_string(),
+    "Masterpiece.".to_string(),
+);
+book_reviews.insert(
+    "Pride and Prejudice".to_string(),
+    "Very enjoyable.".to_string(),
+);
+book_reviews.insert(
+    "The Adventures of Sherlock Holmes".to_string(),
+    "Eye lyked it alot.".to_string(),
+);
+
+// Check for a specific one.
+// When collections store owned values (String), they can still be
+// queried using references (&str).
+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)
+    }
+}
+
+// Look up the value for a key (will panic if the key is not found).
+println!("Review for Jane: {}", book_reviews["Pride and Prejudice"]);
+
+// Iterate over everything.
+for (book, review) in &book_reviews {
+    println!("{}: \"{}\"", book, review);
+}

src/lib.rs

@@ -0,0 +1,87 @@
+use std::collections::hash_map::DefaultHasher;
+use std::hash::{Hash, Hasher};
+use std::mem;
+
+const INITIAL_NBUCKETS: usize = 1;
+
+pub struct HashMap<K, V> {
+    buckets: Vec<Vec<(K, V)>>,
+    items: usize,
+}
+
+impl<K, V> HashMap<K, V> {
+    pub fn new() -> Self {
+        // this should be 'free' to create
+        HashMap {
+            buckets: Vec::new(),
+            items: 0,
+        }
+    }
+}
+
+impl<K, V> HashMap<K, V>
+where
+    K: Hash + Eq,
+{
+    pub fn insert(&mut self, key: K, value: V) -> Option<V> {
+        // if buckets is empty or it is 3/4th full the resize
+        if self.buckets.is_empty() || self.items > 3 * self.buckets.len() / 4 {
+            self.resize();
+        }
+
+        let mut hasher = DefaultHasher::new();
+        key.hash(&mut hasher);
+        let hash = hasher.finish();
+
+        let bucket = (hash % self.buckets.len() as u64) as usize;
+        let bucket = &mut self.buckets[bucket];
+        self.items += 1;
+
+        for (ref k, ref mut v) in bucket.iter_mut() {
+            if k == &key {
+                // update
+                return Some(mem::replace(v, value));
+            }
+        }
+
+        bucket.push((key, value));
+        None
+    }
+
+    pub fn resize(&mut self) {
+        let target_size = match self.buckets.len() {
+            0 => INITIAL_NBUCKETS,
+            n => 2 * n,
+        };
+
+        // create new buckets
+        let mut new_buckets = Vec::with_capacity(target_size);
+        new_buckets.extend((0..target_size).map(|_| Vec::new()));
+
+        // add elements into new buckets
+        for (key, val) in self.buckets.iter_mut().flat_map(|bucket| bucket.drain(..)) {
+            let mut hasher = DefaultHasher::new();
+            key.hash(&mut hasher);
+            let hash = hasher.finish();
+
+            let bucket = (hash % new_buckets.len() as u64) as usize;
+            let bucket = &mut new_buckets[bucket];
+            bucket.push((key, val));
+        }
+
+        // replace old buckets with new buckets
+        mem::replace(&mut self.buckets, new_buckets);
+    }
+}
+
+#[cfg(test)]
+
+mod tests {
+    use super::*;
+
+    #[test]
+    fn insert() {
+        let mut map = HashMap::new();
+        map.insert("foo", 42);
+    }
+}