Move insert fully into the core

Author: cuviper

src/map.rs

@@ -24,7 +24,7 @@ use std::cmp::Ordering;
 use std::fmt;
 
 use equivalent::Equivalent;
-use map_core::{IndexMapCore, InsertValue, MakeEntry, ProbeAction, Size};
+use map_core::{IndexMapCore, MakeEntry, ProbeAction, Size};
 use util::third;
 use {Bucket, Entries, HashValue};
 
@@ -236,23 +236,10 @@ where
     /// FIXME Not implemented fully yet.
     pub fn reserve(&mut self, additional: usize) {
         if additional > 0 {
-            self.reserve_one();
+            self.core.reserve_one();
         }
     }
 
-    fn reserve_one(&mut self) {
-        if self.len() == self.capacity() {
-            dispatch_32_vs_64!(self.double_capacity());
-        }
-    }
-
-    fn double_capacity<Sz>(&mut self)
-    where
-        Sz: Size,
-    {
-        self.core.double_capacity::<Sz>();
-    }
-
     /// Insert a key-value pair in the map.
     ///
     /// If an equivalent key already exists in the map: the key remains and
@@ -284,16 +271,16 @@ where
     /// See also [`entry`](#method.entry) if you you want to insert *or* modify
     /// or if you need to get the index of the corresponding key-value pair.
     pub fn insert_full(&mut self, key: K, value: V) -> (usize, Option<V>) {
-        self.reserve_one();
-        dispatch_32_vs_64!(self.insert_phase_1::<_>(key, InsertValue(value)))
+        let hash = hash_elem_using(&self.hash_builder, &key);
+        self.core.insert_full(hash, key, value)
     }
 
     /// Get the given key’s corresponding entry in the map for insertion and/or
     /// in-place manipulation.
     ///
     /// Computes in **O(1)** time (amortized average).
     pub fn entry(&mut self, key: K) -> Entry<K, V> {
-        self.reserve_one();
+        self.core.reserve_one();
         dispatch_32_vs_64!(self.insert_phase_1::<_>(key, MakeEntry))
     }
 

src/map_core.rs

@@ -436,6 +436,12 @@ impl<K, V> IndexMapCore<K, V> {
         self.entries = Vec::with_capacity(usable_capacity(raw_cap));
     }
 
+    pub(crate) fn reserve_one(&mut self) {
+        if self.len() == self.capacity() {
+            dispatch_32_vs_64!(self.double_capacity());
+        }
+    }
+
     #[inline(never)]
     // `Sz` is *current* Size class, before grow
     pub(crate) fn double_capacity<Sz>(&mut self)
@@ -561,7 +567,7 @@ impl<K, V> IndexMapCore<K, V> {
     }
 
     /// phase 2 is post-insert where we forward-shift `Pos` in the indices.
-    pub(crate) fn insert_phase_2<Sz>(&mut self, mut probe: usize, mut old_pos: Pos)
+    fn insert_phase_2<Sz>(&mut self, mut probe: usize, mut old_pos: Pos)
     where
         Sz: Size,
     {
@@ -576,6 +582,14 @@ impl<K, V> IndexMapCore<K, V> {
         });
     }
 
+    pub(crate) fn insert_full(&mut self, hash: HashValue, key: K, value: V) -> (usize, Option<V>)
+    where
+        K: Eq,
+    {
+        self.reserve_one();
+        dispatch_32_vs_64!(self.insert_phase_1::<_>(hash, key, InsertValue(value)))
+    }
+
     /// Return probe (indices) and position (entries)
     pub(crate) fn find_using<F>(&self, hash: HashValue, key_eq: F) -> Option<(usize, usize)>
     where
@@ -864,7 +878,7 @@ pub(crate) trait ProbeAction<'a, Sz: Size, K, V>: Sized {
     fn steal(self, entry: VacantEntry<'a, K, V>) -> Self::Output;
 }
 
-pub(crate) struct InsertValue<V>(pub(crate) V);
+struct InsertValue<V>(V);
 
 impl<'a, Sz: Size, K, V> ProbeAction<'a, Sz, K, V> for InsertValue<V> {
     type Output = (usize, Option<V>);