[rustc.git] / vendor / tinyvec / src / tinyvec.rs

#![cfg(feature = "alloc")]\r
\r
use super::*;\r
\r
use alloc::vec::{self, Vec};\r
use core::convert::TryFrom;\r
use tinyvec_macros::impl_mirrored;\r
\r
#[cfg(feature = "serde")]\r
use core::marker::PhantomData;\r
#[cfg(feature = "serde")]\r
use serde::de::{Deserialize, Deserializer, SeqAccess, Visitor};\r
#[cfg(feature = "serde")]\r
use serde::ser::{Serialize, SerializeSeq, Serializer};\r
\r
/// Helper to make a `TinyVec`.\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_tv = tiny_vec!([u8; 16]);\r
/// let some_ints = tiny_vec!([i32; 4] => 1, 2, 3);\r
/// let many_ints = tiny_vec!([i32; 4] => 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);\r
///\r
/// // Or left to inference\r
/// let empty_tv: TinyVec<[u8; 16]> = tiny_vec!();\r
/// let some_ints: TinyVec<[i32; 4]> = tiny_vec!(1, 2, 3);\r
/// let many_ints: TinyVec<[i32; 4]> = tiny_vec!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);\r
/// ```\r
#[macro_export]\r
#[cfg_attr(docs_rs, doc(cfg(feature = "alloc")))]\r
macro_rules! tiny_vec {\r
  ($array_type:ty => $($elem:expr),* $(,)?) => {\r
    {\r
      // https://github.com/rust-lang/lang-team/issues/28\r
      const INVOKED_ELEM_COUNT: usize = 0 $( + { let _ = stringify!($elem); 1 })*;\r
      // If we have more `$elem` than the `CAPACITY` we will simply go directly\r
      // to constructing on the heap.\r
      match $crate::TinyVec::constructor_for_capacity(INVOKED_ELEM_COUNT) {\r
        $crate::TinyVecConstructor::Inline(f) => {\r
          f($crate::array_vec!($array_type => $($elem),*))\r
        }\r
        $crate::TinyVecConstructor::Heap(f) => {\r
          f(vec!($($elem),*))\r
        }\r
      }\r
    }\r
  };\r
  ($array_type:ty) => {\r
    $crate::TinyVec::<$array_type>::default()\r
  };\r
  ($($elem:expr),*) => {\r
    $crate::tiny_vec!(_ => $($elem),*)\r
  };\r
  ($elem:expr; $n:expr) => {\r
    $crate::TinyVec::from([$elem; $n])\r
  };\r
  () => {\r
    $crate::tiny_vec!(_)\r
  };\r
}\r
\r
#[doc(hidden)] // Internal implementation details of `tiny_vec!`\r
pub enum TinyVecConstructor<A: Array> {\r
  Inline(fn(ArrayVec<A>) -> TinyVec<A>),\r
  Heap(fn(Vec<A::Item>) -> TinyVec<A>),\r
}\r
\r
/// A vector that starts inline, but can automatically move to the heap.\r
///\r
/// * Requires the `alloc` feature\r
///\r
/// A `TinyVec` is either an Inline([`ArrayVec`](crate::ArrayVec::<A>)) or\r
/// Heap([`Vec`](https://doc.rust-lang.org/alloc/vec/struct.Vec.html)). The\r
/// interface for the type as a whole is a bunch of methods that just match on\r
/// the enum variant and then call the same method on the inner vec.\r
///\r
/// ## Construction\r
///\r
/// Because it's an enum, you can construct a `TinyVec` simply by making an\r
/// `ArrayVec` or `Vec` and then putting it into the enum.\r
///\r
/// There is also a macro\r
///\r
/// ```rust\r
/// # use tinyvec::*;\r
/// let empty_tv = tiny_vec!([u8; 16]);\r
/// let some_ints = tiny_vec!([i32; 4] => 1, 2, 3);\r
/// ```\r
#[cfg_attr(docs_rs, doc(cfg(feature = "alloc")))]\r
pub enum TinyVec<A: Array> {\r
  #[allow(missing_docs)]\r
  Inline(ArrayVec<A>),\r
  #[allow(missing_docs)]\r
  Heap(Vec<A::Item>),\r
}\r
\r
impl<A> Clone for TinyVec<A>\r
where\r
  A: Array + Clone,\r
  A::Item: Clone,\r
{\r
  #[inline]\r
  fn clone(&self) -> Self {\r
    match self {\r
      Self::Heap(v) => Self::Heap(v.clone()),\r
      Self::Inline(v) => Self::Inline(v.clone()),\r
    }\r
  }\r
\r
  #[inline]\r
  fn clone_from(&mut self, o: &Self) {\r
    if o.len() > self.len() {\r
      self.reserve(o.len() - self.len());\r
    } else {\r
      self.truncate(o.len());\r
    }\r
    let (start, end) = o.split_at(self.len());\r
    for (dst, src) in self.iter_mut().zip(start) {\r
      dst.clone_from(src);\r
    }\r
    self.extend_from_slice(end);\r
  }\r
}\r
\r
impl<A: Array> Default for TinyVec<A> {\r
  #[inline]\r
  #[must_use]\r
  fn default() -> Self {\r
    TinyVec::Inline(ArrayVec::default())\r
  }\r
}\r
\r
impl<A: Array> Deref for TinyVec<A> {\r
  type Target = [A::Item];\r
\r
  impl_mirrored! {\r
    type Mirror = TinyVec;\r
    #[inline(always)]\r
    #[must_use]\r
    fn deref(self: &Self) -> &Self::Target;\r
  }\r
}\r
\r
impl<A: Array> DerefMut for TinyVec<A> {\r
  impl_mirrored! {\r
    type Mirror = TinyVec;\r
    #[inline(always)]\r
    #[must_use]\r
    fn deref_mut(self: &mut Self) -> &mut Self::Target;\r
  }\r
}\r
\r
impl<A: Array, I: SliceIndex<[A::Item]>> Index<I> for TinyVec<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 TinyVec<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 TinyVec<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 TinyVec<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(TinyVecVisitor(PhantomData))\r
  }\r
}\r
\r
#[cfg(feature = "arbitrary")]\r
#[cfg_attr(docs_rs, doc(cfg(feature = "arbitrary")))]\r
impl<'a, A> arbitrary::Arbitrary<'a> for TinyVec<A>\r
where\r
  A: Array,\r
  A::Item: arbitrary::Arbitrary<'a>,\r
{\r
  fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {\r
    let v = Vec::arbitrary(u)?;\r
    let mut tv = TinyVec::Heap(v);\r
    tv.shrink_to_fit();\r
    Ok(tv)\r
  }\r
}\r
\r
impl<A: Array> TinyVec<A> {\r
  /// Returns whether elements are on heap\r
  #[inline(always)]\r
  #[must_use]\r
  pub fn is_heap(&self) -> bool {\r
    match self {\r
      TinyVec::Heap(_) => true,\r
      TinyVec::Inline(_) => false,\r
    }\r
  }\r
  /// Returns whether elements are on stack\r
  #[inline(always)]\r
  #[must_use]\r
  pub fn is_inline(&self) -> bool {\r
    !self.is_heap()\r
  }\r
\r
  /// Shrinks the capacity of the vector as much as possible.\\r
  /// It is inlined if length is less than `A::CAPACITY`.\r
  /// ```rust\r
  /// use tinyvec::*;\r
  /// let mut tv = tiny_vec!([i32; 2] => 1, 2, 3);\r
  /// assert!(tv.is_heap());\r
  /// let _ = tv.pop();\r
  /// assert!(tv.is_heap());\r
  /// tv.shrink_to_fit();\r
  /// assert!(tv.is_inline());\r
  /// ```\r
  pub fn shrink_to_fit(&mut self) {\r
    let vec = match self {\r
      TinyVec::Inline(_) => return,\r
      TinyVec::Heap(h) => h,\r
    };\r
\r
    if vec.len() > A::CAPACITY {\r
      return vec.shrink_to_fit();\r
    }\r
\r
    let moved_vec = core::mem::replace(vec, Vec::new());\r
\r
    let mut av = ArrayVec::default();\r
    let mut rest = av.fill(moved_vec);\r
    debug_assert!(rest.next().is_none());\r
    *self = TinyVec::Inline(av);\r
  }\r
\r
  /// Moves the content of the TinyVec to the heap, if it's inline.\r
  /// ```rust\r
  /// use tinyvec::*;\r
  /// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);\r
  /// assert!(tv.is_inline());\r
  /// tv.move_to_the_heap();\r
  /// assert!(tv.is_heap());\r
  /// ```\r
  #[allow(clippy::missing_inline_in_public_items)]\r
  pub fn move_to_the_heap(&mut self) {\r
    let arr = match self {\r
      TinyVec::Heap(_) => return,\r
      TinyVec::Inline(a) => a,\r
    };\r
\r
    let v = arr.drain_to_vec();\r
    *self = TinyVec::Heap(v);\r
  }\r
\r
  /// If TinyVec is inline, moves the content of it to the heap.\r
  /// Also reserves additional space.\r
  /// ```rust\r
  /// use tinyvec::*;\r
  /// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);\r
  /// assert!(tv.is_inline());\r
  /// tv.move_to_the_heap_and_reserve(32);\r
  /// assert!(tv.is_heap());\r
  /// assert!(tv.capacity() >= 35);\r
  /// ```\r
  pub fn move_to_the_heap_and_reserve(&mut self, n: usize) {\r
    let arr = match self {\r
      TinyVec::Heap(h) => return h.reserve(n),\r
      TinyVec::Inline(a) => a,\r
    };\r
\r
    let v = arr.drain_to_vec_and_reserve(n);\r
    *self = TinyVec::Heap(v);\r
  }\r
\r
  /// Reserves additional space.\r
  /// Moves to the heap if array can't hold `n` more items\r
  /// ```rust\r
  /// use tinyvec::*;\r
  /// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3, 4);\r
  /// assert!(tv.is_inline());\r
  /// tv.reserve(1);\r
  /// assert!(tv.is_heap());\r
  /// assert!(tv.capacity() >= 5);\r
  /// ```\r
  pub fn reserve(&mut self, n: usize) {\r
    let arr = match self {\r
      TinyVec::Heap(h) => return h.reserve(n),\r
      TinyVec::Inline(a) => a,\r
    };\r
\r
    if n > arr.capacity() - arr.len() {\r
      let v = arr.drain_to_vec_and_reserve(n);\r
      *self = TinyVec::Heap(v);\r
    }\r
\r
    /* In this place array has enough place, so no work is needed more */\r
    return;\r
  }\r
\r
  /// Reserves additional space.\r
  /// Moves to the heap if array can't hold `n` more items\r
  ///\r
  /// From [Vec::reserve_exact](https://doc.rust-lang.org/std/vec/struct.Vec.html#method.reserve_exact)\r
  /// ```text\r
  /// Note that the allocator may give the collection more space than it requests.\r
  /// Therefore, capacity can not be relied upon to be precisely minimal.\r
  /// Prefer `reserve` if future insertions are expected.\r
  /// ```\r
  /// ```rust\r
  /// use tinyvec::*;\r
  /// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3, 4);\r
  /// assert!(tv.is_inline());\r
  /// tv.reserve_exact(1);\r
  /// assert!(tv.is_heap());\r
  /// assert!(tv.capacity() >= 5);\r
  /// ```\r
  pub fn reserve_exact(&mut self, n: usize) {\r
    let arr = match self {\r
      TinyVec::Heap(h) => return h.reserve_exact(n),\r
      TinyVec::Inline(a) => a,\r
    };\r
\r
    if n > arr.capacity() - arr.len() {\r
      let v = arr.drain_to_vec_and_reserve(n);\r
      *self = TinyVec::Heap(v);\r
    }\r
\r
    /* In this place array has enough place, so no work is needed more */\r
    return;\r
  }\r
\r
  /// Makes a new TinyVec with _at least_ the given capacity.\r
  ///\r
  /// If the requested capacity is less than or equal to the array capacity you\r
  /// get an inline vec. If it's greater than you get a heap vec.\r
  /// ```\r
  /// # use tinyvec::*;\r
  /// let t = TinyVec::<[u8; 10]>::with_capacity(5);\r
  /// assert!(t.is_inline());\r
  /// assert!(t.capacity() >= 5);\r
  ///\r
  /// let t = TinyVec::<[u8; 10]>::with_capacity(20);\r
  /// assert!(t.is_heap());\r
  /// assert!(t.capacity() >= 20);\r
  /// ```\r
  #[inline]\r
  #[must_use]\r
  pub fn with_capacity(cap: usize) -> Self {\r
    if cap <= A::CAPACITY {\r
      TinyVec::Inline(ArrayVec::default())\r
    } else {\r
      TinyVec::Heap(Vec::with_capacity(cap))\r
    }\r
  }\r
}\r
\r
impl<A: Array> TinyVec<A> {\r
  /// Move all values from `other` into this vec.\r
  #[cfg(feature = "rustc_1_40")]\r
  #[inline]\r
  pub fn append(&mut self, other: &mut Self) {\r
    self.reserve(other.len());\r
\r
    /* Doing append should be faster, because it is effectively a memcpy */\r
    match (self, other) {\r
      (TinyVec::Heap(sh), TinyVec::Heap(oh)) => sh.append(oh),\r
      (TinyVec::Inline(a), TinyVec::Heap(h)) => a.extend(h.drain(..)),\r
      (ref mut this, TinyVec::Inline(arr)) => this.extend(arr.drain(..)),\r
    }\r
  }\r
\r
  /// Move all values from `other` into this vec.\r
  #[cfg(not(feature = "rustc_1_40"))]\r
  #[inline]\r
  pub fn append(&mut self, other: &mut Self) {\r
    match other {\r
      TinyVec::Inline(a) => self.extend(a.drain(..)),\r
      TinyVec::Heap(h) => self.extend(h.drain(..)),\r
    }\r
  }\r
\r
  impl_mirrored! {\r
    type Mirror = TinyVec;\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 tv = tiny_vec!([&str; 4] => "foo", "bar", "quack", "zap");\r
    ///\r
    /// assert_eq!(tv.swap_remove(1), "bar");\r
    /// assert_eq!(tv.as_slice(), &["foo", "zap", "quack"][..]);\r
    ///\r
    /// assert_eq!(tv.swap_remove(0), "foo");\r
    /// assert_eq!(tv.as_slice(), &["quack", "zap"][..]);\r
    /// ```\r
    #[inline]\r
    pub fn swap_remove(self: &mut Self, index: usize) -> A::Item;\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
    #[inline]\r
    pub fn pop(self: &mut Self) -> Option<A::Item>;\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 tv = tiny_vec!([i32; 4] => 1, 2, 3);\r
    /// assert_eq!(tv.remove(1), 2);\r
    /// assert_eq!(tv.as_slice(), &[1, 3][..]);\r
    /// ```\r
    #[inline]\r
    pub fn remove(self: &mut Self, index: usize) -> A::Item;\r
\r
    /// The length of the vec (in elements).\r
    #[inline(always)]\r
    #[must_use]\r
    pub fn len(self: &Self) -> usize;\r
\r
    /// The capacity of the `TinyVec`.\r
    ///\r
    /// When not heap allocated this is fixed based on the array type.\r
    /// Otherwise its the result of the underlying Vec::capacity.\r
    #[inline(always)]\r
    #[must_use]\r
    pub fn capacity(self: &Self) -> usize;\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(self: &mut Self, new_len: usize);\r
\r
    /// A mutable pointer to the backing array.\r
    ///\r
    /// ## Safety\r
    ///\r
    /// This pointer has provenance over the _entire_ backing array/buffer.\r
    #[inline(always)]\r
    #[must_use]\r
    pub fn as_mut_ptr(self: &mut Self) -> *mut A::Item;\r
\r
    /// A const pointer to the backing array.\r
    ///\r
    /// ## Safety\r
    ///\r
    /// This pointer has provenance over the _entire_ backing array/buffer.\r
    #[inline(always)]\r
    #[must_use]\r
    pub fn as_ptr(self: &Self) -> *const A::Item;\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 tv = tiny_vec!([i32; 10] => 1, 2, 3, 4);\r
  /// tv.retain(|&x| x % 2 == 0);\r
  /// assert_eq!(tv.as_slice(), &[2, 4][..]);\r
  /// ```\r
  #[inline]\r
  pub fn retain<F: FnMut(&A::Item) -> bool>(self: &mut Self, acceptable: F) {\r
    match self {\r
      TinyVec::Inline(i) => i.retain(acceptable),\r
      TinyVec::Heap(h) => h.retain(acceptable),\r
    }\r
  }\r
\r
  /// Helper for getting the mut slice.\r
  #[inline(always)]\r
  #[must_use]\r
  pub fn as_mut_slice(self: &mut Self) -> &mut [A::Item] {\r
    self.deref_mut()\r
  }\r
\r
  /// Helper for getting the shared slice.\r
  #[inline(always)]\r
  #[must_use]\r
  pub fn as_slice(self: &Self) -> &[A::Item] {\r
    self.deref()\r
  }\r
\r
  /// Removes all elements from the vec.\r
  #[inline(always)]\r
  pub fn clear(&mut self) {\r
    self.truncate(0)\r
  }\r
\r
  /// De-duplicates the vec.\r
  #[cfg(feature = "nightly_slice_partition_dedup")]\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
  #[cfg(feature = "nightly_slice_partition_dedup")]\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
  #[cfg(feature = "nightly_slice_partition_dedup")]\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
  /// Creates a draining iterator that removes the specified range in the vector\r
  /// and yields the removed items.\r
  ///\r
  /// **Note: This method has significant performance issues compared to\r
  /// matching on the TinyVec and then calling drain on the Inline or Heap value\r
  /// inside. The draining iterator has to branch on every single access. It is\r
  /// provided for simplicity and compatability only.**\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 tv = tiny_vec!([i32; 4] => 1, 2, 3);\r
  /// let tv2: TinyVec<[i32; 4]> = tv.drain(1..).collect();\r
  /// assert_eq!(tv.as_slice(), &[1][..]);\r
  /// assert_eq!(tv2.as_slice(), &[2, 3][..]);\r
  ///\r
  /// tv.drain(..);\r
  /// assert_eq!(tv.as_slice(), &[]);\r
  /// ```\r
  #[inline]\r
  pub fn drain<R: RangeBounds<usize>>(\r
    &mut self, range: R,\r
  ) -> TinyVecDrain<'_, A> {\r
    match self {\r
      TinyVec::Inline(i) => TinyVecDrain::Inline(i.drain(range)),\r
      TinyVec::Heap(h) => TinyVecDrain::Heap(h.drain(range)),\r
    }\r
  }\r
\r
  /// Clone each element of the slice into this vec.\r
  /// ```rust\r
  /// use tinyvec::*;\r
  /// let mut tv = tiny_vec!([i32; 4] => 1, 2);\r
  /// tv.extend_from_slice(&[3, 4]);\r
  /// assert_eq!(tv.as_slice(), [1, 2, 3, 4]);\r
  /// ```\r
  #[inline]\r
  pub fn extend_from_slice(&mut self, sli: &[A::Item])\r
  where\r
    A::Item: Clone,\r
  {\r
    self.reserve(sli.len());\r
    match self {\r
      TinyVec::Inline(a) => a.extend_from_slice(sli),\r
      TinyVec::Heap(h) => h.extend_from_slice(sli),\r
    }\r
  }\r
\r
  /// Wraps up an array and uses the given length as the initial length.\r
  ///\r
  /// Note that the `From` impl for arrays assumes the full length is used.\r
  ///\r
  /// ## Panics\r
  ///\r
  /// The length must be less than or equal to the capacity of the 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(_) => {\r
        panic!("TinyVec: length {} exceeds capacity {}!", len, A::CAPACITY)\r
      }\r
    }\r
  }\r
\r
  /// This is an internal implementation detail of the `tiny_vec!` macro, and\r
  /// using it other than from that macro is not supported by this crate's\r
  /// SemVer guarantee.\r
  #[inline(always)]\r
  #[doc(hidden)]\r
  pub fn constructor_for_capacity(cap: usize) -> TinyVecConstructor<A> {\r
    if cap <= A::CAPACITY {\r
      TinyVecConstructor::Inline(TinyVec::Inline)\r
    } else {\r
      TinyVecConstructor::Heap(TinyVec::Heap)\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
  ///\r
  /// ## Example\r
  /// ```rust\r
  /// use tinyvec::*;\r
  /// let mut tv = tiny_vec!([i32; 10] => 1, 2, 3);\r
  /// tv.insert(1, 4);\r
  /// assert_eq!(tv.as_slice(), &[1, 4, 2, 3]);\r
  /// tv.insert(4, 5);\r
  /// assert_eq!(tv.as_slice(), &[1, 4, 2, 3, 5]);\r
  /// ```\r
  #[inline]\r
  pub fn insert(&mut self, index: usize, item: A::Item) {\r
    assert!(\r
      index <= self.len(),\r
      "insertion index (is {}) should be <= len (is {})",\r
      index,\r
      self.len()\r
    );\r
\r
    let arr = match self {\r
      TinyVec::Heap(v) => return v.insert(index, item),\r
      TinyVec::Inline(a) => a,\r
    };\r
\r
    if let Some(x) = arr.try_insert(index, item) {\r
      let mut v = Vec::with_capacity(arr.len() * 2);\r
      let mut it =\r
        arr.iter_mut().map(|r| core::mem::replace(r, Default::default()));\r
      v.extend(it.by_ref().take(index));\r
      v.push(x);\r
      v.extend(it);\r
      *self = TinyVec::Heap(v);\r
    }\r
  }\r
\r
  /// If the vec is empty.\r
  #[inline(always)]\r
  #[must_use]\r
  pub fn is_empty(&self) -> bool {\r
    self.len() == 0\r
  }\r
\r
  /// Makes a new, empty vec.\r
  #[inline(always)]\r
  #[must_use]\r
  pub fn new() -> Self {\r
    Self::default()\r
  }\r
\r
  /// Place an element onto the end of the vec.\r
  /// ## Panics\r
  /// * If the length of the vec would overflow the capacity.\r
  /// ```rust\r
  /// use tinyvec::*;\r
  /// let mut tv = tiny_vec!([i32; 10] => 1, 2, 3);\r
  /// tv.push(4);\r
  /// assert_eq!(tv.as_slice(), &[1, 2, 3, 4]);\r
  /// ```\r
  #[inline]\r
  pub fn push(&mut self, val: A::Item) {\r
    // The code path for moving the inline contents to the heap produces a lot\r
    // of instructions, but we have a strong guarantee that this is a cold\r
    // path. LLVM doesn't know this, inlines it, and this tends to cause a\r
    // cascade of other bad inlining decisions because the body of push looks\r
    // huge even though nearly every call executes the same few instructions.\r
    //\r
    // Moving the logic out of line with #[cold] causes the hot code to  be\r
    // inlined together, and we take the extra cost of a function call only\r
    // in rare cases.\r
    #[cold]\r
    fn drain_to_heap_and_push<A: Array>(\r
      arr: &mut ArrayVec<A>, val: A::Item,\r
    ) -> TinyVec<A> {\r
      /* Make the Vec twice the size to amortize the cost of draining */\r
      let mut v = arr.drain_to_vec_and_reserve(arr.len());\r
      v.push(val);\r
      TinyVec::Heap(v)\r
    }\r
\r
    match self {\r
      TinyVec::Heap(v) => v.push(val),\r
      TinyVec::Inline(arr) => {\r
        if let Some(x) = arr.try_push(val) {\r
          *self = drain_to_heap_and_push(arr, x);\r
        }\r
      }\r
    }\r
  }\r
\r
  /// Resize the vec to the new length.\r
  ///\r
  /// If it needs to be longer, it's filled with clones of the provided value.\r
  /// If it needs to be shorter, it's truncated.\r
  ///\r
  /// ## Example\r
  ///\r
  /// ```rust\r
  /// use tinyvec::*;\r
  ///\r
  /// let mut tv = tiny_vec!([&str; 10] => "hello");\r
  /// tv.resize(3, "world");\r
  /// assert_eq!(tv.as_slice(), &["hello", "world", "world"][..]);\r
  ///\r
  /// let mut tv = tiny_vec!([i32; 10] => 1, 2, 3, 4);\r
  /// tv.resize(2, 0);\r
  /// assert_eq!(tv.as_slice(), &[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 tv = tiny_vec!([i32; 3] => 1, 2, 3);\r
  /// tv.resize_with(5, Default::default);\r
  /// assert_eq!(tv.as_slice(), &[1, 2, 3, 0, 0][..]);\r
  ///\r
  /// let mut tv = tiny_vec!([i32; 2]);\r
  /// let mut p = 1;\r
  /// tv.resize_with(4, || {\r
  ///   p *= 2;\r
  ///   p\r
  /// });\r
  /// assert_eq!(tv.as_slice(), &[2, 4, 8, 16][..]);\r
  /// ```\r
  #[inline]\r
  pub fn resize_with<F: FnMut() -> A::Item>(&mut self, new_len: usize, f: F) {\r
    match new_len.checked_sub(self.len()) {\r
      None => return self.truncate(new_len),\r
      Some(n) => self.reserve(n),\r
    }\r
\r
    match self {\r
      TinyVec::Inline(a) => a.resize_with(new_len, f),\r
      TinyVec::Heap(v) => v.resize_with(new_len, f),\r
    }\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 tv = tiny_vec!([i32; 4] => 1, 2, 3);\r
  /// let tv2 = tv.split_off(1);\r
  /// assert_eq!(tv.as_slice(), &[1][..]);\r
  /// assert_eq!(tv2.as_slice(), &[2, 3][..]);\r
  /// ```\r
  #[inline]\r
  pub fn split_off(&mut self, at: usize) -> Self {\r
    match self {\r
      TinyVec::Inline(a) => TinyVec::Inline(a.split_off(at)),\r
      TinyVec::Heap(v) => TinyVec::Heap(v.split_off(at)),\r
    }\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
  ///\r
  /// ## Example\r
  /// ```rust\r
  /// use tinyvec::*;\r
  /// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);\r
  /// let tv2: TinyVec<[i32; 4]> = tv.splice(1.., 4..=6).collect();\r
  /// assert_eq!(tv.as_slice(), &[1, 4, 5, 6][..]);\r
  /// assert_eq!(tv2.as_slice(), &[2, 3][..]);\r
  ///\r
  /// tv.splice(.., None);\r
  /// assert_eq!(tv.as_slice(), &[]);\r
  /// ```\r
  #[inline]\r
  pub fn splice<R, I>(\r
    &mut self, range: R, replacement: I,\r
  ) -> TinyVecSplice<'_, 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
      "TinyVec::splice> Illegal range, {} to {}",\r
      start,\r
      end\r
    );\r
    assert!(\r
      end <= self.len(),\r
      "TinyVec::splice> Range ends at {} but length is only {}!",\r
      end,\r
      self.len()\r
    );\r
\r
    TinyVecSplice {\r
      removal_start: start,\r
      removal_end: end,\r
      parent: self,\r
      replacement: replacement.into_iter().fuse(),\r
    }\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
    let arr = ArrayVec::try_from_array_len(data, len)?;\r
    Ok(TinyVec::Inline(arr))\r
  }\r
}\r
\r
/// Draining iterator for `TinyVecDrain`\r
///\r
/// See [`TinyVecDrain::drain`](TinyVecDrain::<A>::drain)\r
#[cfg_attr(docs_rs, doc(cfg(feature = "alloc")))]\r
pub enum TinyVecDrain<'p, A: Array> {\r
  #[allow(missing_docs)]\r
  Inline(ArrayVecDrain<'p, A::Item>),\r
  #[allow(missing_docs)]\r
  Heap(vec::Drain<'p, A::Item>),\r
}\r
\r
impl<'p, A: Array> Iterator for TinyVecDrain<'p, A> {\r
  type Item = A::Item;\r
\r
  impl_mirrored! {\r
    type Mirror = TinyVecDrain;\r
\r
    #[inline]\r
    fn next(self: &mut Self) -> Option<Self::Item>;\r
    #[inline]\r
    fn nth(self: &mut Self, n: usize) -> Option<Self::Item>;\r
    #[inline]\r
    fn size_hint(self: &Self) -> (usize, Option<usize>);\r
    #[inline]\r
    fn last(self: Self) -> Option<Self::Item>;\r
    #[inline]\r
    fn count(self: Self) -> usize;\r
  }\r
\r
  #[inline]\r
  fn for_each<F: FnMut(Self::Item)>(self, f: F) {\r
    match self {\r
      TinyVecDrain::Inline(i) => i.for_each(f),\r
      TinyVecDrain::Heap(h) => h.for_each(f),\r
    }\r
  }\r
}\r
\r
impl<'p, A: Array> DoubleEndedIterator for TinyVecDrain<'p, A> {\r
  impl_mirrored! {\r
    type Mirror = TinyVecDrain;\r
\r
    #[inline]\r
    fn next_back(self: &mut Self) -> Option<Self::Item>;\r
\r
    #[cfg(feature = "rustc_1_40")]\r
    #[inline]\r
    fn nth_back(self: &mut Self, n: usize) -> Option<Self::Item>;\r
  }\r
}\r
\r
/// Splicing iterator for `TinyVec`\r
/// See [`TinyVec::splice`](TinyVec::<A>::splice)\r
#[cfg_attr(docs_rs, doc(cfg(feature = "alloc")))]\r
pub struct TinyVecSplice<'p, A: Array, I: Iterator<Item = A::Item>> {\r
  parent: &'p mut TinyVec<A>,\r
  removal_start: usize,\r
  removal_end: usize,\r
  replacement: I,\r
}\r
\r
impl<'p, A, I> Iterator for TinyVecSplice<'p, A, I>\r
where\r
  A: Array,\r
  I: Iterator<Item = A::Item>,\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 TinyVecSplice<'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 TinyVecSplice<'p, A, I>\r
where\r
  A: Array,\r
  I: Iterator<Item = A::Item>,\r
{\r
}\r
\r
impl<'p, A, I> DoubleEndedIterator for TinyVecSplice<'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 TinyVecSplice<'p, A, I>\r
{\r
  fn drop(&mut self) {\r
    for _ in self.by_ref() {}\r
\r
    let (lower_bound, _) = self.replacement.size_hint();\r
    self.parent.reserve(lower_bound);\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 TinyVec<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 TinyVec<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 TinyVec<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 TinyVec<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 TinyVec<A> {\r
  #[inline]\r
  fn extend<T: IntoIterator<Item = A::Item>>(&mut self, iter: T) {\r
    let iter = iter.into_iter();\r
    let (lower_bound, _) = iter.size_hint();\r
    self.reserve(lower_bound);\r
\r
    let a = match self {\r
      TinyVec::Heap(h) => return h.extend(iter),\r
      TinyVec::Inline(a) => a,\r
    };\r
\r
    let mut iter = a.fill(iter);\r
    let maybe = iter.next();\r
\r
    let surely = match maybe {\r
      Some(x) => x,\r
      None => return,\r
    };\r
\r
    let mut v = a.drain_to_vec_and_reserve(a.len());\r
    v.push(surely);\r
    v.extend(iter);\r
    *self = TinyVec::Heap(v);\r
  }\r
}\r
\r
impl<A: Array> From<ArrayVec<A>> for TinyVec<A> {\r
  #[inline(always)]\r
  #[must_use]\r
  fn from(arr: ArrayVec<A>) -> Self {\r
    TinyVec::Inline(arr)\r
  }\r
}\r
\r
impl<A: Array> From<A> for TinyVec<A> {\r
  fn from(array: A) -> Self {\r
    TinyVec::Inline(ArrayVec::from(array))\r
  }\r
}\r
\r
impl<T, A> From<&'_ [T]> for TinyVec<A>\r
where\r
  T: Clone + Default,\r
  A: Array<Item = T>,\r
{\r
  #[inline]\r
  #[must_use]\r
  fn from(slice: &[T]) -> Self {\r
    if let Ok(arr) = ArrayVec::try_from(slice) {\r
      TinyVec::Inline(arr)\r
    } else {\r
      TinyVec::Heap(slice.into())\r
    }\r
  }\r
}\r
\r
impl<T, A> From<&'_ mut [T]> for TinyVec<A>\r
where\r
  T: Clone + Default,\r
  A: Array<Item = T>,\r
{\r
  #[inline]\r
  #[must_use]\r
  fn from(slice: &mut [T]) -> Self {\r
    Self::from(&*slice)\r
  }\r
}\r
\r
impl<A: Array> FromIterator<A::Item> for TinyVec<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
    av.extend(iter);\r
    av\r
  }\r
}\r
\r
/// Iterator for consuming an `TinyVec` and returning owned elements.\r
#[cfg_attr(docs_rs, doc(cfg(feature = "alloc")))]\r
pub enum TinyVecIterator<A: Array> {\r
  #[allow(missing_docs)]\r
  Inline(ArrayVecIterator<A>),\r
  #[allow(missing_docs)]\r
  Heap(alloc::vec::IntoIter<A::Item>),\r
}\r
\r
impl<A: Array> TinyVecIterator<A> {\r
  impl_mirrored! {\r
    type Mirror = TinyVecIterator;\r
    /// Returns the remaining items of this iterator as a slice.\r
    #[inline]\r
    #[must_use]\r
    pub fn as_slice(self: &Self) -> &[A::Item];\r
  }\r
}\r
\r
impl<A: Array> FusedIterator for TinyVecIterator<A> {}\r
\r
impl<A: Array> Iterator for TinyVecIterator<A> {\r
  type Item = A::Item;\r
\r
  impl_mirrored! {\r
    type Mirror = TinyVecIterator;\r
\r
    #[inline]\r
    fn next(self: &mut Self) -> Option<Self::Item>;\r
\r
    #[inline(always)]\r
    #[must_use]\r
    fn size_hint(self: &Self) -> (usize, Option<usize>);\r
\r
    #[inline(always)]\r
    fn count(self: Self) -> usize;\r
\r
    #[inline]\r
    fn last(self: Self) -> Option<Self::Item>;\r
\r
    #[inline]\r
    fn nth(self: &mut Self, n: usize) -> Option<A::Item>;\r
  }\r
}\r
\r
impl<A: Array> DoubleEndedIterator for TinyVecIterator<A> {\r
  impl_mirrored! {\r
    type Mirror = TinyVecIterator;\r
\r
    #[inline]\r
    fn next_back(self: &mut Self) -> Option<Self::Item>;\r
\r
    #[cfg(feature = "rustc_1_40")]\r
    #[inline]\r
    fn nth_back(self: &mut Self, n: usize) -> Option<Self::Item>;\r
  }\r
}\r
\r
impl<A: Array> Debug for TinyVecIterator<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("TinyVecIterator").field(&self.as_slice()).finish()\r
  }\r
}\r
\r
impl<A: Array> IntoIterator for TinyVec<A> {\r
  type Item = A::Item;\r
  type IntoIter = TinyVecIterator<A>;\r
  #[inline(always)]\r
  #[must_use]\r
  fn into_iter(self) -> Self::IntoIter {\r
    match self {\r
      TinyVec::Inline(a) => TinyVecIterator::Inline(a.into_iter()),\r
      TinyVec::Heap(v) => TinyVecIterator::Heap(v.into_iter()),\r
    }\r
  }\r
}\r
\r
impl<'a, A: Array> IntoIterator for &'a mut TinyVec<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 TinyVec<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 TinyVec<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 TinyVec<A> where A::Item: Eq {}\r
\r
impl<A: Array> PartialOrd for TinyVec<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 TinyVec<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 TinyVec<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 TinyVec<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 TinyVec<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
// // // // // // // //\r
// Formatting impls\r
// // // // // // // //\r
\r
impl<A: Array> Binary for TinyVec<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 TinyVec<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 TinyVec<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 TinyVec<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 TinyVec<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 TinyVec<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 TinyVec<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 TinyVec<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 TinyVec<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 = "serde")]\r
#[cfg_attr(docs_rs, doc(cfg(feature = "alloc")))]\r
struct TinyVecVisitor<A: Array>(PhantomData<A>);\r
\r
#[cfg(feature = "serde")]\r
impl<'de, A: Array> Visitor<'de> for TinyVecVisitor<A>\r
where\r
  A::Item: Deserialize<'de>,\r
{\r
  type Value = TinyVec<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_tinyvec = match seq.size_hint() {\r
      Some(expected_size) => TinyVec::with_capacity(expected_size),\r
      None => Default::default(),\r
    };\r
\r
    while let Some(value) = seq.next_element()? {\r
      new_tinyvec.push(value);\r
    }\r
\r
    Ok(new_tinyvec)\r
  }\r
}\r