Skip to content

Commit

Permalink
Merge pull request #158 from alexkazik/remove-leaks
Browse files Browse the repository at this point in the history 
Remove leaks, fixes #102
  • Loading branch information
@yegor256
yegor256 committed Dec 21, 2023
2 parents 48656cd + ccb6b5b commit d2ea751
Show file tree
Hide file tree
Showing 7 changed files with 118 additions and 105 deletions.
12 changes: 6 additions & 6 deletions src/debug.rs
View file
Expand Up @@ -45,17 +45,17 @@ mod test {

#[test]
fn debugs_map() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("one", 42);
m.insert("two", 16);
let mut m: Map<String, i32, 10> = Map::new();
m.insert("one".to_string(), 42);
m.insert("two".to_string(), 16);
assert_eq!("{one: 42, two: 16}", format!("{:?}", m));
}

#[test]
fn displays_map() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("one", 42);
m.insert("two", 16);
let mut m: Map<String, i32, 10> = Map::new();
m.insert("one".to_string(), 42);
m.insert("two".to_string(), 16);
assert_eq!("{one: 42, two: 16}", format!("{}", m));
}
}
8 changes: 4 additions & 4 deletions src/eq.rs
View file
Expand Up @@ -55,10 +55,10 @@ mod test {

#[test]
fn compares_two_maps() {
let mut m1: Map<&str, i32, 10> = Map::new();
m1.insert("first", 42);
let mut m2: Map<&str, i32, 10> = Map::new();
m2.insert("first", 42);
let mut m1: Map<String, i32, 10> = Map::new();
m1.insert("first".to_string(), 42);
let mut m2: Map<String, i32, 10> = Map::new();
m2.insert("first".to_string(), 42);
assert!(m1.eq(&m2));
}
}
12 changes: 6 additions & 6 deletions src/index.rs
View file
Expand Up @@ -47,24 +47,24 @@ mod test {

#[test]
fn index() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("first", 42);
let mut m: Map<String, i32, 10> = Map::new();
m.insert("first".to_string(), 42);
assert_eq!(m["first"], 42);
}

#[test]
fn index_mut() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("first", 42);
let mut m: Map<String, i32, 10> = Map::new();
m.insert("first".to_string(), 42);
m["first"] += 10;
assert_eq!(m["first"], 52);
}

#[test]
#[should_panic]
fn wrong_index() -> () {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("first", 42);
let mut m: Map<String, i32, 10> = Map::new();
m.insert("first".to_string(), 42);
assert_eq!(m["second"], 42);
}

Expand Down
62 changes: 31 additions & 31 deletions src/iterators.rs
View file
Expand Up @@ -142,18 +142,18 @@ mod test {

#[test]
fn insert_and_jump_over_next() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("foo", 42);
let mut m: Map<String, i32, 10> = Map::new();
m.insert("foo".to_string(), 42);
let mut iter = m.into_iter();
assert_eq!(42, iter.next().unwrap().1);
assert!(iter.next().is_none());
}

#[test]
fn insert_and_iterate() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("one", 42);
m.insert("two", 16);
let mut m: Map<String, i32, 10> = Map::new();
m.insert("one".to_string(), 42);
m.insert("two".to_string(), 16);
let mut sum = 0;
for (_k, v) in m.iter() {
sum += v;
Expand All @@ -163,9 +163,9 @@ mod test {

#[test]
fn insert_and_into_iterate() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("one", 42);
m.insert("two", 16);
let mut m: Map<String, i32, 10> = Map::new();
m.insert("one".to_string(), 42);
m.insert("two".to_string(), 16);
let mut sum = 0;
for p in &m {
sum += p.1;
Expand All @@ -175,11 +175,11 @@ mod test {

#[test]
fn iterate_with_blanks() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("one", 1);
m.insert("two", 3);
m.insert("three", 5);
m.remove(&"two");
let mut m: Map<String, i32, 10> = Map::new();
m.insert("one".to_string(), 1);
m.insert("two".to_string(), 3);
m.insert("three".to_string(), 5);
m.remove("two");
let mut sum = 0;
for (_k, v) in m.iter() {
sum += v;
Expand All @@ -189,11 +189,11 @@ mod test {

#[test]
fn into_iterate_with_blanks() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("one", 1);
m.insert("two", 3);
m.insert("three", 5);
m.remove(&"two");
let mut m: Map<String, i32, 10> = Map::new();
m.insert("one".to_string(), 1);
m.insert("two".to_string(), 3);
m.insert("three".to_string(), 5);
m.remove("two");
let mut sum = 0;
for (_k, v) in m {
sum += v;
Expand All @@ -203,10 +203,10 @@ mod test {

#[test]
fn change_with_iter_mut() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("one", 2);
m.insert("two", 3);
m.insert("three", 5);
let mut m: Map<String, i32, 10> = Map::new();
m.insert("one".to_string(), 2);
m.insert("two".to_string(), 3);
m.insert("three".to_string(), 5);
for (_k, v) in m.iter_mut() {
*v *= 2;
}
Expand All @@ -216,22 +216,22 @@ mod test {

#[test]
fn iter_mut_with_blanks() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("one", 1);
m.insert("two", 3);
m.insert("three", 5);
let mut m: Map<String, i32, 10> = Map::new();
m.insert("one".to_string(), 1);
m.insert("two".to_string(), 3);
m.insert("three".to_string(), 5);
assert_eq!(m.iter_mut().count(), 3);
m.remove(&"two");
m.remove("two");
assert_eq!(m.iter_mut().count(), 2);
assert_eq!(m.iter_mut().last().unwrap().1, &5);
}

#[test]
fn into_iter_mut() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("one", 2);
m.insert("two", 3);
m.insert("three", 5);
let mut m: Map<String, i32, 10> = Map::new();
m.insert("one".to_string(), 2);
m.insert("two".to_string(), 3);
m.insert("three".to_string(), 5);
for (_k, v) in &mut m {
*v *= 2;
}
Expand Down
17 changes: 10 additions & 7 deletions src/keys.rs
View file
Expand Up @@ -61,17 +61,20 @@ mod test {

#[test]
fn iterate_keys() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("foo", 0);
m.insert("bar", 0);
let mut m: Map<String, i32, 10> = Map::new();
m.insert("foo".to_string(), 0);
m.insert("bar".to_string(), 0);
assert_eq!(m.keys().collect::<Vec<_>>(), [&"foo", &"bar"]);
}

#[test]
fn iterate_into_keys() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("foo", 0);
m.insert("bar", 0);
assert_eq!(m.into_keys().collect::<Vec<_>>(), ["foo", "bar"]);
let mut m: Map<String, i32, 10> = Map::new();
m.insert("foo".to_string(), 0);
m.insert("bar".to_string(), 0);
assert_eq!(
m.into_keys().collect::<Vec<_>>(),
["foo".to_string(), "bar".to_string()]
);
}
}
90 changes: 50 additions & 40 deletions src/map.rs
View file
Expand Up @@ -54,10 +54,13 @@ impl<K: PartialEq, V, const N: usize> Map<K, V, N> {
/// Does the map contain this key?
#[inline]
#[must_use]
pub fn contains_key(&self, k: &K) -> bool {
pub fn contains_key<Q: PartialEq + ?Sized>(&self, k: &Q) -> bool
where
K: Borrow<Q>,
{
for i in 0..self.next {
if let Some((bk, _bv)) = self.item(i) {
if bk == k {
if bk.borrow() == k {
return true;
}
}
Expand All @@ -67,10 +70,14 @@ impl<K: PartialEq, V, const N: usize> Map<K, V, N> {

/// Remove by key.
#[inline]
pub fn remove(&mut self, k: &K) {
pub fn remove<Q: PartialEq + ?Sized>(&mut self, k: &Q)
where
K: Borrow<Q>,
{
for i in 0..self.next {
if let Some(p) = self.item(i) {
if p.0.borrow() == k {
unsafe { self.pairs[i].assume_init_drop() };
self.pairs[i].write(None);
break;
}
Expand Down Expand Up @@ -160,6 +167,9 @@ impl<K: PartialEq, V, const N: usize> Map<K, V, N> {
/// Remove all pairs from it, but keep the space intact for future use.
#[inline]
pub fn clear(&mut self) {
for i in 0..self.next {
unsafe { self.pairs[i].assume_init_drop() };
}
self.next = 0;
}

Expand Down Expand Up @@ -225,12 +235,12 @@ mod test {

#[test]
fn insert_and_check_length() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("first", 42);
let mut m: Map<String, i32, 10> = Map::new();
m.insert("first".to_string(), 42);
assert_eq!(1, m.len());
m.insert("second", 16);
m.insert("second".to_string(), 16);
assert_eq!(2, m.len());
m.insert("first", 16);
m.insert("first".to_string(), 16);
assert_eq!(2, m.len());
}

Expand Down Expand Up @@ -266,10 +276,10 @@ mod test {

#[test]
fn insert_and_gets() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("one", 42);
m.insert("two", 16);
assert_eq!(16, *m.get(&"two").unwrap());
let mut m: Map<String, i32, 10> = Map::new();
m.insert("one".to_string(), 42);
m.insert("two".to_string(), 16);
assert_eq!(16, *m.get("two").unwrap());
}

#[test]
Expand All @@ -283,33 +293,33 @@ mod test {

#[test]
fn checks_key() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("one", 42);
assert!(m.contains_key(&"one"));
assert!(!m.contains_key(&"another"));
let mut m: Map<String, i32, 10> = Map::new();
m.insert("one".to_string(), 42);
assert!(m.contains_key("one"));
assert!(!m.contains_key("another"));
}

#[test]
fn gets_missing_key() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("one", 42);
assert!(m.get(&"two").is_none());
let mut m: Map<String, i32, 10> = Map::new();
m.insert("one".to_string(), 42);
assert!(m.get("two").is_none());
}

#[test]
fn mut_gets_missing_key() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("one", 42);
assert!(m.get_mut(&"two").is_none());
let mut m: Map<String, i32, 10> = Map::new();
m.insert("one".to_string(), 42);
assert!(m.get_mut("two").is_none());
}

#[test]
fn removes_simple_pair() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("one", 42);
m.remove(&"one");
m.remove(&"another");
assert!(m.get(&"one").is_none());
let mut m: Map<String, i32, 10> = Map::new();
m.insert("one".to_string(), 42);
m.remove("one");
m.remove("another");
assert!(m.get("one").is_none());
}

#[cfg(test)]
Expand Down Expand Up @@ -348,8 +358,8 @@ mod test {

#[test]
fn clears_it_up() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("one", 42);
let mut m: Map<String, i32, 10> = Map::new();
m.insert("one".to_string(), 42);
m.clear();
assert_eq!(0, m.len());
}
Expand Down Expand Up @@ -379,33 +389,33 @@ mod test {

#[test]
fn get_key_value() {
let mut m: Map<&str, i32, 10> = Map::new();
let k = "key";
m.insert(k, 42);
assert_eq!(m.get_key_value(k), Some((&k, &42)));
let mut m: Map<String, i32, 10> = Map::new();
let k = "key".to_string();
m.insert(k.clone(), 42);
assert_eq!(m.get_key_value(&k), Some((&k, &42)));
assert!(m.contains_key(&k));
}

#[test]
fn get_absent_key_value() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("one", 42);
let mut m: Map<String, i32, 10> = Map::new();
m.insert("one".to_string(), 42);
assert_eq!(m.get_key_value("two"), None);
}

#[test]
fn remove_entry_present() {
let mut m: Map<&str, i32, 10> = Map::new();
let k = "key";
m.insert(k, 42);
assert_eq!(m.remove_entry(k), Some((k, 42)));
let mut m: Map<String, i32, 10> = Map::new();
let k = "key".to_string();
m.insert(k.clone(), 42);
assert_eq!(m.remove_entry(&k), Some((k.clone(), 42)));
assert!(!m.contains_key(&k));
}

#[test]
fn remove_entry_absent() {
let mut m: Map<&str, i32, 10> = Map::new();
m.insert("one", 42);
let mut m: Map<String, i32, 10> = Map::new();
m.insert("one".to_string(), 42);
assert_eq!(m.remove_entry("two"), None);
}

Expand Down

0 comments on commit d2ea751

Please sign in to comment.