diff options
Diffstat (limited to 'vendor/tinyvec/src/slicevec.rs')
| -rw-r--r-- | vendor/tinyvec/src/slicevec.rs | 1083 |
1 files changed, 0 insertions, 1083 deletions
diff --git a/vendor/tinyvec/src/slicevec.rs b/vendor/tinyvec/src/slicevec.rs deleted file mode 100644 index c56071f0..00000000 --- a/vendor/tinyvec/src/slicevec.rs +++ /dev/null @@ -1,1083 +0,0 @@ -#![allow(unused_variables)]
-#![allow(missing_docs)]
-
-use super::*;
-
-/// A slice-backed vector-like data structure.
-///
-/// This is a very similar concept to `ArrayVec`, but instead
-/// of the backing memory being an owned array, the backing
-/// memory is a unique-borrowed slice. You can thus create
-/// one of these structures "around" some slice that you're
-/// working with to make it easier to manipulate.
-///
-/// * Has a fixed capacity (the initial slice size).
-/// * Has a variable length.
-pub struct SliceVec<'s, T> {
- data: &'s mut [T],
- len: usize,
-}
-
-impl<'s, T> Default for SliceVec<'s, T> {
- #[inline(always)]
- #[must_use]
- fn default() -> Self {
- Self { data: &mut [], len: 0 }
- }
-}
-
-impl<'s, T> Deref for SliceVec<'s, T> {
- type Target = [T];
- #[inline(always)]
- #[must_use]
- fn deref(&self) -> &Self::Target {
- &self.data[..self.len]
- }
-}
-
-impl<'s, T> DerefMut for SliceVec<'s, T> {
- #[inline(always)]
- #[must_use]
- fn deref_mut(&mut self) -> &mut Self::Target {
- &mut self.data[..self.len]
- }
-}
-
-impl<'s, T, I> Index<I> for SliceVec<'s, T>
-where
- I: SliceIndex<[T]>,
-{
- type Output = <I as SliceIndex<[T]>>::Output;
- #[inline(always)]
- #[must_use]
- fn index(&self, index: I) -> &Self::Output {
- &self.deref()[index]
- }
-}
-
-impl<'s, T, I> IndexMut<I> for SliceVec<'s, T>
-where
- I: SliceIndex<[T]>,
-{
- #[inline(always)]
- #[must_use]
- fn index_mut(&mut self, index: I) -> &mut Self::Output {
- &mut self.deref_mut()[index]
- }
-}
-
-impl<'s, T> SliceVec<'s, T> {
- #[inline]
- pub fn append(&mut self, other: &mut Self)
- where
- T: Default,
- {
- for item in other.drain(..) {
- self.push(item)
- }
- }
-
- /// A `*mut` pointer to the backing slice.
- ///
- /// ## Safety
- ///
- /// This pointer has provenance over the _entire_ backing slice.
- #[inline(always)]
- #[must_use]
- pub fn as_mut_ptr(&mut self) -> *mut T {
- self.data.as_mut_ptr()
- }
-
- /// Performs a `deref_mut`, into unique slice form.
- #[inline(always)]
- #[must_use]
- pub fn as_mut_slice(&mut self) -> &mut [T] {
- self.deref_mut()
- }
-
- /// A `*const` pointer to the backing slice.
- ///
- /// ## Safety
- ///
- /// This pointer has provenance over the _entire_ backing slice.
- #[inline(always)]
- #[must_use]
- pub fn as_ptr(&self) -> *const T {
- self.data.as_ptr()
- }
-
- /// Performs a `deref`, into shared slice form.
- #[inline(always)]
- #[must_use]
- pub fn as_slice(&self) -> &[T] {
- self.deref()
- }
-
- /// The capacity of the `SliceVec`.
- ///
- /// This the length of the initial backing slice.
- #[inline(always)]
- #[must_use]
- pub fn capacity(&self) -> usize {
- self.data.len()
- }
-
- /// Truncates the `SliceVec` down to length 0.
- #[inline(always)]
- pub fn clear(&mut self)
- where
- T: Default,
- {
- self.truncate(0)
- }
-
- /// Creates a draining iterator that removes the specified range in the vector
- /// and yields the removed items.
- ///
- /// ## Panics
- /// * If the start is greater than the end
- /// * If the end is past the edge of the vec.
- ///
- /// ## Example
- /// ```rust
- /// # use tinyvec::*;
- /// let mut arr = [6, 7, 8];
- /// let mut sv = SliceVec::from(&mut arr);
- /// let drained_values: ArrayVec<[i32; 4]> = sv.drain(1..).collect();
- /// assert_eq!(sv.as_slice(), &[6][..]);
- /// assert_eq!(drained_values.as_slice(), &[7, 8][..]);
- ///
- /// sv.drain(..);
- /// assert_eq!(sv.as_slice(), &[]);
- /// ```
- #[inline]
- pub fn drain<'p, R: RangeBounds<usize>>(
- &'p mut self, range: R,
- ) -> SliceVecDrain<'p, 's, T>
- where
- T: Default,
- {
- use core::ops::Bound;
- let start = match range.start_bound() {
- Bound::Included(x) => *x,
- Bound::Excluded(x) => x.saturating_add(1),
- Bound::Unbounded => 0,
- };
- let end = match range.end_bound() {
- Bound::Included(x) => x.saturating_add(1),
- Bound::Excluded(x) => *x,
- Bound::Unbounded => self.len,
- };
- assert!(
- start <= end,
- "SliceVec::drain> Illegal range, {} to {}",
- start,
- end
- );
- assert!(
- end <= self.len,
- "SliceVec::drain> Range ends at {} but length is only {}!",
- end,
- self.len
- );
- SliceVecDrain {
- parent: self,
- target_start: start,
- target_index: start,
- target_end: end,
- }
- }
-
- #[inline]
- pub fn extend_from_slice(&mut self, sli: &[T])
- where
- T: Clone,
- {
- if sli.is_empty() {
- return;
- }
-
- let new_len = self.len + sli.len();
- if new_len > self.capacity() {
- panic!(
- "SliceVec::extend_from_slice> total length {} exceeds capacity {}",
- new_len,
- self.capacity()
- )
- }
-
- let target = &mut self.data[self.len..new_len];
- target.clone_from_slice(sli);
- self.set_len(new_len);
- }
-
- /// Fill the vector until its capacity has been reached.
- ///
- /// Successively fills unused space in the spare slice of the vector with
- /// elements from the iterator. It then returns the remaining iterator
- /// without exhausting it. This also allows appending the head of an
- /// infinite iterator.
- ///
- /// This is an alternative to `Extend::extend` method for cases where the
- /// length of the iterator can not be checked. Since this vector can not
- /// reallocate to increase its capacity, it is unclear what to do with
- /// remaining elements in the iterator and the iterator itself. The
- /// interface also provides no way to communicate this to the caller.
- ///
- /// ## Panics
- /// * If the `next` method of the provided iterator panics.
- ///
- /// ## Example
- ///
- /// ```rust
- /// # use tinyvec::*;
- /// let mut arr = [7, 7, 7, 7];
- /// let mut sv = SliceVec::from_slice_len(&mut arr, 0);
- /// let mut to_inf = sv.fill(0..);
- /// assert_eq!(&sv[..], [0, 1, 2, 3]);
- /// assert_eq!(to_inf.next(), Some(4));
- /// ```
- #[inline]
- pub fn fill<I: IntoIterator<Item = T>>(&mut self, iter: I) -> I::IntoIter {
- let mut iter = iter.into_iter();
- for element in iter.by_ref().take(self.capacity() - self.len()) {
- self.push(element);
- }
- iter
- }
-
- /// Wraps up a slice and uses the given length as the initial length.
- ///
- /// If you want to simply use the full slice, use `from` instead.
- ///
- /// ## Panics
- ///
- /// * The length specified must be less than or equal to the capacity of the
- /// slice.
- #[inline]
- #[must_use]
- #[allow(clippy::match_wild_err_arm)]
- pub fn from_slice_len(data: &'s mut [T], len: usize) -> Self {
- assert!(len <= data.len());
- Self { data, len }
- }
-
- /// Inserts an item at the position given, moving all following elements +1
- /// index.
- ///
- /// ## Panics
- /// * If `index` > `len`
- /// * If the capacity is exhausted
- ///
- /// ## Example
- /// ```rust
- /// # use tinyvec::*;
- /// let mut arr = [1, 2, 3, 0, 0];
- /// let mut sv = SliceVec::from_slice_len(&mut arr, 3);
- /// sv.insert(1, 4);
- /// assert_eq!(sv.as_slice(), &[1, 4, 2, 3]);
- /// sv.insert(4, 5);
- /// assert_eq!(sv.as_slice(), &[1, 4, 2, 3, 5]);
- /// ```
- #[inline]
- pub fn insert(&mut self, index: usize, item: T) {
- if index > self.len {
- panic!("SliceVec::insert> index {} is out of bounds {}", index, self.len);
- }
-
- // Try to push the element.
- self.push(item);
- // And move it into its place.
- self.as_mut_slice()[index..].rotate_right(1);
- }
-
- /// Checks if the length is 0.
- #[inline(always)]
- #[must_use]
- pub fn is_empty(&self) -> bool {
- self.len == 0
- }
-
- /// The length of the `SliceVec` (in elements).
- #[inline(always)]
- #[must_use]
- pub fn len(&self) -> usize {
- self.len
- }
-
- /// Remove and return the last element of the vec, if there is one.
- ///
- /// ## Failure
- /// * If the vec is empty you get `None`.
- ///
- /// ## Example
- /// ```rust
- /// # use tinyvec::*;
- /// let mut arr = [1, 2];
- /// let mut sv = SliceVec::from(&mut arr);
- /// assert_eq!(sv.pop(), Some(2));
- /// assert_eq!(sv.pop(), Some(1));
- /// assert_eq!(sv.pop(), None);
- /// ```
- #[inline]
- pub fn pop(&mut self) -> Option<T>
- where
- T: Default,
- {
- if self.len > 0 {
- self.len -= 1;
- let out = core::mem::take(&mut self.data[self.len]);
- Some(out)
- } else {
- None
- }
- }
-
- /// Place an element onto the end of the vec.
- ///
- /// ## Panics
- /// * If the length of the vec would overflow the capacity.
- ///
- /// ## Example
- /// ```rust
- /// # use tinyvec::*;
- /// let mut arr = [0, 0];
- /// let mut sv = SliceVec::from_slice_len(&mut arr, 0);
- /// assert_eq!(&sv[..], []);
- /// sv.push(1);
- /// assert_eq!(&sv[..], [1]);
- /// sv.push(2);
- /// assert_eq!(&sv[..], [1, 2]);
- /// // sv.push(3); this would overflow the ArrayVec and panic!
- /// ```
- #[inline(always)]
- pub fn push(&mut self, val: T) {
- if self.len < self.capacity() {
- self.data[self.len] = val;
- self.len += 1;
- } else {
- panic!("SliceVec::push> capacity overflow")
- }
- }
-
- /// Removes the item at `index`, shifting all others down by one index.
- ///
- /// Returns the removed element.
- ///
- /// ## Panics
- ///
- /// * If the index is out of bounds.
- ///
- /// ## Example
- ///
- /// ```rust
- /// # use tinyvec::*;
- /// let mut arr = [1, 2, 3];
- /// let mut sv = SliceVec::from(&mut arr);
- /// assert_eq!(sv.remove(1), 2);
- /// assert_eq!(&sv[..], [1, 3]);
- /// ```
- #[inline]
- pub fn remove(&mut self, index: usize) -> T
- where
- T: Default,
- {
- let targets: &mut [T] = &mut self.deref_mut()[index..];
- let item = core::mem::take(&mut targets[0]);
- targets.rotate_left(1);
- self.len -= 1;
- item
- }
-
- /// As [`resize_with`](SliceVec::resize_with)
- /// and it clones the value as the closure.
- ///
- /// ## Example
- ///
- /// ```rust
- /// # use tinyvec::*;
- /// // bigger
- /// let mut arr = ["hello", "", "", "", ""];
- /// let mut sv = SliceVec::from_slice_len(&mut arr, 1);
- /// sv.resize(3, "world");
- /// assert_eq!(&sv[..], ["hello", "world", "world"]);
- ///
- /// // smaller
- /// let mut arr = ['a', 'b', 'c', 'd'];
- /// let mut sv = SliceVec::from(&mut arr);
- /// sv.resize(2, 'z');
- /// assert_eq!(&sv[..], ['a', 'b']);
- /// ```
- #[inline]
- pub fn resize(&mut self, new_len: usize, new_val: T)
- where
- T: Clone,
- {
- self.resize_with(new_len, || new_val.clone())
- }
-
- /// Resize the vec to the new length.
- ///
- /// * If it needs to be longer, it's filled with repeated calls to the
- /// provided function.
- /// * If it needs to be shorter, it's truncated.
- /// * If the type needs to drop the truncated slots are filled with calls to
- /// the provided function.
- ///
- /// ## Example
- ///
- /// ```rust
- /// # use tinyvec::*;
- /// let mut arr = [1, 2, 3, 7, 7, 7, 7];
- /// let mut sv = SliceVec::from_slice_len(&mut arr, 3);
- /// sv.resize_with(5, Default::default);
- /// assert_eq!(&sv[..], [1, 2, 3, 0, 0]);
- ///
- /// let mut arr = [0, 0, 0, 0];
- /// let mut sv = SliceVec::from_slice_len(&mut arr, 0);
- /// let mut p = 1;
- /// sv.resize_with(4, || {
- /// p *= 2;
- /// p
- /// });
- /// assert_eq!(&sv[..], [2, 4, 8, 16]);
- /// ```
- #[inline]
- pub fn resize_with<F: FnMut() -> T>(&mut self, new_len: usize, mut f: F) {
- match new_len.checked_sub(self.len) {
- None => {
- if needs_drop::<T>() {
- while self.len() > new_len {
- self.len -= 1;
- self.data[self.len] = f();
- }
- } else {
- self.len = new_len;
- }
- }
- Some(new_elements) => {
- for _ in 0..new_elements {
- self.push(f());
- }
- }
- }
- }
-
- /// Walk the vec and keep only the elements that pass the predicate given.
- ///
- /// ## Example
- ///
- /// ```rust
- /// # use tinyvec::*;
- ///
- /// let mut arr = [1, 1, 2, 3, 3, 4];
- /// let mut sv = SliceVec::from(&mut arr);
- /// sv.retain(|&x| x % 2 == 0);
- /// assert_eq!(&sv[..], [2, 4]);
- /// ```
- #[inline]
- pub fn retain<F: FnMut(&T) -> bool>(&mut self, mut acceptable: F)
- where
- T: Default,
- {
- // Drop guard to contain exactly the remaining elements when the test
- // panics.
- struct JoinOnDrop<'vec, Item> {
- items: &'vec mut [Item],
- done_end: usize,
- // Start of tail relative to `done_end`.
- tail_start: usize,
- }
-
- impl<Item> Drop for JoinOnDrop<'_, Item> {
- fn drop(&mut self) {
- self.items[self.done_end..].rotate_left(self.tail_start);
- }
- }
-
- let mut rest = JoinOnDrop { items: self.data, done_end: 0, tail_start: 0 };
-
- for idx in 0..self.len {
- // Loop start invariant: idx = rest.done_end + rest.tail_start
- if !acceptable(&rest.items[idx]) {
- let _ = core::mem::take(&mut rest.items[idx]);
- self.len -= 1;
- rest.tail_start += 1;
- } else {
- rest.items.swap(rest.done_end, idx);
- rest.done_end += 1;
- }
- }
- }
-
- /// Forces the length of the vector to `new_len`.
- ///
- /// ## Panics
- /// * If `new_len` is greater than the vec's capacity.
- ///
- /// ## Safety
- /// * This is a fully safe operation! The inactive memory already counts as
- /// "initialized" by Rust's rules.
- /// * Other than "the memory is initialized" there are no other guarantees
- /// regarding what you find in the inactive portion of the vec.
- #[inline(always)]
- pub fn set_len(&mut self, new_len: usize) {
- if new_len > self.capacity() {
- // Note(Lokathor): Technically we don't have to panic here, and we could
- // just let some other call later on trigger a panic on accident when the
- // length is wrong. However, it's a lot easier to catch bugs when things
- // are more "fail-fast".
- panic!(
- "SliceVec::set_len> new length {} exceeds capacity {}",
- new_len,
- self.capacity()
- )
- } else {
- self.len = new_len;
- }
- }
-
- /// Splits the collection at the point given.
- ///
- /// * `[0, at)` stays in this vec (and this vec is now full).
- /// * `[at, len)` ends up in the new vec (with any spare capacity).
- ///
- /// ## Panics
- /// * if `at` > `self.len()`
- ///
- /// ## Example
- ///
- /// ```rust
- /// # use tinyvec::*;
- /// let mut arr = [1, 2, 3];
- /// let mut sv = SliceVec::from(&mut arr);
- /// let sv2 = sv.split_off(1);
- /// assert_eq!(&sv[..], [1]);
- /// assert_eq!(&sv2[..], [2, 3]);
- /// ```
- #[inline]
- pub fn split_off<'a>(&'a mut self, at: usize) -> SliceVec<'s, T> {
- let mut new = Self::default();
- let backing: &'s mut [T] = core::mem::take(&mut self.data);
- let (me, other) = backing.split_at_mut(at);
- new.len = self.len - at;
- new.data = other;
- self.len = me.len();
- self.data = me;
- new
- }
-
- /// Remove an element, swapping the end of the vec into its place.
- ///
- /// ## Panics
- /// * If the index is out of bounds.
- ///
- /// ## Example
- /// ```rust
- /// # use tinyvec::*;
- /// let mut arr = ["foo", "bar", "quack", "zap"];
- /// let mut sv = SliceVec::from(&mut arr);
- ///
- /// assert_eq!(sv.swap_remove(1), "bar");
- /// assert_eq!(&sv[..], ["foo", "zap", "quack"]);
- ///
- /// assert_eq!(sv.swap_remove(0), "foo");
- /// assert_eq!(&sv[..], ["quack", "zap"]);
- /// ```
- #[inline]
- pub fn swap_remove(&mut self, index: usize) -> T
- where
- T: Default,
- {
- assert!(
- index < self.len,
- "SliceVec::swap_remove> index {} is out of bounds {}",
- index,
- self.len
- );
- if index == self.len - 1 {
- self.pop().unwrap()
- } else {
- let i = self.pop().unwrap();
- replace(&mut self[index], i)
- }
- }
-
- /// Reduces the vec's length to the given value.
- ///
- /// If the vec is already shorter than the input, nothing happens.
- #[inline]
- pub fn truncate(&mut self, new_len: usize)
- where
- T: Default,
- {
- if needs_drop::<T>() {
- while self.len > new_len {
- self.pop();
- }
- } else {
- self.len = self.len.min(new_len);
- }
- }
-
- /// Wraps a slice, using the given length as the starting length.
- ///
- /// If you want to use the whole length of the slice, you can just use the
- /// `From` impl.
- ///
- /// ## Failure
- ///
- /// If the given length is greater than the length of the slice you get
- /// `None`.
- #[inline]
- pub fn try_from_slice_len(data: &'s mut [T], len: usize) -> Option<Self> {
- if len <= data.len() {
- Some(Self { data, len })
- } else {
- None
- }
- }
-}
-
-#[cfg(feature = "grab_spare_slice")]
-impl<'s, T> SliceVec<'s, T> {
- /// Obtain the shared slice of the array _after_ the active memory.
- ///
- /// ## Example
- /// ```rust
- /// # use tinyvec::*;
- /// let mut arr = [0; 4];
- /// let mut sv = SliceVec::from_slice_len(&mut arr, 0);
- /// assert_eq!(sv.grab_spare_slice().len(), 4);
- /// sv.push(10);
- /// sv.push(11);
- /// sv.push(12);
- /// sv.push(13);
- /// assert_eq!(sv.grab_spare_slice().len(), 0);
- /// ```
- #[must_use]
- #[inline(always)]
- pub fn grab_spare_slice(&self) -> &[T] {
- &self.data[self.len..]
- }
-
- /// Obtain the mutable slice of the array _after_ the active memory.
- ///
- /// ## Example
- /// ```rust
- /// # use tinyvec::*;
- /// let mut arr = [0; 4];
- /// let mut sv = SliceVec::from_slice_len(&mut arr, 0);
- /// assert_eq!(sv.grab_spare_slice_mut().len(), 4);
- /// sv.push(10);
- /// sv.push(11);
- /// assert_eq!(sv.grab_spare_slice_mut().len(), 2);
- /// ```
- #[inline(always)]
- pub fn grab_spare_slice_mut(&mut self) -> &mut [T] {
- &mut self.data[self.len..]
- }
-}
-
-impl<'s, T> From<&'s mut [T]> for SliceVec<'s, T> {
- /// Uses the full slice as the initial length.
- /// ## Example
- /// ```rust
- /// # use tinyvec::*;
- /// let mut arr = [0_i32; 2];
- /// let mut sv = SliceVec::from(&mut arr[..]);
- /// ```
- #[inline]
- fn from(data: &'s mut [T]) -> Self {
- let len = data.len();
- Self { data, len }
- }
-}
-
-impl<'s, T, A> From<&'s mut A> for SliceVec<'s, T>
-where
- A: AsMut<[T]>,
-{
- /// Calls `AsRef::as_mut` then uses the full slice as the initial length.
- /// ## Example
- /// ```rust
- /// # use tinyvec::*;
- /// let mut arr = [0, 0];
- /// let mut sv = SliceVec::from(&mut arr);
- /// ```
- #[inline]
- fn from(a: &'s mut A) -> Self {
- let data = a.as_mut();
- let len = data.len();
- Self { data, len }
- }
-}
-
-/// Draining iterator for [`SliceVec`]
-///
-/// See [`SliceVec::drain`](SliceVec::drain)
-pub struct SliceVecDrain<'p, 's, T: Default> {
- parent: &'p mut SliceVec<'s, T>,
- target_start: usize,
- target_index: usize,
- target_end: usize,
-}
-impl<'p, 's, T: Default> Iterator for SliceVecDrain<'p, 's, T> {
- type Item = T;
- #[inline]
- fn next(&mut self) -> Option<Self::Item> {
- if self.target_index != self.target_end {
- let out = core::mem::take(&mut self.parent[self.target_index]);
- self.target_index += 1;
- Some(out)
- } else {
- None
- }
- }
-}
-impl<'p, 's, T: Default> FusedIterator for SliceVecDrain<'p, 's, T> {}
-impl<'p, 's, T: Default> Drop for SliceVecDrain<'p, 's, T> {
- #[inline]
- fn drop(&mut self) {
- // Changed because it was moving `self`, it's also more clear and the std
- // does the same
- self.for_each(drop);
- // Implementation very similar to [`SliceVec::remove`](SliceVec::remove)
- let count = self.target_end - self.target_start;
- let targets: &mut [T] = &mut self.parent.deref_mut()[self.target_start..];
- targets.rotate_left(count);
- self.parent.len -= count;
- }
-}
-
-impl<'s, T> AsMut<[T]> for SliceVec<'s, T> {
- #[inline(always)]
- #[must_use]
- fn as_mut(&mut self) -> &mut [T] {
- &mut *self
- }
-}
-
-impl<'s, T> AsRef<[T]> for SliceVec<'s, T> {
- #[inline(always)]
- #[must_use]
- fn as_ref(&self) -> &[T] {
- &*self
- }
-}
-
-impl<'s, T> Borrow<[T]> for SliceVec<'s, T> {
- #[inline(always)]
- #[must_use]
- fn borrow(&self) -> &[T] {
- &*self
- }
-}
-
-impl<'s, T> BorrowMut<[T]> for SliceVec<'s, T> {
- #[inline(always)]
- #[must_use]
- fn borrow_mut(&mut self) -> &mut [T] {
- &mut *self
- }
-}
-
-impl<'s, T> Extend<T> for SliceVec<'s, T> {
- #[inline]
- fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
- for t in iter {
- self.push(t)
- }
- }
-}
-
-impl<'s, T> IntoIterator for SliceVec<'s, T> {
- type Item = &'s mut T;
- type IntoIter = core::slice::IterMut<'s, T>;
- #[inline(always)]
- #[must_use]
- fn into_iter(self) -> Self::IntoIter {
- self.data.iter_mut()
- }
-}
-
-impl<'s, T> PartialEq for SliceVec<'s, T>
-where
- T: PartialEq,
-{
- #[inline]
- #[must_use]
- fn eq(&self, other: &Self) -> bool {
- self.as_slice().eq(other.as_slice())
- }
-}
-impl<'s, T> Eq for SliceVec<'s, T> where T: Eq {}
-
-impl<'s, T> PartialOrd for SliceVec<'s, T>
-where
- T: PartialOrd,
-{
- #[inline]
- #[must_use]
- fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
- self.as_slice().partial_cmp(other.as_slice())
- }
-}
-impl<'s, T> Ord for SliceVec<'s, T>
-where
- T: Ord,
-{
- #[inline]
- #[must_use]
- fn cmp(&self, other: &Self) -> core::cmp::Ordering {
- self.as_slice().cmp(other.as_slice())
- }
-}
-
-impl<'s, T> PartialEq<&[T]> for SliceVec<'s, T>
-where
- T: PartialEq,
-{
- #[inline]
- #[must_use]
- fn eq(&self, other: &&[T]) -> bool {
- self.as_slice().eq(*other)
- }
-}
-
-impl<'s, T> Hash for SliceVec<'s, T>
-where
- T: Hash,
-{
- #[inline]
- fn hash<H: Hasher>(&self, state: &mut H) {
- self.as_slice().hash(state)
- }
-}
-
-#[cfg(feature = "experimental_write_impl")]
-impl<'s> core::fmt::Write for SliceVec<'s, u8> {
- fn write_str(&mut self, s: &str) -> core::fmt::Result {
- let my_len = self.len();
- let str_len = s.as_bytes().len();
- if my_len + str_len <= self.capacity() {
- let remainder = &mut self.data[my_len..];
- let target = &mut remainder[..str_len];
- target.copy_from_slice(s.as_bytes());
- Ok(())
- } else {
- Err(core::fmt::Error)
- }
- }
-}
-
-// // // // // // // //
-// Formatting impls
-// // // // // // // //
-
-impl<'s, T> Binary for SliceVec<'s, T>
-where
- T: Binary,
-{
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
- write!(f, "[")?;
- if f.alternate() {
- write!(f, "\n ")?;
- }
- for (i, elem) in self.iter().enumerate() {
- if i > 0 {
- write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;
- }
- Binary::fmt(elem, f)?;
- }
- if f.alternate() {
- write!(f, ",\n")?;
- }
- write!(f, "]")
- }
-}
-
-impl<'s, T> Debug for SliceVec<'s, T>
-where
- T: Debug,
-{
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
- write!(f, "[")?;
- if f.alternate() && !self.is_empty() {
- write!(f, "\n ")?;
- }
- for (i, elem) in self.iter().enumerate() {
- if i > 0 {
- write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;
- }
- Debug::fmt(elem, f)?;
- }
- if f.alternate() && !self.is_empty() {
- write!(f, ",\n")?;
- }
- write!(f, "]")
- }
-}
-
-impl<'s, T> Display for SliceVec<'s, T>
-where
- T: Display,
-{
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
- write!(f, "[")?;
- if f.alternate() {
- write!(f, "\n ")?;
- }
- for (i, elem) in self.iter().enumerate() {
- if i > 0 {
- write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;
- }
- Display::fmt(elem, f)?;
- }
- if f.alternate() {
- write!(f, ",\n")?;
- }
- write!(f, "]")
- }
-}
-
-impl<'s, T> LowerExp for SliceVec<'s, T>
-where
- T: LowerExp,
-{
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
- write!(f, "[")?;
- if f.alternate() {
- write!(f, "\n ")?;
- }
- for (i, elem) in self.iter().enumerate() {
- if i > 0 {
- write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;
- }
- LowerExp::fmt(elem, f)?;
- }
- if f.alternate() {
- write!(f, ",\n")?;
- }
- write!(f, "]")
- }
-}
-
-impl<'s, T> LowerHex for SliceVec<'s, T>
-where
- T: LowerHex,
-{
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
- write!(f, "[")?;
- if f.alternate() {
- write!(f, "\n ")?;
- }
- for (i, elem) in self.iter().enumerate() {
- if i > 0 {
- write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;
- }
- LowerHex::fmt(elem, f)?;
- }
- if f.alternate() {
- write!(f, ",\n")?;
- }
- write!(f, "]")
- }
-}
-
-impl<'s, T> Octal for SliceVec<'s, T>
-where
- T: Octal,
-{
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
- write!(f, "[")?;
- if f.alternate() {
- write!(f, "\n ")?;
- }
- for (i, elem) in self.iter().enumerate() {
- if i > 0 {
- write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;
- }
- Octal::fmt(elem, f)?;
- }
- if f.alternate() {
- write!(f, ",\n")?;
- }
- write!(f, "]")
- }
-}
-
-impl<'s, T> Pointer for SliceVec<'s, T>
-where
- T: Pointer,
-{
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
- write!(f, "[")?;
- if f.alternate() {
- write!(f, "\n ")?;
- }
- for (i, elem) in self.iter().enumerate() {
- if i > 0 {
- write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;
- }
- Pointer::fmt(elem, f)?;
- }
- if f.alternate() {
- write!(f, ",\n")?;
- }
- write!(f, "]")
- }
-}
-
-impl<'s, T> UpperExp for SliceVec<'s, T>
-where
- T: UpperExp,
-{
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
- write!(f, "[")?;
- if f.alternate() {
- write!(f, "\n ")?;
- }
- for (i, elem) in self.iter().enumerate() {
- if i > 0 {
- write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;
- }
- UpperExp::fmt(elem, f)?;
- }
- if f.alternate() {
- write!(f, ",\n")?;
- }
- write!(f, "]")
- }
-}
-
-impl<'s, T> UpperHex for SliceVec<'s, T>
-where
- T: UpperHex,
-{
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
- write!(f, "[")?;
- if f.alternate() {
- write!(f, "\n ")?;
- }
- for (i, elem) in self.iter().enumerate() {
- if i > 0 {
- write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;
- }
- UpperHex::fmt(elem, f)?;
- }
- if f.alternate() {
- write!(f, ",\n")?;
- }
- write!(f, "]")
- }
-}
|