pub type SubpropertiesVec<T> = ArrayVec<T, { property_counts::MAX_SHORTHAND_EXPANDED }>;
Expand description
An ArrayVec of subproperties, contains space for the longest shorthand except all.
Aliased Type§
struct SubpropertiesVec<T> { /* private fields */ }
Implementations
source§impl<T, const CAP: usize> ArrayVec<T, CAP>
impl<T, const CAP: usize> ArrayVec<T, CAP>
sourcepub fn new() -> ArrayVec<T, CAP>
pub fn new() -> ArrayVec<T, CAP>
Create a new empty ArrayVec
.
The maximum capacity is given by the generic parameter CAP
.
use arrayvec::ArrayVec;
let mut array = ArrayVec::<_, 16>::new();
array.push(1);
array.push(2);
assert_eq!(&array[..], &[1, 2]);
assert_eq!(array.capacity(), 16);
sourcepub const fn new_const() -> ArrayVec<T, CAP>
pub const fn new_const() -> ArrayVec<T, CAP>
Create a new empty ArrayVec
(const fn).
The maximum capacity is given by the generic parameter CAP
.
use arrayvec::ArrayVec;
static ARRAY: ArrayVec<u8, 1024> = ArrayVec::new_const();
sourcepub const fn len(&self) -> usize
pub const fn len(&self) -> usize
Return the number of elements in the ArrayVec
.
use arrayvec::ArrayVec;
let mut array = ArrayVec::from([1, 2, 3]);
array.pop();
assert_eq!(array.len(), 2);
sourcepub const fn is_empty(&self) -> bool
pub const fn is_empty(&self) -> bool
Returns whether the ArrayVec
is empty.
use arrayvec::ArrayVec;
let mut array = ArrayVec::from([1]);
array.pop();
assert_eq!(array.is_empty(), true);
sourcepub const fn capacity(&self) -> usize
pub const fn capacity(&self) -> usize
Return the capacity of the ArrayVec
.
use arrayvec::ArrayVec;
let array = ArrayVec::from([1, 2, 3]);
assert_eq!(array.capacity(), 3);
sourcepub const fn is_full(&self) -> bool
pub const fn is_full(&self) -> bool
Return true if the ArrayVec
is completely filled to its capacity, false otherwise.
use arrayvec::ArrayVec;
let mut array = ArrayVec::<_, 1>::new();
assert!(!array.is_full());
array.push(1);
assert!(array.is_full());
sourcepub const fn remaining_capacity(&self) -> usize
pub const fn remaining_capacity(&self) -> usize
Returns the capacity left in the ArrayVec
.
use arrayvec::ArrayVec;
let mut array = ArrayVec::from([1, 2, 3]);
array.pop();
assert_eq!(array.remaining_capacity(), 1);
sourcepub fn push(&mut self, element: T)
pub fn push(&mut self, element: T)
Push element
to the end of the vector.
Panics if the vector is already full.
use arrayvec::ArrayVec;
let mut array = ArrayVec::<_, 2>::new();
array.push(1);
array.push(2);
assert_eq!(&array[..], &[1, 2]);
sourcepub fn try_push(&mut self, element: T) -> Result<(), CapacityError<T>>
pub fn try_push(&mut self, element: T) -> Result<(), CapacityError<T>>
Push element
to the end of the vector.
Return Ok
if the push succeeds, or return an error if the vector
is already full.
use arrayvec::ArrayVec;
let mut array = ArrayVec::<_, 2>::new();
let push1 = array.try_push(1);
let push2 = array.try_push(2);
assert!(push1.is_ok());
assert!(push2.is_ok());
assert_eq!(&array[..], &[1, 2]);
let overflow = array.try_push(3);
assert!(overflow.is_err());
sourcepub unsafe fn push_unchecked(&mut self, element: T)
pub unsafe fn push_unchecked(&mut self, element: T)
Push element
to the end of the vector without checking the capacity.
It is up to the caller to ensure the capacity of the vector is sufficiently large.
This method uses debug assertions to check that the arrayvec is not full.
use arrayvec::ArrayVec;
let mut array = ArrayVec::<_, 2>::new();
if array.len() + 2 <= array.capacity() {
unsafe {
array.push_unchecked(1);
array.push_unchecked(2);
}
}
assert_eq!(&array[..], &[1, 2]);
sourcepub fn truncate(&mut self, new_len: usize)
pub fn truncate(&mut self, new_len: usize)
Shortens the vector, keeping the first len
elements and dropping
the rest.
If len
is greater than the vector’s current length this has no
effect.
use arrayvec::ArrayVec;
let mut array = ArrayVec::from([1, 2, 3, 4, 5]);
array.truncate(3);
assert_eq!(&array[..], &[1, 2, 3]);
array.truncate(4);
assert_eq!(&array[..], &[1, 2, 3]);
sourcepub fn insert(&mut self, index: usize, element: T)
pub fn insert(&mut self, index: usize, element: T)
Insert element
at position index
.
Shift up all elements after index
.
It is an error if the index is greater than the length or if the arrayvec is full.
Panics if the array is full or the index
is out of bounds. See
try_insert
for fallible version.
use arrayvec::ArrayVec;
let mut array = ArrayVec::<_, 2>::new();
array.insert(0, "x");
array.insert(0, "y");
assert_eq!(&array[..], &["y", "x"]);
sourcepub fn try_insert(
&mut self,
index: usize,
element: T,
) -> Result<(), CapacityError<T>>
pub fn try_insert( &mut self, index: usize, element: T, ) -> Result<(), CapacityError<T>>
Insert element
at position index
.
Shift up all elements after index
; the index
must be less than
or equal to the length.
Returns an error if vector is already at full capacity.
Panics index
is out of bounds.
use arrayvec::ArrayVec;
let mut array = ArrayVec::<_, 2>::new();
assert!(array.try_insert(0, "x").is_ok());
assert!(array.try_insert(0, "y").is_ok());
assert!(array.try_insert(0, "z").is_err());
assert_eq!(&array[..], &["y", "x"]);
sourcepub fn pop(&mut self) -> Option<T>
pub fn pop(&mut self) -> Option<T>
Remove the last element in the vector and return it.
Return Some(
element )
if the vector is non-empty, else None
.
use arrayvec::ArrayVec;
let mut array = ArrayVec::<_, 2>::new();
array.push(1);
assert_eq!(array.pop(), Some(1));
assert_eq!(array.pop(), None);
sourcepub fn swap_remove(&mut self, index: usize) -> T
pub fn swap_remove(&mut self, index: usize) -> T
Remove the element at index
and swap the last element into its place.
This operation is O(1).
Return the element if the index is in bounds, else panic.
Panics if the index
is out of bounds.
use arrayvec::ArrayVec;
let mut array = ArrayVec::from([1, 2, 3]);
assert_eq!(array.swap_remove(0), 1);
assert_eq!(&array[..], &[3, 2]);
assert_eq!(array.swap_remove(1), 2);
assert_eq!(&array[..], &[3]);
sourcepub fn swap_pop(&mut self, index: usize) -> Option<T>
pub fn swap_pop(&mut self, index: usize) -> Option<T>
Remove the element at index
and swap the last element into its place.
This is a checked version of .swap_remove
.
This operation is O(1).
Return Some(
element )
if the index is in bounds, else None
.
use arrayvec::ArrayVec;
let mut array = ArrayVec::from([1, 2, 3]);
assert_eq!(array.swap_pop(0), Some(1));
assert_eq!(&array[..], &[3, 2]);
assert_eq!(array.swap_pop(10), None);
sourcepub fn remove(&mut self, index: usize) -> T
pub fn remove(&mut self, index: usize) -> T
Remove the element at index
and shift down the following elements.
The index
must be strictly less than the length of the vector.
Panics if the index
is out of bounds.
use arrayvec::ArrayVec;
let mut array = ArrayVec::from([1, 2, 3]);
let removed_elt = array.remove(0);
assert_eq!(removed_elt, 1);
assert_eq!(&array[..], &[2, 3]);
sourcepub fn pop_at(&mut self, index: usize) -> Option<T>
pub fn pop_at(&mut self, index: usize) -> Option<T>
Remove the element at index
and shift down the following elements.
This is a checked version of .remove(index)
. Returns None
if there
is no element at index
. Otherwise, return the element inside Some
.
use arrayvec::ArrayVec;
let mut array = ArrayVec::from([1, 2, 3]);
assert!(array.pop_at(0).is_some());
assert_eq!(&array[..], &[2, 3]);
assert!(array.pop_at(2).is_none());
assert!(array.pop_at(10).is_none());
sourcepub fn retain<F>(&mut self, f: F)
pub fn retain<F>(&mut self, f: F)
Retains only the elements specified by the predicate.
In other words, remove all elements e
such that f(&mut e)
returns false.
This method operates in place and preserves the order of the retained
elements.
use arrayvec::ArrayVec;
let mut array = ArrayVec::from([1, 2, 3, 4]);
array.retain(|x| *x & 1 != 0 );
assert_eq!(&array[..], &[1, 3]);
sourcepub unsafe fn set_len(&mut self, length: usize)
pub unsafe fn set_len(&mut self, length: usize)
Set the vector’s length without dropping or moving out elements
This method is unsafe
because it changes the notion of the
number of “valid” elements in the vector. Use with care.
This method uses debug assertions to check that length
is
not greater than the capacity.
sourcepub fn try_extend_from_slice(
&mut self,
other: &[T],
) -> Result<(), CapacityError>where
T: Copy,
pub fn try_extend_from_slice(
&mut self,
other: &[T],
) -> Result<(), CapacityError>where
T: Copy,
Copy all elements from the slice and append to the ArrayVec
.
use arrayvec::ArrayVec;
let mut vec: ArrayVec<usize, 10> = ArrayVec::new();
vec.push(1);
vec.try_extend_from_slice(&[2, 3]).unwrap();
assert_eq!(&vec[..], &[1, 2, 3]);
§Errors
This method will return an error if the capacity left (see
remaining_capacity
) is smaller then the length of the provided
slice.
sourcepub fn drain<R>(&mut self, range: R) -> Drain<'_, T, CAP>where
R: RangeBounds<usize>,
pub fn drain<R>(&mut self, range: R) -> Drain<'_, T, CAP>where
R: RangeBounds<usize>,
Create a draining iterator that removes the specified range in the vector and yields the removed items from start to end. The element range is removed even if the iterator is not consumed until the end.
Note: It is unspecified how many elements are removed from the vector,
if the Drain
value is leaked.
Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.
use arrayvec::ArrayVec;
let mut v1 = ArrayVec::from([1, 2, 3]);
let v2: ArrayVec<_, 3> = v1.drain(0..2).collect();
assert_eq!(&v1[..], &[3]);
assert_eq!(&v2[..], &[1, 2]);
sourcepub fn into_inner(self) -> Result<[T; CAP], ArrayVec<T, CAP>>
pub fn into_inner(self) -> Result<[T; CAP], ArrayVec<T, CAP>>
Return the inner fixed size array, if it is full to its capacity.
Return an Ok
value with the array if length equals capacity,
return an Err
with self otherwise.
sourcepub unsafe fn into_inner_unchecked(self) -> [T; CAP]
pub unsafe fn into_inner_unchecked(self) -> [T; CAP]
Return the inner fixed size array.
Safety: This operation is safe if and only if length equals capacity.
sourcepub fn take(&mut self) -> ArrayVec<T, CAP>
pub fn take(&mut self) -> ArrayVec<T, CAP>
Returns the ArrayVec, replacing the original with a new empty ArrayVec.
use arrayvec::ArrayVec;
let mut v = ArrayVec::from([0, 1, 2, 3]);
assert_eq!([0, 1, 2, 3], v.take().into_inner().unwrap());
assert!(v.is_empty());
sourcepub fn as_mut_slice(&mut self) -> &mut [T]
pub fn as_mut_slice(&mut self) -> &mut [T]
Return a mutable slice containing all elements of the vector.
sourcepub fn as_mut_ptr(&mut self) -> *mut T
pub fn as_mut_ptr(&mut self) -> *mut T
Return a raw mutable pointer to the vector’s buffer.
Trait Implementations
source§impl<T, const CAP: usize> BorrowMut<[T]> for ArrayVec<T, CAP>
impl<T, const CAP: usize> BorrowMut<[T]> for ArrayVec<T, CAP>
source§fn borrow_mut(&mut self) -> &mut [T]
fn borrow_mut(&mut self) -> &mut [T]
source§impl<'de, T, const CAP: usize> Deserialize<'de> for ArrayVec<T, CAP>where
T: Deserialize<'de>,
impl<'de, T, const CAP: usize> Deserialize<'de> for ArrayVec<T, CAP>where
T: Deserialize<'de>,
Requires crate feature "serde"
source§fn deserialize<D>(
deserializer: D,
) -> Result<ArrayVec<T, CAP>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D,
) -> Result<ArrayVec<T, CAP>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
source§impl<T, const CAP: usize> Extend<T> for ArrayVec<T, CAP>
impl<T, const CAP: usize> Extend<T> for ArrayVec<T, CAP>
Extend the ArrayVec
with an iterator.
Panics if extending the vector exceeds its capacity.
source§fn extend<I>(&mut self, iter: I)where
I: IntoIterator<Item = T>,
fn extend<I>(&mut self, iter: I)where
I: IntoIterator<Item = T>,
Extend the ArrayVec
with an iterator.
Panics if extending the vector exceeds its capacity.
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl<T, const CAP: usize> From<[T; CAP]> for ArrayVec<T, CAP>
impl<T, const CAP: usize> From<[T; CAP]> for ArrayVec<T, CAP>
Create an ArrayVec
from an array.
use arrayvec::ArrayVec;
let mut array = ArrayVec::from([1, 2, 3]);
assert_eq!(array.len(), 3);
assert_eq!(array.capacity(), 3);
source§impl<T, const CAP: usize> FromIterator<T> for ArrayVec<T, CAP>
impl<T, const CAP: usize> FromIterator<T> for ArrayVec<T, CAP>
Create an ArrayVec
from an iterator.
Panics if the number of elements in the iterator exceeds the arrayvec’s capacity.
source§fn from_iter<I>(iter: I) -> ArrayVec<T, CAP>where
I: IntoIterator<Item = T>,
fn from_iter<I>(iter: I) -> ArrayVec<T, CAP>where
I: IntoIterator<Item = T>,
Create an ArrayVec
from an iterator.
Panics if the number of elements in the iterator exceeds the arrayvec’s capacity.
source§impl<T, const CAP: usize> IntoIterator for ArrayVec<T, CAP>
impl<T, const CAP: usize> IntoIterator for ArrayVec<T, CAP>
Iterate the ArrayVec
with each element by value.
The vector is consumed by this operation.
use arrayvec::ArrayVec;
for elt in ArrayVec::from([1, 2, 3]) {
// ...
}
source§impl<T, const CAP: usize> Ord for ArrayVec<T, CAP>where
T: Ord,
impl<T, const CAP: usize> Ord for ArrayVec<T, CAP>where
T: Ord,
1.21.0 · source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere
Self: Sized,
source§impl<T, const CAP: usize> PartialOrd for ArrayVec<T, CAP>where
T: PartialOrd,
impl<T, const CAP: usize> PartialOrd for ArrayVec<T, CAP>where
T: PartialOrd,
source§impl<T, const CAP: usize> Serialize for ArrayVec<T, CAP>where
T: Serialize,
impl<T, const CAP: usize> Serialize for ArrayVec<T, CAP>where
T: Serialize,
Requires crate feature "serde"
source§fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
source§impl<T, const CAP: usize> TryFrom<&[T]> for ArrayVec<T, CAP>where
T: Clone,
impl<T, const CAP: usize> TryFrom<&[T]> for ArrayVec<T, CAP>where
T: Clone,
Try to create an ArrayVec
from a slice. This will return an error if the slice was too big to
fit.
use arrayvec::ArrayVec;
use std::convert::TryInto as _;
let array: ArrayVec<_, 4> = (&[1, 2, 3] as &[_]).try_into().unwrap();
assert_eq!(array.len(), 3);
assert_eq!(array.capacity(), 4);
source§impl<const CAP: usize> Write for ArrayVec<u8, CAP>
impl<const CAP: usize> Write for ArrayVec<u8, CAP>
Write
appends written data to the end of the vector.
Requires features="std"
.
source§fn write(&mut self, data: &[u8]) -> Result<usize, Error>
fn write(&mut self, data: &[u8]) -> Result<usize, Error>
source§fn flush(&mut self) -> Result<(), Error>
fn flush(&mut self) -> Result<(), Error>
source§fn is_write_vectored(&self) -> bool
fn is_write_vectored(&self) -> bool
can_vector
)1.0.0 · source§fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
source§fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>
fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>
write_all_vectored
)