-use super::*;
-
-/// Helper to make an `ArrayVec`.
-///
-/// You specify the backing array type, and optionally give all the elements you
-/// want to initially place into the array.
-///
-/// As an unfortunate restriction, the backing array type must support `Default`
-/// for it to work with this macro.
-///
-/// ```rust
-/// use tinyvec::*;
-///
-/// // The backing array type can be specified in the macro call
-/// let empty_av = array_vec!([u8; 16]);
-/// let some_ints = array_vec!([i32; 4], 1, 2, 3);
-///
-/// // Or left to inference
-/// let empty_av: ArrayVec<[u8; 10]> = array_vec!();
-/// let some_ints: ArrayVec<[u8; 10]> = array_vec!(5, 6, 7, 8);
-/// ```
-#[macro_export]
-macro_rules! array_vec {
- ($array_type:ty) => {
- {
- let av: $crate::ArrayVec<$array_type> = Default::default();
- av
- }
- };
- ($array_type:ty, $($elem:expr),*) => {
- {
- let mut av: $crate::ArrayVec<$array_type> = Default::default();
- $( av.push($elem); )*
- av
- }
- };
- () => {
- array_vec!(_)
- };
- ($($elem:expr),*) => {
- array_vec!(_, $($elem),*)
- };
-}
-
-/// An array-backed, vector-like data structure.
-///
-/// * `ArrayVec` has a fixed capacity, equal to the array size.
-/// * `ArrayVec` has a variable length, as you add and remove elements. Attempts
-/// to fill the vec beyond its capacity will cause a panic.
-/// * All of the vec's array slots are always initialized in terms of Rust's
-/// memory model. When you remove a element from a location, the old value at
-/// that location is replaced with the type's default value.
-///
-/// The overall API of this type is intended to, as much as possible, emulate
-/// the API of the [`Vec`](https://doc.rust-lang.org/alloc/vec/struct.Vec.html)
-/// type.
-///
-/// ## Construction
-///
-/// If the backing array supports Default (length 32 or less), then you can use
-/// the `array_vec!` macro similarly to how you might use the `vec!` macro.
-/// Specify the array type, then optionally give all the initial values you want
-/// to have.
-/// ```rust
-/// # use tinyvec::*;
-/// let some_ints = array_vec!([i32; 4], 1, 2, 3);
-/// assert_eq!(some_ints.len(), 3);
-/// ```
-///
-/// The [`default`](ArrayVec::new) for an `ArrayVec` is to have a default
-/// array with length 0. The [`new`](ArrayVec::new) method is the same as
-/// calling `default`
-/// ```rust
-/// # use tinyvec::*;
-/// let some_ints = ArrayVec::<[i32; 7]>::default();
-/// assert_eq!(some_ints.len(), 0);
-///
-/// let more_ints = ArrayVec::<[i32; 7]>::new();
-/// assert_eq!(some_ints, more_ints);
-/// ```
-///
-/// If you have an array and want the _whole thing_ so count as being "in" the
-/// new `ArrayVec` you can use one of the `from` implementations. If you want
-/// _part of_ the array then you can use
-/// [`from_array_len`](ArrayVec::from_array_len):
-/// ```rust
-/// # use tinyvec::*;
-/// let some_ints = ArrayVec::from([5, 6, 7, 8]);
-/// assert_eq!(some_ints.len(), 4);
-///
-/// let more_ints = ArrayVec::from_array_len([5, 6, 7, 8], 2);
-/// assert_eq!(more_ints.len(), 2);
-/// ```
-#[repr(C)]
-#[derive(Clone, Copy, Default)]
-pub struct ArrayVec<A: Array> {
- len: usize,
- data: A,
-}
-
-impl<A: Array> Deref for ArrayVec<A> {
- type Target = [A::Item];
- #[inline(always)]
- #[must_use]
- fn deref(&self) -> &Self::Target {
- &self.data.as_slice()[..self.len]
- }
-}
-
-impl<A: Array> DerefMut for ArrayVec<A> {
- #[inline(always)]
- #[must_use]
- fn deref_mut(&mut self) -> &mut Self::Target {
- &mut self.data.as_slice_mut()[..self.len]
- }
-}
-
-impl<A: Array, I: SliceIndex<[A::Item]>> Index<I> for ArrayVec<A> {
- type Output = <I as SliceIndex<[A::Item]>>::Output;
- #[inline(always)]
- #[must_use]
- fn index(&self, index: I) -> &Self::Output {
- &self.deref()[index]
- }
-}
-
-impl<A: Array, I: SliceIndex<[A::Item]>> IndexMut<I> for ArrayVec<A> {
- #[inline(always)]
- #[must_use]
- fn index_mut(&mut self, index: I) -> &mut Self::Output {
- &mut self.deref_mut()[index]
- }
-}
-
-impl<A: Array> ArrayVec<A> {
- /// Move all values from `other` into this vec.
- ///
- /// ## Panics
- /// * If the vec overflows its capacity
- ///
- /// ## Example
- /// ```rust
- /// # use tinyvec::*;
- /// let mut av = array_vec!([i32; 10], 1, 2, 3);
- /// let mut av2 = array_vec!([i32; 10], 4, 5, 6);
- /// av.append(&mut av2);
- /// assert_eq!(av, &[1, 2, 3, 4, 5, 6][..]);
- /// assert_eq!(av2, &[][..]);
- /// ```
- #[inline]
- pub fn append(&mut self, other: &mut Self) {
- for item in other.drain(..) {
- self.push(item)
- }
- }
-
- /// A `*mut` pointer to the backing array.
- ///
- /// ## Safety
- ///
- /// This pointer has provenance over the _entire_ backing array.
- #[inline(always)]
- #[must_use]
- pub fn as_mut_ptr(&mut self) -> *mut A::Item {
- self.data.as_slice_mut().as_mut_ptr()
- }
-
- /// Performs a `deref_mut`, into unique slice form.
- #[inline(always)]
- #[must_use]
- pub fn as_mut_slice(&mut self) -> &mut [A::Item] {
- self.deref_mut()
- }
-
- /// A `*const` pointer to the backing array.
- ///
- /// ## Safety
- ///
- /// This pointer has provenance over the _entire_ backing array.
- #[inline(always)]
- #[must_use]
- pub fn as_ptr(&self) -> *const A::Item {
- self.data.as_slice().as_ptr()
- }
-
- /// Performs a `deref`, into shared slice form.
- #[inline(always)]
- #[must_use]
- pub fn as_slice(&self) -> &[A::Item] {
- self.deref()
- }
-
- /// The capacity of the `ArrayVec`.
- ///
- /// This is fixed based on the array type, but can't yet be made a `const fn`
- /// on Stable Rust.
- #[inline(always)]
- #[must_use]
- pub fn capacity(&self) -> usize {
- A::CAPACITY
- }
-
- /// Truncates the `ArrayVec` down to length 0.
- #[inline(always)]
- pub fn clear(&mut self) {
- 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 av = array_vec!([i32; 4], 1, 2, 3);
- /// let av2: ArrayVec<[i32; 4]> = av.drain(1..).collect();
- /// assert_eq!(av.as_slice(), &[1][..]);
- /// assert_eq!(av2.as_slice(), &[2, 3][..]);
- ///
- /// av.drain(..);
- /// assert_eq!(av.as_slice(), &[]);
- /// ```
- #[inline]
- pub fn drain<R: RangeBounds<usize>>(
- &mut self,
- range: R,
- ) -> ArrayVecDrain<'_, A> {
- use core::ops::Bound;
- let start = match range.start_bound() {
- Bound::Included(x) => *x,
- Bound::Excluded(x) => x + 1,
- Bound::Unbounded => 0,
- };
- let end = match range.end_bound() {
- Bound::Included(x) => x + 1,
- Bound::Excluded(x) => *x,
- Bound::Unbounded => self.len,
- };
- assert!(
- start <= end,
- "ArrayVec::drain> Illegal range, {} to {}",
- start,
- end
- );
- assert!(
- end <= self.len,
- "ArrayVec::drain> Range ends at {} but length is only {}!",
- end,
- self.len
- );
- ArrayVecDrain {
- parent: self,
- target_start: start,
- target_index: start,
- target_end: end,
- }
- }
-
- /// Clone each element of the slice into this `ArrayVec`.
- ///
- /// ## Panics
- /// * If the `ArrayVec` would overflow, this will panic.
- #[inline]
- pub fn extend_from_slice(&mut self, sli: &[A::Item])
- where
- A::Item: Clone,
- {
- if sli.is_empty() {
- return;
- }
-
- let new_len = self.len + sli.len();
- if new_len > A::CAPACITY {
- panic!(
- "ArrayVec::extend_from_slice> total length {} exceeds capacity {}!",
- new_len,
- A::CAPACITY
- )
- }
-
- let target = &mut self.data.as_slice_mut()[self.len..new_len];
- target.clone_from_slice(sli);
- self.set_len(new_len);
- }
-
- /// Wraps up an array and uses the given length as the initial length.
- ///
- /// If you want to simply use the full array, use `from` instead.
- ///
- /// ## Panics
- ///
- /// * The length specified must be less than or equal to the capacity of the array.
- #[inline]
- #[must_use]
- #[allow(clippy::match_wild_err_arm)]
- pub fn from_array_len(data: A, len: usize) -> Self {
- match Self::try_from_array_len(data, len) {
- Ok(out) => out,
- Err(_) => {
- panic!("ArrayVec::from_array_len> length {} exceeds capacity {}!", len, A::CAPACITY)
- }
- }
- }
-
- /// Inserts an item at the position given, moving all following elements +1
- /// index.
- ///
- /// ## Panics
- /// * If `index` > `len` or
- /// * If the capacity is exhausted
- ///
- /// ## Example
- /// ```rust
- /// use tinyvec::*;
- /// let mut av = array_vec!([i32; 10], 1, 2, 3);
- /// av.insert(1, 4);
- /// assert_eq!(av.as_slice(), &[1, 4, 2, 3]);
- /// av.insert(4, 5);
- /// assert_eq!(av.as_slice(), &[1, 4, 2, 3, 5]);
- /// ```
- #[inline]
- pub fn insert(&mut self, index: usize, item: A::Item) {
- if index > self.len {
- panic!("ArrayVec::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 `ArrayVec` (in elements).
- #[inline(always)]
- #[must_use]
- pub fn len(&self) -> usize {
- self.len
- }
-
- /// Makes a new, empty `ArrayVec`.
- #[inline(always)]
- #[must_use]
- pub fn new() -> Self
- where
- A: Default,
- {
- Self::default()
- }
-
- /// 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 av = array_vec!([i32; 10], 1, 2);
- /// assert_eq!(av.pop(), Some(2));
- /// assert_eq!(av.pop(), Some(1));
- /// assert_eq!(av.pop(), None);
- /// ```
- #[inline]
- pub fn pop(&mut self) -> Option<A::Item> {
- if self.len > 0 {
- self.len -= 1;
- let out = take(&mut self.data.as_slice_mut()[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 av = array_vec!([i32; 2]);
- /// assert_eq!(&av[..], []);
- /// av.push(1);
- /// assert_eq!(&av[..], [1]);
- /// av.push(2);
- /// assert_eq!(&av[..], [1, 2]);
- /// // av.push(3); this would overflow the ArrayVec and panic!
- /// ```
- #[inline(always)]
- pub fn push(&mut self, val: A::Item) {
- if self.len < A::CAPACITY {
- replace(&mut self.data.as_slice_mut()[self.len], val);
- self.len += 1;
- } else {
- panic!("ArrayVec::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 av = array_vec!([i32; 4], 1, 2, 3);
- /// assert_eq!(av.remove(1), 2);
- /// assert_eq!(&av[..], [1, 3]);
- /// ```
- #[inline]
- pub fn remove(&mut self, index: usize) -> A::Item {
- let targets: &mut [A::Item] = &mut self.deref_mut()[index..];
- let item = replace(&mut targets[0], A::Item::default());
- targets.rotate_left(1);
- self.len -= 1;
- item
- }
-
- /// Resize the vec to the new length.
- ///
- /// If it needs to be longer, it's filled with clones of the provided value.
- /// If it needs to be shorter, it's truncated.
- ///
- /// ## Example
- ///
- /// ```rust
- /// # use tinyvec::*;
- ///
- /// let mut av = array_vec!([&str; 10], "hello");
- /// av.resize(3, "world");
- /// assert_eq!(&av[..], ["hello", "world", "world"]);
- ///
- /// let mut av = array_vec!([i32; 10], 1, 2, 3, 4);
- /// av.resize(2, 0);
- /// assert_eq!(&av[..], [1, 2]);
- /// ```
- #[inline]
- pub fn resize(&mut self, new_len: usize, new_val: A::Item)
- where
- A::Item: Clone,
- {
- match new_len.checked_sub(self.len) {
- None => self.truncate(new_len),
- Some(0) => (),
- Some(new_elements) => {
- for _ in 1..new_elements {
- self.push(new_val.clone());
- }
- self.push(new_val);
- }
- }
- }
-
- /// 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.
- ///
- /// ## Example
- ///
- /// ```rust
- /// # use tinyvec::*;
- ///
- /// let mut av = array_vec!([i32; 10], 1, 2, 3);
- /// av.resize_with(5, Default::default);
- /// assert_eq!(&av[..], [1, 2, 3, 0, 0]);
- ///
- /// let mut av = array_vec!([i32; 10]);
- /// let mut p = 1;
- /// av.resize_with(4, || { p *= 2; p });
- /// assert_eq!(&av[..], [2, 4, 8, 16]);
- /// ```
- #[inline]
- pub fn resize_with<F: FnMut() -> A::Item>(
- &mut self,
- new_len: usize,
- mut f: F,
- ) {
- match new_len.checked_sub(self.len) {
- None => self.truncate(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 av = array_vec!([i32; 10], 1, 1, 2, 3, 3, 4);
- /// av.retain(|&x| x % 2 == 0);
- /// assert_eq!(&av[..], [2, 4]);
- /// ```
- #[inline]
- pub fn retain<F: FnMut(&A::Item) -> bool>(&mut self, mut acceptable: F) {
- // 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: &mut self.data.as_slice_mut()[..self.len],
- 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 > A::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!("ArrayVec: set_len overflow!")
- } else {
- self.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 av = array_vec!([i32; 4]);
- /// let mut to_inf = av.fill(0..);
- /// assert_eq!(&av[..], [0, 1, 2, 3]);
- /// assert_eq!(to_inf.next(), Some(4));
- /// ```
- #[inline]
- pub fn fill<I: IntoIterator<Item = A::Item>>(
- &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
- }
-
- /// Splits the collection at the point given.
- ///
- /// * `[0, at)` stays in this vec
- /// * `[at, len)` ends up in the new vec.
- ///
- /// ## Panics
- /// * if at > len
- ///
- /// ## Example
- ///
- /// ```rust
- /// # use tinyvec::*;
- /// let mut av = array_vec!([i32; 4], 1, 2, 3);
- /// let av2 = av.split_off(1);
- /// assert_eq!(&av[..], [1]);
- /// assert_eq!(&av2[..], [2, 3]);
- /// ```
- #[inline]
- pub fn split_off(&mut self, at: usize) -> Self
- where
- Self: Default,
- {
- // FIXME: should this just use drain into the output?
- if at > self.len {
- panic!(
- "ArrayVec::split_off> at value {} exceeds length of {}",
- at, self.len
- );
- }
- let mut new = Self::default();
- let moves = &mut self.as_mut_slice()[at..];
- let split_len = moves.len();
- let targets = &mut new.data.as_slice_mut()[..split_len];
- moves.swap_with_slice(targets);
- new.len = split_len;
- self.len = at;
- 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 av = array_vec!([&str; 4], "foo", "bar", "quack", "zap");
- ///
- /// assert_eq!(av.swap_remove(1), "bar");
- /// assert_eq!(&av[..], ["foo", "zap", "quack"]);
- ///
- /// assert_eq!(av.swap_remove(0), "foo");
- /// assert_eq!(&av[..], ["quack", "zap"]);
- /// ```
- #[inline]
- pub fn swap_remove(&mut self, index: usize) -> A::Item {
- assert!(
- index < self.len,
- "ArrayVec::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) {
- if needs_drop::<A::Item>() {
- while self.len > new_len {
- self.pop();
- }
- } else {
- self.len = self.len.min(new_len);
- }
- }
-
- /// Wraps an array, using the given length as the starting length.
- ///
- /// If you want to use the whole length of the array, you can just use the
- /// `From` impl.
- ///
- /// ## Failure
- ///
- /// If the given length is greater than the capacity of the array this will
- /// error, and you'll get the array back in the `Err`.
- #[inline]
- pub fn try_from_array_len(data: A, len: usize) -> Result<Self, A> {
- if len <= A::CAPACITY {
- Ok(Self { data, len })
- } else {
- Err(data)
- }
- }
-}
-
-#[cfg(feature = "grab_spare_slice")]
-impl<A: Array> ArrayVec<A> {
- /// Obtain the shared slice of the array _after_ the active memory.
- ///
- /// ## Example
- /// ```rust
- /// # use tinyvec::*;
- /// let mut av = array_vec!([i32; 4]);
- /// assert_eq!(av.grab_spare_slice().len(), 4);
- /// av.push(10);
- /// av.push(11);
- /// av.push(12);
- /// av.push(13);
- /// assert_eq!(av.grab_spare_slice().len(), 0);
- /// ```
- #[inline(always)]
- pub fn grab_spare_slice(&self) -> &[A::Item] {
- &self.data.as_slice()[self.len..]
- }
-
- /// Obtain the mutable slice of the array _after_ the active memory.
- ///
- /// ## Example
- /// ```rust
- /// # use tinyvec::*;
- /// let mut av = array_vec!([i32; 4]);
- /// assert_eq!(av.grab_spare_slice_mut().len(), 4);
- /// av.push(10);
- /// av.push(11);
- /// assert_eq!(av.grab_spare_slice_mut().len(), 2);
- /// ```
- #[inline(always)]
- pub fn grab_spare_slice_mut(&mut self) -> &mut [A::Item] {
- &mut self.data.as_slice_mut()[self.len..]
- }
-}
-
-#[cfg(feature = "nightly_slice_partition_dedup")]
-impl<A: Array> ArrayVec<A> {
- /// De-duplicates the vec contents.
- #[inline(always)]
- pub fn dedup(&mut self)
- where
- A::Item: PartialEq,
- {
- self.dedup_by(|a, b| a == b)
- }
-
- /// De-duplicates the vec according to the predicate given.
- #[inline(always)]
- pub fn dedup_by<F>(&mut self, same_bucket: F)
- where
- F: FnMut(&mut A::Item, &mut A::Item) -> bool,
- {
- let len = {
- let (dedup, _) = self.as_mut_slice().partition_dedup_by(same_bucket);
- dedup.len()
- };
- self.truncate(len);
- }
-
- /// De-duplicates the vec according to the key selector given.
- #[inline(always)]
- pub fn dedup_by_key<F, K>(&mut self, mut key: F)
- where
- F: FnMut(&mut A::Item) -> K,
- K: PartialEq,
- {
- self.dedup_by(|a, b| key(a) == key(b))
- }
-}
-
-/// Draining iterator for `ArrayVecDrain`
-///
-/// See [`ArrayVec::drain`](ArrayVec::drain)
-pub struct ArrayVecDrain<'p, A: Array> {
- parent: &'p mut ArrayVec<A>,
- target_start: usize,
- target_index: usize,
- target_end: usize,
-}
-impl<'p, A: Array> Iterator for ArrayVecDrain<'p, A> {
- type Item = A::Item;
- #[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, A: Array> FusedIterator for ArrayVecDrain<'p, A> { }
-impl<'p, A: Array> Drop for ArrayVecDrain<'p, A> {
- #[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 [`ArrayVec::remove`](ArrayVec::remove)
- let count = self.target_end - self.target_start;
- let targets: &mut [A::Item] = &mut self.parent.deref_mut()[self.target_start..];
- targets.rotate_left(count);
- self.parent.len -= count;
- }
-}
-
-impl<A: Array> AsMut<[A::Item]> for ArrayVec<A> {
- #[inline(always)]
- #[must_use]
- fn as_mut(&mut self) -> &mut [A::Item] {
- &mut *self
- }
-}
-
-impl<A: Array> AsRef<[A::Item]> for ArrayVec<A> {
- #[inline(always)]
- #[must_use]
- fn as_ref(&self) -> &[A::Item] {
- &*self
- }
-}
-
-impl<A: Array> Borrow<[A::Item]> for ArrayVec<A> {
- #[inline(always)]
- #[must_use]
- fn borrow(&self) -> &[A::Item] {
- &*self
- }
-}
-
-impl<A: Array> BorrowMut<[A::Item]> for ArrayVec<A> {
- #[inline(always)]
- #[must_use]
- fn borrow_mut(&mut self) -> &mut [A::Item] {
- &mut *self
- }
-}
-
-impl<A: Array> Extend<A::Item> for ArrayVec<A> {
- #[inline]
- fn extend<T: IntoIterator<Item = A::Item>>(&mut self, iter: T) {
- for t in iter {
- self.push(t)
- }
- }
-}
-
-impl<A: Array> From<A> for ArrayVec<A> {
- #[inline(always)]
- #[must_use]
- /// The output has a length equal to the full array.
- ///
- /// If you want to select a length, use
- /// [`from_array_len`](ArrayVec::from_array_len)
- fn from(data: A) -> Self {
- Self { len: data.as_slice().len(), data }
- }
-}
-
-impl<A: Array + Default> FromIterator<A::Item> for ArrayVec<A> {
- #[inline]
- #[must_use]
- fn from_iter<T: IntoIterator<Item = A::Item>>(iter: T) -> Self {
- let mut av = Self::default();
- for i in iter {
- av.push(i)
- }
- av
- }
-}
-
-/// Iterator for consuming an `ArrayVec` and returning owned elements.
-pub struct ArrayVecIterator<A: Array> {
- base: usize,
- len: usize,
- data: A,
-}
-
-impl<A: Array> ArrayVecIterator<A> {
- /// Returns the remaining items of this iterator as a slice.
- #[inline]
- #[must_use]
- pub fn as_slice(&self) -> &[A::Item] {
- &self.data.as_slice()[self.base..self.len]
- }
-}
-impl<A: Array> FusedIterator for ArrayVecIterator<A> { }
-impl<A: Array> Iterator for ArrayVecIterator<A> {
- type Item = A::Item;
- #[inline]
- fn next(&mut self) -> Option<Self::Item> {
- if self.base < self.len {
- let out = take(&mut self.data.as_slice_mut()[self.base]);
- self.base += 1;
- Some(out)
- } else {
- None
- }
- }
- #[inline(always)]
- #[must_use]
- fn size_hint(&self) -> (usize, Option<usize>) {
- let s = self.len - self.base;
- (s, Some(s))
- }
- #[inline(always)]
- fn count(self) -> usize {
- self.len - self.base
- }
- #[inline]
- fn last(mut self) -> Option<Self::Item> {
- Some(take(&mut self.data.as_slice_mut()[self.len]))
- }
- #[inline]
- fn nth(&mut self, n: usize) -> Option<A::Item> {
- let i = self.base + (n - 1);
- if i < self.len {
- let out = take(&mut self.data.as_slice_mut()[i]);
- self.base = i + 1;
- Some(out)
- } else {
- None
- }
- }
-}
-
-impl<A: Array> Debug for ArrayVecIterator<A> where A::Item: Debug {
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
- f.debug_tuple("ArrayVecIterator").field(&self.as_slice()).finish()
- }
-}
-
-impl<A: Array> IntoIterator for ArrayVec<A> {
- type Item = A::Item;
- type IntoIter = ArrayVecIterator<A>;
- #[inline(always)]
- #[must_use]
- fn into_iter(self) -> Self::IntoIter {
- ArrayVecIterator { base: 0, len: self.len, data: self.data }
- }
-}
-
-impl<A: Array> PartialEq for ArrayVec<A>
-where
- A::Item: PartialEq,
-{
- #[inline]
- #[must_use]
- fn eq(&self, other: &Self) -> bool {
- self.as_slice().eq(other.as_slice())
- }
-}
-impl<A: Array> Eq for ArrayVec<A> where A::Item: Eq {}
-
-impl<A: Array> PartialOrd for ArrayVec<A>
-where
- A::Item: PartialOrd,
-{
- #[inline]
- #[must_use]
- fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
- self.as_slice().partial_cmp(other.as_slice())
- }
-}
-impl<A: Array> Ord for ArrayVec<A>
-where
- A::Item: Ord,
-{
- #[inline]
- #[must_use]
- fn cmp(&self, other: &Self) -> core::cmp::Ordering {
- self.as_slice().cmp(other.as_slice())
- }
-}
-
-impl<A: Array> PartialEq<&A> for ArrayVec<A>
-where
- A::Item: PartialEq,
-{
- #[inline]
- #[must_use]
- fn eq(&self, other: &&A) -> bool {
- self.as_slice().eq(other.as_slice())
- }
-}
-
-impl<A: Array> PartialEq<&[A::Item]> for ArrayVec<A>
-where
- A::Item: PartialEq,
-{
- #[inline]
- #[must_use]
- fn eq(&self, other: &&[A::Item]) -> bool {
- self.as_slice().eq(*other)
- }
-}
-
-impl<A: Array> Hash for ArrayVec<A>
-where
- A::Item: Hash,
-{
- #[inline]
- fn hash<H: Hasher>(&self, state: &mut H) {
- self.as_slice().hash(state)
- }
-}
-
-#[cfg(feature = "experimental_write_impl")]
-impl<A: Array<Item=u8>> core::fmt::Write for ArrayVec<A>
-{
- 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 <= A::CAPACITY {
- let remainder = &mut self.data.as_slice_mut()[my_len..];
- let target = &mut remainder[..str_len];
- target.copy_from_slice(s.as_bytes());
- Ok(())
- } else {
- Err(core::fmt::Error)
- }
- }
-}
-
-// // // // // // // //
-// Formatting impls
-// // // // // // // //
-
-impl<A: Array> Binary for ArrayVec<A>
-where
- A::Item: Binary,
-{
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
- write!(f, "[")?;
- for (i, elem) in self.iter().enumerate() {
- if i > 0 {
- write!(f, ", ")?;
- }
- Binary::fmt(elem, f)?;
- }
- write!(f, "]")
- }
-}
-
-impl<A: Array> Debug for ArrayVec<A>
-where
- A::Item: Debug,
-{
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
- write!(f, "[")?;
- for (i, elem) in self.iter().enumerate() {
- if i > 0 {
- write!(f, ", ")?;
- }
- Debug::fmt(elem, f)?;
- }
- write!(f, "]")
- }
-}
-
-impl<A: Array> Display for ArrayVec<A>
-where
- A::Item: Display,
-{
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
- write!(f, "[")?;
- for (i, elem) in self.iter().enumerate() {
- if i > 0 {
- write!(f, ", ")?;
- }
- Display::fmt(elem, f)?;
- }
- write!(f, "]")
- }
-}
-
-impl<A: Array> LowerExp for ArrayVec<A>
-where
- A::Item: LowerExp,
-{
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
- write!(f, "[")?;
- for (i, elem) in self.iter().enumerate() {
- if i > 0 {
- write!(f, ", ")?;
- }
- LowerExp::fmt(elem, f)?;
- }
- write!(f, "]")
- }
-}
-
-impl<A: Array> LowerHex for ArrayVec<A>
-where
- A::Item: LowerHex,
-{
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
- write!(f, "[")?;
- for (i, elem) in self.iter().enumerate() {
- if i > 0 {
- write!(f, ", ")?;
- }
- LowerHex::fmt(elem, f)?;
- }
- write!(f, "]")
- }
-}
-
-impl<A: Array> Octal for ArrayVec<A>
-where
- A::Item: Octal,
-{
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
- write!(f, "[")?;
- for (i, elem) in self.iter().enumerate() {
- if i > 0 {
- write!(f, ", ")?;
- }
- Octal::fmt(elem, f)?;
- }
- write!(f, "]")
- }
-}
-
-impl<A: Array> Pointer for ArrayVec<A>
-where
- A::Item: Pointer,
-{
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
- write!(f, "[")?;
- for (i, elem) in self.iter().enumerate() {
- if i > 0 {
- write!(f, ", ")?;
- }
- Pointer::fmt(elem, f)?;
- }
- write!(f, "]")
- }
-}
-
-impl<A: Array> UpperExp for ArrayVec<A>
-where
- A::Item: UpperExp,
-{
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
- write!(f, "[")?;
- for (i, elem) in self.iter().enumerate() {
- if i > 0 {
- write!(f, ", ")?;
- }
- UpperExp::fmt(elem, f)?;
- }
- write!(f, "]")
- }
-}
-
-impl<A: Array> UpperHex for ArrayVec<A>
-where
- A::Item: UpperHex,
-{
- #[allow(clippy::missing_inline_in_public_items)]
- fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
- write!(f, "[")?;
- for (i, elem) in self.iter().enumerate() {
- if i > 0 {
- write!(f, ", ")?;
- }
- UpperHex::fmt(elem, f)?;
- }
- write!(f, "]")
- }
-}
+use super::*;\r
+use core::convert::{TryFrom, TryInto};\r
+\r
+#[cfg(feature = "serde")]\r
+use core::marker::PhantomData;\r
+#[cfg(feature = "serde")]\r
+use serde::de::{\r
+ Deserialize, Deserializer, Error as DeserializeError, SeqAccess, Visitor,\r
+};\r
+#[cfg(feature = "serde")]\r
+use serde::ser::{Serialize, SerializeSeq, Serializer};\r
+\r
+/// Helper to make an `ArrayVec`.\r
+///\r
+/// You specify the backing array type, and optionally give all the elements you\r
+/// want to initially place into the array.\r
+///\r
+/// ```rust\r
+/// use tinyvec::*;\r
+///\r
+/// // The backing array type can be specified in the macro call\r
+/// let empty_av = array_vec!([u8; 16]);\r
+/// let some_ints = array_vec!([i32; 4] => 1, 2, 3);\r
+///\r
+/// // Or left to inference\r
+/// let empty_av: ArrayVec<[u8; 10]> = array_vec!();\r
+/// let some_ints: ArrayVec<[u8; 10]> = array_vec!(5, 6, 7, 8);\r
+/// ```\r
+#[macro_export]\r
+macro_rules! array_vec {\r
+ ($array_type:ty => $($elem:expr),* $(,)?) => {\r
+ {\r
+ let mut av: $crate::ArrayVec<$array_type> = Default::default();\r
+ $( av.push($elem); )*\r
+ av\r
+ }\r
+ };\r
+ ($array_type:ty) => {\r
+ $crate::ArrayVec::<$array_type>::default()\r
+ };\r
+ ($($elem:expr),*) => {\r
+ $crate::array_vec!(_ => $($elem),*)\r
+ };\r
+ ($elem:expr; $n:expr) => {\r
+ $crate::ArrayVec::from([$elem; $n])\r
+ };\r
+ () => {\r
+ $crate::array_vec!(_)\r
+ };\r
+}\r
+\r
+/// An array-backed, vector-like data structure.\r
+///\r
+/// * `ArrayVec` has a fixed capacity, equal to the array size.\r
+/// * `ArrayVec` has a variable length, as you add and remove elements. Attempts\r
+/// to fill the vec beyond its capacity will cause a panic.\r
+/// * All of the vec's array slots are always initialized in terms of Rust's\r
+/// memory model. When you remove a element from a location, the old value at\r
+/// that location is replaced with the type's default value.\r
+///\r
+/// The overall API of this type is intended to, as much as possible, emulate\r
+/// the API of the [`Vec`](https://doc.rust-lang.org/alloc/vec/struct.Vec.html)\r
+/// type.\r
+///\r
+/// ## Construction\r
+///\r
+/// You can use the `array_vec!` macro similarly to how you might use the `vec!`\r
+/// macro. Specify the array type, then optionally give all the initial values\r
+/// you want to have.\r
+/// ```rust\r
+/// # use tinyvec::*;\r
+/// let some_ints = array_vec!([i32; 4] => 1, 2, 3);\r
+/// assert_eq!(some_ints.len(), 3);\r
+/// ```\r
+///\r
+/// The [`default`](ArrayVec::new) for an `ArrayVec` is to have a default\r
+/// array with length 0. The [`new`](ArrayVec::new) method is the same as\r
+/// calling `default`\r
+/// ```rust\r
+/// # use tinyvec::*;\r
+/// let some_ints = ArrayVec::<[i32; 7]>::default();\r
+/// assert_eq!(some_ints.len(), 0);\r
+///\r
+/// let more_ints = ArrayVec::<[i32; 7]>::new();\r
+/// assert_eq!(some_ints, more_ints);\r
+/// ```\r
+///\r
+/// If you have an array and want the _whole thing_ so count as being "in" the\r
+/// new `ArrayVec` you can use one of the `from` implementations. If you want\r
+/// _part of_ the array then you can use\r
+/// [`from_array_len`](ArrayVec::from_array_len):\r
+/// ```rust\r
+/// # use tinyvec::*;\r
+/// let some_ints = ArrayVec::from([5, 6, 7, 8]);\r
+/// assert_eq!(some_ints.len(), 4);\r
+///\r
+/// let more_ints = ArrayVec::from_array_len([5, 6, 7, 8], 2);\r
+/// assert_eq!(more_ints.len(), 2);\r
+///\r
+/// let no_ints: ArrayVec<[u8; 5]> = ArrayVec::from_array_empty([1, 2, 3, 4, 5]);\r
+/// assert_eq!(no_ints.len(), 0);\r
+/// ```\r
+#[repr(C)]\r
+#[derive(Clone, Copy)]\r
+pub struct ArrayVec<A> {\r
+ len: u16,\r
+ pub(crate) data: A,\r
+}\r
+\r
+impl<A: Array> Default for ArrayVec<A> {\r
+ fn default() -> Self {\r
+ Self { len: 0, data: A::default() }\r
+ }\r
+}\r
+\r
+impl<A: Array> Deref for ArrayVec<A> {\r
+ type Target = [A::Item];\r
+ #[inline(always)]\r
+ #[must_use]\r
+ fn deref(&self) -> &Self::Target {\r
+ &self.data.as_slice()[..self.len as usize]\r
+ }\r
+}\r
+\r
+impl<A: Array> DerefMut for ArrayVec<A> {\r
+ #[inline(always)]\r
+ #[must_use]\r
+ fn deref_mut(&mut self) -> &mut Self::Target {\r
+ &mut self.data.as_slice_mut()[..self.len as usize]\r
+ }\r
+}\r
+\r
+impl<A: Array, I: SliceIndex<[A::Item]>> Index<I> for ArrayVec<A> {\r
+ type Output = <I as SliceIndex<[A::Item]>>::Output;\r
+ #[inline(always)]\r
+ #[must_use]\r
+ fn index(&self, index: I) -> &Self::Output {\r
+ &self.deref()[index]\r
+ }\r
+}\r
+\r
+impl<A: Array, I: SliceIndex<[A::Item]>> IndexMut<I> for ArrayVec<A> {\r
+ #[inline(always)]\r
+ #[must_use]\r
+ fn index_mut(&mut self, index: I) -> &mut Self::Output {\r
+ &mut self.deref_mut()[index]\r
+ }\r
+}\r
+\r
+#[cfg(feature = "serde")]\r
+#[cfg_attr(docs_rs, doc(cfg(feature = "serde")))]\r
+impl<A: Array> Serialize for ArrayVec<A>\r
+where\r
+ A::Item: Serialize,\r
+{\r
+ #[must_use]\r
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>\r
+ where\r
+ S: Serializer,\r
+ {\r
+ let mut seq = serializer.serialize_seq(Some(self.len()))?;\r
+ for element in self.iter() {\r
+ seq.serialize_element(element)?;\r
+ }\r
+ seq.end()\r
+ }\r
+}\r
+\r
+#[cfg(feature = "serde")]\r
+#[cfg_attr(docs_rs, doc(cfg(feature = "serde")))]\r
+impl<'de, A: Array> Deserialize<'de> for ArrayVec<A>\r
+where\r
+ A::Item: Deserialize<'de>,\r
+{\r
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>\r
+ where\r
+ D: Deserializer<'de>,\r
+ {\r
+ deserializer.deserialize_seq(ArrayVecVisitor(PhantomData))\r
+ }\r
+}\r
+\r
+impl<A: Array> ArrayVec<A> {\r
+ /// Move all values from `other` into this vec.\r
+ ///\r
+ /// ## Panics\r
+ /// * If the vec overflows its capacity\r
+ ///\r
+ /// ## Example\r
+ /// ```rust\r
+ /// # use tinyvec::*;\r
+ /// let mut av = array_vec!([i32; 10] => 1, 2, 3);\r
+ /// let mut av2 = array_vec!([i32; 10] => 4, 5, 6);\r
+ /// av.append(&mut av2);\r
+ /// assert_eq!(av, &[1, 2, 3, 4, 5, 6][..]);\r
+ /// assert_eq!(av2, &[][..]);\r
+ /// ```\r
+ #[inline]\r
+ pub fn append(&mut self, other: &mut Self) {\r
+ assert!(\r
+ self.try_append(other).is_none(),\r
+ "ArrayVec::append> total length {} exceeds capacity {}!",\r
+ self.len() + other.len(),\r
+ A::CAPACITY\r
+ );\r
+ }\r
+\r
+ /// Move all values from `other` into this vec.\r
+ /// If appending would overflow the capacity, Some(other) is returned.\r
+ /// ## Example\r
+ /// ```rust\r
+ /// # use tinyvec::*;\r
+ /// let mut av = array_vec!([i32; 7] => 1, 2, 3);\r
+ /// let mut av2 = array_vec!([i32; 7] => 4, 5, 6);\r
+ /// av.append(&mut av2);\r
+ /// assert_eq!(av, &[1, 2, 3, 4, 5, 6][..]);\r
+ /// assert_eq!(av2, &[][..]);\r
+ ///\r
+ /// let mut av3 = array_vec!([i32; 7] => 7, 8, 9);\r
+ /// assert!(av.try_append(&mut av3).is_some());\r
+ /// assert_eq!(av, &[1, 2, 3, 4, 5, 6][..]);\r
+ /// assert_eq!(av3, &[7, 8, 9][..]);\r
+ /// ```\r
+ #[inline]\r
+ pub fn try_append<'other>(\r
+ &mut self, other: &'other mut Self,\r
+ ) -> Option<&'other mut Self> {\r
+ let new_len = self.len() + other.len();\r
+ if new_len > A::CAPACITY {\r
+ return Some(other);\r
+ }\r
+\r
+ let iter = other.iter_mut().map(take);\r
+ for item in iter {\r
+ self.push(item);\r
+ }\r
+\r
+ other.set_len(0);\r
+\r
+ return None;\r
+ }\r
+\r
+ /// A `*mut` pointer to the backing array.\r
+ ///\r
+ /// ## Safety\r
+ ///\r
+ /// This pointer has provenance over the _entire_ backing array.\r
+ #[inline(always)]\r
+ #[must_use]\r
+ pub fn as_mut_ptr(&mut self) -> *mut A::Item {\r
+ self.data.as_slice_mut().as_mut_ptr()\r
+ }\r
+\r
+ /// Performs a `deref_mut`, into unique slice form.\r
+ #[inline(always)]\r
+ #[must_use]\r
+ pub fn as_mut_slice(&mut self) -> &mut [A::Item] {\r
+ self.deref_mut()\r
+ }\r
+\r
+ /// A `*const` pointer to the backing array.\r
+ ///\r
+ /// ## Safety\r
+ ///\r
+ /// This pointer has provenance over the _entire_ backing array.\r
+ #[inline(always)]\r
+ #[must_use]\r
+ pub fn as_ptr(&self) -> *const A::Item {\r
+ self.data.as_slice().as_ptr()\r
+ }\r
+\r
+ /// Performs a `deref`, into shared slice form.\r
+ #[inline(always)]\r
+ #[must_use]\r
+ pub fn as_slice(&self) -> &[A::Item] {\r
+ self.deref()\r
+ }\r
+\r
+ /// The capacity of the `ArrayVec`.\r
+ ///\r
+ /// This is fixed based on the array type, but can't yet be made a `const fn`\r
+ /// on Stable Rust.\r
+ #[inline(always)]\r
+ #[must_use]\r
+ pub fn capacity(&self) -> usize {\r
+ // Note: This shouldn't use A::CAPACITY, because unsafe code can't rely on\r
+ // any Array invariants. This ensures that at the very least, the returned\r
+ // value is a valid length for a subslice of the backing array.\r
+ self.data.as_slice().len()\r
+ }\r
+\r
+ /// Truncates the `ArrayVec` down to length 0.\r
+ #[inline(always)]\r
+ pub fn clear(&mut self) {\r
+ self.truncate(0)\r
+ }\r
+\r
+ /// Creates a draining iterator that removes the specified range in the vector\r
+ /// and yields the removed items.\r
+ ///\r
+ /// ## Panics\r
+ /// * If the start is greater than the end\r
+ /// * If the end is past the edge of the vec.\r
+ ///\r
+ /// ## Example\r
+ /// ```rust\r
+ /// # use tinyvec::*;\r
+ /// let mut av = array_vec!([i32; 4] => 1, 2, 3);\r
+ /// let av2: ArrayVec<[i32; 4]> = av.drain(1..).collect();\r
+ /// assert_eq!(av.as_slice(), &[1][..]);\r
+ /// assert_eq!(av2.as_slice(), &[2, 3][..]);\r
+ ///\r
+ /// av.drain(..);\r
+ /// assert_eq!(av.as_slice(), &[]);\r
+ /// ```\r
+ #[inline]\r
+ pub fn drain<R>(&mut self, range: R) -> ArrayVecDrain<'_, A::Item>\r
+ where\r
+ R: RangeBounds<usize>,\r
+ {\r
+ ArrayVecDrain::new(self, range)\r
+ }\r
+\r
+ /// Returns the inner array of the `ArrayVec`.\r
+ ///\r
+ /// This returns the full array, even if the `ArrayVec` length is currently\r
+ /// less than that.\r
+ ///\r
+ /// ## Example\r
+ ///\r
+ /// ```rust\r
+ /// # use tinyvec::{array_vec, ArrayVec};\r
+ /// let mut favorite_numbers = array_vec!([i32; 5] => 87, 48, 33, 9, 26);\r
+ /// assert_eq!(favorite_numbers.clone().into_inner(), [87, 48, 33, 9, 26]);\r
+ ///\r
+ /// favorite_numbers.pop();\r
+ /// assert_eq!(favorite_numbers.into_inner(), [87, 48, 33, 9, 0]);\r
+ /// ```\r
+ ///\r
+ /// A use for this function is to build an array from an iterator by first\r
+ /// collecting it into an `ArrayVec`.\r
+ ///\r
+ /// ```rust\r
+ /// # use tinyvec::ArrayVec;\r
+ /// let arr_vec: ArrayVec<[i32; 10]> = (1..=3).cycle().take(10).collect();\r
+ /// let inner = arr_vec.into_inner();\r
+ /// assert_eq!(inner, [1, 2, 3, 1, 2, 3, 1, 2, 3, 1]);\r
+ /// ```\r
+ #[inline]\r
+ pub fn into_inner(self) -> A {\r
+ self.data\r
+ }\r
+\r
+ /// Clone each element of the slice into this `ArrayVec`.\r
+ ///\r
+ /// ## Panics\r
+ /// * If the `ArrayVec` would overflow, this will panic.\r
+ #[inline]\r
+ pub fn extend_from_slice(&mut self, sli: &[A::Item])\r
+ where\r
+ A::Item: Clone,\r
+ {\r
+ if sli.is_empty() {\r
+ return;\r
+ }\r
+\r
+ let new_len = self.len as usize + sli.len();\r
+ assert!(\r
+ new_len <= A::CAPACITY,\r
+ "ArrayVec::extend_from_slice> total length {} exceeds capacity {}!",\r
+ new_len,\r
+ A::CAPACITY\r
+ );\r
+\r
+ let target = &mut self.data.as_slice_mut()[self.len as usize..new_len];\r
+ target.clone_from_slice(sli);\r
+ self.set_len(new_len);\r
+ }\r
+\r
+ /// Fill the vector until its capacity has been reached.\r
+ ///\r
+ /// Successively fills unused space in the spare slice of the vector with\r
+ /// elements from the iterator. It then returns the remaining iterator\r
+ /// without exhausting it. This also allows appending the head of an\r
+ /// infinite iterator.\r
+ ///\r
+ /// This is an alternative to `Extend::extend` method for cases where the\r
+ /// length of the iterator can not be checked. Since this vector can not\r
+ /// reallocate to increase its capacity, it is unclear what to do with\r
+ /// remaining elements in the iterator and the iterator itself. The\r
+ /// interface also provides no way to communicate this to the caller.\r
+ ///\r
+ /// ## Panics\r
+ /// * If the `next` method of the provided iterator panics.\r
+ ///\r
+ /// ## Example\r
+ ///\r
+ /// ```rust\r
+ /// # use tinyvec::*;\r
+ /// let mut av = array_vec!([i32; 4]);\r
+ /// let mut to_inf = av.fill(0..);\r
+ /// assert_eq!(&av[..], [0, 1, 2, 3]);\r
+ /// assert_eq!(to_inf.next(), Some(4));\r
+ /// ```\r
+ #[inline]\r
+ pub fn fill<I: IntoIterator<Item = A::Item>>(\r
+ &mut self, iter: I,\r
+ ) -> I::IntoIter {\r
+ // If this is written as a call to push for each element in iter, the\r
+ // compiler emits code that updates the length for every element. The\r
+ // additional complexity from that length update is worth nearly 2x in\r
+ // the runtime of this function.\r
+ let mut iter = iter.into_iter();\r
+ let mut pushed = 0;\r
+ let to_take = self.capacity() - self.len();\r
+ let target = &mut self.data.as_slice_mut()[self.len as usize..];\r
+ for element in iter.by_ref().take(to_take) {\r
+ target[pushed] = element;\r
+ pushed += 1;\r
+ }\r
+ self.len += pushed as u16;\r
+ iter\r
+ }\r
+\r
+ /// Wraps up an array and uses the given length as the initial length.\r
+ ///\r
+ /// If you want to simply use the full array, use `from` instead.\r
+ ///\r
+ /// ## Panics\r
+ ///\r
+ /// * The length specified must be less than or equal to the capacity of the\r
+ /// array.\r
+ #[inline]\r
+ #[must_use]\r
+ #[allow(clippy::match_wild_err_arm)]\r
+ pub fn from_array_len(data: A, len: usize) -> Self {\r
+ match Self::try_from_array_len(data, len) {\r
+ Ok(out) => out,\r
+ Err(_) => panic!(\r
+ "ArrayVec::from_array_len> length {} exceeds capacity {}!",\r
+ len,\r
+ A::CAPACITY\r
+ ),\r
+ }\r
+ }\r
+\r
+ /// Inserts an item at the position given, moving all following elements +1\r
+ /// index.\r
+ ///\r
+ /// ## Panics\r
+ /// * If `index` > `len`\r
+ /// * If the capacity is exhausted\r
+ ///\r
+ /// ## Example\r
+ /// ```rust\r
+ /// use tinyvec::*;\r
+ /// let mut av = array_vec!([i32; 10] => 1, 2, 3);\r
+ /// av.insert(1, 4);\r
+ /// assert_eq!(av.as_slice(), &[1, 4, 2, 3]);\r
+ /// av.insert(4, 5);\r
+ /// assert_eq!(av.as_slice(), &[1, 4, 2, 3, 5]);\r
+ /// ```\r
+ #[inline]\r
+ pub fn insert(&mut self, index: usize, item: A::Item) {\r
+ let x = self.try_insert(index, item);\r
+ assert!(x.is_none(), "ArrayVec::insert> capacity overflow!");\r
+ }\r
+\r
+ /// Tries to insert an item at the position given, moving all following\r
+ /// elements +1 index.\r
+ /// Returns back the element if the capacity is exhausted,\r
+ /// otherwise returns None.\r
+ ///\r
+ /// ## Panics\r
+ /// * If `index` > `len`\r
+ ///\r
+ /// ## Example\r
+ /// ```rust\r
+ /// use tinyvec::*;\r
+ /// let mut av = array_vec!([&'static str; 4] => "one", "two", "three");\r
+ /// av.insert(1, "four");\r
+ /// assert_eq!(av.as_slice(), &["one", "four", "two", "three"]);\r
+ /// assert_eq!(av.try_insert(4, "five"), Some("five"));\r
+ /// ```\r
+ #[inline]\r
+ pub fn try_insert(\r
+ &mut self, index: usize, mut item: A::Item,\r
+ ) -> Option<A::Item> {\r
+ assert!(\r
+ index <= self.len as usize,\r
+ "ArrayVec::try_insert> index {} is out of bounds {}",\r
+ index,\r
+ self.len\r
+ );\r
+\r
+ // A previous implementation used self.try_push and slice::rotate_right\r
+ // rotate_right and rotate_left generate a huge amount of code and fail to\r
+ // inline; calling them here incurs the cost of all the cases they\r
+ // handle even though we're rotating a usually-small array by a constant\r
+ // 1 offset. This swap-based implementation benchmarks much better for\r
+ // small array lengths in particular.\r
+\r
+ if (self.len as usize) < A::CAPACITY {\r
+ self.len += 1;\r
+ } else {\r
+ return Some(item);\r
+ }\r
+\r
+ let target = &mut self.as_mut_slice()[index..];\r
+ for i in 0..target.len() {\r
+ core::mem::swap(&mut item, &mut target[i]);\r
+ }\r
+ return None;\r
+ }\r
+\r
+ /// Checks if the length is 0.\r
+ #[inline(always)]\r
+ #[must_use]\r
+ pub fn is_empty(&self) -> bool {\r
+ self.len == 0\r
+ }\r
+\r
+ /// The length of the `ArrayVec` (in elements).\r
+ #[inline(always)]\r
+ #[must_use]\r
+ pub fn len(&self) -> usize {\r
+ self.len as usize\r
+ }\r
+\r
+ /// Makes a new, empty `ArrayVec`.\r
+ #[inline(always)]\r
+ #[must_use]\r
+ pub fn new() -> Self {\r
+ Self::default()\r
+ }\r
+\r
+ /// Remove and return the last element of the vec, if there is one.\r
+ ///\r
+ /// ## Failure\r
+ /// * If the vec is empty you get `None`.\r
+ ///\r
+ /// ## Example\r
+ /// ```rust\r
+ /// # use tinyvec::*;\r
+ /// let mut av = array_vec!([i32; 10] => 1, 2);\r
+ /// assert_eq!(av.pop(), Some(2));\r
+ /// assert_eq!(av.pop(), Some(1));\r
+ /// assert_eq!(av.pop(), None);\r
+ /// ```\r
+ #[inline]\r
+ pub fn pop(&mut self) -> Option<A::Item> {\r
+ if self.len > 0 {\r
+ self.len -= 1;\r
+ let out = take(&mut self.data.as_slice_mut()[self.len as usize]);\r
+ Some(out)\r
+ } else {\r
+ None\r
+ }\r
+ }\r
+\r
+ /// Place an element onto the end of the vec.\r
+ ///\r
+ /// ## Panics\r
+ /// * If the length of the vec would overflow the capacity.\r
+ ///\r
+ /// ## Example\r
+ /// ```rust\r
+ /// # use tinyvec::*;\r
+ /// let mut av = array_vec!([i32; 2]);\r
+ /// assert_eq!(&av[..], []);\r
+ /// av.push(1);\r
+ /// assert_eq!(&av[..], [1]);\r
+ /// av.push(2);\r
+ /// assert_eq!(&av[..], [1, 2]);\r
+ /// // av.push(3); this would overflow the ArrayVec and panic!\r
+ /// ```\r
+ #[inline(always)]\r
+ pub fn push(&mut self, val: A::Item) {\r
+ let x = self.try_push(val);\r
+ assert!(x.is_none(), "ArrayVec::push> capacity overflow!");\r
+ }\r
+\r
+ /// Tries to place an element onto the end of the vec.\\r
+ /// Returns back the element if the capacity is exhausted,\r
+ /// otherwise returns None.\r
+ /// ```rust\r
+ /// # use tinyvec::*;\r
+ /// let mut av = array_vec!([i32; 2]);\r
+ /// assert_eq!(av.as_slice(), []);\r
+ /// assert_eq!(av.try_push(1), None);\r
+ /// assert_eq!(&av[..], [1]);\r
+ /// assert_eq!(av.try_push(2), None);\r
+ /// assert_eq!(&av[..], [1, 2]);\r
+ /// assert_eq!(av.try_push(3), Some(3));\r
+ /// ```\r
+ #[inline(always)]\r
+ pub fn try_push(&mut self, val: A::Item) -> Option<A::Item> {\r
+ debug_assert!(self.len as usize <= A::CAPACITY);\r
+\r
+ let itemref = match self.data.as_slice_mut().get_mut(self.len as usize) {\r
+ None => return Some(val),\r
+ Some(x) => x,\r
+ };\r
+\r
+ *itemref = val;\r
+ self.len += 1;\r
+ return None;\r
+ }\r
+\r
+ /// Removes the item at `index`, shifting all others down by one index.\r
+ ///\r
+ /// Returns the removed element.\r
+ ///\r
+ /// ## Panics\r
+ ///\r
+ /// * If the index is out of bounds.\r
+ ///\r
+ /// ## Example\r
+ ///\r
+ /// ```rust\r
+ /// # use tinyvec::*;\r
+ /// let mut av = array_vec!([i32; 4] => 1, 2, 3);\r
+ /// assert_eq!(av.remove(1), 2);\r
+ /// assert_eq!(&av[..], [1, 3]);\r
+ /// ```\r
+ #[inline]\r
+ pub fn remove(&mut self, index: usize) -> A::Item {\r
+ let targets: &mut [A::Item] = &mut self.deref_mut()[index..];\r
+ let item = take(&mut targets[0]);\r
+\r
+ // A previous implementation used rotate_left\r
+ // rotate_right and rotate_left generate a huge amount of code and fail to\r
+ // inline; calling them here incurs the cost of all the cases they\r
+ // handle even though we're rotating a usually-small array by a constant\r
+ // 1 offset. This swap-based implementation benchmarks much better for\r
+ // small array lengths in particular.\r
+\r
+ for i in 0..targets.len() - 1 {\r
+ targets.swap(i, i + 1);\r
+ }\r
+ self.len -= 1;\r
+ item\r
+ }\r
+\r
+ /// As [`resize_with`](ArrayVec::resize_with)\r
+ /// and it clones the value as the closure.\r
+ ///\r
+ /// ## Example\r
+ ///\r
+ /// ```rust\r
+ /// # use tinyvec::*;\r
+ ///\r
+ /// let mut av = array_vec!([&str; 10] => "hello");\r
+ /// av.resize(3, "world");\r
+ /// assert_eq!(&av[..], ["hello", "world", "world"]);\r
+ ///\r
+ /// let mut av = array_vec!([i32; 10] => 1, 2, 3, 4);\r
+ /// av.resize(2, 0);\r
+ /// assert_eq!(&av[..], [1, 2]);\r
+ /// ```\r
+ #[inline]\r
+ pub fn resize(&mut self, new_len: usize, new_val: A::Item)\r
+ where\r
+ A::Item: Clone,\r
+ {\r
+ self.resize_with(new_len, || new_val.clone())\r
+ }\r
+\r
+ /// Resize the vec to the new length.\r
+ ///\r
+ /// If it needs to be longer, it's filled with repeated calls to the provided\r
+ /// function. If it needs to be shorter, it's truncated.\r
+ ///\r
+ /// ## Example\r
+ ///\r
+ /// ```rust\r
+ /// # use tinyvec::*;\r
+ ///\r
+ /// let mut av = array_vec!([i32; 10] => 1, 2, 3);\r
+ /// av.resize_with(5, Default::default);\r
+ /// assert_eq!(&av[..], [1, 2, 3, 0, 0]);\r
+ ///\r
+ /// let mut av = array_vec!([i32; 10]);\r
+ /// let mut p = 1;\r
+ /// av.resize_with(4, || {\r
+ /// p *= 2;\r
+ /// p\r
+ /// });\r
+ /// assert_eq!(&av[..], [2, 4, 8, 16]);\r
+ /// ```\r
+ #[inline]\r
+ pub fn resize_with<F: FnMut() -> A::Item>(\r
+ &mut self, new_len: usize, mut f: F,\r
+ ) {\r
+ match new_len.checked_sub(self.len as usize) {\r
+ None => self.truncate(new_len),\r
+ Some(new_elements) => {\r
+ for _ in 0..new_elements {\r
+ self.push(f());\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ /// Walk the vec and keep only the elements that pass the predicate given.\r
+ ///\r
+ /// ## Example\r
+ ///\r
+ /// ```rust\r
+ /// # use tinyvec::*;\r
+ ///\r
+ /// let mut av = array_vec!([i32; 10] => 1, 1, 2, 3, 3, 4);\r
+ /// av.retain(|&x| x % 2 == 0);\r
+ /// assert_eq!(&av[..], [2, 4]);\r
+ /// ```\r
+ #[inline]\r
+ pub fn retain<F: FnMut(&A::Item) -> bool>(&mut self, mut acceptable: F) {\r
+ // Drop guard to contain exactly the remaining elements when the test\r
+ // panics.\r
+ struct JoinOnDrop<'vec, Item> {\r
+ items: &'vec mut [Item],\r
+ done_end: usize,\r
+ // Start of tail relative to `done_end`.\r
+ tail_start: usize,\r
+ }\r
+\r
+ impl<Item> Drop for JoinOnDrop<'_, Item> {\r
+ fn drop(&mut self) {\r
+ self.items[self.done_end..].rotate_left(self.tail_start);\r
+ }\r
+ }\r
+\r
+ let mut rest = JoinOnDrop {\r
+ items: &mut self.data.as_slice_mut()[..self.len as usize],\r
+ done_end: 0,\r
+ tail_start: 0,\r
+ };\r
+\r
+ let len = self.len as usize;\r
+ for idx in 0..len {\r
+ // Loop start invariant: idx = rest.done_end + rest.tail_start\r
+ if !acceptable(&rest.items[idx]) {\r
+ let _ = take(&mut rest.items[idx]);\r
+ self.len -= 1;\r
+ rest.tail_start += 1;\r
+ } else {\r
+ rest.items.swap(rest.done_end, idx);\r
+ rest.done_end += 1;\r
+ }\r
+ }\r
+ }\r
+\r
+ /// Forces the length of the vector to `new_len`.\r
+ ///\r
+ /// ## Panics\r
+ /// * If `new_len` is greater than the vec's capacity.\r
+ ///\r
+ /// ## Safety\r
+ /// * This is a fully safe operation! The inactive memory already counts as\r
+ /// "initialized" by Rust's rules.\r
+ /// * Other than "the memory is initialized" there are no other guarantees\r
+ /// regarding what you find in the inactive portion of the vec.\r
+ #[inline(always)]\r
+ pub fn set_len(&mut self, new_len: usize) {\r
+ if new_len > A::CAPACITY {\r
+ // Note(Lokathor): Technically we don't have to panic here, and we could\r
+ // just let some other call later on trigger a panic on accident when the\r
+ // length is wrong. However, it's a lot easier to catch bugs when things\r
+ // are more "fail-fast".\r
+ panic!(\r
+ "ArrayVec::set_len> new length {} exceeds capacity {}",\r
+ new_len,\r
+ A::CAPACITY\r
+ )\r
+ }\r
+\r
+ let new_len: u16 = new_len\r
+ .try_into()\r
+ .expect("ArrayVec::set_len> new length is not in range 0..=u16::MAX");\r
+ self.len = new_len;\r
+ }\r
+\r
+ /// Splits the collection at the point given.\r
+ ///\r
+ /// * `[0, at)` stays in this vec\r
+ /// * `[at, len)` ends up in the new vec.\r
+ ///\r
+ /// ## Panics\r
+ /// * if at > len\r
+ ///\r
+ /// ## Example\r
+ ///\r
+ /// ```rust\r
+ /// # use tinyvec::*;\r
+ /// let mut av = array_vec!([i32; 4] => 1, 2, 3);\r
+ /// let av2 = av.split_off(1);\r
+ /// assert_eq!(&av[..], [1]);\r
+ /// assert_eq!(&av2[..], [2, 3]);\r
+ /// ```\r
+ #[inline]\r
+ pub fn split_off(&mut self, at: usize) -> Self {\r
+ // FIXME: should this just use drain into the output?\r
+ if at > self.len() {\r
+ panic!(\r
+ "ArrayVec::split_off> at value {} exceeds length of {}",\r
+ at, self.len\r
+ );\r
+ }\r
+ let mut new = Self::default();\r
+ let moves = &mut self.as_mut_slice()[at..];\r
+ let split_len = moves.len();\r
+ let targets = &mut new.data.as_slice_mut()[..split_len];\r
+ moves.swap_with_slice(targets);\r
+\r
+ /* moves.len() <= u16::MAX, so these are surely in u16 range */\r
+ new.len = split_len as u16;\r
+ self.len = at as u16;\r
+ new\r
+ }\r
+\r
+ /// Creates a splicing iterator that removes the specified range in the\r
+ /// vector, yields the removed items, and replaces them with elements from\r
+ /// the provided iterator.\r
+ ///\r
+ /// `splice` fuses the provided iterator, so elements after the first `None`\r
+ /// are ignored.\r
+ ///\r
+ /// ## Panics\r
+ /// * If the start is greater than the end.\r
+ /// * If the end is past the edge of the vec.\r
+ /// * If the provided iterator panics.\r
+ /// * If the new length would overflow the capacity of the array. Because\r
+ /// `ArrayVecSplice` adds elements to this vec in its destructor when\r
+ /// necessary, this panic would occur when it is dropped.\r
+ ///\r
+ /// ## Example\r
+ /// ```rust\r
+ /// use tinyvec::*;\r
+ /// let mut av = array_vec!([i32; 4] => 1, 2, 3);\r
+ /// let av2: ArrayVec<[i32; 4]> = av.splice(1.., 4..=6).collect();\r
+ /// assert_eq!(av.as_slice(), &[1, 4, 5, 6][..]);\r
+ /// assert_eq!(av2.as_slice(), &[2, 3][..]);\r
+ ///\r
+ /// av.splice(.., None);\r
+ /// assert_eq!(av.as_slice(), &[]);\r
+ /// ```\r
+ #[inline]\r
+ pub fn splice<R, I>(\r
+ &mut self, range: R, replacement: I,\r
+ ) -> ArrayVecSplice<'_, A, core::iter::Fuse<I::IntoIter>>\r
+ where\r
+ R: RangeBounds<usize>,\r
+ I: IntoIterator<Item = A::Item>,\r
+ {\r
+ use core::ops::Bound;\r
+ let start = match range.start_bound() {\r
+ Bound::Included(x) => *x,\r
+ Bound::Excluded(x) => x.saturating_add(1),\r
+ Bound::Unbounded => 0,\r
+ };\r
+ let end = match range.end_bound() {\r
+ Bound::Included(x) => x.saturating_add(1),\r
+ Bound::Excluded(x) => *x,\r
+ Bound::Unbounded => self.len(),\r
+ };\r
+ assert!(\r
+ start <= end,\r
+ "ArrayVec::splice> Illegal range, {} to {}",\r
+ start,\r
+ end\r
+ );\r
+ assert!(\r
+ end <= self.len(),\r
+ "ArrayVec::splice> Range ends at {} but length is only {}!",\r
+ end,\r
+ self.len()\r
+ );\r
+\r
+ ArrayVecSplice {\r
+ removal_start: start,\r
+ removal_end: end,\r
+ parent: self,\r
+ replacement: replacement.into_iter().fuse(),\r
+ }\r
+ }\r
+\r
+ /// Remove an element, swapping the end of the vec into its place.\r
+ ///\r
+ /// ## Panics\r
+ /// * If the index is out of bounds.\r
+ ///\r
+ /// ## Example\r
+ /// ```rust\r
+ /// # use tinyvec::*;\r
+ /// let mut av = array_vec!([&str; 4] => "foo", "bar", "quack", "zap");\r
+ ///\r
+ /// assert_eq!(av.swap_remove(1), "bar");\r
+ /// assert_eq!(&av[..], ["foo", "zap", "quack"]);\r
+ ///\r
+ /// assert_eq!(av.swap_remove(0), "foo");\r
+ /// assert_eq!(&av[..], ["quack", "zap"]);\r
+ /// ```\r
+ #[inline]\r
+ pub fn swap_remove(&mut self, index: usize) -> A::Item {\r
+ assert!(\r
+ index < self.len(),\r
+ "ArrayVec::swap_remove> index {} is out of bounds {}",\r
+ index,\r
+ self.len\r
+ );\r
+ if index == self.len() - 1 {\r
+ self.pop().unwrap()\r
+ } else {\r
+ let i = self.pop().unwrap();\r
+ replace(&mut self[index], i)\r
+ }\r
+ }\r
+\r
+ /// Reduces the vec's length to the given value.\r
+ ///\r
+ /// If the vec is already shorter than the input, nothing happens.\r
+ #[inline]\r
+ pub fn truncate(&mut self, new_len: usize) {\r
+ if new_len >= self.len as usize {\r
+ return;\r
+ }\r
+\r
+ if needs_drop::<A::Item>() {\r
+ let len = self.len as usize;\r
+ self.data.as_slice_mut()[new_len..len]\r
+ .iter_mut()\r
+ .map(take)\r
+ .for_each(drop);\r
+ }\r
+\r
+ /* new_len is less than self.len */\r
+ self.len = new_len as u16;\r
+ }\r
+\r
+ /// Wraps an array, using the given length as the starting length.\r
+ ///\r
+ /// If you want to use the whole length of the array, you can just use the\r
+ /// `From` impl.\r
+ ///\r
+ /// ## Failure\r
+ ///\r
+ /// If the given length is greater than the capacity of the array this will\r
+ /// error, and you'll get the array back in the `Err`.\r
+ #[inline]\r
+ pub fn try_from_array_len(data: A, len: usize) -> Result<Self, A> {\r
+ /* Note(Soveu): Should we allow A::CAPACITY > u16::MAX for now? */\r
+ if len <= A::CAPACITY {\r
+ Ok(Self { data, len: len as u16 })\r
+ } else {\r
+ Err(data)\r
+ }\r
+ }\r
+}\r
+\r
+impl<A> ArrayVec<A> {\r
+ /// Wraps up an array as a new empty `ArrayVec`.\r
+ ///\r
+ /// If you want to simply use the full array, use `from` instead.\r
+ ///\r
+ /// ## Examples\r
+ ///\r
+ /// This method in particular allows to create values for statics:\r
+ ///\r
+ /// ```rust\r
+ /// # use tinyvec::ArrayVec;\r
+ /// static DATA: ArrayVec<[u8; 5]> = ArrayVec::from_array_empty([0; 5]);\r
+ /// assert_eq!(DATA.len(), 0);\r
+ /// ```\r
+ ///\r
+ /// But of course it is just an normal empty `ArrayVec`:\r
+ ///\r
+ /// ```rust\r
+ /// # use tinyvec::ArrayVec;\r
+ /// let mut data = ArrayVec::from_array_empty([1, 2, 3, 4]);\r
+ /// assert_eq!(&data[..], &[]);\r
+ /// data.push(42);\r
+ /// assert_eq!(&data[..], &[42]);\r
+ /// ```\r
+ #[inline]\r
+ #[must_use]\r
+ pub const fn from_array_empty(data: A) -> Self {\r
+ Self { data, len: 0 }\r
+ }\r
+}\r
+\r
+#[cfg(feature = "grab_spare_slice")]\r
+impl<A: Array> ArrayVec<A> {\r
+ /// Obtain the shared slice of the array _after_ the active memory.\r
+ ///\r
+ /// ## Example\r
+ /// ```rust\r
+ /// # use tinyvec::*;\r
+ /// let mut av = array_vec!([i32; 4]);\r
+ /// assert_eq!(av.grab_spare_slice().len(), 4);\r
+ /// av.push(10);\r
+ /// av.push(11);\r
+ /// av.push(12);\r
+ /// av.push(13);\r
+ /// assert_eq!(av.grab_spare_slice().len(), 0);\r
+ /// ```\r
+ #[inline(always)]\r
+ pub fn grab_spare_slice(&self) -> &[A::Item] {\r
+ &self.data.as_slice()[self.len as usize..]\r
+ }\r
+\r
+ /// Obtain the mutable slice of the array _after_ the active memory.\r
+ ///\r
+ /// ## Example\r
+ /// ```rust\r
+ /// # use tinyvec::*;\r
+ /// let mut av = array_vec!([i32; 4]);\r
+ /// assert_eq!(av.grab_spare_slice_mut().len(), 4);\r
+ /// av.push(10);\r
+ /// av.push(11);\r
+ /// assert_eq!(av.grab_spare_slice_mut().len(), 2);\r
+ /// ```\r
+ #[inline(always)]\r
+ pub fn grab_spare_slice_mut(&mut self) -> &mut [A::Item] {\r
+ &mut self.data.as_slice_mut()[self.len as usize..]\r
+ }\r
+}\r
+\r
+#[cfg(feature = "nightly_slice_partition_dedup")]\r
+impl<A: Array> ArrayVec<A> {\r
+ /// De-duplicates the vec contents.\r
+ #[inline(always)]\r
+ pub fn dedup(&mut self)\r
+ where\r
+ A::Item: PartialEq,\r
+ {\r
+ self.dedup_by(|a, b| a == b)\r
+ }\r
+\r
+ /// De-duplicates the vec according to the predicate given.\r
+ #[inline(always)]\r
+ pub fn dedup_by<F>(&mut self, same_bucket: F)\r
+ where\r
+ F: FnMut(&mut A::Item, &mut A::Item) -> bool,\r
+ {\r
+ let len = {\r
+ let (dedup, _) = self.as_mut_slice().partition_dedup_by(same_bucket);\r
+ dedup.len()\r
+ };\r
+ self.truncate(len);\r
+ }\r
+\r
+ /// De-duplicates the vec according to the key selector given.\r
+ #[inline(always)]\r
+ pub fn dedup_by_key<F, K>(&mut self, mut key: F)\r
+ where\r
+ F: FnMut(&mut A::Item) -> K,\r
+ K: PartialEq,\r
+ {\r
+ self.dedup_by(|a, b| key(a) == key(b))\r
+ }\r
+}\r
+\r
+/// Splicing iterator for `ArrayVec`\r
+/// See [`ArrayVec::splice`](ArrayVec::<A>::splice)\r
+pub struct ArrayVecSplice<'p, A: Array, I: Iterator<Item = A::Item>> {\r
+ parent: &'p mut ArrayVec<A>,\r
+ removal_start: usize,\r
+ removal_end: usize,\r
+ replacement: I,\r
+}\r
+\r
+impl<'p, A: Array, I: Iterator<Item = A::Item>> Iterator\r
+ for ArrayVecSplice<'p, A, I>\r
+{\r
+ type Item = A::Item;\r
+\r
+ #[inline]\r
+ fn next(&mut self) -> Option<A::Item> {\r
+ if self.removal_start < self.removal_end {\r
+ match self.replacement.next() {\r
+ Some(replacement) => {\r
+ let removed = core::mem::replace(\r
+ &mut self.parent[self.removal_start],\r
+ replacement,\r
+ );\r
+ self.removal_start += 1;\r
+ Some(removed)\r
+ }\r
+ None => {\r
+ let removed = self.parent.remove(self.removal_start);\r
+ self.removal_end -= 1;\r
+ Some(removed)\r
+ }\r
+ }\r
+ } else {\r
+ None\r
+ }\r
+ }\r
+\r
+ #[inline]\r
+ fn size_hint(&self) -> (usize, Option<usize>) {\r
+ let len = self.len();\r
+ (len, Some(len))\r
+ }\r
+}\r
+\r
+impl<'p, A, I> ExactSizeIterator for ArrayVecSplice<'p, A, I>\r
+where\r
+ A: Array,\r
+ I: Iterator<Item = A::Item>,\r
+{\r
+ #[inline]\r
+ fn len(&self) -> usize {\r
+ self.removal_end - self.removal_start\r
+ }\r
+}\r
+\r
+impl<'p, A, I> FusedIterator for ArrayVecSplice<'p, A, I>\r
+where\r
+ A: Array,\r
+ I: Iterator<Item = A::Item>,\r
+{\r
+}\r
+\r
+impl<'p, A, I> DoubleEndedIterator for ArrayVecSplice<'p, A, I>\r
+where\r
+ A: Array,\r
+ I: Iterator<Item = A::Item> + DoubleEndedIterator,\r
+{\r
+ #[inline]\r
+ fn next_back(&mut self) -> Option<A::Item> {\r
+ if self.removal_start < self.removal_end {\r
+ match self.replacement.next_back() {\r
+ Some(replacement) => {\r
+ let removed = core::mem::replace(\r
+ &mut self.parent[self.removal_end - 1],\r
+ replacement,\r
+ );\r
+ self.removal_end -= 1;\r
+ Some(removed)\r
+ }\r
+ None => {\r
+ let removed = self.parent.remove(self.removal_end - 1);\r
+ self.removal_end -= 1;\r
+ Some(removed)\r
+ }\r
+ }\r
+ } else {\r
+ None\r
+ }\r
+ }\r
+}\r
+\r
+impl<'p, A: Array, I: Iterator<Item = A::Item>> Drop\r
+ for ArrayVecSplice<'p, A, I>\r
+{\r
+ fn drop(&mut self) {\r
+ for _ in self.by_ref() {}\r
+\r
+ // FIXME: reserve lower bound of size_hint\r
+\r
+ for replacement in self.replacement.by_ref() {\r
+ self.parent.insert(self.removal_end, replacement);\r
+ self.removal_end += 1;\r
+ }\r
+ }\r
+}\r
+\r
+impl<A: Array> AsMut<[A::Item]> for ArrayVec<A> {\r
+ #[inline(always)]\r
+ #[must_use]\r
+ fn as_mut(&mut self) -> &mut [A::Item] {\r
+ &mut *self\r
+ }\r
+}\r
+\r
+impl<A: Array> AsRef<[A::Item]> for ArrayVec<A> {\r
+ #[inline(always)]\r
+ #[must_use]\r
+ fn as_ref(&self) -> &[A::Item] {\r
+ &*self\r
+ }\r
+}\r
+\r
+impl<A: Array> Borrow<[A::Item]> for ArrayVec<A> {\r
+ #[inline(always)]\r
+ #[must_use]\r
+ fn borrow(&self) -> &[A::Item] {\r
+ &*self\r
+ }\r
+}\r
+\r
+impl<A: Array> BorrowMut<[A::Item]> for ArrayVec<A> {\r
+ #[inline(always)]\r
+ #[must_use]\r
+ fn borrow_mut(&mut self) -> &mut [A::Item] {\r
+ &mut *self\r
+ }\r
+}\r
+\r
+impl<A: Array> Extend<A::Item> for ArrayVec<A> {\r
+ #[inline]\r
+ fn extend<T: IntoIterator<Item = A::Item>>(&mut self, iter: T) {\r
+ for t in iter {\r
+ self.push(t)\r
+ }\r
+ }\r
+}\r
+\r
+impl<A: Array> From<A> for ArrayVec<A> {\r
+ #[inline(always)]\r
+ #[must_use]\r
+ /// The output has a length equal to the full array.\r
+ ///\r
+ /// If you want to select a length, use\r
+ /// [`from_array_len`](ArrayVec::from_array_len)\r
+ fn from(data: A) -> Self {\r
+ let len: u16 = data\r
+ .as_slice()\r
+ .len()\r
+ .try_into()\r
+ .expect("ArrayVec::from> lenght must be in range 0..=u16::MAX");\r
+ Self { len, data }\r
+ }\r
+}\r
+\r
+/// The error type returned when a conversion from a slice to an [`ArrayVec`]\r
+/// fails.\r
+#[derive(Debug, Copy, Clone)]\r
+pub struct TryFromSliceError(());\r
+\r
+impl<T, A> TryFrom<&'_ [T]> for ArrayVec<A>\r
+where\r
+ T: Clone + Default,\r
+ A: Array<Item = T>,\r
+{\r
+ type Error = TryFromSliceError;\r
+\r
+ #[inline]\r
+ #[must_use]\r
+ /// The output has a length equal to that of the slice, with the same capacity\r
+ /// as `A`.\r
+ fn try_from(slice: &[T]) -> Result<Self, Self::Error> {\r
+ if slice.len() > A::CAPACITY {\r
+ Err(TryFromSliceError(()))\r
+ } else {\r
+ let mut arr = ArrayVec::new();\r
+ // We do not use ArrayVec::extend_from_slice, because it looks like LLVM\r
+ // fails to deduplicate all the length-checking logic between the\r
+ // above if and the contents of that method, thus producing much\r
+ // slower code. Unlike many of the other optimizations in this\r
+ // crate, this one is worth keeping an eye on. I see no reason, for\r
+ // any element type, that these should produce different code. But\r
+ // they do. (rustc 1.51.0)\r
+ arr.set_len(slice.len());\r
+ arr.as_mut_slice().clone_from_slice(slice);\r
+ Ok(arr)\r
+ }\r
+ }\r
+}\r
+\r
+impl<A: Array> FromIterator<A::Item> for ArrayVec<A> {\r
+ #[inline]\r
+ #[must_use]\r
+ fn from_iter<T: IntoIterator<Item = A::Item>>(iter: T) -> Self {\r
+ let mut av = Self::default();\r
+ for i in iter {\r
+ av.push(i)\r
+ }\r
+ av\r
+ }\r
+}\r
+\r
+/// Iterator for consuming an `ArrayVec` and returning owned elements.\r
+pub struct ArrayVecIterator<A: Array> {\r
+ base: u16,\r
+ tail: u16,\r
+ data: A,\r
+}\r
+\r
+impl<A: Array> ArrayVecIterator<A> {\r
+ /// Returns the remaining items of this iterator as a slice.\r
+ #[inline]\r
+ #[must_use]\r
+ pub fn as_slice(&self) -> &[A::Item] {\r
+ &self.data.as_slice()[self.base as usize..self.tail as usize]\r
+ }\r
+}\r
+impl<A: Array> FusedIterator for ArrayVecIterator<A> {}\r
+impl<A: Array> Iterator for ArrayVecIterator<A> {\r
+ type Item = A::Item;\r
+ #[inline]\r
+ fn next(&mut self) -> Option<Self::Item> {\r
+ let slice =\r
+ &mut self.data.as_slice_mut()[self.base as usize..self.tail as usize];\r
+ let itemref = slice.first_mut()?;\r
+ self.base += 1;\r
+ return Some(take(itemref));\r
+ }\r
+ #[inline(always)]\r
+ #[must_use]\r
+ fn size_hint(&self) -> (usize, Option<usize>) {\r
+ let s = self.tail - self.base;\r
+ let s = s as usize;\r
+ (s, Some(s))\r
+ }\r
+ #[inline(always)]\r
+ fn count(self) -> usize {\r
+ self.size_hint().0\r
+ }\r
+ #[inline]\r
+ fn last(mut self) -> Option<Self::Item> {\r
+ self.next_back()\r
+ }\r
+ #[inline]\r
+ fn nth(&mut self, n: usize) -> Option<A::Item> {\r
+ let slice = &mut self.data.as_slice_mut();\r
+ let slice = &mut slice[self.base as usize..self.tail as usize];\r
+\r
+ if let Some(x) = slice.get_mut(n) {\r
+ /* n is in range [0 .. self.tail - self.base) so in u16 range */\r
+ self.base += n as u16 + 1;\r
+ return Some(take(x));\r
+ }\r
+\r
+ self.base = self.tail;\r
+ return None;\r
+ }\r
+}\r
+\r
+impl<A: Array> DoubleEndedIterator for ArrayVecIterator<A> {\r
+ #[inline]\r
+ fn next_back(&mut self) -> Option<Self::Item> {\r
+ let slice =\r
+ &mut self.data.as_slice_mut()[self.base as usize..self.tail as usize];\r
+ let item = slice.last_mut()?;\r
+ self.tail -= 1;\r
+ return Some(take(item));\r
+ }\r
+ #[cfg(feature = "rustc_1_40")]\r
+ #[inline]\r
+ fn nth_back(&mut self, n: usize) -> Option<Self::Item> {\r
+ let base = self.base as usize;\r
+ let tail = self.tail as usize;\r
+ let slice = &mut self.data.as_slice_mut()[base..tail];\r
+ let n = n.saturating_add(1);\r
+\r
+ if let Some(n) = slice.len().checked_sub(n) {\r
+ let item = &mut slice[n];\r
+ /* n is in [0..self.tail - self.base] range, so in u16 range */\r
+ self.tail = self.base + n as u16;\r
+ return Some(take(item));\r
+ }\r
+\r
+ self.tail = self.base;\r
+ return None;\r
+ }\r
+}\r
+\r
+impl<A: Array> Debug for ArrayVecIterator<A>\r
+where\r
+ A::Item: Debug,\r
+{\r
+ #[allow(clippy::missing_inline_in_public_items)]\r
+ fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {\r
+ f.debug_tuple("ArrayVecIterator").field(&self.as_slice()).finish()\r
+ }\r
+}\r
+\r
+impl<A: Array> IntoIterator for ArrayVec<A> {\r
+ type Item = A::Item;\r
+ type IntoIter = ArrayVecIterator<A>;\r
+ #[inline(always)]\r
+ #[must_use]\r
+ fn into_iter(self) -> Self::IntoIter {\r
+ ArrayVecIterator { base: 0, tail: self.len, data: self.data }\r
+ }\r
+}\r
+\r
+impl<'a, A: Array> IntoIterator for &'a mut ArrayVec<A> {\r
+ type Item = &'a mut A::Item;\r
+ type IntoIter = core::slice::IterMut<'a, A::Item>;\r
+ #[inline(always)]\r
+ #[must_use]\r
+ fn into_iter(self) -> Self::IntoIter {\r
+ self.iter_mut()\r
+ }\r
+}\r
+\r
+impl<'a, A: Array> IntoIterator for &'a ArrayVec<A> {\r
+ type Item = &'a A::Item;\r
+ type IntoIter = core::slice::Iter<'a, A::Item>;\r
+ #[inline(always)]\r
+ #[must_use]\r
+ fn into_iter(self) -> Self::IntoIter {\r
+ self.iter()\r
+ }\r
+}\r
+\r
+impl<A: Array> PartialEq for ArrayVec<A>\r
+where\r
+ A::Item: PartialEq,\r
+{\r
+ #[inline]\r
+ #[must_use]\r
+ fn eq(&self, other: &Self) -> bool {\r
+ self.as_slice().eq(other.as_slice())\r
+ }\r
+}\r
+impl<A: Array> Eq for ArrayVec<A> where A::Item: Eq {}\r
+\r
+impl<A: Array> PartialOrd for ArrayVec<A>\r
+where\r
+ A::Item: PartialOrd,\r
+{\r
+ #[inline]\r
+ #[must_use]\r
+ fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {\r
+ self.as_slice().partial_cmp(other.as_slice())\r
+ }\r
+}\r
+impl<A: Array> Ord for ArrayVec<A>\r
+where\r
+ A::Item: Ord,\r
+{\r
+ #[inline]\r
+ #[must_use]\r
+ fn cmp(&self, other: &Self) -> core::cmp::Ordering {\r
+ self.as_slice().cmp(other.as_slice())\r
+ }\r
+}\r
+\r
+impl<A: Array> PartialEq<&A> for ArrayVec<A>\r
+where\r
+ A::Item: PartialEq,\r
+{\r
+ #[inline]\r
+ #[must_use]\r
+ fn eq(&self, other: &&A) -> bool {\r
+ self.as_slice().eq(other.as_slice())\r
+ }\r
+}\r
+\r
+impl<A: Array> PartialEq<&[A::Item]> for ArrayVec<A>\r
+where\r
+ A::Item: PartialEq,\r
+{\r
+ #[inline]\r
+ #[must_use]\r
+ fn eq(&self, other: &&[A::Item]) -> bool {\r
+ self.as_slice().eq(*other)\r
+ }\r
+}\r
+\r
+impl<A: Array> Hash for ArrayVec<A>\r
+where\r
+ A::Item: Hash,\r
+{\r
+ #[inline]\r
+ fn hash<H: Hasher>(&self, state: &mut H) {\r
+ self.as_slice().hash(state)\r
+ }\r
+}\r
+\r
+#[cfg(feature = "experimental_write_impl")]\r
+impl<A: Array<Item = u8>> core::fmt::Write for ArrayVec<A> {\r
+ fn write_str(&mut self, s: &str) -> core::fmt::Result {\r
+ let my_len = self.len();\r
+ let str_len = s.as_bytes().len();\r
+ if my_len + str_len <= A::CAPACITY {\r
+ let remainder = &mut self.data.as_slice_mut()[my_len..];\r
+ let target = &mut remainder[..str_len];\r
+ target.copy_from_slice(s.as_bytes());\r
+ Ok(())\r
+ } else {\r
+ Err(core::fmt::Error)\r
+ }\r
+ }\r
+}\r
+\r
+// // // // // // // //\r
+// Formatting impls\r
+// // // // // // // //\r
+\r
+impl<A: Array> Binary for ArrayVec<A>\r
+where\r
+ A::Item: Binary,\r
+{\r
+ #[allow(clippy::missing_inline_in_public_items)]\r
+ fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {\r
+ write!(f, "[")?;\r
+ if f.alternate() {\r
+ write!(f, "\n ")?;\r
+ }\r
+ for (i, elem) in self.iter().enumerate() {\r
+ if i > 0 {\r
+ write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;\r
+ }\r
+ Binary::fmt(elem, f)?;\r
+ }\r
+ if f.alternate() {\r
+ write!(f, ",\n")?;\r
+ }\r
+ write!(f, "]")\r
+ }\r
+}\r
+\r
+impl<A: Array> Debug for ArrayVec<A>\r
+where\r
+ A::Item: Debug,\r
+{\r
+ #[allow(clippy::missing_inline_in_public_items)]\r
+ fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {\r
+ write!(f, "[")?;\r
+ if f.alternate() {\r
+ write!(f, "\n ")?;\r
+ }\r
+ for (i, elem) in self.iter().enumerate() {\r
+ if i > 0 {\r
+ write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;\r
+ }\r
+ Debug::fmt(elem, f)?;\r
+ }\r
+ if f.alternate() {\r
+ write!(f, ",\n")?;\r
+ }\r
+ write!(f, "]")\r
+ }\r
+}\r
+\r
+impl<A: Array> Display for ArrayVec<A>\r
+where\r
+ A::Item: Display,\r
+{\r
+ #[allow(clippy::missing_inline_in_public_items)]\r
+ fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {\r
+ write!(f, "[")?;\r
+ if f.alternate() {\r
+ write!(f, "\n ")?;\r
+ }\r
+ for (i, elem) in self.iter().enumerate() {\r
+ if i > 0 {\r
+ write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;\r
+ }\r
+ Display::fmt(elem, f)?;\r
+ }\r
+ if f.alternate() {\r
+ write!(f, ",\n")?;\r
+ }\r
+ write!(f, "]")\r
+ }\r
+}\r
+\r
+impl<A: Array> LowerExp for ArrayVec<A>\r
+where\r
+ A::Item: LowerExp,\r
+{\r
+ #[allow(clippy::missing_inline_in_public_items)]\r
+ fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {\r
+ write!(f, "[")?;\r
+ if f.alternate() {\r
+ write!(f, "\n ")?;\r
+ }\r
+ for (i, elem) in self.iter().enumerate() {\r
+ if i > 0 {\r
+ write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;\r
+ }\r
+ LowerExp::fmt(elem, f)?;\r
+ }\r
+ if f.alternate() {\r
+ write!(f, ",\n")?;\r
+ }\r
+ write!(f, "]")\r
+ }\r
+}\r
+\r
+impl<A: Array> LowerHex for ArrayVec<A>\r
+where\r
+ A::Item: LowerHex,\r
+{\r
+ #[allow(clippy::missing_inline_in_public_items)]\r
+ fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {\r
+ write!(f, "[")?;\r
+ if f.alternate() {\r
+ write!(f, "\n ")?;\r
+ }\r
+ for (i, elem) in self.iter().enumerate() {\r
+ if i > 0 {\r
+ write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;\r
+ }\r
+ LowerHex::fmt(elem, f)?;\r
+ }\r
+ if f.alternate() {\r
+ write!(f, ",\n")?;\r
+ }\r
+ write!(f, "]")\r
+ }\r
+}\r
+\r
+impl<A: Array> Octal for ArrayVec<A>\r
+where\r
+ A::Item: Octal,\r
+{\r
+ #[allow(clippy::missing_inline_in_public_items)]\r
+ fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {\r
+ write!(f, "[")?;\r
+ if f.alternate() {\r
+ write!(f, "\n ")?;\r
+ }\r
+ for (i, elem) in self.iter().enumerate() {\r
+ if i > 0 {\r
+ write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;\r
+ }\r
+ Octal::fmt(elem, f)?;\r
+ }\r
+ if f.alternate() {\r
+ write!(f, ",\n")?;\r
+ }\r
+ write!(f, "]")\r
+ }\r
+}\r
+\r
+impl<A: Array> Pointer for ArrayVec<A>\r
+where\r
+ A::Item: Pointer,\r
+{\r
+ #[allow(clippy::missing_inline_in_public_items)]\r
+ fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {\r
+ write!(f, "[")?;\r
+ if f.alternate() {\r
+ write!(f, "\n ")?;\r
+ }\r
+ for (i, elem) in self.iter().enumerate() {\r
+ if i > 0 {\r
+ write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;\r
+ }\r
+ Pointer::fmt(elem, f)?;\r
+ }\r
+ if f.alternate() {\r
+ write!(f, ",\n")?;\r
+ }\r
+ write!(f, "]")\r
+ }\r
+}\r
+\r
+impl<A: Array> UpperExp for ArrayVec<A>\r
+where\r
+ A::Item: UpperExp,\r
+{\r
+ #[allow(clippy::missing_inline_in_public_items)]\r
+ fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {\r
+ write!(f, "[")?;\r
+ if f.alternate() {\r
+ write!(f, "\n ")?;\r
+ }\r
+ for (i, elem) in self.iter().enumerate() {\r
+ if i > 0 {\r
+ write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;\r
+ }\r
+ UpperExp::fmt(elem, f)?;\r
+ }\r
+ if f.alternate() {\r
+ write!(f, ",\n")?;\r
+ }\r
+ write!(f, "]")\r
+ }\r
+}\r
+\r
+impl<A: Array> UpperHex for ArrayVec<A>\r
+where\r
+ A::Item: UpperHex,\r
+{\r
+ #[allow(clippy::missing_inline_in_public_items)]\r
+ fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {\r
+ write!(f, "[")?;\r
+ if f.alternate() {\r
+ write!(f, "\n ")?;\r
+ }\r
+ for (i, elem) in self.iter().enumerate() {\r
+ if i > 0 {\r
+ write!(f, ",{}", if f.alternate() { "\n " } else { " " })?;\r
+ }\r
+ UpperHex::fmt(elem, f)?;\r
+ }\r
+ if f.alternate() {\r
+ write!(f, ",\n")?;\r
+ }\r
+ write!(f, "]")\r
+ }\r
+}\r
+\r
+#[cfg(feature = "alloc")]\r
+use alloc::vec::Vec;\r
+\r
+#[cfg(feature = "alloc")]\r
+impl<A: Array> ArrayVec<A> {\r
+ /// Drains all elements to a Vec, but reserves additional space\r
+ /// ```\r
+ /// # use tinyvec::*;\r
+ /// let mut av = array_vec!([i32; 7] => 1, 2, 3);\r
+ /// let v = av.drain_to_vec_and_reserve(10);\r
+ /// assert_eq!(v, &[1, 2, 3]);\r
+ /// assert_eq!(v.capacity(), 13);\r
+ /// ```\r
+ pub fn drain_to_vec_and_reserve(&mut self, n: usize) -> Vec<A::Item> {\r
+ let cap = n + self.len();\r
+ let mut v = Vec::with_capacity(cap);\r
+ let iter = self.iter_mut().map(take);\r
+ v.extend(iter);\r
+ self.set_len(0);\r
+ return v;\r
+ }\r
+\r
+ /// Drains all elements to a Vec\r
+ /// ```\r
+ /// # use tinyvec::*;\r
+ /// let mut av = array_vec!([i32; 7] => 1, 2, 3);\r
+ /// let v = av.drain_to_vec();\r
+ /// assert_eq!(v, &[1, 2, 3]);\r
+ /// assert_eq!(v.capacity(), 3);\r
+ /// ```\r
+ pub fn drain_to_vec(&mut self) -> Vec<A::Item> {\r
+ self.drain_to_vec_and_reserve(0)\r
+ }\r
+}\r
+\r
+#[cfg(feature = "serde")]\r
+struct ArrayVecVisitor<A: Array>(PhantomData<A>);\r
+\r
+#[cfg(feature = "serde")]\r
+impl<'de, A: Array> Visitor<'de> for ArrayVecVisitor<A>\r
+where\r
+ A::Item: Deserialize<'de>,\r
+{\r
+ type Value = ArrayVec<A>;\r
+\r
+ fn expecting(\r
+ &self, formatter: &mut core::fmt::Formatter,\r
+ ) -> core::fmt::Result {\r
+ formatter.write_str("a sequence")\r
+ }\r
+\r
+ fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>\r
+ where\r
+ S: SeqAccess<'de>,\r
+ {\r
+ let mut new_arrayvec: ArrayVec<A> = Default::default();\r
+\r
+ let mut idx = 0usize;\r
+ while let Some(value) = seq.next_element()? {\r
+ if new_arrayvec.len() >= new_arrayvec.capacity() {\r
+ return Err(DeserializeError::invalid_length(idx, &self));\r
+ }\r
+ new_arrayvec.push(value);\r
+ idx = idx + 1;\r
+ }\r
+\r
+ Ok(new_arrayvec)\r
+ }\r
+}\r
projects / cargo.git / blobdiff