Implement clone_from to reuse allocations

Author: cuviper

src/lib.rs

@@ -107,13 +107,33 @@ impl HashValue {
     }
 }
 
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Debug)]
 struct Bucket<K, V> {
     hash: HashValue,
     key: K,
     value: V,
 }
 
+impl<K, V> Clone for Bucket<K, V>
+where
+    K: Clone,
+    V: Clone,
+{
+    fn clone(&self) -> Self {
+        Bucket {
+            hash: self.hash,
+            key: self.key.clone(),
+            value: self.value.clone(),
+        }
+    }
+
+    fn clone_from(&mut self, other: &Self) {
+        self.hash = other.hash;
+        self.key.clone_from(&other.key);
+        self.value.clone_from(&other.value);
+    }
+}
+
 impl<K, V> Bucket<K, V> {
     // field accessors -- used for `f` instead of closures in `.map(f)`
     fn key_ref(&self) -> &K {

src/map.rs

@@ -77,19 +77,36 @@ fn hash_elem_using<B: BuildHasher, K: ?Sized + Hash>(build: &B, k: &K) -> HashVa
 /// assert_eq!(letters[&'u'], 1);
 /// assert_eq!(letters.get(&'y'), None);
 /// ```
-#[derive(Clone)]
 #[cfg(has_std)]
 pub struct IndexMap<K, V, S = RandomState> {
     core: IndexMapCore<K, V>,
     hash_builder: S,
 }
-#[derive(Clone)]
 #[cfg(not(has_std))]
 pub struct IndexMap<K, V, S> {
     core: IndexMapCore<K, V>,
     hash_builder: S,
 }
 
+impl<K, V, S> Clone for IndexMap<K, V, S>
+where
+    K: Clone,
+    V: Clone,
+    S: Clone,
+{
+    fn clone(&self) -> Self {
+        IndexMap {
+            core: self.core.clone(),
+            hash_builder: self.hash_builder.clone(),
+        }
+    }
+
+    fn clone_from(&mut self, other: &Self) {
+        self.core.clone_from(&other.core);
+        self.hash_builder.clone_from(&other.hash_builder);
+    }
+}
+
 impl<K, V, S> Entries for IndexMap<K, V, S> {
     type Entry = Bucket<K, V>;
 

src/map_core.rs

@@ -362,7 +362,6 @@ where
 }
 
 /// Core of the map that does not depend on S
-#[derive(Clone)]
 pub(crate) struct IndexMapCore<K, V> {
     mask: usize,
     /// indices are the buckets. indices.len() == raw capacity
@@ -371,6 +370,26 @@ pub(crate) struct IndexMapCore<K, V> {
     entries: Vec<Bucket<K, V>>,
 }
 
+impl<K, V> Clone for IndexMapCore<K, V>
+where
+    K: Clone,
+    V: Clone,
+{
+    fn clone(&self) -> Self {
+        IndexMapCore {
+            mask: self.mask,
+            indices: self.indices.clone(),
+            entries: self.entries.clone(),
+        }
+    }
+
+    fn clone_from(&mut self, other: &Self) {
+        self.mask = other.mask;
+        self.indices.clone_from(&other.indices);
+        self.entries.clone_from(&other.entries);
+    }
+}
+
 impl<K, V> Entries for IndexMapCore<K, V> {
     type Entry = Bucket<K, V>;
 

src/set.rs

@@ -63,17 +63,31 @@ type Bucket<T> = super::Bucket<T, ()>;
 /// assert!(letters.contains(&'u'));
 /// assert!(!letters.contains(&'y'));
 /// ```
-#[derive(Clone)]
 #[cfg(has_std)]
 pub struct IndexSet<T, S = RandomState> {
     map: IndexMap<T, (), S>,
 }
 #[cfg(not(has_std))]
-#[derive(Clone)]
 pub struct IndexSet<T, S> {
     map: IndexMap<T, (), S>,
 }
 
+impl<T, S> Clone for IndexSet<T, S>
+where
+    T: Clone,
+    S: Clone,
+{
+    fn clone(&self) -> Self {
+        IndexSet {
+            map: self.map.clone(),
+        }
+    }
+
+    fn clone_from(&mut self, other: &Self) {
+        self.map.clone_from(&other.map);
+    }
+}
+
 impl<T, S> Entries for IndexSet<T, S> {
     type Entry = Bucket<T>;