move indexing impl to new mod
This commit is contained in:
Lzu Tao
parent
bcd18f977b
commit
fbad684e2f
286
library/core/src/slice/cmp.rs
Normal file
286
library/core/src/slice/cmp.rs
Normal file
@ -0,0 +1,286 @@
|
||||
//! Comparison traits for `[T]`.
|
||||
|
||||
use crate::cmp;
|
||||
use crate::cmp::Ordering::{self, Greater, Less};
|
||||
use crate::mem;
|
||||
|
||||
use super::from_raw_parts;
|
||||
use super::memchr;
|
||||
|
||||
extern "C" {
|
||||
/// Calls implementation provided memcmp.
|
||||
///
|
||||
/// Interprets the data as u8.
|
||||
///
|
||||
/// Returns 0 for equal, < 0 for less than and > 0 for greater
|
||||
/// than.
|
||||
// FIXME(#32610): Return type should be c_int
|
||||
fn memcmp(s1: *const u8, s2: *const u8, n: usize) -> i32;
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<A, B> PartialEq<[B]> for [A]
|
||||
where
|
||||
A: PartialEq<B>,
|
||||
{
|
||||
fn eq(&self, other: &[B]) -> bool {
|
||||
SlicePartialEq::equal(self, other)
|
||||
}
|
||||
|
||||
fn ne(&self, other: &[B]) -> bool {
|
||||
SlicePartialEq::not_equal(self, other)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<T: Eq> Eq for [T] {}
|
||||
|
||||
/// Implements comparison of vectors lexicographically.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<T: Ord> Ord for [T] {
|
||||
fn cmp(&self, other: &[T]) -> Ordering {
|
||||
SliceOrd::compare(self, other)
|
||||
}
|
||||
}
|
||||
|
||||
/// Implements comparison of vectors lexicographically.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<T: PartialOrd> PartialOrd for [T] {
|
||||
fn partial_cmp(&self, other: &[T]) -> Option<Ordering> {
|
||||
SlicePartialOrd::partial_compare(self, other)
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
// intermediate trait for specialization of slice's PartialEq
|
||||
trait SlicePartialEq<B> {
|
||||
fn equal(&self, other: &[B]) -> bool;
|
||||
|
||||
fn not_equal(&self, other: &[B]) -> bool {
|
||||
!self.equal(other)
|
||||
}
|
||||
}
|
||||
|
||||
// Generic slice equality
|
||||
impl<A, B> SlicePartialEq<B> for [A]
|
||||
where
|
||||
A: PartialEq<B>,
|
||||
{
|
||||
default fn equal(&self, other: &[B]) -> bool {
|
||||
if self.len() != other.len() {
|
||||
return false;
|
||||
}
|
||||
|
||||
self.iter().zip(other.iter()).all(|(x, y)| x == y)
|
||||
}
|
||||
}
|
||||
|
||||
// Use an equal-pointer optimization when types are `Eq`
|
||||
// We can't make `A` and `B` the same type because `min_specialization` won't
|
||||
// allow it.
|
||||
impl<A, B> SlicePartialEq<B> for [A]
|
||||
where
|
||||
A: MarkerEq<B>,
|
||||
{
|
||||
default fn equal(&self, other: &[B]) -> bool {
|
||||
if self.len() != other.len() {
|
||||
return false;
|
||||
}
|
||||
|
||||
// While performance would suffer if `guaranteed_eq` just returned `false`
|
||||
// for all arguments, correctness and return value of this function are not affected.
|
||||
if self.as_ptr().guaranteed_eq(other.as_ptr() as *const A) {
|
||||
return true;
|
||||
}
|
||||
|
||||
self.iter().zip(other.iter()).all(|(x, y)| x == y)
|
||||
}
|
||||
}
|
||||
|
||||
// Use memcmp for bytewise equality when the types allow
|
||||
impl<A, B> SlicePartialEq<B> for [A]
|
||||
where
|
||||
A: BytewiseEquality<B>,
|
||||
{
|
||||
fn equal(&self, other: &[B]) -> bool {
|
||||
if self.len() != other.len() {
|
||||
return false;
|
||||
}
|
||||
|
||||
// While performance would suffer if `guaranteed_eq` just returned `false`
|
||||
// for all arguments, correctness and return value of this function are not affected.
|
||||
if self.as_ptr().guaranteed_eq(other.as_ptr() as *const A) {
|
||||
return true;
|
||||
}
|
||||
// SAFETY: `self` and `other` are references and are thus guaranteed to be valid.
|
||||
// The two slices have been checked to have the same size above.
|
||||
unsafe {
|
||||
let size = mem::size_of_val(self);
|
||||
memcmp(self.as_ptr() as *const u8, other.as_ptr() as *const u8, size) == 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
// intermediate trait for specialization of slice's PartialOrd
|
||||
trait SlicePartialOrd: Sized {
|
||||
fn partial_compare(left: &[Self], right: &[Self]) -> Option<Ordering>;
|
||||
}
|
||||
|
||||
impl<A: PartialOrd> SlicePartialOrd for A {
|
||||
default fn partial_compare(left: &[A], right: &[A]) -> Option<Ordering> {
|
||||
let l = cmp::min(left.len(), right.len());
|
||||
|
||||
// Slice to the loop iteration range to enable bound check
|
||||
// elimination in the compiler
|
||||
let lhs = &left[..l];
|
||||
let rhs = &right[..l];
|
||||
|
||||
for i in 0..l {
|
||||
match lhs[i].partial_cmp(&rhs[i]) {
|
||||
Some(Ordering::Equal) => (),
|
||||
non_eq => return non_eq,
|
||||
}
|
||||
}
|
||||
|
||||
left.len().partial_cmp(&right.len())
|
||||
}
|
||||
}
|
||||
|
||||
// This is the impl that we would like to have. Unfortunately it's not sound.
|
||||
// See `partial_ord_slice.rs`.
|
||||
/*
|
||||
impl<A> SlicePartialOrd for A
|
||||
where
|
||||
A: Ord,
|
||||
{
|
||||
default fn partial_compare(left: &[A], right: &[A]) -> Option<Ordering> {
|
||||
Some(SliceOrd::compare(left, right))
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
impl<A: AlwaysApplicableOrd> SlicePartialOrd for A {
|
||||
fn partial_compare(left: &[A], right: &[A]) -> Option<Ordering> {
|
||||
Some(SliceOrd::compare(left, right))
|
||||
}
|
||||
}
|
||||
|
||||
#[rustc_specialization_trait]
|
||||
trait AlwaysApplicableOrd: SliceOrd + Ord {}
|
||||
|
||||
macro_rules! always_applicable_ord {
|
||||
($([$($p:tt)*] $t:ty,)*) => {
|
||||
$(impl<$($p)*> AlwaysApplicableOrd for $t {})*
|
||||
}
|
||||
}
|
||||
|
||||
always_applicable_ord! {
|
||||
[] u8, [] u16, [] u32, [] u64, [] u128, [] usize,
|
||||
[] i8, [] i16, [] i32, [] i64, [] i128, [] isize,
|
||||
[] bool, [] char,
|
||||
[T: ?Sized] *const T, [T: ?Sized] *mut T,
|
||||
[T: AlwaysApplicableOrd] &T,
|
||||
[T: AlwaysApplicableOrd] &mut T,
|
||||
[T: AlwaysApplicableOrd] Option<T>,
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
// intermediate trait for specialization of slice's Ord
|
||||
trait SliceOrd: Sized {
|
||||
fn compare(left: &[Self], right: &[Self]) -> Ordering;
|
||||
}
|
||||
|
||||
impl<A: Ord> SliceOrd for A {
|
||||
default fn compare(left: &[Self], right: &[Self]) -> Ordering {
|
||||
let l = cmp::min(left.len(), right.len());
|
||||
|
||||
// Slice to the loop iteration range to enable bound check
|
||||
// elimination in the compiler
|
||||
let lhs = &left[..l];
|
||||
let rhs = &right[..l];
|
||||
|
||||
for i in 0..l {
|
||||
match lhs[i].cmp(&rhs[i]) {
|
||||
Ordering::Equal => (),
|
||||
non_eq => return non_eq,
|
||||
}
|
||||
}
|
||||
|
||||
left.len().cmp(&right.len())
|
||||
}
|
||||
}
|
||||
|
||||
// memcmp compares a sequence of unsigned bytes lexicographically.
|
||||
// this matches the order we want for [u8], but no others (not even [i8]).
|
||||
impl SliceOrd for u8 {
|
||||
#[inline]
|
||||
fn compare(left: &[Self], right: &[Self]) -> Ordering {
|
||||
let order =
|
||||
// SAFETY: `left` and `right` are references and are thus guaranteed to be valid.
|
||||
// We use the minimum of both lengths which guarantees that both regions are
|
||||
// valid for reads in that interval.
|
||||
unsafe { memcmp(left.as_ptr(), right.as_ptr(), cmp::min(left.len(), right.len())) };
|
||||
if order == 0 {
|
||||
left.len().cmp(&right.len())
|
||||
} else if order < 0 {
|
||||
Less
|
||||
} else {
|
||||
Greater
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Hack to allow specializing on `Eq` even though `Eq` has a method.
|
||||
#[rustc_unsafe_specialization_marker]
|
||||
trait MarkerEq<T>: PartialEq<T> {}
|
||||
|
||||
impl<T: Eq> MarkerEq<T> for T {}
|
||||
|
||||
#[doc(hidden)]
|
||||
/// Trait implemented for types that can be compared for equality using
|
||||
/// their bytewise representation
|
||||
#[rustc_specialization_trait]
|
||||
trait BytewiseEquality<T>: MarkerEq<T> + Copy {}
|
||||
|
||||
macro_rules! impl_marker_for {
|
||||
($traitname:ident, $($ty:ty)*) => {
|
||||
$(
|
||||
impl $traitname<$ty> for $ty { }
|
||||
)*
|
||||
}
|
||||
}
|
||||
|
||||
impl_marker_for!(BytewiseEquality,
|
||||
u8 i8 u16 i16 u32 i32 u64 i64 u128 i128 usize isize char bool);
|
||||
|
||||
pub(super) trait SliceContains: Sized {
|
||||
fn slice_contains(&self, x: &[Self]) -> bool;
|
||||
}
|
||||
|
||||
impl<T> SliceContains for T
|
||||
where
|
||||
T: PartialEq,
|
||||
{
|
||||
default fn slice_contains(&self, x: &[Self]) -> bool {
|
||||
x.iter().any(|y| *y == *self)
|
||||
}
|
||||
}
|
||||
|
||||
impl SliceContains for u8 {
|
||||
fn slice_contains(&self, x: &[Self]) -> bool {
|
||||
memchr::memchr(*self, x).is_some()
|
||||
}
|
||||
}
|
||||
|
||||
impl SliceContains for i8 {
|
||||
fn slice_contains(&self, x: &[Self]) -> bool {
|
||||
let byte = *self as u8;
|
||||
// SAFETY: `i8` and `u8` have the same memory layout, thus casting `x.as_ptr()`
|
||||
// as `*const u8` is safe. The `x.as_ptr()` comes from a reference and is thus guaranteed
|
||||
// to be valid for reads for the length of the slice `x.len()`, which cannot be larger
|
||||
// than `isize::MAX`. The returned slice is never mutated.
|
||||
let bytes: &[u8] = unsafe { from_raw_parts(x.as_ptr() as *const u8, x.len()) };
|
||||
memchr::memchr(byte, bytes).is_some()
|
||||
}
|
||||
}
|
||||
455
library/core/src/slice/index.rs
Normal file
455
library/core/src/slice/index.rs
Normal file
@ -0,0 +1,455 @@
|
||||
//! Indexing implementations for `[T]`.
|
||||
|
||||
use crate::ops;
|
||||
use crate::ptr;
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<T, I> ops::Index<I> for [T]
|
||||
where
|
||||
I: SliceIndex<[T]>,
|
||||
{
|
||||
type Output = I::Output;
|
||||
|
||||
#[inline]
|
||||
fn index(&self, index: I) -> &I::Output {
|
||||
index.index(self)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<T, I> ops::IndexMut<I> for [T]
|
||||
where
|
||||
I: SliceIndex<[T]>,
|
||||
{
|
||||
#[inline]
|
||||
fn index_mut(&mut self, index: I) -> &mut I::Output {
|
||||
index.index_mut(self)
|
||||
}
|
||||
}
|
||||
|
||||
#[inline(never)]
|
||||
#[cold]
|
||||
#[track_caller]
|
||||
fn slice_start_index_len_fail(index: usize, len: usize) -> ! {
|
||||
panic!("range start index {} out of range for slice of length {}", index, len);
|
||||
}
|
||||
|
||||
#[inline(never)]
|
||||
#[cold]
|
||||
#[track_caller]
|
||||
pub(super) fn slice_end_index_len_fail(index: usize, len: usize) -> ! {
|
||||
panic!("range end index {} out of range for slice of length {}", index, len);
|
||||
}
|
||||
|
||||
#[inline(never)]
|
||||
#[cold]
|
||||
#[track_caller]
|
||||
pub(super) fn slice_index_order_fail(index: usize, end: usize) -> ! {
|
||||
panic!("slice index starts at {} but ends at {}", index, end);
|
||||
}
|
||||
|
||||
#[inline(never)]
|
||||
#[cold]
|
||||
#[track_caller]
|
||||
pub(super) fn slice_start_index_overflow_fail() -> ! {
|
||||
panic!("attempted to index slice from after maximum usize");
|
||||
}
|
||||
|
||||
#[inline(never)]
|
||||
#[cold]
|
||||
#[track_caller]
|
||||
pub(super) fn slice_end_index_overflow_fail() -> ! {
|
||||
panic!("attempted to index slice up to maximum usize");
|
||||
}
|
||||
|
||||
mod private_slice_index {
|
||||
use super::ops;
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
pub trait Sealed {}
|
||||
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
impl Sealed for usize {}
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
impl Sealed for ops::Range<usize> {}
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
impl Sealed for ops::RangeTo<usize> {}
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
impl Sealed for ops::RangeFrom<usize> {}
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
impl Sealed for ops::RangeFull {}
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
impl Sealed for ops::RangeInclusive<usize> {}
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
impl Sealed for ops::RangeToInclusive<usize> {}
|
||||
}
|
||||
|
||||
/// A helper trait used for indexing operations.
|
||||
///
|
||||
/// Implementations of this trait have to promise that if the argument
|
||||
/// to `get_(mut_)unchecked` is a safe reference, then so is the result.
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
#[rustc_on_unimplemented(
|
||||
on(T = "str", label = "string indices are ranges of `usize`",),
|
||||
on(
|
||||
all(any(T = "str", T = "&str", T = "std::string::String"), _Self = "{integer}"),
|
||||
note = "you can use `.chars().nth()` or `.bytes().nth()`\n\
|
||||
for more information, see chapter 8 in The Book: \
|
||||
<https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>"
|
||||
),
|
||||
message = "the type `{T}` cannot be indexed by `{Self}`",
|
||||
label = "slice indices are of type `usize` or ranges of `usize`"
|
||||
)]
|
||||
pub unsafe trait SliceIndex<T: ?Sized>: private_slice_index::Sealed {
|
||||
/// The output type returned by methods.
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
type Output: ?Sized;
|
||||
|
||||
/// Returns a shared reference to the output at this location, if in
|
||||
/// bounds.
|
||||
#[unstable(feature = "slice_index_methods", issue = "none")]
|
||||
fn get(self, slice: &T) -> Option<&Self::Output>;
|
||||
|
||||
/// Returns a mutable reference to the output at this location, if in
|
||||
/// bounds.
|
||||
#[unstable(feature = "slice_index_methods", issue = "none")]
|
||||
fn get_mut(self, slice: &mut T) -> Option<&mut Self::Output>;
|
||||
|
||||
/// Returns a shared reference to the output at this location, without
|
||||
/// performing any bounds checking.
|
||||
/// Calling this method with an out-of-bounds index or a dangling `slice` pointer
|
||||
/// is *[undefined behavior]* even if the resulting reference is not used.
|
||||
///
|
||||
/// [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html
|
||||
#[unstable(feature = "slice_index_methods", issue = "none")]
|
||||
unsafe fn get_unchecked(self, slice: *const T) -> *const Self::Output;
|
||||
|
||||
/// Returns a mutable reference to the output at this location, without
|
||||
/// performing any bounds checking.
|
||||
/// Calling this method with an out-of-bounds index or a dangling `slice` pointer
|
||||
/// is *[undefined behavior]* even if the resulting reference is not used.
|
||||
///
|
||||
/// [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html
|
||||
#[unstable(feature = "slice_index_methods", issue = "none")]
|
||||
unsafe fn get_unchecked_mut(self, slice: *mut T) -> *mut Self::Output;
|
||||
|
||||
/// Returns a shared reference to the output at this location, panicking
|
||||
/// if out of bounds.
|
||||
#[unstable(feature = "slice_index_methods", issue = "none")]
|
||||
#[track_caller]
|
||||
fn index(self, slice: &T) -> &Self::Output;
|
||||
|
||||
/// Returns a mutable reference to the output at this location, panicking
|
||||
/// if out of bounds.
|
||||
#[unstable(feature = "slice_index_methods", issue = "none")]
|
||||
#[track_caller]
|
||||
fn index_mut(self, slice: &mut T) -> &mut Self::Output;
|
||||
}
|
||||
|
||||
#[stable(feature = "slice_get_slice_impls", since = "1.15.0")]
|
||||
unsafe impl<T> SliceIndex<[T]> for usize {
|
||||
type Output = T;
|
||||
|
||||
#[inline]
|
||||
fn get(self, slice: &[T]) -> Option<&T> {
|
||||
// SAFETY: `self` is checked to be in bounds.
|
||||
if self < slice.len() { unsafe { Some(&*self.get_unchecked(slice)) } } else { None }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_mut(self, slice: &mut [T]) -> Option<&mut T> {
|
||||
// SAFETY: `self` is checked to be in bounds.
|
||||
if self < slice.len() { unsafe { Some(&mut *self.get_unchecked_mut(slice)) } } else { None }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked(self, slice: *const [T]) -> *const T {
|
||||
// SAFETY: the caller guarantees that `slice` is not dangling, so it
|
||||
// cannot be longer than `isize::MAX`. They also guarantee that
|
||||
// `self` is in bounds of `slice` so `self` cannot overflow an `isize`,
|
||||
// so the call to `add` is safe.
|
||||
unsafe { slice.as_ptr().add(self) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut T {
|
||||
// SAFETY: see comments for `get_unchecked` above.
|
||||
unsafe { slice.as_mut_ptr().add(self) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index(self, slice: &[T]) -> &T {
|
||||
// N.B., use intrinsic indexing
|
||||
&(*slice)[self]
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index_mut(self, slice: &mut [T]) -> &mut T {
|
||||
// N.B., use intrinsic indexing
|
||||
&mut (*slice)[self]
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "slice_get_slice_impls", since = "1.15.0")]
|
||||
unsafe impl<T> SliceIndex<[T]> for ops::Range<usize> {
|
||||
type Output = [T];
|
||||
|
||||
#[inline]
|
||||
fn get(self, slice: &[T]) -> Option<&[T]> {
|
||||
if self.start > self.end || self.end > slice.len() {
|
||||
None
|
||||
} else {
|
||||
// SAFETY: `self` is checked to be valid and in bounds above.
|
||||
unsafe { Some(&*self.get_unchecked(slice)) }
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {
|
||||
if self.start > self.end || self.end > slice.len() {
|
||||
None
|
||||
} else {
|
||||
// SAFETY: `self` is checked to be valid and in bounds above.
|
||||
unsafe { Some(&mut *self.get_unchecked_mut(slice)) }
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T] {
|
||||
// SAFETY: the caller guarantees that `slice` is not dangling, so it
|
||||
// cannot be longer than `isize::MAX`. They also guarantee that
|
||||
// `self` is in bounds of `slice` so `self` cannot overflow an `isize`,
|
||||
// so the call to `add` is safe.
|
||||
unsafe { ptr::slice_from_raw_parts(slice.as_ptr().add(self.start), self.end - self.start) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T] {
|
||||
// SAFETY: see comments for `get_unchecked` above.
|
||||
unsafe {
|
||||
ptr::slice_from_raw_parts_mut(slice.as_mut_ptr().add(self.start), self.end - self.start)
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index(self, slice: &[T]) -> &[T] {
|
||||
if self.start > self.end {
|
||||
slice_index_order_fail(self.start, self.end);
|
||||
} else if self.end > slice.len() {
|
||||
slice_end_index_len_fail(self.end, slice.len());
|
||||
}
|
||||
// SAFETY: `self` is checked to be valid and in bounds above.
|
||||
unsafe { &*self.get_unchecked(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index_mut(self, slice: &mut [T]) -> &mut [T] {
|
||||
if self.start > self.end {
|
||||
slice_index_order_fail(self.start, self.end);
|
||||
} else if self.end > slice.len() {
|
||||
slice_end_index_len_fail(self.end, slice.len());
|
||||
}
|
||||
// SAFETY: `self` is checked to be valid and in bounds above.
|
||||
unsafe { &mut *self.get_unchecked_mut(slice) }
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "slice_get_slice_impls", since = "1.15.0")]
|
||||
unsafe impl<T> SliceIndex<[T]> for ops::RangeTo<usize> {
|
||||
type Output = [T];
|
||||
|
||||
#[inline]
|
||||
fn get(self, slice: &[T]) -> Option<&[T]> {
|
||||
(0..self.end).get(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {
|
||||
(0..self.end).get_mut(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T] {
|
||||
// SAFETY: the caller has to uphold the safety contract for `get_unchecked`.
|
||||
unsafe { (0..self.end).get_unchecked(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T] {
|
||||
// SAFETY: the caller has to uphold the safety contract for `get_unchecked_mut`.
|
||||
unsafe { (0..self.end).get_unchecked_mut(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index(self, slice: &[T]) -> &[T] {
|
||||
(0..self.end).index(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index_mut(self, slice: &mut [T]) -> &mut [T] {
|
||||
(0..self.end).index_mut(slice)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "slice_get_slice_impls", since = "1.15.0")]
|
||||
unsafe impl<T> SliceIndex<[T]> for ops::RangeFrom<usize> {
|
||||
type Output = [T];
|
||||
|
||||
#[inline]
|
||||
fn get(self, slice: &[T]) -> Option<&[T]> {
|
||||
(self.start..slice.len()).get(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {
|
||||
(self.start..slice.len()).get_mut(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T] {
|
||||
// SAFETY: the caller has to uphold the safety contract for `get_unchecked`.
|
||||
unsafe { (self.start..slice.len()).get_unchecked(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T] {
|
||||
// SAFETY: the caller has to uphold the safety contract for `get_unchecked_mut`.
|
||||
unsafe { (self.start..slice.len()).get_unchecked_mut(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index(self, slice: &[T]) -> &[T] {
|
||||
if self.start > slice.len() {
|
||||
slice_start_index_len_fail(self.start, slice.len());
|
||||
}
|
||||
// SAFETY: `self` is checked to be valid and in bounds above.
|
||||
unsafe { &*self.get_unchecked(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index_mut(self, slice: &mut [T]) -> &mut [T] {
|
||||
if self.start > slice.len() {
|
||||
slice_start_index_len_fail(self.start, slice.len());
|
||||
}
|
||||
// SAFETY: `self` is checked to be valid and in bounds above.
|
||||
unsafe { &mut *self.get_unchecked_mut(slice) }
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "slice_get_slice_impls", since = "1.15.0")]
|
||||
unsafe impl<T> SliceIndex<[T]> for ops::RangeFull {
|
||||
type Output = [T];
|
||||
|
||||
#[inline]
|
||||
fn get(self, slice: &[T]) -> Option<&[T]> {
|
||||
Some(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {
|
||||
Some(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T] {
|
||||
slice
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T] {
|
||||
slice
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index(self, slice: &[T]) -> &[T] {
|
||||
slice
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index_mut(self, slice: &mut [T]) -> &mut [T] {
|
||||
slice
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "inclusive_range", since = "1.26.0")]
|
||||
unsafe impl<T> SliceIndex<[T]> for ops::RangeInclusive<usize> {
|
||||
type Output = [T];
|
||||
|
||||
#[inline]
|
||||
fn get(self, slice: &[T]) -> Option<&[T]> {
|
||||
if *self.end() == usize::MAX { None } else { (*self.start()..self.end() + 1).get(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {
|
||||
if *self.end() == usize::MAX {
|
||||
None
|
||||
} else {
|
||||
(*self.start()..self.end() + 1).get_mut(slice)
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T] {
|
||||
// SAFETY: the caller has to uphold the safety contract for `get_unchecked`.
|
||||
unsafe { (*self.start()..self.end() + 1).get_unchecked(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T] {
|
||||
// SAFETY: the caller has to uphold the safety contract for `get_unchecked_mut`.
|
||||
unsafe { (*self.start()..self.end() + 1).get_unchecked_mut(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index(self, slice: &[T]) -> &[T] {
|
||||
if *self.end() == usize::MAX {
|
||||
slice_end_index_overflow_fail();
|
||||
}
|
||||
(*self.start()..self.end() + 1).index(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index_mut(self, slice: &mut [T]) -> &mut [T] {
|
||||
if *self.end() == usize::MAX {
|
||||
slice_end_index_overflow_fail();
|
||||
}
|
||||
(*self.start()..self.end() + 1).index_mut(slice)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "inclusive_range", since = "1.26.0")]
|
||||
unsafe impl<T> SliceIndex<[T]> for ops::RangeToInclusive<usize> {
|
||||
type Output = [T];
|
||||
|
||||
#[inline]
|
||||
fn get(self, slice: &[T]) -> Option<&[T]> {
|
||||
(0..=self.end).get(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {
|
||||
(0..=self.end).get_mut(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T] {
|
||||
// SAFETY: the caller has to uphold the safety contract for `get_unchecked`.
|
||||
unsafe { (0..=self.end).get_unchecked(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T] {
|
||||
// SAFETY: the caller has to uphold the safety contract for `get_unchecked_mut`.
|
||||
unsafe { (0..=self.end).get_unchecked_mut(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index(self, slice: &[T]) -> &[T] {
|
||||
(0..=self.end).index(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index_mut(self, slice: &mut [T]) -> &mut [T] {
|
||||
(0..=self.end).index_mut(slice)
|
||||
}
|
||||
}
|
||||
@ -20,12 +20,11 @@
|
||||
// * The `raw` and `bytes` submodules.
|
||||
// * Boilerplate trait implementations.
|
||||
|
||||
use crate::cmp;
|
||||
use crate::cmp::Ordering::{self, Equal, Greater, Less};
|
||||
use crate::intrinsics::assume;
|
||||
use crate::marker::{self, Copy, Sized};
|
||||
use crate::marker::{self, Copy};
|
||||
use crate::mem;
|
||||
use crate::ops::{self, Bound, FnMut, Range, RangeBounds};
|
||||
use crate::ops::{Bound, FnMut, Range, RangeBounds};
|
||||
use crate::option::Option;
|
||||
use crate::option::Option::{None, Some};
|
||||
use crate::ptr::{self, NonNull};
|
||||
@ -40,6 +39,8 @@ use crate::result::Result::{Err, Ok};
|
||||
/// Pure rust memchr implementation, taken from rust-memchr
|
||||
pub mod memchr;
|
||||
|
||||
mod cmp;
|
||||
mod index;
|
||||
mod iter;
|
||||
mod raw;
|
||||
mod rotate;
|
||||
@ -79,6 +80,12 @@ pub use raw::{from_mut, from_ref};
|
||||
#[unstable(feature = "sort_internals", reason = "internal to sort module", issue = "none")]
|
||||
pub use sort::heapsort;
|
||||
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
pub use index::SliceIndex;
|
||||
|
||||
use index::{slice_end_index_len_fail, slice_index_order_fail};
|
||||
use index::{slice_end_index_overflow_fail, slice_start_index_overflow_fail};
|
||||
|
||||
//
|
||||
// Extension traits
|
||||
//
|
||||
@ -428,7 +435,7 @@ impl<T> [T] {
|
||||
/// [10, 40, 30].check_range(1..=usize::MAX);
|
||||
/// ```
|
||||
///
|
||||
/// [`Index::index`]: ops::Index::index
|
||||
/// [`Index::index`]: crate::ops::Index::index
|
||||
#[track_caller]
|
||||
#[unstable(feature = "slice_check_range", issue = "76393")]
|
||||
pub fn check_range<R: RangeBounds<usize>>(&self, range: R) -> Range<usize> {
|
||||
@ -1766,7 +1773,7 @@ impl<T> [T] {
|
||||
where
|
||||
T: PartialEq,
|
||||
{
|
||||
x.slice_contains(self)
|
||||
cmp::SliceContains::slice_contains(x, self)
|
||||
}
|
||||
|
||||
/// Returns `true` if `needle` is a prefix of the slice.
|
||||
@ -3343,457 +3350,6 @@ fn is_ascii(s: &[u8]) -> bool {
|
||||
!contains_nonascii(last_word)
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<T, I> ops::Index<I> for [T]
|
||||
where
|
||||
I: SliceIndex<[T]>,
|
||||
{
|
||||
type Output = I::Output;
|
||||
|
||||
#[inline]
|
||||
fn index(&self, index: I) -> &I::Output {
|
||||
index.index(self)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<T, I> ops::IndexMut<I> for [T]
|
||||
where
|
||||
I: SliceIndex<[T]>,
|
||||
{
|
||||
#[inline]
|
||||
fn index_mut(&mut self, index: I) -> &mut I::Output {
|
||||
index.index_mut(self)
|
||||
}
|
||||
}
|
||||
|
||||
#[inline(never)]
|
||||
#[cold]
|
||||
#[track_caller]
|
||||
fn slice_start_index_len_fail(index: usize, len: usize) -> ! {
|
||||
panic!("range start index {} out of range for slice of length {}", index, len);
|
||||
}
|
||||
|
||||
#[inline(never)]
|
||||
#[cold]
|
||||
#[track_caller]
|
||||
fn slice_end_index_len_fail(index: usize, len: usize) -> ! {
|
||||
panic!("range end index {} out of range for slice of length {}", index, len);
|
||||
}
|
||||
|
||||
#[inline(never)]
|
||||
#[cold]
|
||||
#[track_caller]
|
||||
fn slice_index_order_fail(index: usize, end: usize) -> ! {
|
||||
panic!("slice index starts at {} but ends at {}", index, end);
|
||||
}
|
||||
|
||||
#[inline(never)]
|
||||
#[cold]
|
||||
#[track_caller]
|
||||
fn slice_start_index_overflow_fail() -> ! {
|
||||
panic!("attempted to index slice from after maximum usize");
|
||||
}
|
||||
|
||||
#[inline(never)]
|
||||
#[cold]
|
||||
#[track_caller]
|
||||
fn slice_end_index_overflow_fail() -> ! {
|
||||
panic!("attempted to index slice up to maximum usize");
|
||||
}
|
||||
|
||||
mod private_slice_index {
|
||||
use super::ops;
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
pub trait Sealed {}
|
||||
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
impl Sealed for usize {}
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
impl Sealed for ops::Range<usize> {}
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
impl Sealed for ops::RangeTo<usize> {}
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
impl Sealed for ops::RangeFrom<usize> {}
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
impl Sealed for ops::RangeFull {}
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
impl Sealed for ops::RangeInclusive<usize> {}
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
impl Sealed for ops::RangeToInclusive<usize> {}
|
||||
}
|
||||
|
||||
/// A helper trait used for indexing operations.
|
||||
///
|
||||
/// Implementations of this trait have to promise that if the argument
|
||||
/// to `get_(mut_)unchecked` is a safe reference, then so is the result.
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
#[rustc_on_unimplemented(
|
||||
on(T = "str", label = "string indices are ranges of `usize`",),
|
||||
on(
|
||||
all(any(T = "str", T = "&str", T = "std::string::String"), _Self = "{integer}"),
|
||||
note = "you can use `.chars().nth()` or `.bytes().nth()`\n\
|
||||
for more information, see chapter 8 in The Book: \
|
||||
<https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>"
|
||||
),
|
||||
message = "the type `{T}` cannot be indexed by `{Self}`",
|
||||
label = "slice indices are of type `usize` or ranges of `usize`"
|
||||
)]
|
||||
pub unsafe trait SliceIndex<T: ?Sized>: private_slice_index::Sealed {
|
||||
/// The output type returned by methods.
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
type Output: ?Sized;
|
||||
|
||||
/// Returns a shared reference to the output at this location, if in
|
||||
/// bounds.
|
||||
#[unstable(feature = "slice_index_methods", issue = "none")]
|
||||
fn get(self, slice: &T) -> Option<&Self::Output>;
|
||||
|
||||
/// Returns a mutable reference to the output at this location, if in
|
||||
/// bounds.
|
||||
#[unstable(feature = "slice_index_methods", issue = "none")]
|
||||
fn get_mut(self, slice: &mut T) -> Option<&mut Self::Output>;
|
||||
|
||||
/// Returns a shared reference to the output at this location, without
|
||||
/// performing any bounds checking.
|
||||
/// Calling this method with an out-of-bounds index or a dangling `slice` pointer
|
||||
/// is *[undefined behavior]* even if the resulting reference is not used.
|
||||
///
|
||||
/// [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html
|
||||
#[unstable(feature = "slice_index_methods", issue = "none")]
|
||||
unsafe fn get_unchecked(self, slice: *const T) -> *const Self::Output;
|
||||
|
||||
/// Returns a mutable reference to the output at this location, without
|
||||
/// performing any bounds checking.
|
||||
/// Calling this method with an out-of-bounds index or a dangling `slice` pointer
|
||||
/// is *[undefined behavior]* even if the resulting reference is not used.
|
||||
///
|
||||
/// [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html
|
||||
#[unstable(feature = "slice_index_methods", issue = "none")]
|
||||
unsafe fn get_unchecked_mut(self, slice: *mut T) -> *mut Self::Output;
|
||||
|
||||
/// Returns a shared reference to the output at this location, panicking
|
||||
/// if out of bounds.
|
||||
#[unstable(feature = "slice_index_methods", issue = "none")]
|
||||
#[track_caller]
|
||||
fn index(self, slice: &T) -> &Self::Output;
|
||||
|
||||
/// Returns a mutable reference to the output at this location, panicking
|
||||
/// if out of bounds.
|
||||
#[unstable(feature = "slice_index_methods", issue = "none")]
|
||||
#[track_caller]
|
||||
fn index_mut(self, slice: &mut T) -> &mut Self::Output;
|
||||
}
|
||||
|
||||
#[stable(feature = "slice_get_slice_impls", since = "1.15.0")]
|
||||
unsafe impl<T> SliceIndex<[T]> for usize {
|
||||
type Output = T;
|
||||
|
||||
#[inline]
|
||||
fn get(self, slice: &[T]) -> Option<&T> {
|
||||
// SAFETY: `self` is checked to be in bounds.
|
||||
if self < slice.len() { unsafe { Some(&*self.get_unchecked(slice)) } } else { None }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_mut(self, slice: &mut [T]) -> Option<&mut T> {
|
||||
// SAFETY: `self` is checked to be in bounds.
|
||||
if self < slice.len() { unsafe { Some(&mut *self.get_unchecked_mut(slice)) } } else { None }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked(self, slice: *const [T]) -> *const T {
|
||||
// SAFETY: the caller guarantees that `slice` is not dangling, so it
|
||||
// cannot be longer than `isize::MAX`. They also guarantee that
|
||||
// `self` is in bounds of `slice` so `self` cannot overflow an `isize`,
|
||||
// so the call to `add` is safe.
|
||||
unsafe { slice.as_ptr().add(self) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut T {
|
||||
// SAFETY: see comments for `get_unchecked` above.
|
||||
unsafe { slice.as_mut_ptr().add(self) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index(self, slice: &[T]) -> &T {
|
||||
// N.B., use intrinsic indexing
|
||||
&(*slice)[self]
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index_mut(self, slice: &mut [T]) -> &mut T {
|
||||
// N.B., use intrinsic indexing
|
||||
&mut (*slice)[self]
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "slice_get_slice_impls", since = "1.15.0")]
|
||||
unsafe impl<T> SliceIndex<[T]> for ops::Range<usize> {
|
||||
type Output = [T];
|
||||
|
||||
#[inline]
|
||||
fn get(self, slice: &[T]) -> Option<&[T]> {
|
||||
if self.start > self.end || self.end > slice.len() {
|
||||
None
|
||||
} else {
|
||||
// SAFETY: `self` is checked to be valid and in bounds above.
|
||||
unsafe { Some(&*self.get_unchecked(slice)) }
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {
|
||||
if self.start > self.end || self.end > slice.len() {
|
||||
None
|
||||
} else {
|
||||
// SAFETY: `self` is checked to be valid and in bounds above.
|
||||
unsafe { Some(&mut *self.get_unchecked_mut(slice)) }
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T] {
|
||||
// SAFETY: the caller guarantees that `slice` is not dangling, so it
|
||||
// cannot be longer than `isize::MAX`. They also guarantee that
|
||||
// `self` is in bounds of `slice` so `self` cannot overflow an `isize`,
|
||||
// so the call to `add` is safe.
|
||||
unsafe { ptr::slice_from_raw_parts(slice.as_ptr().add(self.start), self.end - self.start) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T] {
|
||||
// SAFETY: see comments for `get_unchecked` above.
|
||||
unsafe {
|
||||
ptr::slice_from_raw_parts_mut(slice.as_mut_ptr().add(self.start), self.end - self.start)
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index(self, slice: &[T]) -> &[T] {
|
||||
if self.start > self.end {
|
||||
slice_index_order_fail(self.start, self.end);
|
||||
} else if self.end > slice.len() {
|
||||
slice_end_index_len_fail(self.end, slice.len());
|
||||
}
|
||||
// SAFETY: `self` is checked to be valid and in bounds above.
|
||||
unsafe { &*self.get_unchecked(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index_mut(self, slice: &mut [T]) -> &mut [T] {
|
||||
if self.start > self.end {
|
||||
slice_index_order_fail(self.start, self.end);
|
||||
} else if self.end > slice.len() {
|
||||
slice_end_index_len_fail(self.end, slice.len());
|
||||
}
|
||||
// SAFETY: `self` is checked to be valid and in bounds above.
|
||||
unsafe { &mut *self.get_unchecked_mut(slice) }
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "slice_get_slice_impls", since = "1.15.0")]
|
||||
unsafe impl<T> SliceIndex<[T]> for ops::RangeTo<usize> {
|
||||
type Output = [T];
|
||||
|
||||
#[inline]
|
||||
fn get(self, slice: &[T]) -> Option<&[T]> {
|
||||
(0..self.end).get(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {
|
||||
(0..self.end).get_mut(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T] {
|
||||
// SAFETY: the caller has to uphold the safety contract for `get_unchecked`.
|
||||
unsafe { (0..self.end).get_unchecked(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T] {
|
||||
// SAFETY: the caller has to uphold the safety contract for `get_unchecked_mut`.
|
||||
unsafe { (0..self.end).get_unchecked_mut(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index(self, slice: &[T]) -> &[T] {
|
||||
(0..self.end).index(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index_mut(self, slice: &mut [T]) -> &mut [T] {
|
||||
(0..self.end).index_mut(slice)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "slice_get_slice_impls", since = "1.15.0")]
|
||||
unsafe impl<T> SliceIndex<[T]> for ops::RangeFrom<usize> {
|
||||
type Output = [T];
|
||||
|
||||
#[inline]
|
||||
fn get(self, slice: &[T]) -> Option<&[T]> {
|
||||
(self.start..slice.len()).get(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {
|
||||
(self.start..slice.len()).get_mut(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T] {
|
||||
// SAFETY: the caller has to uphold the safety contract for `get_unchecked`.
|
||||
unsafe { (self.start..slice.len()).get_unchecked(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T] {
|
||||
// SAFETY: the caller has to uphold the safety contract for `get_unchecked_mut`.
|
||||
unsafe { (self.start..slice.len()).get_unchecked_mut(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index(self, slice: &[T]) -> &[T] {
|
||||
if self.start > slice.len() {
|
||||
slice_start_index_len_fail(self.start, slice.len());
|
||||
}
|
||||
// SAFETY: `self` is checked to be valid and in bounds above.
|
||||
unsafe { &*self.get_unchecked(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index_mut(self, slice: &mut [T]) -> &mut [T] {
|
||||
if self.start > slice.len() {
|
||||
slice_start_index_len_fail(self.start, slice.len());
|
||||
}
|
||||
// SAFETY: `self` is checked to be valid and in bounds above.
|
||||
unsafe { &mut *self.get_unchecked_mut(slice) }
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "slice_get_slice_impls", since = "1.15.0")]
|
||||
unsafe impl<T> SliceIndex<[T]> for ops::RangeFull {
|
||||
type Output = [T];
|
||||
|
||||
#[inline]
|
||||
fn get(self, slice: &[T]) -> Option<&[T]> {
|
||||
Some(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {
|
||||
Some(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T] {
|
||||
slice
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T] {
|
||||
slice
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index(self, slice: &[T]) -> &[T] {
|
||||
slice
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index_mut(self, slice: &mut [T]) -> &mut [T] {
|
||||
slice
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "inclusive_range", since = "1.26.0")]
|
||||
unsafe impl<T> SliceIndex<[T]> for ops::RangeInclusive<usize> {
|
||||
type Output = [T];
|
||||
|
||||
#[inline]
|
||||
fn get(self, slice: &[T]) -> Option<&[T]> {
|
||||
if *self.end() == usize::MAX { None } else { (*self.start()..self.end() + 1).get(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {
|
||||
if *self.end() == usize::MAX {
|
||||
None
|
||||
} else {
|
||||
(*self.start()..self.end() + 1).get_mut(slice)
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T] {
|
||||
// SAFETY: the caller has to uphold the safety contract for `get_unchecked`.
|
||||
unsafe { (*self.start()..self.end() + 1).get_unchecked(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T] {
|
||||
// SAFETY: the caller has to uphold the safety contract for `get_unchecked_mut`.
|
||||
unsafe { (*self.start()..self.end() + 1).get_unchecked_mut(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index(self, slice: &[T]) -> &[T] {
|
||||
if *self.end() == usize::MAX {
|
||||
slice_end_index_overflow_fail();
|
||||
}
|
||||
(*self.start()..self.end() + 1).index(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index_mut(self, slice: &mut [T]) -> &mut [T] {
|
||||
if *self.end() == usize::MAX {
|
||||
slice_end_index_overflow_fail();
|
||||
}
|
||||
(*self.start()..self.end() + 1).index_mut(slice)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "inclusive_range", since = "1.26.0")]
|
||||
unsafe impl<T> SliceIndex<[T]> for ops::RangeToInclusive<usize> {
|
||||
type Output = [T];
|
||||
|
||||
#[inline]
|
||||
fn get(self, slice: &[T]) -> Option<&[T]> {
|
||||
(0..=self.end).get(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {
|
||||
(0..=self.end).get_mut(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T] {
|
||||
// SAFETY: the caller has to uphold the safety contract for `get_unchecked`.
|
||||
unsafe { (0..=self.end).get_unchecked(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T] {
|
||||
// SAFETY: the caller has to uphold the safety contract for `get_unchecked_mut`.
|
||||
unsafe { (0..=self.end).get_unchecked_mut(slice) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index(self, slice: &[T]) -> &[T] {
|
||||
(0..=self.end).index(slice)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn index_mut(self, slice: &mut [T]) -> &mut [T] {
|
||||
(0..=self.end).index_mut(slice)
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Common traits
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
@ -3813,284 +3369,3 @@ impl<T> Default for &mut [T] {
|
||||
&mut []
|
||||
}
|
||||
}
|
||||
|
||||
// Comparison traits
|
||||
//
|
||||
|
||||
extern "C" {
|
||||
/// Calls implementation provided memcmp.
|
||||
///
|
||||
/// Interprets the data as u8.
|
||||
///
|
||||
/// Returns 0 for equal, < 0 for less than and > 0 for greater
|
||||
/// than.
|
||||
// FIXME(#32610): Return type should be c_int
|
||||
fn memcmp(s1: *const u8, s2: *const u8, n: usize) -> i32;
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<A, B> PartialEq<[B]> for [A]
|
||||
where
|
||||
A: PartialEq<B>,
|
||||
{
|
||||
fn eq(&self, other: &[B]) -> bool {
|
||||
SlicePartialEq::equal(self, other)
|
||||
}
|
||||
|
||||
fn ne(&self, other: &[B]) -> bool {
|
||||
SlicePartialEq::not_equal(self, other)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<T: Eq> Eq for [T] {}
|
||||
|
||||
/// Implements comparison of vectors lexicographically.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<T: Ord> Ord for [T] {
|
||||
fn cmp(&self, other: &[T]) -> Ordering {
|
||||
SliceOrd::compare(self, other)
|
||||
}
|
||||
}
|
||||
|
||||
/// Implements comparison of vectors lexicographically.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<T: PartialOrd> PartialOrd for [T] {
|
||||
fn partial_cmp(&self, other: &[T]) -> Option<Ordering> {
|
||||
SlicePartialOrd::partial_compare(self, other)
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
// intermediate trait for specialization of slice's PartialEq
|
||||
trait SlicePartialEq<B> {
|
||||
fn equal(&self, other: &[B]) -> bool;
|
||||
|
||||
fn not_equal(&self, other: &[B]) -> bool {
|
||||
!self.equal(other)
|
||||
}
|
||||
}
|
||||
|
||||
// Generic slice equality
|
||||
impl<A, B> SlicePartialEq<B> for [A]
|
||||
where
|
||||
A: PartialEq<B>,
|
||||
{
|
||||
default fn equal(&self, other: &[B]) -> bool {
|
||||
if self.len() != other.len() {
|
||||
return false;
|
||||
}
|
||||
|
||||
self.iter().zip(other.iter()).all(|(x, y)| x == y)
|
||||
}
|
||||
}
|
||||
|
||||
// Use an equal-pointer optimization when types are `Eq`
|
||||
// We can't make `A` and `B` the same type because `min_specialization` won't
|
||||
// allow it.
|
||||
impl<A, B> SlicePartialEq<B> for [A]
|
||||
where
|
||||
A: MarkerEq<B>,
|
||||
{
|
||||
default fn equal(&self, other: &[B]) -> bool {
|
||||
if self.len() != other.len() {
|
||||
return false;
|
||||
}
|
||||
|
||||
// While performance would suffer if `guaranteed_eq` just returned `false`
|
||||
// for all arguments, correctness and return value of this function are not affected.
|
||||
if self.as_ptr().guaranteed_eq(other.as_ptr() as *const A) {
|
||||
return true;
|
||||
}
|
||||
|
||||
self.iter().zip(other.iter()).all(|(x, y)| x == y)
|
||||
}
|
||||
}
|
||||
|
||||
// Use memcmp for bytewise equality when the types allow
|
||||
impl<A, B> SlicePartialEq<B> for [A]
|
||||
where
|
||||
A: BytewiseEquality<B>,
|
||||
{
|
||||
fn equal(&self, other: &[B]) -> bool {
|
||||
if self.len() != other.len() {
|
||||
return false;
|
||||
}
|
||||
|
||||
// While performance would suffer if `guaranteed_eq` just returned `false`
|
||||
// for all arguments, correctness and return value of this function are not affected.
|
||||
if self.as_ptr().guaranteed_eq(other.as_ptr() as *const A) {
|
||||
return true;
|
||||
}
|
||||
// SAFETY: `self` and `other` are references and are thus guaranteed to be valid.
|
||||
// The two slices have been checked to have the same size above.
|
||||
unsafe {
|
||||
let size = mem::size_of_val(self);
|
||||
memcmp(self.as_ptr() as *const u8, other.as_ptr() as *const u8, size) == 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
// intermediate trait for specialization of slice's PartialOrd
|
||||
trait SlicePartialOrd: Sized {
|
||||
fn partial_compare(left: &[Self], right: &[Self]) -> Option<Ordering>;
|
||||
}
|
||||
|
||||
impl<A: PartialOrd> SlicePartialOrd for A {
|
||||
default fn partial_compare(left: &[A], right: &[A]) -> Option<Ordering> {
|
||||
let l = cmp::min(left.len(), right.len());
|
||||
|
||||
// Slice to the loop iteration range to enable bound check
|
||||
// elimination in the compiler
|
||||
let lhs = &left[..l];
|
||||
let rhs = &right[..l];
|
||||
|
||||
for i in 0..l {
|
||||
match lhs[i].partial_cmp(&rhs[i]) {
|
||||
Some(Ordering::Equal) => (),
|
||||
non_eq => return non_eq,
|
||||
}
|
||||
}
|
||||
|
||||
left.len().partial_cmp(&right.len())
|
||||
}
|
||||
}
|
||||
|
||||
// This is the impl that we would like to have. Unfortunately it's not sound.
|
||||
// See `partial_ord_slice.rs`.
|
||||
/*
|
||||
impl<A> SlicePartialOrd for A
|
||||
where
|
||||
A: Ord,
|
||||
{
|
||||
default fn partial_compare(left: &[A], right: &[A]) -> Option<Ordering> {
|
||||
Some(SliceOrd::compare(left, right))
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
impl<A: AlwaysApplicableOrd> SlicePartialOrd for A {
|
||||
fn partial_compare(left: &[A], right: &[A]) -> Option<Ordering> {
|
||||
Some(SliceOrd::compare(left, right))
|
||||
}
|
||||
}
|
||||
|
||||
#[rustc_specialization_trait]
|
||||
trait AlwaysApplicableOrd: SliceOrd + Ord {}
|
||||
|
||||
macro_rules! always_applicable_ord {
|
||||
($([$($p:tt)*] $t:ty,)*) => {
|
||||
$(impl<$($p)*> AlwaysApplicableOrd for $t {})*
|
||||
}
|
||||
}
|
||||
|
||||
always_applicable_ord! {
|
||||
[] u8, [] u16, [] u32, [] u64, [] u128, [] usize,
|
||||
[] i8, [] i16, [] i32, [] i64, [] i128, [] isize,
|
||||
[] bool, [] char,
|
||||
[T: ?Sized] *const T, [T: ?Sized] *mut T,
|
||||
[T: AlwaysApplicableOrd] &T,
|
||||
[T: AlwaysApplicableOrd] &mut T,
|
||||
[T: AlwaysApplicableOrd] Option<T>,
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
// intermediate trait for specialization of slice's Ord
|
||||
trait SliceOrd: Sized {
|
||||
fn compare(left: &[Self], right: &[Self]) -> Ordering;
|
||||
}
|
||||
|
||||
impl<A: Ord> SliceOrd for A {
|
||||
default fn compare(left: &[Self], right: &[Self]) -> Ordering {
|
||||
let l = cmp::min(left.len(), right.len());
|
||||
|
||||
// Slice to the loop iteration range to enable bound check
|
||||
// elimination in the compiler
|
||||
let lhs = &left[..l];
|
||||
let rhs = &right[..l];
|
||||
|
||||
for i in 0..l {
|
||||
match lhs[i].cmp(&rhs[i]) {
|
||||
Ordering::Equal => (),
|
||||
non_eq => return non_eq,
|
||||
}
|
||||
}
|
||||
|
||||
left.len().cmp(&right.len())
|
||||
}
|
||||
}
|
||||
|
||||
// memcmp compares a sequence of unsigned bytes lexicographically.
|
||||
// this matches the order we want for [u8], but no others (not even [i8]).
|
||||
impl SliceOrd for u8 {
|
||||
#[inline]
|
||||
fn compare(left: &[Self], right: &[Self]) -> Ordering {
|
||||
let order =
|
||||
// SAFETY: `left` and `right` are references and are thus guaranteed to be valid.
|
||||
// We use the minimum of both lengths which guarantees that both regions are
|
||||
// valid for reads in that interval.
|
||||
unsafe { memcmp(left.as_ptr(), right.as_ptr(), cmp::min(left.len(), right.len())) };
|
||||
if order == 0 {
|
||||
left.len().cmp(&right.len())
|
||||
} else if order < 0 {
|
||||
Less
|
||||
} else {
|
||||
Greater
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Hack to allow specializing on `Eq` even though `Eq` has a method.
|
||||
#[rustc_unsafe_specialization_marker]
|
||||
trait MarkerEq<T>: PartialEq<T> {}
|
||||
|
||||
impl<T: Eq> MarkerEq<T> for T {}
|
||||
|
||||
#[doc(hidden)]
|
||||
/// Trait implemented for types that can be compared for equality using
|
||||
/// their bytewise representation
|
||||
#[rustc_specialization_trait]
|
||||
trait BytewiseEquality<T>: MarkerEq<T> + Copy {}
|
||||
|
||||
macro_rules! impl_marker_for {
|
||||
($traitname:ident, $($ty:ty)*) => {
|
||||
$(
|
||||
impl $traitname<$ty> for $ty { }
|
||||
)*
|
||||
}
|
||||
}
|
||||
|
||||
impl_marker_for!(BytewiseEquality,
|
||||
u8 i8 u16 i16 u32 i32 u64 i64 u128 i128 usize isize char bool);
|
||||
|
||||
trait SliceContains: Sized {
|
||||
fn slice_contains(&self, x: &[Self]) -> bool;
|
||||
}
|
||||
|
||||
impl<T> SliceContains for T
|
||||
where
|
||||
T: PartialEq,
|
||||
{
|
||||
default fn slice_contains(&self, x: &[Self]) -> bool {
|
||||
x.iter().any(|y| *y == *self)
|
||||
}
|
||||
}
|
||||
|
||||
impl SliceContains for u8 {
|
||||
fn slice_contains(&self, x: &[Self]) -> bool {
|
||||
memchr::memchr(*self, x).is_some()
|
||||
}
|
||||
}
|
||||
|
||||
impl SliceContains for i8 {
|
||||
fn slice_contains(&self, x: &[Self]) -> bool {
|
||||
let byte = *self as u8;
|
||||
// SAFETY: `i8` and `u8` have the same memory layout, thus casting `x.as_ptr()`
|
||||
// as `*const u8` is safe. The `x.as_ptr()` comes from a reference and is thus guaranteed
|
||||
// to be valid for reads for the length of the slice `x.len()`, which cannot be larger
|
||||
// than `isize::MAX`. The returned slice is never mutated.
|
||||
let bytes: &[u8] = unsafe { from_raw_parts(x.as_ptr() as *const u8, x.len()) };
|
||||
memchr::memchr(byte, bytes).is_some()
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user