Add boxed slices, including owned iterators

Author: cuviper

src/map.rs

@@ -17,6 +17,7 @@ use ::core::hash::{BuildHasher, Hash, Hasher};
 use ::core::iter::FusedIterator;
 use ::core::ops::{Index, IndexMut, RangeBounds};
 use ::core::slice::{Iter as SliceIter, IterMut as SliceIterMut};
+use alloc::boxed::Box;
 
 #[cfg(feature = "std")]
 use std::collections::hash_map::RandomState;
@@ -774,6 +775,13 @@ impl<K, V, S> IndexMap<K, V, S> {
         Slice::from_mut_slice(self.as_entries_mut())
     }
 
+    /// Converts into a boxed slice of all the key-value pairs in the map.
+    ///
+    /// Note that this will drop the inner hash table and any excess capacity.
+    pub fn into_boxed_slice(self) -> Box<Slice<K, V>> {
+        Slice::from_boxed(self.into_entries().into_boxed_slice())
+    }
+
     /// Get a key-value pair by index
     ///
     /// Valid indices are *0 <= index < self.len()*

src/map/slice.rs

@@ -1,6 +1,11 @@
-use super::{Bucket, Entries, IndexMap, Iter, IterMut, Keys, Values, ValuesMut};
+use super::{
+    Bucket, Entries, IndexMap, IntoIter, IntoKeys, IntoValues, Iter, IterMut, Keys, Values,
+    ValuesMut,
+};
 use crate::util::try_simplify_range;
 
+use alloc::boxed::Box;
+use alloc::vec::Vec;
 use core::cmp::Ordering;
 use core::fmt;
 use core::hash::{Hash, Hasher};
@@ -18,22 +23,32 @@ pub struct Slice<K, V> {
     pub(crate) entries: [Bucket<K, V>],
 }
 
+// SAFETY: `Slice<K, V>` is a transparent wrapper around `[Bucket<K, V>]`,
+// and reference lifetimes are bound together in function signatures.
 #[allow(unsafe_code)]
 impl<K, V> Slice<K, V> {
     pub(super) fn from_slice(entries: &[Bucket<K, V>]) -> &Self {
-        // SAFETY: `Slice<K, V>` is a transparent wrapper around `[Bucket<K, V>]`,
-        // and the lifetimes are bound together by this function's signature.
         unsafe { &*(entries as *const [Bucket<K, V>] as *const Self) }
     }
 
     pub(super) fn from_mut_slice(entries: &mut [Bucket<K, V>]) -> &mut Self {
-        // SAFETY: `Slice<K, V>` is a transparent wrapper around `[Bucket<K, V>]`,
-        // and the lifetimes are bound together by this function's signature.
         unsafe { &mut *(entries as *mut [Bucket<K, V>] as *mut Self) }
     }
+
+    pub(super) fn from_boxed(entries: Box<[Bucket<K, V>]>) -> Box<Self> {
+        unsafe { Box::from_raw(Box::into_raw(entries) as *mut Self) }
+    }
+
+    fn into_boxed(self: Box<Self>) -> Box<[Bucket<K, V>]> {
+        unsafe { Box::from_raw(Box::into_raw(self) as *mut [Bucket<K, V>]) }
+    }
 }
 
 impl<K, V> Slice<K, V> {
+    pub(crate) fn into_entries(self: Box<Self>) -> Vec<Bucket<K, V>> {
+        self.into_boxed().into_vec()
+    }
+
     /// Return the number of key-value pairs in the map slice.
     #[inline]
     pub fn len(&self) -> usize {
@@ -173,6 +188,13 @@ impl<K, V> Slice<K, V> {
         }
     }
 
+    /// Return an owning iterator over the keys of the map slice.
+    pub fn into_keys(self: Box<Self>) -> IntoKeys<K, V> {
+        IntoKeys {
+            iter: self.into_entries().into_iter(),
+        }
+    }
+
     /// Return an iterator over the values of the map slice.
     pub fn values(&self) -> Values<'_, K, V> {
         Values {
@@ -186,6 +208,13 @@ impl<K, V> Slice<K, V> {
             iter: self.entries.iter_mut(),
         }
     }
+
+    /// Return an owning iterator over the values of the map slice.
+    pub fn into_values(self: Box<Self>) -> IntoValues<K, V> {
+        IntoValues {
+            iter: self.into_entries().into_iter(),
+        }
+    }
 }
 
 impl<'a, K, V> IntoIterator for &'a Slice<K, V> {
@@ -206,6 +235,17 @@ impl<'a, K, V> IntoIterator for &'a mut Slice<K, V> {
     }
 }
 
+impl<K, V> IntoIterator for Box<Slice<K, V>> {
+    type IntoIter = IntoIter<K, V>;
+    type Item = (K, V);
+
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter {
+            iter: self.into_entries().into_iter(),
+        }
+    }
+}
+
 impl<K, V> Default for &'_ Slice<K, V> {
     fn default() -> Self {
         Slice::from_slice(&[])

src/rayon/map.rs

@@ -10,6 +10,7 @@ use rayon::iter::plumbing::{Consumer, ProducerCallback, UnindexedConsumer};
 use rayon::prelude::*;
 
 use crate::vec::Vec;
+use alloc::boxed::Box;
 use core::cmp::Ordering;
 use core::fmt;
 use core::hash::{BuildHasher, Hash};
@@ -36,6 +37,22 @@ where
     }
 }
 
+/// Requires crate feature `"rayon"`.
+impl<K, V> IntoParallelIterator for Box<Slice<K, V>>
+where
+    K: Send,
+    V: Send,
+{
+    type Item = (K, V);
+    type Iter = IntoParIter<K, V>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        IntoParIter {
+            entries: self.into_entries(),
+        }
+    }
+}
+
 /// A parallel owning iterator over the entries of a `IndexMap`.
 ///
 /// This `struct` is created by the [`into_par_iter`] method on [`IndexMap`]

src/rayon/set.rs

@@ -10,6 +10,7 @@ use rayon::iter::plumbing::{Consumer, ProducerCallback, UnindexedConsumer};
 use rayon::prelude::*;
 
 use crate::vec::Vec;
+use alloc::boxed::Box;
 use core::cmp::Ordering;
 use core::fmt;
 use core::hash::{BuildHasher, Hash};
@@ -36,6 +37,21 @@ where
     }
 }
 
+/// Requires crate feature `"rayon"`.
+impl<T> IntoParallelIterator for Box<Slice<T>>
+where
+    T: Send,
+{
+    type Item = T;
+    type Iter = IntoParIter<T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        IntoParIter {
+            entries: self.into_entries(),
+        }
+    }
+}
+
 /// A parallel owning iterator over the items of a `IndexSet`.
 ///
 /// This `struct` is created by the [`into_par_iter`] method on [`IndexSet`]

src/set.rs

@@ -12,6 +12,7 @@ use std::collections::hash_map::RandomState;
 
 use crate::util::try_simplify_range;
 use crate::vec::{self, Vec};
+use alloc::boxed::Box;
 use core::cmp::Ordering;
 use core::fmt;
 use core::hash::{BuildHasher, Hash};
@@ -663,6 +664,13 @@ impl<T, S> IndexSet<T, S> {
         Slice::from_slice(self.as_entries())
     }
 
+    /// Converts into a boxed slice of all the values in the set.
+    ///
+    /// Note that this will drop the inner hash table and any excess capacity.
+    pub fn into_boxed_slice(self) -> Box<Slice<T>> {
+        Slice::from_boxed(self.into_entries().into_boxed_slice())
+    }
+
     /// Get a value by index
     ///
     /// Valid indices are *0 <= index < self.len()*

src/set/slice.rs

@@ -1,6 +1,8 @@
-use super::{Bucket, Entries, IndexSet, Iter};
+use super::{Bucket, Entries, IndexSet, IntoIter, Iter};
 use crate::util::try_simplify_range;
 
+use alloc::boxed::Box;
+use alloc::vec::Vec;
 use core::cmp::Ordering;
 use core::fmt;
 use core::hash::{Hash, Hasher};
@@ -18,16 +20,28 @@ pub struct Slice<T> {
     pub(crate) entries: [Bucket<T>],
 }
 
+// SAFETY: `Slice<T>` is a transparent wrapper around `[Bucket<T>]`,
+// and reference lifetimes are bound together in function signatures.
 #[allow(unsafe_code)]
 impl<T> Slice<T> {
     pub(super) fn from_slice(entries: &[Bucket<T>]) -> &Self {
-        // SAFETY: `Slice<T>` is a transparent wrapper around `[Bucket<T>]`,
-        // and the lifetimes are bound together by this function's signature.
         unsafe { &*(entries as *const [Bucket<T>] as *const Self) }
     }
+
+    pub(super) fn from_boxed(entries: Box<[Bucket<T>]>) -> Box<Self> {
+        unsafe { Box::from_raw(Box::into_raw(entries) as *mut Self) }
+    }
+
+    fn into_boxed(self: Box<Self>) -> Box<[Bucket<T>]> {
+        unsafe { Box::from_raw(Box::into_raw(self) as *mut [Bucket<T>]) }
+    }
 }
 
 impl<T> Slice<T> {
+    pub(crate) fn into_entries(self: Box<Self>) -> Vec<Bucket<T>> {
+        self.into_boxed().into_vec()
+    }
+
     /// Return the number of elements in the set slice.
     pub fn len(&self) -> usize {
         self.entries.len()
@@ -108,6 +122,17 @@ impl<'a, T> IntoIterator for &'a Slice<T> {
     }
 }
 
+impl<T> IntoIterator for Box<Slice<T>> {
+    type IntoIter = IntoIter<T>;
+    type Item = T;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter {
+            iter: self.into_entries().into_iter(),
+        }
+    }
+}
+
 impl<T> Default for &'_ Slice<T> {
     fn default() -> Self {
         Slice::from_slice(&[])