use super::*;
#[macro_export]
macro_rules! array_vec {
($array_type:ty) => {
{
let mut av: ArrayVec<$array_type> = Default::default();
av
}
};
($array_type:ty, $($elem:expr),*) => {
{
let mut av: ArrayVec<$array_type> = Default::default();
$( av.push($elem); )*
av
}
};
}
#[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.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.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> {
#[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 {
self.data.slice_mut().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 {
self.data.slice().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,
) -> 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_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!("ArrayVec: length {} exceeds capacity {}!", len, A::CAPACITY)
}
}
}
#[inline]
pub fn insert(&mut self, index: usize, item: A::Item) {
use core::cmp::Ordering;
match index.cmp(&self.len) {
Ordering::Less => {
let targets: &mut [A::Item] = &mut self.as_mut_slice()[index..];
let mut temp = item;
for target in targets.iter_mut() {
temp = replace(target, temp);
}
self.push(temp);
}
Ordering::Equal => {
self.push(item);
}
Ordering::Greater => {
panic!(
"ArrayVec::insert> index {} is out of bounds {}",
index, self.len
);
}
}
}
#[inline(always)]
#[must_use]
pub fn is_empty(&self) -> bool {
self.len == 0
}
#[inline(always)]
#[must_use]
pub fn len(&self) -> usize {
self.len
}
#[inline(always)]
#[must_use]
pub fn new() -> Self
where
A: Default,
{
Self::default()
}
#[inline]
pub fn pop(&mut self) -> Option<A::Item> {
if self.len > 0 {
self.len -= 1;
let out =
replace(&mut self.data.slice_mut()[self.len], A::Item::default());
Some(out)
} else {
None
}
}
#[inline(always)]
pub fn push(&mut self, val: A::Item) {
if self.try_push(val).is_err() {
panic!("ArrayVec: overflow!")
}
}
#[inline]
pub fn remove(&mut self, index: usize) -> A::Item {
let targets: &mut [A::Item] = &mut self.deref_mut()[index..];
let mut spare = A::Item::default();
for target in targets.iter_mut().rev() {
spare = replace(target, spare);
}
self.len -= 1;
spare
}
#[inline]
pub fn resize(&mut self, new_len: usize, new_val: A::Item)
where
A::Item: Clone,
{
use core::cmp::Ordering;
match new_len.cmp(&self.len) {
Ordering::Less => self.truncate(new_len),
Ordering::Equal => (),
Ordering::Greater => {
while self.len < new_len {
self.push(new_val.clone());
}
}
}
}
#[inline]
pub fn resize_with<F: FnMut() -> A::Item>(
&mut self,
new_len: usize,
mut f: F,
) {
use core::cmp::Ordering;
match new_len.cmp(&self.len) {
Ordering::Less => self.truncate(new_len),
Ordering::Equal => (),
Ordering::Greater => {
while self.len < new_len {
self.push(f());
}
}
}
}
#[inline]
pub fn retain<F: FnMut(&A::Item) -> bool>(&mut self, mut acceptable: F) {
let mut i = 0;
while i < self.len {
if !acceptable(&self[i]) {
self.remove(i);
}
i += 1;
}
}
#[inline]
pub fn split_off(&mut self, at: usize) -> Self
where
Self: Default,
{
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 targets = new.data.slice_mut();
for (m, t) in moves.iter_mut().zip(targets) {
replace(t, replace(m, A::Item::default()));
}
new.len = self.len - at;
self.len = at;
new
}
#[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)
}
}
#[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);
}
}
#[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)
}
}
#[inline]
pub fn try_push(&mut self, val: A::Item) -> Result<(), A::Item> {
if self.len < A::CAPACITY {
replace(&mut self.data.slice_mut()[self.len], val);
self.len += 1;
Ok(())
} else {
Err(val)
}
}
}
pub struct ArrayVecDrain<'p, A: Array> {
parent: &'p mut ArrayVec<A>,
target_index: usize,
target_count: 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_count > 0 {
let out = self.parent.remove(self.target_index);
self.target_count -= 1;
Some(out)
} else {
None
}
}
}
impl<'p, A: Array> Drop for ArrayVecDrain<'p, A> {
#[inline]
fn drop(&mut self) {
for _ in self {}
}
}
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]
fn from(data: A) -> Self {
Self { len: data.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
}
}
pub struct ArrayVecIterator<A: Array> {
base: usize,
len: usize,
data: 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 =
replace(&mut self.data.slice_mut()[self.base], A::Item::default());
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(replace(&mut self.data.slice_mut()[self.len], A::Item::default()))
}
#[inline]
fn nth(&mut self, n: usize) -> Option<A::Item> {
let i = self.base + (n - 1);
if i < self.len {
let out = replace(&mut self.data.slice_mut()[i], A::Item::default());
self.base = i + 1;
Some(out)
} else {
None
}
}
}
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.deref().eq(other.deref())
}
}
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.deref().partial_cmp(other.deref())
}
}
impl<A: Array> Ord for ArrayVec<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 ArrayVec<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 ArrayVec<A>
where
A::Item: PartialEq,
{
#[inline]
#[must_use]
fn eq(&self, other: &&[A::Item]) -> bool {
self.deref() == *other
}
}
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, "]")
}
}