rustfmt libcollections
This commit is contained in:
Nick Cameron
parent
1f1a1e6595
commit
0dfd875b6e
14 changed files with 1414 additions and 970 deletions
|
|
@ -52,7 +52,6 @@ pub struct VecDeque<T> {
|
|||
// to where data should be written.
|
||||
// If tail == head the buffer is empty. The length of the ringbuffer
|
||||
// is defined as the distance between the two.
|
||||
|
||||
tail: usize,
|
||||
head: usize,
|
||||
buf: RawVec<T>,
|
||||
|
|
@ -77,7 +76,9 @@ impl<T> Drop for VecDeque<T> {
|
|||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<T> Default for VecDeque<T> {
|
||||
#[inline]
|
||||
fn default() -> VecDeque<T> { VecDeque::new() }
|
||||
fn default() -> VecDeque<T> {
|
||||
VecDeque::new()
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> VecDeque<T> {
|
||||
|
|
@ -124,12 +125,16 @@ impl<T> VecDeque<T> {
|
|||
|
||||
/// Returns true if and only if the buffer is at capacity
|
||||
#[inline]
|
||||
fn is_full(&self) -> bool { self.cap() - self.len() == 1 }
|
||||
fn is_full(&self) -> bool {
|
||||
self.cap() - self.len() == 1
|
||||
}
|
||||
|
||||
/// Returns the index in the underlying buffer for a given logical element
|
||||
/// index.
|
||||
#[inline]
|
||||
fn wrap_index(&self, idx: usize) -> usize { wrap_index(idx, self.cap()) }
|
||||
fn wrap_index(&self, idx: usize) -> usize {
|
||||
wrap_index(idx, self.cap())
|
||||
}
|
||||
|
||||
/// Returns the index in the underlying buffer for a given logical element
|
||||
/// index + addend.
|
||||
|
|
@ -148,27 +153,41 @@ impl<T> VecDeque<T> {
|
|||
/// Copies a contiguous block of memory len long from src to dst
|
||||
#[inline]
|
||||
unsafe fn copy(&self, dst: usize, src: usize, len: usize) {
|
||||
debug_assert!(dst + len <= self.cap(), "cpy dst={} src={} len={} cap={}", dst, src, len,
|
||||
debug_assert!(dst + len <= self.cap(),
|
||||
"cpy dst={} src={} len={} cap={}",
|
||||
dst,
|
||||
src,
|
||||
len,
|
||||
self.cap());
|
||||
debug_assert!(src + len <= self.cap(), "cpy dst={} src={} len={} cap={}", dst, src, len,
|
||||
debug_assert!(src + len <= self.cap(),
|
||||
"cpy dst={} src={} len={} cap={}",
|
||||
dst,
|
||||
src,
|
||||
len,
|
||||
self.cap());
|
||||
ptr::copy(
|
||||
self.ptr().offset(src as isize),
|
||||
self.ptr().offset(dst as isize),
|
||||
len);
|
||||
ptr::copy(self.ptr().offset(src as isize),
|
||||
self.ptr().offset(dst as isize),
|
||||
len);
|
||||
}
|
||||
|
||||
/// Copies a contiguous block of memory len long from src to dst
|
||||
#[inline]
|
||||
unsafe fn copy_nonoverlapping(&self, dst: usize, src: usize, len: usize) {
|
||||
debug_assert!(dst + len <= self.cap(), "cno dst={} src={} len={} cap={}", dst, src, len,
|
||||
debug_assert!(dst + len <= self.cap(),
|
||||
"cno dst={} src={} len={} cap={}",
|
||||
dst,
|
||||
src,
|
||||
len,
|
||||
self.cap());
|
||||
debug_assert!(src + len <= self.cap(), "cno dst={} src={} len={} cap={}", dst, src, len,
|
||||
debug_assert!(src + len <= self.cap(),
|
||||
"cno dst={} src={} len={} cap={}",
|
||||
dst,
|
||||
src,
|
||||
len,
|
||||
self.cap());
|
||||
ptr::copy_nonoverlapping(
|
||||
self.ptr().offset(src as isize),
|
||||
self.ptr().offset(dst as isize),
|
||||
len);
|
||||
ptr::copy_nonoverlapping(self.ptr().offset(src as isize),
|
||||
self.ptr().offset(dst as isize),
|
||||
len);
|
||||
}
|
||||
|
||||
/// Copies a potentially wrapping block of memory len long from src to dest.
|
||||
|
|
@ -176,12 +195,23 @@ impl<T> VecDeque<T> {
|
|||
/// most one continuous overlapping region between src and dest).
|
||||
unsafe fn wrap_copy(&self, dst: usize, src: usize, len: usize) {
|
||||
#[allow(dead_code)]
|
||||
fn diff(a: usize, b: usize) -> usize {if a <= b {b - a} else {a - b}}
|
||||
debug_assert!(cmp::min(diff(dst, src),
|
||||
self.cap() - diff(dst, src)) + len <= self.cap(),
|
||||
"wrc dst={} src={} len={} cap={}", dst, src, len, self.cap());
|
||||
fn diff(a: usize, b: usize) -> usize {
|
||||
if a <= b {
|
||||
b - a
|
||||
} else {
|
||||
a - b
|
||||
}
|
||||
}
|
||||
debug_assert!(cmp::min(diff(dst, src), self.cap() - diff(dst, src)) + len <= self.cap(),
|
||||
"wrc dst={} src={} len={} cap={}",
|
||||
dst,
|
||||
src,
|
||||
len,
|
||||
self.cap());
|
||||
|
||||
if src == dst || len == 0 { return }
|
||||
if src == dst || len == 0 {
|
||||
return;
|
||||
}
|
||||
|
||||
let dst_after_src = self.wrap_sub(dst, src) < len;
|
||||
|
||||
|
|
@ -304,13 +334,16 @@ impl<T> VecDeque<T> {
|
|||
// H T
|
||||
// C [o o o o o . . . . . . . . . o o ]
|
||||
|
||||
if self.tail <= self.head { // A
|
||||
if self.tail <= self.head {
|
||||
// A
|
||||
// Nop
|
||||
} else if self.head < old_cap - self.tail { // B
|
||||
} else if self.head < old_cap - self.tail {
|
||||
// B
|
||||
self.copy_nonoverlapping(old_cap, 0, self.head);
|
||||
self.head += old_cap;
|
||||
debug_assert!(self.head > self.tail);
|
||||
} else { // C
|
||||
} else {
|
||||
// C
|
||||
let new_tail = new_cap - (old_cap - self.tail);
|
||||
self.copy_nonoverlapping(new_tail, self.tail, old_cap - self.tail);
|
||||
self.tail = new_tail;
|
||||
|
|
@ -419,7 +452,8 @@ impl<T> VecDeque<T> {
|
|||
let ri = self.wrap_add(self.tail, i);
|
||||
let rj = self.wrap_add(self.tail, j);
|
||||
unsafe {
|
||||
ptr::swap(self.ptr().offset(ri as isize), self.ptr().offset(rj as isize))
|
||||
ptr::swap(self.ptr().offset(ri as isize),
|
||||
self.ptr().offset(rj as isize))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -436,7 +470,9 @@ impl<T> VecDeque<T> {
|
|||
/// ```
|
||||
#[inline]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn capacity(&self) -> usize { self.cap() - 1 }
|
||||
pub fn capacity(&self) -> usize {
|
||||
self.cap() - 1
|
||||
}
|
||||
|
||||
/// Reserves the minimum capacity for exactly `additional` more elements to be inserted in the
|
||||
/// given `VecDeque`. Does nothing if the capacity is already sufficient.
|
||||
|
|
@ -483,14 +519,15 @@ impl<T> VecDeque<T> {
|
|||
pub fn reserve(&mut self, additional: usize) {
|
||||
let old_cap = self.cap();
|
||||
let used_cap = self.len() + 1;
|
||||
let new_cap = used_cap
|
||||
.checked_add(additional)
|
||||
.and_then(|needed_cap| needed_cap.checked_next_power_of_two())
|
||||
.expect("capacity overflow");
|
||||
let new_cap = used_cap.checked_add(additional)
|
||||
.and_then(|needed_cap| needed_cap.checked_next_power_of_two())
|
||||
.expect("capacity overflow");
|
||||
|
||||
if new_cap > self.capacity() {
|
||||
self.buf.reserve_exact(used_cap, new_cap - used_cap);
|
||||
unsafe { self.handle_cap_increase(old_cap); }
|
||||
unsafe {
|
||||
self.handle_cap_increase(old_cap);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -619,7 +656,7 @@ impl<T> VecDeque<T> {
|
|||
Iter {
|
||||
tail: self.tail,
|
||||
head: self.head,
|
||||
ring: unsafe { self.buffer_as_slice() }
|
||||
ring: unsafe { self.buffer_as_slice() },
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -681,7 +718,7 @@ impl<T> VecDeque<T> {
|
|||
|
||||
if contiguous {
|
||||
let (empty, buf) = buf.split_at_mut(0);
|
||||
(&mut buf[tail .. head], empty)
|
||||
(&mut buf[tail..head], empty)
|
||||
} else {
|
||||
let (mid, right) = buf.split_at_mut(tail);
|
||||
let (left, _) = mid.split_at_mut(head);
|
||||
|
|
@ -704,7 +741,9 @@ impl<T> VecDeque<T> {
|
|||
/// assert_eq!(v.len(), 1);
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn len(&self) -> usize { count(self.tail, self.head, self.cap()) }
|
||||
pub fn len(&self) -> usize {
|
||||
count(self.tail, self.head, self.cap())
|
||||
}
|
||||
|
||||
/// Returns true if the buffer contains no elements
|
||||
///
|
||||
|
|
@ -719,7 +758,9 @@ impl<T> VecDeque<T> {
|
|||
/// assert!(!v.is_empty());
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn is_empty(&self) -> bool { self.len() == 0 }
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.len() == 0
|
||||
}
|
||||
|
||||
/// Create a draining iterator that removes the specified range in the
|
||||
/// `VecDeque` and yields the removed items from start to end. The element
|
||||
|
|
@ -751,7 +792,9 @@ impl<T> VecDeque<T> {
|
|||
#[unstable(feature = "drain",
|
||||
reason = "matches collection reform specification, waiting for dust to settle",
|
||||
issue = "27711")]
|
||||
pub fn drain<R>(&mut self, range: R) -> Drain<T> where R: RangeArgument<usize> {
|
||||
pub fn drain<R>(&mut self, range: R) -> Drain<T>
|
||||
where R: RangeArgument<usize>
|
||||
{
|
||||
// Memory safety
|
||||
//
|
||||
// When the Drain is first created, the source deque is shortened to
|
||||
|
|
@ -839,7 +882,11 @@ impl<T> VecDeque<T> {
|
|||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn front(&self) -> Option<&T> {
|
||||
if !self.is_empty() { Some(&self[0]) } else { None }
|
||||
if !self.is_empty() {
|
||||
Some(&self[0])
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Provides a mutable reference to the front element, or `None` if the
|
||||
|
|
@ -863,7 +910,11 @@ impl<T> VecDeque<T> {
|
|||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn front_mut(&mut self) -> Option<&mut T> {
|
||||
if !self.is_empty() { Some(&mut self[0]) } else { None }
|
||||
if !self.is_empty() {
|
||||
Some(&mut self[0])
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Provides a reference to the back element, or `None` if the sequence is
|
||||
|
|
@ -883,7 +934,11 @@ impl<T> VecDeque<T> {
|
|||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn back(&self) -> Option<&T> {
|
||||
if !self.is_empty() { Some(&self[self.len() - 1]) } else { None }
|
||||
if !self.is_empty() {
|
||||
Some(&self[self.len() - 1])
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Provides a mutable reference to the back element, or `None` if the
|
||||
|
|
@ -908,7 +963,11 @@ impl<T> VecDeque<T> {
|
|||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn back_mut(&mut self) -> Option<&mut T> {
|
||||
let len = self.len();
|
||||
if !self.is_empty() { Some(&mut self[len - 1]) } else { None }
|
||||
if !self.is_empty() {
|
||||
Some(&mut self[len - 1])
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Removes the first element and returns it, or `None` if the sequence is
|
||||
|
|
@ -955,13 +1014,17 @@ impl<T> VecDeque<T> {
|
|||
if self.is_full() {
|
||||
let old_cap = self.cap();
|
||||
self.buf.double();
|
||||
unsafe { self.handle_cap_increase(old_cap); }
|
||||
unsafe {
|
||||
self.handle_cap_increase(old_cap);
|
||||
}
|
||||
debug_assert!(!self.is_full());
|
||||
}
|
||||
|
||||
self.tail = self.wrap_sub(self.tail, 1);
|
||||
let tail = self.tail;
|
||||
unsafe { self.buffer_write(tail, value); }
|
||||
unsafe {
|
||||
self.buffer_write(tail, value);
|
||||
}
|
||||
}
|
||||
|
||||
/// Appends an element to the back of a buffer
|
||||
|
|
@ -981,7 +1044,9 @@ impl<T> VecDeque<T> {
|
|||
if self.is_full() {
|
||||
let old_cap = self.cap();
|
||||
self.buf.double();
|
||||
unsafe { self.handle_cap_increase(old_cap); }
|
||||
unsafe {
|
||||
self.handle_cap_increase(old_cap);
|
||||
}
|
||||
debug_assert!(!self.is_full());
|
||||
}
|
||||
|
||||
|
|
@ -1130,7 +1195,9 @@ impl<T> VecDeque<T> {
|
|||
if self.is_full() {
|
||||
let old_cap = self.cap();
|
||||
self.buf.double();
|
||||
unsafe { self.handle_cap_increase(old_cap); }
|
||||
unsafe {
|
||||
self.handle_cap_increase(old_cap);
|
||||
}
|
||||
debug_assert!(!self.is_full());
|
||||
}
|
||||
|
||||
|
|
@ -1163,7 +1230,9 @@ impl<T> VecDeque<T> {
|
|||
|
||||
let contiguous = self.is_contiguous();
|
||||
|
||||
match (contiguous, distance_to_tail <= distance_to_head, idx >= self.tail) {
|
||||
match (contiguous,
|
||||
distance_to_tail <= distance_to_head,
|
||||
idx >= self.tail) {
|
||||
(true, true, _) if index == 0 => {
|
||||
// push_front
|
||||
//
|
||||
|
|
@ -1176,134 +1245,148 @@ impl<T> VecDeque<T> {
|
|||
//
|
||||
|
||||
self.tail = self.wrap_sub(self.tail, 1);
|
||||
},
|
||||
(true, true, _) => unsafe {
|
||||
// contiguous, insert closer to tail:
|
||||
//
|
||||
// T I H
|
||||
// [. . . o o A o o o o . . . . . .]
|
||||
//
|
||||
// T H
|
||||
// [. . o o I A o o o o . . . . . .]
|
||||
// M M
|
||||
//
|
||||
// contiguous, insert closer to tail and tail is 0:
|
||||
//
|
||||
//
|
||||
// T I H
|
||||
// [o o A o o o o . . . . . . . . .]
|
||||
//
|
||||
// H T
|
||||
// [o I A o o o o o . . . . . . . o]
|
||||
// M M
|
||||
}
|
||||
(true, true, _) => {
|
||||
unsafe {
|
||||
// contiguous, insert closer to tail:
|
||||
//
|
||||
// T I H
|
||||
// [. . . o o A o o o o . . . . . .]
|
||||
//
|
||||
// T H
|
||||
// [. . o o I A o o o o . . . . . .]
|
||||
// M M
|
||||
//
|
||||
// contiguous, insert closer to tail and tail is 0:
|
||||
//
|
||||
//
|
||||
// T I H
|
||||
// [o o A o o o o . . . . . . . . .]
|
||||
//
|
||||
// H T
|
||||
// [o I A o o o o o . . . . . . . o]
|
||||
// M M
|
||||
|
||||
let new_tail = self.wrap_sub(self.tail, 1);
|
||||
let new_tail = self.wrap_sub(self.tail, 1);
|
||||
|
||||
self.copy(new_tail, self.tail, 1);
|
||||
// Already moved the tail, so we only copy `index - 1` elements.
|
||||
self.copy(self.tail, self.tail + 1, index - 1);
|
||||
self.copy(new_tail, self.tail, 1);
|
||||
// Already moved the tail, so we only copy `index - 1` elements.
|
||||
self.copy(self.tail, self.tail + 1, index - 1);
|
||||
|
||||
self.tail = new_tail;
|
||||
},
|
||||
(true, false, _) => unsafe {
|
||||
// contiguous, insert closer to head:
|
||||
//
|
||||
// T I H
|
||||
// [. . . o o o o A o o . . . . . .]
|
||||
//
|
||||
// T H
|
||||
// [. . . o o o o I A o o . . . . .]
|
||||
// M M M
|
||||
self.tail = new_tail;
|
||||
}
|
||||
}
|
||||
(true, false, _) => {
|
||||
unsafe {
|
||||
// contiguous, insert closer to head:
|
||||
//
|
||||
// T I H
|
||||
// [. . . o o o o A o o . . . . . .]
|
||||
//
|
||||
// T H
|
||||
// [. . . o o o o I A o o . . . . .]
|
||||
// M M M
|
||||
|
||||
self.copy(idx + 1, idx, self.head - idx);
|
||||
self.head = self.wrap_add(self.head, 1);
|
||||
},
|
||||
(false, true, true) => unsafe {
|
||||
// discontiguous, insert closer to tail, tail section:
|
||||
//
|
||||
// H T I
|
||||
// [o o o o o o . . . . . o o A o o]
|
||||
//
|
||||
// H T
|
||||
// [o o o o o o . . . . o o I A o o]
|
||||
// M M
|
||||
self.copy(idx + 1, idx, self.head - idx);
|
||||
self.head = self.wrap_add(self.head, 1);
|
||||
}
|
||||
}
|
||||
(false, true, true) => {
|
||||
unsafe {
|
||||
// discontiguous, insert closer to tail, tail section:
|
||||
//
|
||||
// H T I
|
||||
// [o o o o o o . . . . . o o A o o]
|
||||
//
|
||||
// H T
|
||||
// [o o o o o o . . . . o o I A o o]
|
||||
// M M
|
||||
|
||||
self.copy(self.tail - 1, self.tail, index);
|
||||
self.tail -= 1;
|
||||
},
|
||||
(false, false, true) => unsafe {
|
||||
// discontiguous, insert closer to head, tail section:
|
||||
//
|
||||
// H T I
|
||||
// [o o . . . . . . . o o o o o A o]
|
||||
//
|
||||
// H T
|
||||
// [o o o . . . . . . o o o o o I A]
|
||||
// M M M M
|
||||
self.copy(self.tail - 1, self.tail, index);
|
||||
self.tail -= 1;
|
||||
}
|
||||
}
|
||||
(false, false, true) => {
|
||||
unsafe {
|
||||
// discontiguous, insert closer to head, tail section:
|
||||
//
|
||||
// H T I
|
||||
// [o o . . . . . . . o o o o o A o]
|
||||
//
|
||||
// H T
|
||||
// [o o o . . . . . . o o o o o I A]
|
||||
// M M M M
|
||||
|
||||
// copy elements up to new head
|
||||
self.copy(1, 0, self.head);
|
||||
// copy elements up to new head
|
||||
self.copy(1, 0, self.head);
|
||||
|
||||
// copy last element into empty spot at bottom of buffer
|
||||
self.copy(0, self.cap() - 1, 1);
|
||||
// copy last element into empty spot at bottom of buffer
|
||||
self.copy(0, self.cap() - 1, 1);
|
||||
|
||||
// move elements from idx to end forward not including ^ element
|
||||
self.copy(idx + 1, idx, self.cap() - 1 - idx);
|
||||
// move elements from idx to end forward not including ^ element
|
||||
self.copy(idx + 1, idx, self.cap() - 1 - idx);
|
||||
|
||||
self.head += 1;
|
||||
},
|
||||
(false, true, false) if idx == 0 => unsafe {
|
||||
// discontiguous, insert is closer to tail, head section,
|
||||
// and is at index zero in the internal buffer:
|
||||
//
|
||||
// I H T
|
||||
// [A o o o o o o o o o . . . o o o]
|
||||
//
|
||||
// H T
|
||||
// [A o o o o o o o o o . . o o o I]
|
||||
// M M M
|
||||
self.head += 1;
|
||||
}
|
||||
}
|
||||
(false, true, false) if idx == 0 => {
|
||||
unsafe {
|
||||
// discontiguous, insert is closer to tail, head section,
|
||||
// and is at index zero in the internal buffer:
|
||||
//
|
||||
// I H T
|
||||
// [A o o o o o o o o o . . . o o o]
|
||||
//
|
||||
// H T
|
||||
// [A o o o o o o o o o . . o o o I]
|
||||
// M M M
|
||||
|
||||
// copy elements up to new tail
|
||||
self.copy(self.tail - 1, self.tail, self.cap() - self.tail);
|
||||
// copy elements up to new tail
|
||||
self.copy(self.tail - 1, self.tail, self.cap() - self.tail);
|
||||
|
||||
// copy last element into empty spot at bottom of buffer
|
||||
self.copy(self.cap() - 1, 0, 1);
|
||||
// copy last element into empty spot at bottom of buffer
|
||||
self.copy(self.cap() - 1, 0, 1);
|
||||
|
||||
self.tail -= 1;
|
||||
},
|
||||
(false, true, false) => unsafe {
|
||||
// discontiguous, insert closer to tail, head section:
|
||||
//
|
||||
// I H T
|
||||
// [o o o A o o o o o o . . . o o o]
|
||||
//
|
||||
// H T
|
||||
// [o o I A o o o o o o . . o o o o]
|
||||
// M M M M M M
|
||||
self.tail -= 1;
|
||||
}
|
||||
}
|
||||
(false, true, false) => {
|
||||
unsafe {
|
||||
// discontiguous, insert closer to tail, head section:
|
||||
//
|
||||
// I H T
|
||||
// [o o o A o o o o o o . . . o o o]
|
||||
//
|
||||
// H T
|
||||
// [o o I A o o o o o o . . o o o o]
|
||||
// M M M M M M
|
||||
|
||||
// copy elements up to new tail
|
||||
self.copy(self.tail - 1, self.tail, self.cap() - self.tail);
|
||||
// copy elements up to new tail
|
||||
self.copy(self.tail - 1, self.tail, self.cap() - self.tail);
|
||||
|
||||
// copy last element into empty spot at bottom of buffer
|
||||
self.copy(self.cap() - 1, 0, 1);
|
||||
// copy last element into empty spot at bottom of buffer
|
||||
self.copy(self.cap() - 1, 0, 1);
|
||||
|
||||
// move elements from idx-1 to end forward not including ^ element
|
||||
self.copy(0, 1, idx - 1);
|
||||
// move elements from idx-1 to end forward not including ^ element
|
||||
self.copy(0, 1, idx - 1);
|
||||
|
||||
self.tail -= 1;
|
||||
},
|
||||
(false, false, false) => unsafe {
|
||||
// discontiguous, insert closer to head, head section:
|
||||
//
|
||||
// I H T
|
||||
// [o o o o A o o . . . . . . o o o]
|
||||
//
|
||||
// H T
|
||||
// [o o o o I A o o . . . . . o o o]
|
||||
// M M M
|
||||
self.tail -= 1;
|
||||
}
|
||||
}
|
||||
(false, false, false) => {
|
||||
unsafe {
|
||||
// discontiguous, insert closer to head, head section:
|
||||
//
|
||||
// I H T
|
||||
// [o o o o A o o . . . . . . o o o]
|
||||
//
|
||||
// H T
|
||||
// [o o o o I A o o . . . . . o o o]
|
||||
// M M M
|
||||
|
||||
self.copy(idx + 1, idx, self.head - idx);
|
||||
self.head += 1;
|
||||
self.copy(idx + 1, idx, self.head - idx);
|
||||
self.head += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1357,121 +1440,133 @@ impl<T> VecDeque<T> {
|
|||
|
||||
let idx = self.wrap_add(self.tail, index);
|
||||
|
||||
let elem = unsafe {
|
||||
Some(self.buffer_read(idx))
|
||||
};
|
||||
let elem = unsafe { Some(self.buffer_read(idx)) };
|
||||
|
||||
let distance_to_tail = index;
|
||||
let distance_to_head = self.len() - index;
|
||||
|
||||
let contiguous = self.is_contiguous();
|
||||
|
||||
match (contiguous, distance_to_tail <= distance_to_head, idx >= self.tail) {
|
||||
(true, true, _) => unsafe {
|
||||
// contiguous, remove closer to tail:
|
||||
//
|
||||
// T R H
|
||||
// [. . . o o x o o o o . . . . . .]
|
||||
//
|
||||
// T H
|
||||
// [. . . . o o o o o o . . . . . .]
|
||||
// M M
|
||||
match (contiguous,
|
||||
distance_to_tail <= distance_to_head,
|
||||
idx >= self.tail) {
|
||||
(true, true, _) => {
|
||||
unsafe {
|
||||
// contiguous, remove closer to tail:
|
||||
//
|
||||
// T R H
|
||||
// [. . . o o x o o o o . . . . . .]
|
||||
//
|
||||
// T H
|
||||
// [. . . . o o o o o o . . . . . .]
|
||||
// M M
|
||||
|
||||
self.copy(self.tail + 1, self.tail, index);
|
||||
self.tail += 1;
|
||||
},
|
||||
(true, false, _) => unsafe {
|
||||
// contiguous, remove closer to head:
|
||||
//
|
||||
// T R H
|
||||
// [. . . o o o o x o o . . . . . .]
|
||||
//
|
||||
// T H
|
||||
// [. . . o o o o o o . . . . . . .]
|
||||
// M M
|
||||
|
||||
self.copy(idx, idx + 1, self.head - idx - 1);
|
||||
self.head -= 1;
|
||||
},
|
||||
(false, true, true) => unsafe {
|
||||
// discontiguous, remove closer to tail, tail section:
|
||||
//
|
||||
// H T R
|
||||
// [o o o o o o . . . . . o o x o o]
|
||||
//
|
||||
// H T
|
||||
// [o o o o o o . . . . . . o o o o]
|
||||
// M M
|
||||
|
||||
self.copy(self.tail + 1, self.tail, index);
|
||||
self.tail = self.wrap_add(self.tail, 1);
|
||||
},
|
||||
(false, false, false) => unsafe {
|
||||
// discontiguous, remove closer to head, head section:
|
||||
//
|
||||
// R H T
|
||||
// [o o o o x o o . . . . . . o o o]
|
||||
//
|
||||
// H T
|
||||
// [o o o o o o . . . . . . . o o o]
|
||||
// M M
|
||||
|
||||
self.copy(idx, idx + 1, self.head - idx - 1);
|
||||
self.head -= 1;
|
||||
},
|
||||
(false, false, true) => unsafe {
|
||||
// discontiguous, remove closer to head, tail section:
|
||||
//
|
||||
// H T R
|
||||
// [o o o . . . . . . o o o o o x o]
|
||||
//
|
||||
// H T
|
||||
// [o o . . . . . . . o o o o o o o]
|
||||
// M M M M
|
||||
//
|
||||
// or quasi-discontiguous, remove next to head, tail section:
|
||||
//
|
||||
// H T R
|
||||
// [. . . . . . . . . o o o o o x o]
|
||||
//
|
||||
// T H
|
||||
// [. . . . . . . . . o o o o o o .]
|
||||
// M
|
||||
|
||||
// draw in elements in the tail section
|
||||
self.copy(idx, idx + 1, self.cap() - idx - 1);
|
||||
|
||||
// Prevents underflow.
|
||||
if self.head != 0 {
|
||||
// copy first element into empty spot
|
||||
self.copy(self.cap() - 1, 0, 1);
|
||||
|
||||
// move elements in the head section backwards
|
||||
self.copy(0, 1, self.head - 1);
|
||||
self.copy(self.tail + 1, self.tail, index);
|
||||
self.tail += 1;
|
||||
}
|
||||
}
|
||||
(true, false, _) => {
|
||||
unsafe {
|
||||
// contiguous, remove closer to head:
|
||||
//
|
||||
// T R H
|
||||
// [. . . o o o o x o o . . . . . .]
|
||||
//
|
||||
// T H
|
||||
// [. . . o o o o o o . . . . . . .]
|
||||
// M M
|
||||
|
||||
self.head = self.wrap_sub(self.head, 1);
|
||||
},
|
||||
(false, true, false) => unsafe {
|
||||
// discontiguous, remove closer to tail, head section:
|
||||
//
|
||||
// R H T
|
||||
// [o o x o o o o o o o . . . o o o]
|
||||
//
|
||||
// H T
|
||||
// [o o o o o o o o o o . . . . o o]
|
||||
// M M M M M
|
||||
self.copy(idx, idx + 1, self.head - idx - 1);
|
||||
self.head -= 1;
|
||||
}
|
||||
}
|
||||
(false, true, true) => {
|
||||
unsafe {
|
||||
// discontiguous, remove closer to tail, tail section:
|
||||
//
|
||||
// H T R
|
||||
// [o o o o o o . . . . . o o x o o]
|
||||
//
|
||||
// H T
|
||||
// [o o o o o o . . . . . . o o o o]
|
||||
// M M
|
||||
|
||||
// draw in elements up to idx
|
||||
self.copy(1, 0, idx);
|
||||
self.copy(self.tail + 1, self.tail, index);
|
||||
self.tail = self.wrap_add(self.tail, 1);
|
||||
}
|
||||
}
|
||||
(false, false, false) => {
|
||||
unsafe {
|
||||
// discontiguous, remove closer to head, head section:
|
||||
//
|
||||
// R H T
|
||||
// [o o o o x o o . . . . . . o o o]
|
||||
//
|
||||
// H T
|
||||
// [o o o o o o . . . . . . . o o o]
|
||||
// M M
|
||||
|
||||
// copy last element into empty spot
|
||||
self.copy(0, self.cap() - 1, 1);
|
||||
self.copy(idx, idx + 1, self.head - idx - 1);
|
||||
self.head -= 1;
|
||||
}
|
||||
}
|
||||
(false, false, true) => {
|
||||
unsafe {
|
||||
// discontiguous, remove closer to head, tail section:
|
||||
//
|
||||
// H T R
|
||||
// [o o o . . . . . . o o o o o x o]
|
||||
//
|
||||
// H T
|
||||
// [o o . . . . . . . o o o o o o o]
|
||||
// M M M M
|
||||
//
|
||||
// or quasi-discontiguous, remove next to head, tail section:
|
||||
//
|
||||
// H T R
|
||||
// [. . . . . . . . . o o o o o x o]
|
||||
//
|
||||
// T H
|
||||
// [. . . . . . . . . o o o o o o .]
|
||||
// M
|
||||
|
||||
// move elements from tail to end forward, excluding the last one
|
||||
self.copy(self.tail + 1, self.tail, self.cap() - self.tail - 1);
|
||||
// draw in elements in the tail section
|
||||
self.copy(idx, idx + 1, self.cap() - idx - 1);
|
||||
|
||||
self.tail = self.wrap_add(self.tail, 1);
|
||||
// Prevents underflow.
|
||||
if self.head != 0 {
|
||||
// copy first element into empty spot
|
||||
self.copy(self.cap() - 1, 0, 1);
|
||||
|
||||
// move elements in the head section backwards
|
||||
self.copy(0, 1, self.head - 1);
|
||||
}
|
||||
|
||||
self.head = self.wrap_sub(self.head, 1);
|
||||
}
|
||||
}
|
||||
(false, true, false) => {
|
||||
unsafe {
|
||||
// discontiguous, remove closer to tail, head section:
|
||||
//
|
||||
// R H T
|
||||
// [o o x o o o o o o o . . . o o o]
|
||||
//
|
||||
// H T
|
||||
// [o o o o o o o o o o . . . . o o]
|
||||
// M M M M M
|
||||
|
||||
// draw in elements up to idx
|
||||
self.copy(1, 0, idx);
|
||||
|
||||
// copy last element into empty spot
|
||||
self.copy(0, self.cap() - 1, 1);
|
||||
|
||||
// move elements from tail to end forward, excluding the last one
|
||||
self.copy(self.tail + 1, self.tail, self.cap() - self.tail - 1);
|
||||
|
||||
self.tail = self.wrap_add(self.tail, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1587,14 +1682,16 @@ impl<T> VecDeque<T> {
|
|||
/// assert_eq!(&v[..], &[2, 4]);
|
||||
/// ```
|
||||
#[stable(feature = "vec_deque_retain", since = "1.4.0")]
|
||||
pub fn retain<F>(&mut self, mut f: F) where F: FnMut(&T) -> bool {
|
||||
pub fn retain<F>(&mut self, mut f: F)
|
||||
where F: FnMut(&T) -> bool
|
||||
{
|
||||
let len = self.len();
|
||||
let mut del = 0;
|
||||
for i in 0..len {
|
||||
if !f(&self[i]) {
|
||||
del += 1;
|
||||
} else if del > 0 {
|
||||
self.swap(i-del, i);
|
||||
self.swap(i - del, i);
|
||||
}
|
||||
}
|
||||
if del > 0 {
|
||||
|
|
@ -1655,10 +1752,10 @@ fn count(tail: usize, head: usize, size: usize) -> usize {
|
|||
|
||||
/// `VecDeque` iterator.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub struct Iter<'a, T:'a> {
|
||||
pub struct Iter<'a, T: 'a> {
|
||||
ring: &'a [T],
|
||||
tail: usize,
|
||||
head: usize
|
||||
head: usize,
|
||||
}
|
||||
|
||||
// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
|
||||
|
|
@ -1668,7 +1765,7 @@ impl<'a, T> Clone for Iter<'a, T> {
|
|||
Iter {
|
||||
ring: self.ring,
|
||||
tail: self.tail,
|
||||
head: self.head
|
||||
head: self.head,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1711,7 +1808,7 @@ impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
|
|||
|
||||
/// `VecDeque` mutable iterator.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub struct IterMut<'a, T:'a> {
|
||||
pub struct IterMut<'a, T: 'a> {
|
||||
ring: &'a mut [T],
|
||||
tail: usize,
|
||||
head: usize,
|
||||
|
|
@ -1845,13 +1942,15 @@ impl<'a, T: 'a> Drop for Drain<'a, T> {
|
|||
(_, 0) => {
|
||||
source_deque.head = drain_tail;
|
||||
}
|
||||
_ => unsafe {
|
||||
if tail_len <= head_len {
|
||||
source_deque.tail = source_deque.wrap_sub(drain_head, tail_len);
|
||||
source_deque.wrap_copy(source_deque.tail, orig_tail, tail_len);
|
||||
} else {
|
||||
source_deque.head = source_deque.wrap_add(drain_tail, head_len);
|
||||
source_deque.wrap_copy(drain_tail, drain_head, head_len);
|
||||
_ => {
|
||||
unsafe {
|
||||
if tail_len <= head_len {
|
||||
source_deque.tail = source_deque.wrap_sub(drain_head, tail_len);
|
||||
source_deque.wrap_copy(source_deque.tail, orig_tail, tail_len);
|
||||
} else {
|
||||
source_deque.head = source_deque.wrap_add(drain_tail, head_len);
|
||||
source_deque.wrap_copy(drain_tail, drain_head, head_len);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1864,11 +1963,7 @@ impl<'a, T: 'a> Iterator for Drain<'a, T> {
|
|||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<T> {
|
||||
self.iter.next().map(|elt|
|
||||
unsafe {
|
||||
ptr::read(elt)
|
||||
}
|
||||
)
|
||||
self.iter.next().map(|elt| unsafe { ptr::read(elt) })
|
||||
}
|
||||
|
||||
#[inline]
|
||||
|
|
@ -1881,11 +1976,7 @@ impl<'a, T: 'a> Iterator for Drain<'a, T> {
|
|||
impl<'a, T: 'a> DoubleEndedIterator for Drain<'a, T> {
|
||||
#[inline]
|
||||
fn next_back(&mut self) -> Option<T> {
|
||||
self.iter.next_back().map(|elt|
|
||||
unsafe {
|
||||
ptr::read(elt)
|
||||
}
|
||||
)
|
||||
self.iter.next_back().map(|elt| unsafe { ptr::read(elt) })
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1895,8 +1986,7 @@ impl<'a, T: 'a> ExactSizeIterator for Drain<'a, T> {}
|
|||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<A: PartialEq> PartialEq for VecDeque<A> {
|
||||
fn eq(&self, other: &VecDeque<A>) -> bool {
|
||||
self.len() == other.len() &&
|
||||
self.iter().zip(other).all(|(a, b)| a.eq(b))
|
||||
self.len() == other.len() && self.iter().zip(other).all(|(a, b)| a.eq(b))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1948,7 +2038,7 @@ impl<A> IndexMut<usize> for VecDeque<A> {
|
|||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<A> FromIterator<A> for VecDeque<A> {
|
||||
fn from_iter<T: IntoIterator<Item=A>>(iterable: T) -> VecDeque<A> {
|
||||
fn from_iter<T: IntoIterator<Item = A>>(iterable: T) -> VecDeque<A> {
|
||||
let iterator = iterable.into_iter();
|
||||
let (lower, _) = iterator.size_hint();
|
||||
let mut deq = VecDeque::with_capacity(lower);
|
||||
|
|
@ -1965,9 +2055,7 @@ impl<T> IntoIterator for VecDeque<T> {
|
|||
/// Consumes the list into a front-to-back iterator yielding elements by
|
||||
/// value.
|
||||
fn into_iter(self) -> IntoIter<T> {
|
||||
IntoIter {
|
||||
inner: self,
|
||||
}
|
||||
IntoIter { inner: self }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1993,7 +2081,7 @@ impl<'a, T> IntoIterator for &'a mut VecDeque<T> {
|
|||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<A> Extend<A> for VecDeque<A> {
|
||||
fn extend<T: IntoIterator<Item=A>>(&mut self, iter: T) {
|
||||
fn extend<T: IntoIterator<Item = A>>(&mut self, iter: T) {
|
||||
for elt in iter {
|
||||
self.push_back(elt);
|
||||
}
|
||||
|
|
@ -2002,7 +2090,7 @@ impl<A> Extend<A> for VecDeque<A> {
|
|||
|
||||
#[stable(feature = "extend_ref", since = "1.2.0")]
|
||||
impl<'a, T: 'a + Copy> Extend<&'a T> for VecDeque<T> {
|
||||
fn extend<I: IntoIterator<Item=&'a T>>(&mut self, iter: I) {
|
||||
fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
|
||||
self.extend(iter.into_iter().cloned());
|
||||
}
|
||||
}
|
||||
|
|
@ -2049,7 +2137,7 @@ mod tests {
|
|||
|
||||
#[bench]
|
||||
fn bench_pop_back_100(b: &mut test::Bencher) {
|
||||
let mut deq= VecDeque::<i32>::with_capacity(101);
|
||||
let mut deq = VecDeque::<i32>::with_capacity(101);
|
||||
|
||||
b.iter(|| {
|
||||
deq.head = 100;
|
||||
|
|
@ -2204,10 +2292,8 @@ mod tests {
|
|||
}
|
||||
|
||||
// Check that we drain the correct values
|
||||
let drained: VecDeque<_> =
|
||||
tester.drain(drain_start..drain_end).collect();
|
||||
let drained_expected: VecDeque<_> =
|
||||
(drain_start..drain_end).collect();
|
||||
let drained: VecDeque<_> = tester.drain(drain_start..drain_end).collect();
|
||||
let drained_expected: VecDeque<_> = (drain_start..drain_end).collect();
|
||||
assert_eq!(drained, drained_expected);
|
||||
|
||||
// We shouldn't have changed the capacity or made the
|
||||
|
|
@ -2217,8 +2303,9 @@ mod tests {
|
|||
assert!(tester.head < tester.cap());
|
||||
|
||||
// We should see the correct values in the VecDeque
|
||||
let expected: VecDeque<_> =
|
||||
(0..drain_start).chain(drain_end..len).collect();
|
||||
let expected: VecDeque<_> = (0..drain_start)
|
||||
.chain(drain_end..len)
|
||||
.collect();
|
||||
assert_eq!(expected, tester);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue