Struct SliceAnyMut 

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

A type-erased mutable slice.

Semantically &mut [dyn Any].

Examples

use list_any::SliceAnyMut;
let mut data = *b"hello";
let mut slice_any: SliceAnyMut = SliceAnyMut::from(&mut data[..]);
let new_ref = slice_any.downcast_mut::<u8>().unwrap();
new_ref[1] = b'a';
assert_eq!(&data, b"hallo");

Implementations

impl<'a> SliceAnyMut<'a>

pub fn opaque() -> Self

Create a SliceAnyMut with a length of 0, for which downcasting will always return None.

use list_any::SliceAnyMut;
let mut slice = SliceAnyMut::opaque();
assert_eq!(slice.downcast_mut::<f64>(), None);
assert_eq!(slice.downcast_mut::<u32>(), None);
assert_eq!(slice.downcast_mut::<()>(), None);

pub fn deferred() -> Self

Create a SliceAnyMut with a length of 0, for which downcasting will always return Some.

use list_any::SliceAnyMut;
let mut slice = SliceAnyMut::deferred();
assert_eq!(slice.downcast_mut::<f64>(), Some(&mut [][..]));
assert_eq!(slice.downcast_mut::<u32>(), Some(&mut [][..]));
assert_eq!(slice.downcast_mut::<()>(), Some(&mut [][..]));

impl<'a, B: ?Sized> SliceAnyMut<'a, B>

pub fn len(&self) -> usize

Returns the number of elements in the slice.

pub fn is_empty(&self) -> bool

Returns true if the slice has a length of 0.

pub fn type_id_of_element(&self) -> TypeId

Returns the TypeId of the elements contained in this slice.

Examples

use core::any::TypeId;
use list_any::SliceAnyMut;
let mut data = *b"hello";
let slice_any: SliceAnyMut = SliceAnyMut::from(&mut data[..]);
assert_eq!(slice_any.type_id_of_element(), TypeId::of::<u8>());

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

Returns some mutable reference to the original slice if the elements are of type T, or None if they are not.

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

Returns this SliceAnyMut as an immutable SliceAny.

Trait Implementations

impl<'a, B: Debug + ?Sized> Debug for SliceAnyMut<'a, B>

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

Formats the value using the given formatter.

impl<'a, B: ?Sized, T: AnyBound<B>> From<&'a mut [T]> for SliceAnyMut<'a, B>

fn from(slice: &mut [T]) -> Self

Converts to this type from the input type.

impl<'a, B: ?Sized + Send + Sync> Send for SliceAnyMut<'a, B>

impl<'a, B: ?Sized + Sync> Sync for SliceAnyMut<'a, B>