#![cfg(feature = "alloc")]
use super::*;
use alloc::vec::Vec;
#[macro_export]
macro_rules! tiny_vec {
($array_type:ty) => {
{
let mut tv: TinyVec<$array_type> = Default::default();
tv
}
};
($array_type:ty, $($elem:expr),*) => {
{
let mut tv: TinyVec<$array_type> = Default::default();
$( tv.push($elem); )*
tv
}
};
}
#[derive(Clone)]
pub enum TinyVec<A: Array> {
#[allow(missing_docs)]
Inline(ArrayVec<A>),
#[allow(missing_docs)]
Heap(Vec<A::Item>)
}
impl<A: Array + Default> Default for TinyVec<A> {
#[inline]
#[must_use]
fn default() -> Self {
TinyVec::Inline(ArrayVec::default())
}
}
impl<A: Array> TinyVec<A> {
#[allow(clippy::missing_inline_in_public_items)]
pub fn move_to_the_heap(&mut self) {
match self {
TinyVec::Inline(ref mut arr) => {
let mut v = Vec::with_capacity(A::CAPACITY * 2);
for item in arr.drain(..) {
v.push(item);
}
replace(self, TinyVec::Heap(v));
}
TinyVec::Heap(_) => (),
}
}
}
impl<A: Array> Deref for TinyVec<A> {
type Target = [A::Item];
#[inline(always)]
#[must_use]
fn deref(&self) -> &Self::Target {
match self {
TinyVec::Inline(a) => a.deref(),
TinyVec::Heap(v) => v.deref(),
}
}
}
impl<A: Array> DerefMut for TinyVec<A> {
#[inline(always)]
#[must_use]
fn deref_mut(&mut self) -> &mut Self::Target {
match self {
TinyVec::Inline(a) => a.deref_mut(),
TinyVec::Heap(v) => v.deref_mut(),
}
}
}
impl<A: Array, I: SliceIndex<[A::Item]>> Index<I> for TinyVec<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 TinyVec<A> {
#[inline(always)]
#[must_use]
fn index_mut(&mut self, index: I) -> &mut Self::Output {
&mut self.deref_mut()[index]
}
}
impl<A: Array> TinyVec<A> {
#[inline]
pub fn append(&mut self, other: &mut Self) {
for item in other.drain(..) {
self.push(item)
}
}
#[inline(always)]
#[must_use]
pub fn as_mut_ptr(&mut self) -> *mut A::Item {
match self {
TinyVec::Inline(a) => a.as_mut_ptr(),
TinyVec::Heap(v) => v.as_mut_ptr(),
}
}
#[inline(always)]
#[must_use]
pub fn as_mut_slice(&mut self) -> &mut [A::Item] {
self.deref_mut()
}
#[inline(always)]
#[must_use]
pub fn as_ptr(&self) -> *const A::Item {
match self {
TinyVec::Inline(a) => a.as_ptr(),
TinyVec::Heap(v) => v.as_ptr(),
}
}
#[inline(always)]
#[must_use]
pub fn as_slice(&self) -> &[A::Item] {
self.deref()
}
#[inline(always)]
#[must_use]
pub fn capacity(&self) -> usize {
A::CAPACITY
}
#[inline(always)]
pub fn clear(&mut self) {
self.truncate(0)
}
#[cfg(feature = "nightly_slice_partition_dedup")]
#[inline(always)]
pub fn dedup(&mut self)
where
A::Item: PartialEq,
{
self.dedup_by(|a, b| a == b)
}
#[cfg(feature = "nightly_slice_partition_dedup")]
#[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);
}
#[cfg(feature = "nightly_slice_partition_dedup")]
#[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))
}
#[inline]
pub fn drain<R: RangeBounds<usize>>(
&mut self,
range: R,
) -> TinyVecDrain<'_, 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,
"TinyVec::drain> Illegal range, {} to {}",
start,
end
);
assert!(
end <= self.len(),
"TinyVec::drain> Range ends at {} but length is only {}!",
end,
self.len()
);
TinyVecDrain {
parent: self,
target_index: start,
target_count: end - start,
}
}
#[inline]
pub fn extend_from_slice(&mut self, sli: &[A::Item])
where
A::Item: Clone,
{
for i in sli {
self.push(i.clone())
}
}
#[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!("TinyVec: length {} exceeds capacity {}!", len, A::CAPACITY)
}
}
}
#[inline]
pub fn insert(&mut self, index: usize, item: A::Item) {
match self {
TinyVec::Inline(a) => if a.len() == A::CAPACITY {
self.move_to_the_heap();
self.insert(index, item)
} else {
a.insert(index, item);
},
TinyVec::Heap(v) => v.insert(index, item),
}
}
#[inline(always)]
#[must_use]
pub fn is_empty(&self) -> bool {
self.len() == 0
}
#[inline(always)]
#[must_use]
pub fn len(&self) -> usize {
match self {
TinyVec::Inline(a) => a.len(),
TinyVec::Heap(v) => v.len(),
}
}
#[inline(always)]
#[must_use]
pub fn new() -> Self
where
A: Default,
{
Self::default()
}
#[inline]
pub fn pop(&mut self) -> Option<A::Item> {
match self {
TinyVec::Inline(a) => a.pop(),
TinyVec::Heap(v) => v.pop(),
}
}
#[inline(always)]
pub fn push(&mut self, val: A::Item) {
match self {
TinyVec::Inline(a) => if a.len() == A::CAPACITY {
self.move_to_the_heap();
self.push(val)
} else {
a.push(val);
},
TinyVec::Heap(v) => v.push(val),
}
}
#[inline]
pub fn remove(&mut self, index: usize) -> A::Item {
match self {
TinyVec::Inline(a) => a.remove(index),
TinyVec::Heap(v) => v.remove(index),
}
}
#[inline]
pub fn resize(&mut self, new_len: usize, new_val: A::Item)
where
A::Item: Clone,
{
match self {
TinyVec::Inline(a) => if new_len > A::CAPACITY {
self.move_to_the_heap();
self.resize(new_len, new_val);
} else {
a.resize(new_len, new_val);
},
TinyVec::Heap(v) => v.resize(new_len, new_val),
}
}
#[inline]
pub fn resize_with<F: FnMut() -> A::Item>(
&mut self,
new_len: usize,
f: F,
) {
match self {
TinyVec::Inline(a) => a.resize_with(new_len, f),
TinyVec::Heap(v) => v.resize_with(new_len, f),
}
}
#[inline]
pub fn retain<F: FnMut(&A::Item) -> bool>(&mut self, acceptable: F) {
match self {
TinyVec::Inline(a) => a.retain(acceptable),
TinyVec::Heap(v) => v.retain(acceptable),
}
}
#[inline]
pub fn split_off(&mut self, at: usize) -> Self
where
A: Default,
{
match self {
TinyVec::Inline(a) => TinyVec::Inline(a.split_off(at)),
TinyVec::Heap(v) => TinyVec::Heap(v.split_off(at)),
}
}
#[inline]
pub fn swap_remove(&mut self, index: usize) -> A::Item {
match self {
TinyVec::Inline(a) => a.swap_remove(index),
TinyVec::Heap(v) => v.swap_remove(index),
}
}
#[inline]
pub fn truncate(&mut self, new_len: usize) {
match self {
TinyVec::Inline(a) => a.truncate(new_len),
TinyVec::Heap(v) => v.truncate(new_len),
}
}
#[inline]
pub fn try_from_array_len(data: A, len: usize) -> Result<Self, A> {
let arr = ArrayVec::try_from_array_len(data, len)?;
Ok(TinyVec::Inline(arr))
}
}
pub struct TinyVecDrain<'p, A: Array> {
parent: &'p mut TinyVec<A>,
target_index: usize,
target_count: usize,
}
impl<'p, A: Array> Iterator for TinyVecDrain<'p, A> {
type Item = A::Item;
#[inline]
fn next(&mut self) -> Option<Self::Item> {
if self.target_count > 0 {
let out = self.parent.remove(self.target_index);
self.target_count -= 1;
Some(out)
} else {
None
}
}
}
impl<'p, A: Array> Drop for TinyVecDrain<'p, A> {
#[inline]
fn drop(&mut self) {
for _ in self {}
}
}
impl<A: Array> AsMut<[A::Item]> for TinyVec<A> {
#[inline(always)]
#[must_use]
fn as_mut(&mut self) -> &mut [A::Item] {
&mut *self
}
}
impl<A: Array> AsRef<[A::Item]> for TinyVec<A> {
#[inline(always)]
#[must_use]
fn as_ref(&self) -> &[A::Item] {
&*self
}
}
impl<A: Array> Borrow<[A::Item]> for TinyVec<A> {
#[inline(always)]
#[must_use]
fn borrow(&self) -> &[A::Item] {
&*self
}
}
impl<A: Array> BorrowMut<[A::Item]> for TinyVec<A> {
#[inline(always)]
#[must_use]
fn borrow_mut(&mut self) -> &mut [A::Item] {
&mut *self
}
}
impl<A: Array> Extend<A::Item> for TinyVec<A> {
#[inline]
fn extend<T: IntoIterator<Item = A::Item>>(&mut self, iter: T) {
for t in iter {
self.push(t)
}
}
}
impl<A: Array> From<ArrayVec<A>> for TinyVec<A> {
#[inline(always)]
#[must_use]
fn from(arr: ArrayVec<A>) -> Self {
TinyVec::Inline(arr)
}
}
impl<A: Array + Default> FromIterator<A::Item> for TinyVec<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
}
}
pub enum TinyVecIterator<A: Array> {
#[allow(missing_docs)]
Inline(ArrayVecIterator<A>),
#[allow(missing_docs)]
Heap(alloc::vec::IntoIter<A::Item>)
}
impl<A: Array> Iterator for TinyVecIterator<A> {
type Item = A::Item;
#[inline]
fn next(&mut self) -> Option<Self::Item> {
match self {
TinyVecIterator::Inline(a) => a.next(),
TinyVecIterator::Heap(v) => v.next(),
}
}
#[inline(always)]
#[must_use]
fn size_hint(&self) -> (usize, Option<usize>) {
match self {
TinyVecIterator::Inline(a) => a.size_hint(),
TinyVecIterator::Heap(v) => v.size_hint(),
}
}
#[inline(always)]
fn count(self) -> usize {
match self {
TinyVecIterator::Inline(a) => a.count(),
TinyVecIterator::Heap(v) => v.count(),
}
}
#[inline]
fn last(self) -> Option<Self::Item> {
match self {
TinyVecIterator::Inline(a) => a.last(),
TinyVecIterator::Heap(v) => v.last(),
}
}
#[inline]
fn nth(&mut self, n: usize) -> Option<A::Item> {
match self {
TinyVecIterator::Inline(a) => a.nth(n),
TinyVecIterator::Heap(v) => v.nth(n),
}
}
}
impl<A: Array> IntoIterator for TinyVec<A> {
type Item = A::Item;
type IntoIter = TinyVecIterator<A>;
#[inline(always)]
#[must_use]
fn into_iter(self) -> Self::IntoIter {
match self {
TinyVec::Inline(a) => TinyVecIterator::Inline(a.into_iter()),
TinyVec::Heap(v) => TinyVecIterator::Heap(v.into_iter()),
}
}
}
impl<A: Array> PartialEq for TinyVec<A>
where
A::Item: PartialEq,
{
#[inline]
#[must_use]
fn eq(&self, other: &Self) -> bool {
self.deref().eq(other.deref())
}
}
impl<A: Array> Eq for TinyVec<A> where A::Item: Eq {}
impl<A: Array> PartialOrd for TinyVec<A>
where
A::Item: PartialOrd,
{
#[inline]
#[must_use]
fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
self.deref().partial_cmp(other.deref())
}
}
impl<A: Array> Ord for TinyVec<A>
where
A::Item: Ord,
{
#[inline]
#[must_use]
fn cmp(&self, other: &Self) -> core::cmp::Ordering {
self.deref().cmp(other.deref())
}
}
impl<A: Array> PartialEq<&A> for TinyVec<A>
where
A::Item: PartialEq,
{
#[inline]
#[must_use]
fn eq(&self, other: &&A) -> bool {
self.deref() == other.slice()
}
}
impl<A: Array> PartialEq<&[A::Item]> for TinyVec<A>
where
A::Item: PartialEq,
{
#[inline]
#[must_use]
fn eq(&self, other: &&[A::Item]) -> bool {
self.deref() == *other
}
}
impl<A: Array> Binary for TinyVec<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 TinyVec<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 TinyVec<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 TinyVec<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 TinyVec<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 TinyVec<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 TinyVec<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 TinyVec<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 TinyVec<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, "]")
}
}