1#![allow(unused_variables)]
2#![allow(missing_docs)]
3
4use super::*;
5
6/// A slice-backed vector-like data structure.
7///
8/// This is a very similar concept to `ArrayVec`, but instead
9/// of the backing memory being an owned array, the backing
10/// memory is a unique-borrowed slice. You can thus create
11/// one of these structures "around" some slice that you're
12/// working with to make it easier to manipulate.
13///
14/// * Has a fixed capacity (the initial slice size).
15/// * Has a variable length.
16pub struct SliceVec<'s, T> {
17 data: &'s mut [T],
18 len: usize,
19}
20
21impl<'s, T> Default for SliceVec<'s, T> {
22 #[inline(always)]
23 #[must_use]
24 fn default() -> Self {
25 Self { data: &mut [], len: 0 }
26 }
27}
28
29impl<'s, T> Deref for SliceVec<'s, T> {
30 type Target = [T];
31 #[inline(always)]
32 #[must_use]
33 fn deref(&self) -> &Self::Target {
34 &self.data[..self.len]
35 }
36}
37
38impl<'s, T> DerefMut for SliceVec<'s, T> {
39 #[inline(always)]
40 #[must_use]
41 fn deref_mut(&mut self) -> &mut Self::Target {
42 &mut self.data[..self.len]
43 }
44}
45
46impl<'s, T, I> Index<I> for SliceVec<'s, T>
47where
48 I: SliceIndex<[T]>,
49{
50 type Output = <I as SliceIndex<[T]>>::Output;
51 #[inline(always)]
52 #[must_use]
53 fn index(&self, index: I) -> &Self::Output {
54 &self.deref()[index]
55 }
56}
57
58impl<'s, T, I> IndexMut<I> for SliceVec<'s, T>
59where
60 I: SliceIndex<[T]>,
61{
62 #[inline(always)]
63 #[must_use]
64 fn index_mut(&mut self, index: I) -> &mut Self::Output {
65 &mut self.deref_mut()[index]
66 }
67}
68
69impl<'s, T> SliceVec<'s, T> {
70 #[inline]
71 pub fn append(&mut self, other: &mut Self)
72 where
73 T: Default,
74 {
75 for item in other.drain(..) {
76 self.push(item)
77 }
78 }
79
80 /// A `*mut` pointer to the backing slice.
81 ///
82 /// ## Safety
83 ///
84 /// This pointer has provenance over the _entire_ backing slice.
85 #[inline(always)]
86 #[must_use]
87 pub fn as_mut_ptr(&mut self) -> *mut T {
88 self.data.as_mut_ptr()
89 }
90
91 /// Performs a `deref_mut`, into unique slice form.
92 #[inline(always)]
93 #[must_use]
94 pub fn as_mut_slice(&mut self) -> &mut [T] {
95 self.deref_mut()
96 }
97
98 /// A `*const` pointer to the backing slice.
99 ///
100 /// ## Safety
101 ///
102 /// This pointer has provenance over the _entire_ backing slice.
103 #[inline(always)]
104 #[must_use]
105 pub fn as_ptr(&self) -> *const T {
106 self.data.as_ptr()
107 }
108
109 /// Performs a `deref`, into shared slice form.
110 #[inline(always)]
111 #[must_use]
112 pub fn as_slice(&self) -> &[T] {
113 self.deref()
114 }
115
116 /// The capacity of the `SliceVec`.
117 ///
118 /// This the length of the initial backing slice.
119 #[inline(always)]
120 #[must_use]
121 pub fn capacity(&self) -> usize {
122 self.data.len()
123 }
124
125 /// Truncates the `SliceVec` down to length 0.
126 #[inline(always)]
127 pub fn clear(&mut self)
128 where
129 T: Default,
130 {
131 self.truncate(0)
132 }
133
134 /// Creates a draining iterator that removes the specified range in the vector
135 /// and yields the removed items.
136 ///
137 /// ## Panics
138 /// * If the start is greater than the end
139 /// * If the end is past the edge of the vec.
140 ///
141 /// ## Example
142 /// ```rust
143 /// # use tinyvec::*;
144 /// let mut arr = [6, 7, 8];
145 /// let mut sv = SliceVec::from(&mut arr);
146 /// let drained_values: ArrayVec<[i32; 4]> = sv.drain(1..).collect();
147 /// assert_eq!(sv.as_slice(), &[6][..]);
148 /// assert_eq!(drained_values.as_slice(), &[7, 8][..]);
149 ///
150 /// sv.drain(..);
151 /// assert_eq!(sv.as_slice(), &[]);
152 /// ```
153 #[inline]
154 pub fn drain<'p, R: RangeBounds<usize>>(
155 &'p mut self, range: R,
156 ) -> SliceVecDrain<'p, 's, T>
157 where
158 T: Default,
159 {
160 use core::ops::Bound;
161 let start = match range.start_bound() {
162 Bound::Included(x) => *x,
163 Bound::Excluded(x) => x.saturating_add(1),
164 Bound::Unbounded => 0,
165 };
166 let end = match range.end_bound() {
167 Bound::Included(x) => x.saturating_add(1),
168 Bound::Excluded(x) => *x,
169 Bound::Unbounded => self.len,
170 };
171 assert!(
172 start <= end,
173 "SliceVec::drain> Illegal range, {} to {}",
174 start,
175 end
176 );
177 assert!(
178 end <= self.len,
179 "SliceVec::drain> Range ends at {} but length is only {}!",
180 end,
181 self.len
182 );
183 SliceVecDrain {
184 parent: self,
185 target_start: start,
186 target_index: start,
187 target_end: end,
188 }
189 }
190
191 #[inline]
192 pub fn extend_from_slice(&mut self, sli: &[T])
193 where
194 T: Clone,
195 {
196 if sli.is_empty() {
197 return;
198 }
199
200 let new_len = self.len + sli.len();
201 if new_len > self.capacity() {
202 panic!(
203 "SliceVec::extend_from_slice> total length {} exceeds capacity {}",
204 new_len,
205 self.capacity()
206 )
207 }
208
209 let target = &mut self.data[self.len..new_len];
210 target.clone_from_slice(sli);
211 self.set_len(new_len);
212 }
213
214 /// Fill the vector until its capacity has been reached.
215 ///
216 /// Successively fills unused space in the spare slice of the vector with
217 /// elements from the iterator. It then returns the remaining iterator
218 /// without exhausting it. This also allows appending the head of an
219 /// infinite iterator.
220 ///
221 /// This is an alternative to `Extend::extend` method for cases where the
222 /// length of the iterator can not be checked. Since this vector can not
223 /// reallocate to increase its capacity, it is unclear what to do with
224 /// remaining elements in the iterator and the iterator itself. The
225 /// interface also provides no way to communicate this to the caller.
226 ///
227 /// ## Panics
228 /// * If the `next` method of the provided iterator panics.
229 ///
230 /// ## Example
231 ///
232 /// ```rust
233 /// # use tinyvec::*;
234 /// let mut arr = [7, 7, 7, 7];
235 /// let mut sv = SliceVec::from_slice_len(&mut arr, 0);
236 /// let mut to_inf = sv.fill(0..);
237 /// assert_eq!(&sv[..], [0, 1, 2, 3]);
238 /// assert_eq!(to_inf.next(), Some(4));
239 /// ```
240 #[inline]
241 pub fn fill<I: IntoIterator<Item = T>>(&mut self, iter: I) -> I::IntoIter {
242 let mut iter = iter.into_iter();
243 for element in iter.by_ref().take(self.capacity() - self.len()) {
244 self.push(element);
245 }
246 iter
247 }
248
249 /// Wraps up a slice and uses the given length as the initial length.
250 ///
251 /// If you want to simply use the full slice, use `from` instead.
252 ///
253 /// ## Panics
254 ///
255 /// * The length specified must be less than or equal to the capacity of the
256 /// slice.
257 #[inline]
258 #[must_use]
259 #[allow(clippy::match_wild_err_arm)]
260 pub fn from_slice_len(data: &'s mut [T], len: usize) -> Self {
261 assert!(len <= data.len());
262 Self { data, len }
263 }
264
265 /// Inserts an item at the position given, moving all following elements +1
266 /// index.
267 ///
268 /// ## Panics
269 /// * If `index` > `len`
270 /// * If the capacity is exhausted
271 ///
272 /// ## Example
273 /// ```rust
274 /// # use tinyvec::*;
275 /// let mut arr = [1, 2, 3, 0, 0];
276 /// let mut sv = SliceVec::from_slice_len(&mut arr, 3);
277 /// sv.insert(1, 4);
278 /// assert_eq!(sv.as_slice(), &[1, 4, 2, 3]);
279 /// sv.insert(4, 5);
280 /// assert_eq!(sv.as_slice(), &[1, 4, 2, 3, 5]);
281 /// ```
282 #[inline]
283 pub fn insert(&mut self, index: usize, item: T) {
284 if index > self.len {
285 panic!("SliceVec::insert> index {} is out of bounds {}", index, self.len);
286 }
287
288 // Try to push the element.
289 self.push(item);
290 // And move it into its place.
291 self.as_mut_slice()[index..].rotate_right(1);
292 }
293
294 /// Checks if the length is 0.
295 #[inline(always)]
296 #[must_use]
297 pub fn is_empty(&self) -> bool {
298 self.len == 0
299 }
300
301 /// The length of the `SliceVec` (in elements).
302 #[inline(always)]
303 #[must_use]
304 pub fn len(&self) -> usize {
305 self.len
306 }
307
308 /// Remove and return the last element of the vec, if there is one.
309 ///
310 /// ## Failure
311 /// * If the vec is empty you get `None`.
312 ///
313 /// ## Example
314 /// ```rust
315 /// # use tinyvec::*;
316 /// let mut arr = [1, 2];
317 /// let mut sv = SliceVec::from(&mut arr);
318 /// assert_eq!(sv.pop(), Some(2));
319 /// assert_eq!(sv.pop(), Some(1));
320 /// assert_eq!(sv.pop(), None);
321 /// ```
322 #[inline]
323 pub fn pop(&mut self) -> Option<T>
324 where
325 T: Default,
326 {
327 if self.len > 0 {
328 self.len -= 1;
329 let out = take(&mut self.data[self.len]);
330 Some(out)
331 } else {
332 None
333 }
334 }
335
336 /// Place an element onto the end of the vec.
337 ///
338 /// ## Panics
339 /// * If the length of the vec would overflow the capacity.
340 ///
341 /// ## Example
342 /// ```rust
343 /// # use tinyvec::*;
344 /// let mut arr = [0, 0];
345 /// let mut sv = SliceVec::from_slice_len(&mut arr, 0);
346 /// assert_eq!(&sv[..], []);
347 /// sv.push(1);
348 /// assert_eq!(&sv[..], [1]);
349 /// sv.push(2);
350 /// assert_eq!(&sv[..], [1, 2]);
351 /// // sv.push(3); this would overflow the ArrayVec and panic!
352 /// ```
353 #[inline(always)]
354 pub fn push(&mut self, val: T) {
355 if self.len < self.capacity() {
356 self.data[self.len] = val;
357 self.len += 1;
358 } else {
359 panic!("SliceVec::push> capacity overflow")
360 }
361 }
362
363 /// Removes the item at `index`, shifting all others down by one index.
364 ///
365 /// Returns the removed element.
366 ///
367 /// ## Panics
368 ///
369 /// * If the index is out of bounds.
370 ///
371 /// ## Example
372 ///
373 /// ```rust
374 /// # use tinyvec::*;
375 /// let mut arr = [1, 2, 3];
376 /// let mut sv = SliceVec::from(&mut arr);
377 /// assert_eq!(sv.remove(1), 2);
378 /// assert_eq!(&sv[..], [1, 3]);
379 /// ```
380 #[inline]
381 pub fn remove(&mut self, index: usize) -> T
382 where
383 T: Default,
384 {
385 let targets: &mut [T] = &mut self.deref_mut()[index..];
386 let item = take(&mut targets[0]);
387 targets.rotate_left(1);
388 self.len -= 1;
389 item
390 }
391
392 /// As [`resize_with`](SliceVec::resize_with)
393 /// and it clones the value as the closure.
394 ///
395 /// ## Example
396 ///
397 /// ```rust
398 /// # use tinyvec::*;
399 /// // bigger
400 /// let mut arr = ["hello", "", "", "", ""];
401 /// let mut sv = SliceVec::from_slice_len(&mut arr, 1);
402 /// sv.resize(3, "world");
403 /// assert_eq!(&sv[..], ["hello", "world", "world"]);
404 ///
405 /// // smaller
406 /// let mut arr = ['a', 'b', 'c', 'd'];
407 /// let mut sv = SliceVec::from(&mut arr);
408 /// sv.resize(2, 'z');
409 /// assert_eq!(&sv[..], ['a', 'b']);
410 /// ```
411 #[inline]
412 pub fn resize(&mut self, new_len: usize, new_val: T)
413 where
414 T: Clone,
415 {
416 self.resize_with(new_len, || new_val.clone())
417 }
418
419 /// Resize the vec to the new length.
420 ///
421 /// * If it needs to be longer, it's filled with repeated calls to the
422 /// provided function.
423 /// * If it needs to be shorter, it's truncated.
424 /// * If the type needs to drop the truncated slots are filled with calls to
425 /// the provided function.
426 ///
427 /// ## Example
428 ///
429 /// ```rust
430 /// # use tinyvec::*;
431 /// let mut arr = [1, 2, 3, 7, 7, 7, 7];
432 /// let mut sv = SliceVec::from_slice_len(&mut arr, 3);
433 /// sv.resize_with(5, Default::default);
434 /// assert_eq!(&sv[..], [1, 2, 3, 0, 0]);
435 ///
436 /// let mut arr = [0, 0, 0, 0];
437 /// let mut sv = SliceVec::from_slice_len(&mut arr, 0);
438 /// let mut p = 1;
439 /// sv.resize_with(4, || {
440 /// p *= 2;
441 /// p
442 /// });
443 /// assert_eq!(&sv[..], [2, 4, 8, 16]);
444 /// ```
445 #[inline]
446 pub fn resize_with<F: FnMut() -> T>(&mut self, new_len: usize, mut f: F) {
447 match new_len.checked_sub(self.len) {
448 None => {
449 if needs_drop::<T>() {
450 while self.len() > new_len {
451 self.len -= 1;
452 self.data[self.len] = f();
453 }
454 } else {
455 self.len = new_len;
456 }
457 }
458 Some(new_elements) => {
459 for _ in 0..new_elements {
460 self.push(f());
461 }
462 }
463 }
464 }
465
466 /// Walk the vec and keep only the elements that pass the predicate given.
467 ///
468 /// ## Example
469 ///
470 /// ```rust
471 /// # use tinyvec::*;
472 ///
473 /// let mut arr = [1, 1, 2, 3, 3, 4];
474 /// let mut sv = SliceVec::from(&mut arr);
475 /// sv.retain(|&x| x % 2 == 0);
476 /// assert_eq!(&sv[..], [2, 4]);
477 /// ```
478 #[inline]
479 pub fn retain<F: FnMut(&T) -> bool>(&mut self, mut acceptable: F)
480 where
481 T: Default,
482 {
483 // Drop guard to contain exactly the remaining elements when the test
484 // panics.
485 struct JoinOnDrop<'vec, Item> {
486 items: &'vec mut [Item],
487 done_end: usize,
488 // Start of tail relative to `done_end`.
489 tail_start: usize,
490 }
491
492 impl<Item> Drop for JoinOnDrop<'_, Item> {
493 fn drop(&mut self) {
494 self.items[self.done_end..].rotate_left(self.tail_start);
495 }
496 }
497
498 let mut rest = JoinOnDrop { items: self.data, done_end: 0, tail_start: 0 };
499
500 for idx in 0..self.len {
501 // Loop start invariant: idx = rest.done_end + rest.tail_start
502 if !acceptable(&rest.items[idx]) {
503 let _ = take(&mut rest.items[idx]);
504 self.len -= 1;
505 rest.tail_start += 1;
506 } else {
507 rest.items.swap(rest.done_end, idx);
508 rest.done_end += 1;
509 }
510 }
511 }
512
513 /// Forces the length of the vector to `new_len`.
514 ///
515 /// ## Panics
516 /// * If `new_len` is greater than the vec's capacity.
517 ///
518 /// ## Safety
519 /// * This is a fully safe operation! The inactive memory already counts as
520 /// "initialized" by Rust's rules.
521 /// * Other than "the memory is initialized" there are no other guarantees
522 /// regarding what you find in the inactive portion of the vec.
523 #[inline(always)]
524 pub fn set_len(&mut self, new_len: usize) {
525 if new_len > self.capacity() {
526 // Note(Lokathor): Technically we don't have to panic here, and we could
527 // just let some other call later on trigger a panic on accident when the
528 // length is wrong. However, it's a lot easier to catch bugs when things
529 // are more "fail-fast".
530 panic!(
531 "SliceVec::set_len> new length {} exceeds capacity {}",
532 new_len,
533 self.capacity()
534 )
535 } else {
536 self.len = new_len;
537 }
538 }
539
540 /// Splits the collection at the point given.
541 ///
542 /// * `[0, at)` stays in this vec (and this vec is now full).
543 /// * `[at, len)` ends up in the new vec (with any spare capacity).
544 ///
545 /// ## Panics
546 /// * if `at` > `self.len()`
547 ///
548 /// ## Example
549 ///
550 /// ```rust
551 /// # use tinyvec::*;
552 /// let mut arr = [1, 2, 3];
553 /// let mut sv = SliceVec::from(&mut arr);
554 /// let sv2 = sv.split_off(1);
555 /// assert_eq!(&sv[..], [1]);
556 /// assert_eq!(&sv2[..], [2, 3]);
557 /// ```
558 #[inline]
559 pub fn split_off<'a>(&'a mut self, at: usize) -> SliceVec<'s, T> {
560 let mut new = Self::default();
561 let backing: &'s mut [T] = replace(&mut self.data, &mut []);
562 let (me, other) = backing.split_at_mut(at);
563 new.len = self.len - at;
564 new.data = other;
565 self.len = me.len();
566 self.data = me;
567 new
568 }
569
570 /// Remove an element, swapping the end of the vec into its place.
571 ///
572 /// ## Panics
573 /// * If the index is out of bounds.
574 ///
575 /// ## Example
576 /// ```rust
577 /// # use tinyvec::*;
578 /// let mut arr = ["foo", "bar", "quack", "zap"];
579 /// let mut sv = SliceVec::from(&mut arr);
580 ///
581 /// assert_eq!(sv.swap_remove(1), "bar");
582 /// assert_eq!(&sv[..], ["foo", "zap", "quack"]);
583 ///
584 /// assert_eq!(sv.swap_remove(0), "foo");
585 /// assert_eq!(&sv[..], ["quack", "zap"]);
586 /// ```
587 #[inline]
588 pub fn swap_remove(&mut self, index: usize) -> T
589 where
590 T: Default,
591 {
592 assert!(
593 index < self.len,
594 "SliceVec::swap_remove> index {} is out of bounds {}",
595 index,
596 self.len
597 );
598 if index == self.len - 1 {
599 self.pop().unwrap()
600 } else {
601 let i = self.pop().unwrap();
602 replace(&mut self[index], i)
603 }
604 }
605
606 /// Reduces the vec's length to the given value.
607 ///
608 /// If the vec is already shorter than the input, nothing happens.
609 #[inline]
610 pub fn truncate(&mut self, new_len: usize)
611 where
612 T: Default,
613 {
614 if needs_drop::<T>() {
615 while self.len > new_len {
616 self.pop();
617 }
618 } else {
619 self.len = self.len.min(new_len);
620 }
621 }
622
623 /// Wraps a slice, using the given length as the starting length.
624 ///
625 /// If you want to use the whole length of the slice, you can just use the
626 /// `From` impl.
627 ///
628 /// ## Failure
629 ///
630 /// If the given length is greater than the length of the slice you get
631 /// `None`.
632 #[inline]
633 pub fn try_from_slice_len(data: &'s mut [T], len: usize) -> Option<Self> {
634 if len <= data.len() {
635 Some(Self { data, len })
636 } else {
637 None
638 }
639 }
640}
641
642#[cfg(feature = "grab_spare_slice")]
643impl<'s, T> SliceVec<'s, T> {
644 /// Obtain the shared slice of the array _after_ the active memory.
645 ///
646 /// ## Example
647 /// ```rust
648 /// # use tinyvec::*;
649 /// let mut arr = [0; 4];
650 /// let mut sv = SliceVec::from_slice_len(&mut arr, 0);
651 /// assert_eq!(sv.grab_spare_slice().len(), 4);
652 /// sv.push(10);
653 /// sv.push(11);
654 /// sv.push(12);
655 /// sv.push(13);
656 /// assert_eq!(sv.grab_spare_slice().len(), 0);
657 /// ```
658 #[inline(always)]
659 pub fn grab_spare_slice(&self) -> &[T] {
660 &self.data[self.len..]
661 }
662
663 /// Obtain the mutable slice of the array _after_ the active memory.
664 ///
665 /// ## Example
666 /// ```rust
667 /// # use tinyvec::*;
668 /// let mut arr = [0; 4];
669 /// let mut sv = SliceVec::from_slice_len(&mut arr, 0);
670 /// assert_eq!(sv.grab_spare_slice_mut().len(), 4);
671 /// sv.push(10);
672 /// sv.push(11);
673 /// assert_eq!(sv.grab_spare_slice_mut().len(), 2);
674 /// ```
675 #[inline(always)]
676 pub fn grab_spare_slice_mut(&mut self) -> &mut [T] {
677 &mut self.data[self.len..]
678 }
679}
680
681impl<'s, T> From<&'s mut [T]> for SliceVec<'s, T> {
682 /// Uses the full slice as the initial length.
683 /// ## Example
684 /// ```rust
685 /// # use tinyvec::*;
686 /// let mut arr = [0_i32; 2];
687 /// let mut sv = SliceVec::from(&mut arr[..]);
688 /// ```
689 fn from(data: &'s mut [T]) -> Self {
690 let len: usize = data.len();
691 Self { data, len }
692 }
693}
694
695impl<'s, T, A> From<&'s mut A> for SliceVec<'s, T>
696where
697 A: AsMut<[T]>,
698{
699 /// Calls `AsRef::as_mut` then uses the full slice as the initial length.
700 /// ## Example
701 /// ```rust
702 /// # use tinyvec::*;
703 /// let mut arr = [0, 0];
704 /// let mut sv = SliceVec::from(&mut arr);
705 /// ```
706 fn from(a: &'s mut A) -> Self {
707 let data: &mut [T] = a.as_mut();
708 let len: usize = data.len();
709 Self { data, len }
710 }
711}
712
713/// Draining iterator for [`SliceVec`]
714///
715/// See [`SliceVec::drain`](SliceVec::drain)
716pub struct SliceVecDrain<'p, 's, T: Default> {
717 parent: &'p mut SliceVec<'s, T>,
718 target_start: usize,
719 target_index: usize,
720 target_end: usize,
721}
722impl<'p, 's, T: Default> Iterator for SliceVecDrain<'p, 's, T> {
723 type Item = T;
724 #[inline]
725 fn next(&mut self) -> Option<Self::Item> {
726 if self.target_index != self.target_end {
727 let out: T = take(&mut self.parent[self.target_index]);
728 self.target_index += 1;
729 Some(out)
730 } else {
731 None
732 }
733 }
734}
735impl<'p, 's, T: Default> FusedIterator for SliceVecDrain<'p, 's, T> {}
736impl<'p, 's, T: Default> Drop for SliceVecDrain<'p, 's, T> {
737 #[inline]
738 fn drop(&mut self) {
739 // Changed because it was moving `self`, it's also more clear and the std
740 // does the same
741 self.for_each(drop);
742 // Implementation very similar to [`SliceVec::remove`](SliceVec::remove)
743 let count: usize = self.target_end - self.target_start;
744 let targets: &mut [T] = &mut self.parent.deref_mut()[self.target_start..];
745 targets.rotate_left(mid:count);
746 self.parent.len -= count;
747 }
748}
749
750impl<'s, T> AsMut<[T]> for SliceVec<'s, T> {
751 #[inline(always)]
752 #[must_use]
753 fn as_mut(&mut self) -> &mut [T] {
754 &mut *self
755 }
756}
757
758impl<'s, T> AsRef<[T]> for SliceVec<'s, T> {
759 #[inline(always)]
760 #[must_use]
761 fn as_ref(&self) -> &[T] {
762 &*self
763 }
764}
765
766impl<'s, T> Borrow<[T]> for SliceVec<'s, T> {
767 #[inline(always)]
768 #[must_use]
769 fn borrow(&self) -> &[T] {
770 &*self
771 }
772}
773
774impl<'s, T> BorrowMut<[T]> for SliceVec<'s, T> {
775 #[inline(always)]
776 #[must_use]
777 fn borrow_mut(&mut self) -> &mut [T] {
778 &mut *self
779 }
780}
781
782impl<'s, T> Extend<T> for SliceVec<'s, T> {
783 #[inline]
784 fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
785 for t: T in iter {
786 self.push(val:t)
787 }
788 }
789}
790
791impl<'s, T> IntoIterator for SliceVec<'s, T> {
792 type Item = &'s mut T;
793 type IntoIter = core::slice::IterMut<'s, T>;
794 #[inline(always)]
795 #[must_use]
796 fn into_iter(self) -> Self::IntoIter {
797 self.data.iter_mut()
798 }
799}
800
801impl<'s, T> PartialEq for SliceVec<'s, T>
802where
803 T: PartialEq,
804{
805 #[inline]
806 #[must_use]
807 fn eq(&self, other: &Self) -> bool {
808 self.as_slice().eq(other.as_slice())
809 }
810}
811impl<'s, T> Eq for SliceVec<'s, T> where T: Eq {}
812
813impl<'s, T> PartialOrd for SliceVec<'s, T>
814where
815 T: PartialOrd,
816{
817 #[inline]
818 #[must_use]
819 fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
820 self.as_slice().partial_cmp(other.as_slice())
821 }
822}
823impl<'s, T> Ord for SliceVec<'s, T>
824where
825 T: Ord,
826{
827 #[inline]
828 #[must_use]
829 fn cmp(&self, other: &Self) -> core::cmp::Ordering {
830 self.as_slice().cmp(other.as_slice())
831 }
832}
833
834impl<'s, T> PartialEq<&[T]> for SliceVec<'s, T>
835where
836 T: PartialEq,
837{
838 #[inline]
839 #[must_use]
840 fn eq(&self, other: &&[T]) -> bool {
841 self.as_slice().eq(*other)
842 }
843}
844
845impl<'s, T> Hash for SliceVec<'s, T>
846where
847 T: Hash,
848{
849 #[inline]
850 fn hash<H: Hasher>(&self, state: &mut H) {
851 self.as_slice().hash(state)
852 }
853}
854
855#[cfg(feature = "experimental_write_impl")]
856impl<'s> core::fmt::Write for SliceVec<'s, u8> {
857 fn write_str(&mut self, s: &str) -> core::fmt::Result {
858 let my_len = self.len();
859 let str_len = s.as_bytes().len();
860 if my_len + str_len <= self.capacity() {
861 let remainder = &mut self.data[my_len..];
862 let target = &mut remainder[..str_len];
863 target.copy_from_slice(s.as_bytes());
864 Ok(())
865 } else {
866 Err(core::fmt::Error)
867 }
868 }
869}
870
871// // // // // // // //
872// Formatting impls
873// // // // // // // //
874
875impl<'s, T> Binary for SliceVec<'s, T>
876where
877 T: Binary,
878{
879 #[allow(clippy::missing_inline_in_public_items)]
880 fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
881 write!(f, "[")?;
882 if f.alternate() {
883 write!(f, "\n ")?;
884 }
885 for (i: usize, elem: &T) in self.iter().enumerate() {
886 if i > 0 {
887 write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;
888 }
889 Binary::fmt(self:elem, f)?;
890 }
891 if f.alternate() {
892 write!(f, ",\n")?;
893 }
894 write!(f, "]")
895 }
896}
897
898impl<'s, T> Debug for SliceVec<'s, T>
899where
900 T: Debug,
901{
902 #[allow(clippy::missing_inline_in_public_items)]
903 fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
904 write!(f, "[")?;
905 if f.alternate() {
906 write!(f, "\n ")?;
907 }
908 for (i: usize, elem: &T) in self.iter().enumerate() {
909 if i > 0 {
910 write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;
911 }
912 Debug::fmt(self:elem, f)?;
913 }
914 if f.alternate() {
915 write!(f, ",\n")?;
916 }
917 write!(f, "]")
918 }
919}
920
921impl<'s, T> Display for SliceVec<'s, T>
922where
923 T: Display,
924{
925 #[allow(clippy::missing_inline_in_public_items)]
926 fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
927 write!(f, "[")?;
928 if f.alternate() {
929 write!(f, "\n ")?;
930 }
931 for (i: usize, elem: &T) in self.iter().enumerate() {
932 if i > 0 {
933 write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;
934 }
935 Display::fmt(self:elem, f)?;
936 }
937 if f.alternate() {
938 write!(f, ",\n")?;
939 }
940 write!(f, "]")
941 }
942}
943
944impl<'s, T> LowerExp for SliceVec<'s, T>
945where
946 T: LowerExp,
947{
948 #[allow(clippy::missing_inline_in_public_items)]
949 fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
950 write!(f, "[")?;
951 if f.alternate() {
952 write!(f, "\n ")?;
953 }
954 for (i: usize, elem: &T) in self.iter().enumerate() {
955 if i > 0 {
956 write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;
957 }
958 LowerExp::fmt(self:elem, f)?;
959 }
960 if f.alternate() {
961 write!(f, ",\n")?;
962 }
963 write!(f, "]")
964 }
965}
966
967impl<'s, T> LowerHex for SliceVec<'s, T>
968where
969 T: LowerHex,
970{
971 #[allow(clippy::missing_inline_in_public_items)]
972 fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
973 write!(f, "[")?;
974 if f.alternate() {
975 write!(f, "\n ")?;
976 }
977 for (i: usize, elem: &T) in self.iter().enumerate() {
978 if i > 0 {
979 write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;
980 }
981 LowerHex::fmt(self:elem, f)?;
982 }
983 if f.alternate() {
984 write!(f, ",\n")?;
985 }
986 write!(f, "]")
987 }
988}
989
990impl<'s, T> Octal for SliceVec<'s, T>
991where
992 T: Octal,
993{
994 #[allow(clippy::missing_inline_in_public_items)]
995 fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
996 write!(f, "[")?;
997 if f.alternate() {
998 write!(f, "\n ")?;
999 }
1000 for (i: usize, elem: &T) in self.iter().enumerate() {
1001 if i > 0 {
1002 write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;
1003 }
1004 Octal::fmt(self:elem, f)?;
1005 }
1006 if f.alternate() {
1007 write!(f, ",\n")?;
1008 }
1009 write!(f, "]")
1010 }
1011}
1012
1013impl<'s, T> Pointer for SliceVec<'s, T>
1014where
1015 T: Pointer,
1016{
1017 #[allow(clippy::missing_inline_in_public_items)]
1018 fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
1019 write!(f, "[")?;
1020 if f.alternate() {
1021 write!(f, "\n ")?;
1022 }
1023 for (i: usize, elem: &T) in self.iter().enumerate() {
1024 if i > 0 {
1025 write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;
1026 }
1027 Pointer::fmt(self:elem, f)?;
1028 }
1029 if f.alternate() {
1030 write!(f, ",\n")?;
1031 }
1032 write!(f, "]")
1033 }
1034}
1035
1036impl<'s, T> UpperExp for SliceVec<'s, T>
1037where
1038 T: UpperExp,
1039{
1040 #[allow(clippy::missing_inline_in_public_items)]
1041 fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
1042 write!(f, "[")?;
1043 if f.alternate() {
1044 write!(f, "\n ")?;
1045 }
1046 for (i: usize, elem: &T) in self.iter().enumerate() {
1047 if i > 0 {
1048 write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;
1049 }
1050 UpperExp::fmt(self:elem, f)?;
1051 }
1052 if f.alternate() {
1053 write!(f, ",\n")?;
1054 }
1055 write!(f, "]")
1056 }
1057}
1058
1059impl<'s, T> UpperHex for SliceVec<'s, T>
1060where
1061 T: UpperHex,
1062{
1063 #[allow(clippy::missing_inline_in_public_items)]
1064 fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
1065 write!(f, "[")?;
1066 if f.alternate() {
1067 write!(f, "\n ")?;
1068 }
1069 for (i: usize, elem: &T) in self.iter().enumerate() {
1070 if i > 0 {
1071 write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;
1072 }
1073 UpperHex::fmt(self:elem, f)?;
1074 }
1075 if f.alternate() {
1076 write!(f, ",\n")?;
1077 }
1078 write!(f, "]")
1079 }
1080}
1081