mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename VecDeque's rotate_left and rotate_right parameters

Browse Source
This commit is contained in:
Pedro Lobo 2023-07-13 18:10:52 +01:00
parent 33a2c2487a
commit c0a105be7c
No known key found for this signature in database
GPG Key ID: 0AFF77833048F8EC
1 changed files with 23 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
library/alloc/src/collections/vec_deque/mod.rs
View File

@ -2283,21 +2283,21 @@ impl<T, A: Allocator> VecDeque<T, A> {
unsafe { slice::from_raw_parts_mut(ptr.add(self.head), self.len) }
}
/// Rotates the double-ended queue `mid` places to the left.
/// Rotates the double-ended queue `n` places to the left.
///
/// Equivalently,
/// - Rotates item `mid` into the first position.
/// - Pops the first `mid` items and pushes them to the end.
/// - Rotates `len() - mid` places to the right.
/// - Rotates item `n` into the first position.
/// - Pops the first `n` items and pushes them to the end.
/// - Rotates `len() - n` places to the right.
///
/// # Panics
///
/// If `mid` is greater than `len()`. Note that `mid == len()`
/// If `n` is greater than `len()`. Note that `n == len()`
/// does _not_ panic and is a no-op rotation.
///
/// # Complexity
///
/// Takes `*O*(min(mid, len() - mid))` time and no extra space.
/// Takes `*O*(min(n, len() - n))` time and no extra space.
///
/// # Examples
///
@ -2316,31 +2316,31 @@ impl<T, A: Allocator> VecDeque<T, A> {
/// assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
/// ```
#[stable(feature = "vecdeque_rotate", since = "1.36.0")]
pub fn rotate_left(&mut self, mid: usize) {
assert!(mid <= self.len());
let k = self.len - mid;
if mid <= k {
unsafe { self.rotate_left_inner(mid) }
pub fn rotate_left(&mut self, n: usize) {
assert!(n <= self.len());
let k = self.len - n;
if n <= k {
unsafe { self.rotate_left_inner(n) }
} else {
unsafe { self.rotate_right_inner(k) }
}
}
/// Rotates the double-ended queue `k` places to the right.
/// Rotates the double-ended queue `n` places to the right.
///
/// Equivalently,
/// - Rotates the first item into position `k`.
/// - Pops the last `k` items and pushes them to the front.
/// - Rotates `len() - k` places to the left.
/// - Rotates the first item into position `n`.
/// - Pops the last `n` items and pushes them to the front.
/// - Rotates `len() - n` places to the left.
///
/// # Panics
///
/// If `k` is greater than `len()`. Note that `k == len()`
/// If `n` is greater than `len()`. Note that `n == len()`
/// does _not_ panic and is a no-op rotation.
///
/// # Complexity
///
/// Takes `*O*(min(k, len() - k))` time and no extra space.
/// Takes `*O*(min(n, len() - n))` time and no extra space.
///
/// # Examples
///
@ -2359,13 +2359,13 @@ impl<T, A: Allocator> VecDeque<T, A> {
/// assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
/// ```
#[stable(feature = "vecdeque_rotate", since = "1.36.0")]
pub fn rotate_right(&mut self, k: usize) {
assert!(k <= self.len());
let mid = self.len - k;
if k <= mid {
unsafe { self.rotate_right_inner(k) }
pub fn rotate_right(&mut self, n: usize) {
assert!(n <= self.len());
let k = self.len - n;
if n <= k {
unsafe { self.rotate_right_inner(n) }
} else {
unsafe { self.rotate_left_inner(mid) }
unsafe { self.rotate_left_inner(k) }
}
}