Struct dync::SliceDropMut

pub struct SliceDropMut<'a, V = (DropFn, ())> where
    V: ?Sized,  { /* fields omitted */ }

Implementations

impl<'a, V: HasDrop> SliceDropMut<'a, V>

pub fn from_slice<T: Elem>(slice: &'a mut [T]) -> SliceDropMut<'a, V> where
    V: VTable<T>, 

Construct a SliceDropMut from a given typed slice by reusing the provided memory.

impl<'a, V: ?Sized + HasDrop> SliceDropMut<'a, V>

pub fn into_raw_parts(
    self
) -> (&'a [MaybeUninit<u8>], usize, TypeId, VTableRef<'a, V>)

Convert this collection into its raw components.

This function exists mainly to enable the into_dyn macro until CoerceUnsized is stabilized.

pub unsafe fn from_raw_parts(
    data: &'a mut [MaybeUninit<u8>],
    element_size: usize,
    element_type_id: TypeId,
    vtable: impl Into<VTableRef<'a, V>>
) -> SliceDropMut<'a, V>

Construct a SliceDropMut from raw bytes and type metadata.

Safety

Almost exclusively the only inputs that are safe here are the ones returned by into_raw_parts.

This function should not be used other than in internal APIs. It exists to enable the into_dyn macro until CoerceUsize is stabilized.

pub fn upcast<U: From<V>>(self) -> SliceDropMut<'a, U> where
    V: Clone, 

Upcast the SliceDropMut into a more general base SliceDropMut.

This function converts the underlying virtual function table into a subset of the existing

pub fn check<T: Any>(&mut self) -> Option<&mut Self>

Check if the current buffer contains elements of the specified type. Returns Some(self) if the type matches and None otherwise.

pub fn reborrow(&self) -> SliceDrop<V>

Construct a clone of the current slice with a reduced lifetime.

This is equivalent to calling subslice with the entire range.

pub fn reborrow_mut(&mut self) -> SliceDropMut<V>

Construct a clone of the current slice with a reduced lifetime.

This is equivalent to calling subslice_mut with the entire range.

pub fn swap(&mut self, i: usize, j: usize)

Swap the values at the two given indices.

pub fn element_type_id(&self) -> TypeId

Get the TypeId of data stored within this buffer.

pub fn len(&self) -> usize

Get the number of elements stored in this buffer.

pub fn is_empty(&self) -> bool

Check if there are any elements stored in this buffer.

pub fn element_size(&self) -> usize

Get the size of the element type in bytes.

pub fn iter_as<T: Any>(&mut self) -> Option<IterMut<T>>

Return an iterator to a slice representing typed data. Returs None if the given type T doesn't match the internal.

Examples

use dync::SliceDropMut;
let mut vec = vec![1.0_f32, 23.0, 0.01, 42.0, 11.43];
let mut buf: SliceDropMut = vec.as_mut_slice().into();
for val in buf.iter_as::<f32>().unwrap() {
    *val += 1.0_f32;
}

pub fn as_slice<T: Any>(&mut self) -> Option<&mut [T]>

Convert this SliceDropMut into a typed slice. Returs None if the given type T doesn't match the internal.

pub fn get_as<T: Elem>(&mut self, i: usize) -> Option<&mut T>

Get i'th element of the buffer.

pub fn rotate_left(&mut self, mid: usize)

Rotates the slice in-place such that the first mid elements of the slice move to the end while the last self.len() - mid elements move to the front. After calling rotate_left, the element previously at index mid will become the first element in the slice.

Example

use dync::*;
let mut vec = vec![1u32,2,3,4,5];
let mut buf: SliceDropMut = vec.as_mut_slice().into();
buf.rotate_left(3);
assert_eq!(buf.as_slice::<u32>().unwrap(), &[4,5,1,2,3]);

pub fn rotate_right(&mut self, k: usize)

Rotates the slice in-place such that the first self.len() - k elements of the slice move to the end while the last k elements move to the front. After calling rotate_right, the element previously at index k will become the first element in the slice.

Example

use dync::*;
let mut vec = vec![1u32,2,3,4,5];
let mut buf: SliceDropMut = vec.as_mut_slice().into();
buf.rotate_right(3);
assert_eq!(buf.as_slice::<u32>().unwrap(), &[3,4,5,1,2]);

pub fn iter(&mut self) -> impl Iterator<Item = ValueMut<V>> where
    V: Clone, 

Return an iterator over untyped value references stored in this slice.

In contrast to iter_as, this function defers downcasting on a per element basis. As a result, this type of iteration is typically less efficient if a typed value is needed for each element.

pub fn chunks_exact(
    &self,
    chunk_size: usize
) -> impl Iterator<Item = SliceDrop<V>>

pub fn chunks_exact_mut(
    &mut self,
    chunk_size: usize
) -> impl Iterator<Item = SliceDropMut<V>>

pub fn split_at(&mut self, mid: usize) -> (SliceDropMut<V>, SliceDropMut<V>)

pub fn get(&self, i: usize) -> ValueRef<V>

Get a reference to a value stored in this container at index i.

pub fn get_mut(&mut self, i: usize) -> ValueMut<V>

Get a mutable reference to a value stored in this container at index i.

pub fn subslice<I>(&self, i: I) -> SliceDrop<V> where
    I: SliceIndex<[MaybeUninit<u8>], Output = [MaybeUninit<u8>]> + ScaleRange, 

Get an immutable subslice from the given range of indices.

pub fn subslice_mut<I>(&mut self, i: I) -> SliceDropMut<V> where
    I: SliceIndex<[MaybeUninit<u8>], Output = [MaybeUninit<u8>]> + ScaleRange, 

Get a mutable subslice from the given range of indices.

pub fn into_subslice<I>(self, i: I) -> SliceDropMut<'a, V> where
    I: SliceIndex<[MaybeUninit<u8>], Output = [MaybeUninit<u8>]> + ScaleRange, 

Convert this slice into a mutable subslice from the given range of indices.

impl<'a, V: HasDrop + HasClone> SliceDropMut<'a, V>

pub fn clone_from_slice<T: Elem + Clone>(
    &mut self,
    slice: &[T]
) -> Option<&mut Self>

Clone data from a given slice into the current slice.

Panics

This function will panic if the given slice has as different size than current.

pub fn append_clone_to_vec<'b, T: Elem + Clone>(
    &self,
    vec: &'b mut Vec<T>
) -> Option<&'b mut Vec<T>>

Append cloned items from this slice to a given Vec<T>. Return the mutable reference Some(vec) if type matched the internal type and None otherwise.

pub fn clone_into_vec<T: Elem + Clone>(self) -> Option<Vec<T>>

Clones contents of self into the given Vec.

Trait Implementations

impl<'a, T, V> From<&'a mut [T]> for SliceDropMut<'a, V> where
    T: Elem,
    V: VTable<T> + HasDrop, 

Convert a &mut [T] to a SliceDropMut.

fn from(s: &'a mut [T]) -> SliceDropMut<'a, V>

Performs the conversion.

impl<'b, 'a: 'b, V: ?Sized + HasDrop> From<&'b SliceDropMut<'a, V>> for SliceDrop<'b, V>

fn from(s: &'b SliceDropMut<'a, V>) -> SliceDrop<'b, V>

Performs the conversion.

impl<'a, V> From<SliceDropMut<'a, V>> for Meta<VTableRef<'a, V>>

fn from(slice: SliceDropMut<'a, V>) -> Self

Performs the conversion.

impl<'a, V: Clone> From<SliceDropMut<'a, V>> for Meta<Ptr<V>>

fn from(slice: SliceDropMut<'a, V>) -> Self

Performs the conversion.

impl<'a, V: ?Sized> From<SliceDropMut<'a, V>> for SliceDrop<'a, V>

fn from(s: SliceDropMut<'a, V>) -> SliceDrop<'a, V>

Performs the conversion.

impl<'a, V: ?Sized + HasDrop + HasSend> Send for SliceDropMut<'a, V>

impl<'a, V: ?Sized + HasDrop + HasSync> Sync for SliceDropMut<'a, V>