Struct VecAny 

pub struct VecAny<B: ?Sized = dyn Any + Send + Sync> { /* private fields */ }

A type-erased Vec.

Semantically Vec<dyn Any>.

Examples

use list_any::VecAny;
let data: Vec<u8> = b"hello".to_vec();
let vec_any: VecAny = VecAny::from(data);
let data_returned = vec_any.downcast::<u8>().unwrap();
assert_eq!(data_returned, b"hello");

Implementations

impl VecAny

pub fn opaque() -> Self

Create a new, empty, VecAny for which downcasting will always return None.

pub fn deferred() -> Self

Create a new, empty, VecAny with a internal type deferred until the first mutable downcast. Note that, until this type is otherwise downcast, downcast_slice will always succeed.

use list_any::VecAny;
let mut v = VecAny::deferred();
assert_eq!(v.downcast_slice::<f64>(), Some(&[][..]));
assert_eq!(v.downcast_slice_mut::<u32>(), Some(&mut [][..]));
assert_eq!(v.downcast_slice::<f64>(), None);

impl<B: ?Sized> VecAny<B>

pub fn new<T: AnyBound<B>>() -> Self

Create a new, empty, VecAny with a given internal type.

pub fn len(&self) -> usize

Returns the number of elements in the vector.

pub fn capcaity(&self) -> usize

👎Deprecated since 0.2.1: method name was misspelled, use the correct spelling instead

Returns the number of elements the vector can hold without reallocating.

pub fn capacity(&self) -> usize

Returns the number of elements the vector can hold without reallocating.

pub fn is_empty(&self) -> bool

Returns true if the vector contains no elements.

pub fn type_id_of_element(&self) -> TypeId

Returns the TypeId of the elements contained within the vector.

use core::any::TypeId;
use list_any::VecAny;
let data: Vec<u8> = b"hello".to_vec();
let vec_any: VecAny = VecAny::from(data);
assert_eq!(vec_any.type_id_of_element(), TypeId::of::<u8>());

pub fn as_slice_any(&self) -> SliceAny<'_>

Returns a borrow of this VecAny as a SliceAny.

pub fn as_slice_any_mut(&mut self) -> SliceAnyMut<'_>

Returns a mutable borrow of this VecAny as a SliceAnyMut.

pub fn downcast<T: AnyBound<B>>(self) -> Result<Vec<T>, Self>

Attempts to downcast this VecAny to a concrete vector type.

Errors

Returns self unchanged if the VecAny did not contain elements of type T.

pub fn downcast_mut<T: AnyBound<B>>(&mut self) -> Option<VecAnyGuard<'_, T, B>>

Returns some mutable guard over the original vector if the elements are of type T, or None if they are not.

Leaking this guard (through forget or similar) is safe, however it will have the effect of leaking all of the elements in the vector, and the source VecAny will be left empty.

pub fn downcast_slice<T: AnyBound<B>>(&self) -> Option<&[T]>

Returns some reference to the contained vector as a slice if the contained elements are of type T, or None if they are not.

pub fn downcast_slice_mut<T: AnyBound<B>>(&mut self) -> Option<&mut [T]>

Returns some mutable reference to the contained vector as a slice if the contained elements are of type T, or None if they are not.

Trait Implementations

impl<B: Debug + ?Sized> Debug for VecAny<B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B: ?Sized> Drop for VecAny<B>

fn drop(&mut self)

Executes the destructor for this type.

impl<B: ?Sized, T: AnyBound<B>> From<Vec<T>> for VecAny<B>

fn from(vec: Vec<T>) -> Self

Converts to this type from the input type.

impl<B: ?Sized + Send> Send for VecAny<B>

impl<B: ?Sized + Sync> Sync for VecAny<B>