Move entry fully into the core

Author: cuviper

src/lib.rs

@@ -79,7 +79,6 @@ mod mutable_keys;
 mod serde;
 mod util;
 
-#[macro_use]
 mod map_core;
 
 pub mod map;

src/map.rs

@@ -24,7 +24,7 @@ use std::cmp::Ordering;
 use std::fmt;
 
 use equivalent::Equivalent;
-use map_core::{IndexMapCore, Size};
+use map_core::IndexMapCore;
 use util::third;
 use {Bucket, Entries, HashValue};
 
@@ -203,27 +203,13 @@ impl<K, V, S> IndexMap<K, V, S> {
     pub fn capacity(&self) -> usize {
         self.core.capacity()
     }
-
-    #[inline]
-    fn size_class_is_64bit(&self) -> bool {
-        self.core.size_class_is_64bit()
-    }
 }
 
 impl<K, V, S> IndexMap<K, V, S>
 where
     K: Hash + Eq,
     S: BuildHasher,
 {
-    // FIXME: reduce duplication (compare with insert)
-    fn entry_phase_1<Sz>(&mut self, key: K) -> Entry<K, V>
-    where
-        Sz: Size,
-    {
-        let hash = hash_elem_using(&self.hash_builder, &key);
-        self.core.entry_phase_1::<Sz>(hash, key)
-    }
-
     /// Remove all key-value pairs in the map, while preserving its capacity.
     ///
     /// Computes in **O(n)** time.
@@ -289,8 +275,8 @@ where
     ///
     /// Computes in **O(1)** time (amortized average).
     pub fn entry(&mut self, key: K) -> Entry<K, V> {
-        self.core.reserve_one();
-        dispatch_32_vs_64!(self.entry_phase_1(key))
+        let hash = hash_elem_using(&self.hash_builder, &key);
+        self.core.entry(hash, key)
     }
 
     /// Return an iterator over the key-value pairs of the map, in their order

src/map_core.rs

@@ -23,7 +23,7 @@ use {Bucket, HashValue};
 
 /// Trait for the "size class". Either u32 or u64 depending on the index
 /// size needed to address an entry's index in self.core.entries.
-pub(crate) trait Size {
+trait Size {
     fn is_64_bit() -> bool;
     fn is_same_size<T: Size>() -> bool {
         Self::is_64_bit() == T::is_64_bit()
@@ -398,14 +398,14 @@ impl<K, V> IndexMapCore<K, V> {
 
     // Return whether we need 32 or 64 bits to specify a bucket or entry index
     #[cfg(not(feature = "test_low_transition_point"))]
-    pub(crate) fn size_class_is_64bit(&self) -> bool {
+    fn size_class_is_64bit(&self) -> bool {
         usize::max_value() > u32::max_value() as usize
             && self.raw_capacity() >= u32::max_value() as usize
     }
 
     // for testing
     #[cfg(feature = "test_low_transition_point")]
-    pub(crate) fn size_class_is_64bit(&self) -> bool {
+    fn size_class_is_64bit(&self) -> bool {
         self.raw_capacity() >= 64
     }
 
@@ -450,7 +450,7 @@ impl<K, V> IndexMapCore<K, V> {
 
     #[inline(never)]
     // `Sz` is *current* Size class, before grow
-    pub(crate) fn double_capacity<Sz>(&mut self)
+    fn double_capacity<Sz>(&mut self)
     where
         Sz: Size,
     {
@@ -529,8 +529,16 @@ impl<K, V> IndexMapCore<K, V> {
         Some(self.swap_remove_found(probe, found))
     }
 
+    pub(crate) fn entry(&mut self, hash: HashValue, key: K) -> Entry<K, V>
+    where
+        K: Eq,
+    {
+        self.reserve_one();
+        dispatch_32_vs_64!(self.entry_phase_1(hash, key))
+    }
+
     // FIXME: reduce duplication (compare with insert)
-    pub(crate) fn entry_phase_1<Sz>(&mut self, hash: HashValue, key: K) -> Entry<K, V>
+    fn entry_phase_1<Sz>(&mut self, hash: HashValue, key: K) -> Entry<K, V>
     where
         Sz: Size,
         K: Eq,