Implement VecDeque::truncate_to_range

Author: cammeresi

library/alloc/src/collections/vec_deque/mod.rs

@@ -1454,6 +1454,92 @@ impl<T, A: Allocator> VecDeque<T, A> {
         }
     }
 
+    /// Shortens the deque to the elements within `range`, dropping the rest.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the starting point is greater than the end point or if
+    /// the end point is greater than the length of the deque.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #![feature(vec_deque_truncate_to_range)]
+    /// use std::collections::VecDeque;
+    ///
+    /// let mut buf: VecDeque<_> = (0..6).collect();
+    /// buf.truncate_to_range(2..5);
+    /// assert_eq!(buf, [2, 3, 4]);
+    /// ```
+    #[unstable(feature = "vec_deque_truncate_to_range", issue = "156215")]
+    pub fn truncate_to_range<R>(&mut self, range: R)
+    where
+        R: RangeBounds<usize>,
+    {
+        let Range { start, end } = slice::range(range, ..self.len);
+
+        if start == 0 && end == self.len {
+            return;
+        } else if start == end {
+            self.clear();
+            return;
+        } else if start == 0 {
+            self.truncate(end);
+            return;
+        } else if end == self.len {
+            self.truncate_front(self.len - start);
+            return;
+        }
+
+        // Both the dropped prefix [0..start) and the dropped suffix [end..self.len) are
+        // non-empty.  Plan up to three physical slices to drop, then update head/len, then
+        // drop.  Only one of the dropped prefix or dropped suffix can cross between slices.
+        let (front, back) = self.as_mut_slices();
+        let flen = front.len();
+        let blen = back.len();
+        let fptr = front.as_mut_ptr();
+        let bptr = back.as_mut_ptr();
+
+        unsafe {
+            let (drop_a, drop_b, drop_c) = if end <= flen {
+                // Kept range lies in `front`.  The dropped suffix is the rest of `front`
+                // plus all of `back`.
+                let pre = ptr::slice_from_raw_parts_mut(fptr, start);
+                let mid = ptr::slice_from_raw_parts_mut(fptr.add(end), flen - end);
+                (pre, mid, Some(back as *mut [T]))
+            } else if start >= flen {
+                // Kept range lies in `back`.  The dropped prefix is all of `front` plus the
+                // start of `back`.
+                let mid = ptr::slice_from_raw_parts_mut(bptr, start - flen);
+                let suf = ptr::slice_from_raw_parts_mut(bptr.add(end - flen), blen - (end - flen));
+                (front as *mut [T], mid, Some(suf))
+            } else {
+                // Kept range straddles the boundary.  The dropped prefix is in `front`, the
+                // dropped suffix is in `back`.  Only two regions to drop.
+                let pre = ptr::slice_from_raw_parts_mut(fptr, start);
+                let suf = ptr::slice_from_raw_parts_mut(bptr.add(end - flen), blen - (end - flen));
+                (pre, suf, None)
+            };
+
+            // Set these once only, then drop.  If we called truncate + truncate_front, a panic in
+            // a destructor could leave this truncation in a half completed state.
+            self.head = self.to_physical_idx(start);
+            self.len = end - start;
+
+            match drop_c {
+                Some(c) => {
+                    let _g_a = Dropper(&mut *drop_a);
+                    let _g_b = Dropper(&mut *drop_b);
+                    ptr::drop_in_place(c);
+                }
+                None => {
+                    let _g_a = Dropper(&mut *drop_a);
+                    ptr::drop_in_place(drop_b);
+                }
+            }
+        }
+    }
+
     /// Returns a reference to the underlying allocator.
     #[unstable(feature = "allocator_api", issue = "32838")]
     #[inline]

library/alloctests/tests/lib.rs

@@ -37,6 +37,7 @@
 #![feature(strict_provenance_lints)]
 #![feature(string_replace_in_place)]
 #![feature(vec_deque_truncate_front)]
+#![feature(vec_deque_truncate_to_range)]
 #![feature(unique_rc_arc)]
 #![feature(macro_metavar_expr_concat)]
 #![feature(vec_peek_mut)]

library/alloctests/tests/vec_deque.rs

@@ -2360,3 +2360,118 @@ fn test_splice_wrapping_and_resize() {
 
     assert_eq!(Vec::from(vec), [1, 2, 3, 4, 1, 1, 1, 1, 1])
 }
+
+#[test]
+fn truncate_to_range_basic() {
+    // no-op
+    let mut v: VecDeque<_> = (0..6).collect();
+    v.truncate_to_range(..);
+    assert_eq!(v, [0, 1, 2, 3, 4, 5]);
+
+    // clear
+    let mut v: VecDeque<_> = (0..6).collect();
+    v.truncate_to_range(3..3);
+    assert_eq!(v, [] as [i32; 0]);
+
+    // truncate
+    let mut v: VecDeque<_> = (0..6).collect();
+    v.truncate_to_range(..3);
+    assert_eq!(v, [0, 1, 2]);
+
+    // truncate front
+    let mut v: VecDeque<_> = (0..6).collect();
+    v.truncate_to_range(2..);
+    assert_eq!(v, [2, 3, 4, 5]);
+
+    let mut v: VecDeque<_> = (0..6).collect();
+    v.truncate_to_range(2..5);
+    assert_eq!(v, [2, 3, 4]);
+
+    let mut v: VecDeque<_> = (0..6).collect();
+    v.truncate_to_range(3..=5);
+    assert_eq!(v, [3, 4, 5]);
+
+    let mut v: VecDeque<_> = (0..6).collect();
+    v.truncate_to_range(..=3);
+    assert_eq!(v, [0, 1, 2, 3]);
+}
+
+fn make_wrapped() -> VecDeque<i32> {
+    let mut v = VecDeque::new();
+    v.extend(0..5);
+    v.push_front(-1);
+    v.push_front(-2);
+    v.push_front(-3);
+    assert_eq!(v.as_slices(), ([-3, -2, -1].as_slice(), [0, 1, 2, 3, 4].as_slice()));
+    v
+}
+
+#[test]
+fn truncate_to_range_kept_in_front() {
+    let mut v = make_wrapped();
+    v.truncate_to_range(1..3);
+    assert_eq!(v, [-2, -1]);
+}
+
+#[test]
+fn truncate_to_range_kept_in_back() {
+    let mut v = make_wrapped();
+    v.truncate_to_range(4..7);
+    assert_eq!(v, [1, 2, 3]);
+}
+
+#[test]
+fn truncate_to_range_kept_straddles() {
+    let mut v = make_wrapped();
+    v.truncate_to_range(1..6);
+    assert_eq!(v, [-2, -1, 0, 1, 2]);
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore = "test requires unwinding support")]
+fn truncate_to_range_leak() {
+    struct_with_counted_drop!(D(bool), DROPS => |this: &D| if this.0 { panic!("panic in `drop`"); } );
+
+    let mut q = VecDeque::new();
+    q.push_back(D(true));
+    q.push_back(D(false));
+    q.push_back(D(false));
+    q.push_back(D(false));
+    q.push_back(D(false));
+    q.push_front(D(false));
+    q.push_front(D(false));
+    q.push_front(D(false));
+
+    catch_unwind(AssertUnwindSafe(|| q.truncate_to_range(4..7))).ok();
+
+    assert_eq!(DROPS.get(), 5);
+}
+
+#[test]
+#[should_panic]
+fn truncate_to_range_start_greater_than_end() {
+    let mut v: VecDeque<_> = (0..6).collect();
+    #[allow(clippy::reversed_empty_ranges)]
+    v.truncate_to_range(4..2);
+}
+
+#[test]
+#[should_panic]
+fn truncate_to_range_end_past_len() {
+    let mut v: VecDeque<_> = (0..6).collect();
+    v.truncate_to_range(2..7);
+}
+
+#[test]
+#[should_panic]
+fn truncate_to_range_start_past_len() {
+    let mut v: VecDeque<_> = (0..6).collect();
+    v.truncate_to_range(7..8);
+}
+
+#[test]
+#[should_panic]
+fn truncate_to_range_inclusive_end_overflow() {
+    let mut v: VecDeque<_> = (0..6).collect();
+    v.truncate_to_range(0..=usize::MAX);
+}