Add get_range and get_range_mut

Author: cuviper

src/map/slice.rs

@@ -1,10 +1,10 @@
 use super::{Bucket, Entries, IndexMap, Iter, IterMut, Keys, Values, ValuesMut};
-use crate::util::simplify_range;
+use crate::util::{simplify_range, try_simplify_range};
 
 use core::cmp::Ordering;
 use core::fmt;
 use core::hash::{Hash, Hasher};
-use core::ops::{self, Bound, Index, IndexMut};
+use core::ops::{self, Bound, Index, IndexMut, RangeBounds};
 
 /// A dynamically-sized slice of key-value pairs in an `IndexMap`.
 ///
@@ -43,6 +43,24 @@ impl<K, V, S> IndexMap<K, V, S> {
     pub fn as_mut_slice(&mut self) -> &mut Slice<K, V> {
         Slice::from_mut_slice(self.as_entries_mut())
     }
+
+    /// Returns a slice of entries in the given range of indices.
+    ///
+    /// Valid indices are *0 <= index < self.len()*
+    pub fn get_range<R: RangeBounds<usize>>(&self, range: R) -> Option<&Slice<K, V>> {
+        let entries = self.as_entries();
+        let range = try_simplify_range(range, entries.len())?;
+        entries.get(range).map(Slice::from_slice)
+    }
+
+    /// Returns a mutable slice of entries in the given range of indices.
+    ///
+    /// Valid indices are *0 <= index < self.len()*
+    pub fn get_range_mut<R: RangeBounds<usize>>(&mut self, range: R) -> Option<&mut Slice<K, V>> {
+        let entries = self.as_entries_mut();
+        let range = try_simplify_range(range, entries.len())?;
+        entries.get_mut(range).map(Slice::from_mut_slice)
+    }
 }
 
 impl<'a, K, V> Iter<'a, K, V> {
@@ -90,6 +108,22 @@ impl<K, V> Slice<K, V> {
         self.entries.get_mut(index).map(Bucket::ref_mut)
     }
 
+    /// Returns a slice of key-value pairs in the given range of indices.
+    ///
+    /// Valid indices are *0 <= index < self.len()*
+    pub fn get_range<R: RangeBounds<usize>>(&self, range: R) -> Option<&Self> {
+        let range = try_simplify_range(range, self.entries.len())?;
+        self.entries.get(range).map(Slice::from_slice)
+    }
+
+    /// Returns a mutable slice of key-value pairs in the given range of indices.
+    ///
+    /// Valid indices are *0 <= index < self.len()*
+    pub fn get_range_mut<R: RangeBounds<usize>>(&mut self, range: R) -> Option<&mut Self> {
+        let range = try_simplify_range(range, self.entries.len())?;
+        self.entries.get_mut(range).map(Slice::from_mut_slice)
+    }
+
     /// Get the first key-value pair.
     pub fn first(&self) -> Option<(&K, &V)> {
         self.entries.first().map(Bucket::refs)

src/set/slice.rs

@@ -1,10 +1,10 @@
 use super::{Bucket, Entries, IndexSet, Iter};
-use crate::util::simplify_range;
+use crate::util::{simplify_range, try_simplify_range};
 
 use core::cmp::Ordering;
 use core::fmt;
 use core::hash::{Hash, Hasher};
-use core::ops::{self, Bound, Index};
+use core::ops::{self, Bound, Index, RangeBounds};
 
 /// A dynamically-sized slice of values in an `IndexSet`.
 ///
@@ -32,6 +32,15 @@ impl<T, S> IndexSet<T, S> {
     pub fn as_slice(&self) -> &Slice<T> {
         Slice::from_slice(self.as_entries())
     }
+
+    /// Returns a slice of values in the given range of indices.
+    ///
+    /// Valid indices are *0 <= index < self.len()*
+    pub fn get_range<R: RangeBounds<usize>>(&self, range: R) -> Option<&Slice<T>> {
+        let entries = self.as_entries();
+        let range = try_simplify_range(range, entries.len())?;
+        entries.get(range).map(Slice::from_slice)
+    }
 }
 
 impl<'a, T> Iter<'a, T> {
@@ -59,6 +68,14 @@ impl<T> Slice<T> {
         self.entries.get(index).map(Bucket::key_ref)
     }
 
+    /// Returns a slice of values in the given range of indices.
+    ///
+    /// Valid indices are *0 <= index < self.len()*
+    pub fn get_range<R: RangeBounds<usize>>(&self, range: R) -> Option<&Self> {
+        let range = try_simplify_range(range, self.entries.len())?;
+        self.entries.get(range).map(Self::from_slice)
+    }
+
     /// Get the first value.
     pub fn first(&self) -> Option<&T> {
         self.entries.first().map(Bucket::key_ref)

src/util.rs

@@ -29,3 +29,25 @@ where
     }
     start..end
 }
+
+pub(crate) fn try_simplify_range<R>(range: R, len: usize) -> Option<Range<usize>>
+where
+    R: RangeBounds<usize>,
+{
+    let start = match range.start_bound() {
+        Bound::Unbounded => 0,
+        Bound::Included(&i) if i <= len => i,
+        Bound::Excluded(&i) if i < len => i + 1,
+        _ => return None,
+    };
+    let end = match range.end_bound() {
+        Bound::Unbounded => len,
+        Bound::Excluded(&i) if i <= len => i,
+        Bound::Included(&i) if i < len => i + 1,
+        _ => return None,
+    };
+    if start > end {
+        return None;
+    }
+    Some(start..end)
+}