diff options
Diffstat (limited to 'vendor/tinyvec/src/slicevec.rs')
| -rw-r--r-- | vendor/tinyvec/src/slicevec.rs | 1080 |
1 files changed, 1080 insertions, 0 deletions
diff --git a/vendor/tinyvec/src/slicevec.rs b/vendor/tinyvec/src/slicevec.rs new file mode 100644 index 000000000..11664e1e9 --- /dev/null +++ b/vendor/tinyvec/src/slicevec.rs @@ -0,0 +1,1080 @@ +#![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 = 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 = 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 _ = 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] = replace(&mut self.data, &mut []);
+ 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);
+ /// ```
+ #[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[..]);
+ /// ```
+ 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);
+ /// ```
+ 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 = 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() {
+ 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() {
+ 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, "]")
+ }
+}
|