Implement range iterators

Cargo.toml

@@ -20,6 +20,7 @@ exclude = [ "/.*" ]
 [features]
 std = [ ]
 default = [ "std" ]
+range = [ ]
 
 [build-dependencies]
 autocfg = "1"
@@ -31,3 +32,4 @@ serde = { version = "1.0", optional = true, default-features = false, features =
 rustversion = "1"
 serde = { version = "1", features = [ "derive" ] }
 serde_test = "1"
+rand = "0.8"

src/builder.rs

@@ -1,3 +1,5 @@
+use core::mem::replace;
+
 use crate::entries::{Entries, Entry};
 use crate::generic::GenericSlab;
 use crate::key::Key;
@@ -29,19 +31,32 @@ where
         let slab = &mut self.slab;
 
         if index < slab.entries.as_ref().len() {
-            let entry = &mut slab.entries.as_mut()[index];
-
-            // iterator is not sorted, might need to recreate vacant list
-            if let Entry::Vacant { .. } = &*entry {
-                self.vacant_list_broken = true;
-                slab.meta.len += 1;
+            match replace(&mut slab.entries.as_mut()[index], Entry::Unknown) {
+                Entry::Vacant { .. } => {
+                    self.vacant_list_broken = true;
+                    slab.meta.len += 1;
+                }
+                Entry::Occupied {
+                    #[cfg(feature = "range")]
+                    range,
+                    ..
+                } => {
+                    #[cfg(feature = "range")]
+                    slab.remove_occupied_index(index, range);
+                }
+                _ => unreachable!(),
             }
 
+            #[cfg(feature = "range")]
+            let range = slab.insert_occupied_index(index);
+
             // if an element with this key already exists, replace it.
             // This is consistent with HashMap and BtreeMap
-            *entry = Entry::Occupied {
+            slab.entries.as_mut()[index] = Entry::Occupied {
                 value,
-                key_data: Default::default(),
+                key_data: key.into_occupied_data(),
+                #[cfg(feature = "range")]
+                range,
             };
         } else {
             if self.first_vacant_index.is_none() && slab.entries.as_ref().len() < index {
@@ -58,9 +73,15 @@ where
                     key_data: Default::default(),
                 });
             }
+
+            #[cfg(feature = "range")]
+            let range = slab.insert_occupied_index(index);
+
             slab.entries.push(Entry::Occupied {
                 value,
-                key_data: Default::default(),
+                key_data: key.into_occupied_data(),
+                #[cfg(feature = "range")]
+                range,
             });
             slab.meta.len += 1;
         }

src/entries.rs

@@ -112,6 +112,10 @@ where
 
         /// Key related data for this entry
         key_data: TKey::OccupiedData,
+
+        /// Indices of the range feature
+        #[cfg(feature = "range")]
+        range: RangeIndices,
     },
 
     /// Unknown state for this entry
@@ -128,13 +132,20 @@ where
     fn clone(&self) -> Self {
         match self {
             Entry::Unknown => unreachable!(),
-            Entry::Vacant { next, key_data } => Self::Vacant {
+            Entry::Vacant { next, key_data } => Entry::Vacant {
                 next: *next,
                 key_data: key_data.clone(),
             },
-            Entry::Occupied { value, key_data } => Self::Occupied {
+            Entry::Occupied {
+                value,
+                key_data,
+                #[cfg(feature = "range")]
+                range,
+            } => Entry::Occupied {
                 value: value.clone(),
                 key_data: key_data.clone(),
+                #[cfg(feature = "range")]
+                range: *range,
             },
         }
     }
@@ -149,17 +160,34 @@ where
 {
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         match self {
-            Self::Unknown => write!(f, "Unknown"),
-            Self::Vacant { next, key_data } => f
+            Entry::Unknown => write!(f, "Unknown"),
+            Entry::Vacant { next, key_data } => f
                 .debug_struct("Vacant")
                 .field("next", next)
                 .field("key_data", key_data)
                 .finish(),
-            Self::Occupied { value, key_data } => f
-                .debug_struct("Occupied")
-                .field("value", value)
-                .field("key_data", key_data)
-                .finish(),
+            Entry::Occupied {
+                value,
+                key_data,
+                #[cfg(feature = "range")]
+                range,
+            } => {
+                let mut s = f.debug_struct("Occupied");
+                s.field("value", value);
+                s.field("key_data", key_data);
+                #[cfg(feature = "range")]
+                s.field("range", range);
+                s.finish()
+            }
         }
     }
 }
+
+/* RangeIndices */
+
+#[cfg(feature = "range")]
+#[derive(Debug, Clone, Copy)]
+pub struct RangeIndices {
+    pub(crate) prev: usize,
+    pub(crate) next: usize,
+}