Struct SliceCopy

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

Implementations

impl<'a, V> SliceCopy<'a, V>

pub fn from_slice<T: CopyElem>(slice: &[T]) -> Self

where V: VTable<T>,

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

impl<'a, V: ?Sized> SliceCopy<'a, V>

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

Convert this collection into its raw components.

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

Safety

Calling this function is not inherently unsafe, but using the returned values incorrectly may cause undefined behaviour.

pub unsafe fn from_raw_parts( data: &'a [MaybeUninit<u8>], elem: ElemInfo, vtable: impl Into<VTableRef<'a, V>>, ) -> Self

Construct a SliceCopy from raw bytes and type metadata.

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

Safety

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) -> SliceCopy<'a, U>

where V: Clone,

Upcast the SliceCopy into a more general base SliceCopy.

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

pub fn check<T: Any>(&self) -> Option<&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) -> SliceCopy<'_, V>

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

This is equivalent to calling subslice with the entire range.

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>(&self) -> Option<Iter<'_, 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::SliceCopy;
let vec = vec![1.0_f32, 23.0, 0.01, 42.0, 11.43];
let buf = SliceCopy::<()>::from_slice(vec.as_slice());
for (i, &val) in buf.iter_as::<f32>().unwrap().enumerate() {
    assert_eq!(val, vec[i]);
}

pub fn append_copy_to_vec<'b, T: CopyElem>( &self, vec: &'b mut Vec<T>, ) -> Option<&'b mut Vec<T>>

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

pub fn copy_into_vec<T: CopyElem>(&self) -> Option<Vec<T>>

Copies contents of self into the given Vec.

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

Borrow this slice as a typed slice.

Returns None if the given type T doesn’t match the internal.

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

Get i’th element of the buffer.

pub fn iter(&self) -> impl Iterator<Item = CopyValueRef<'_, V>>

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

In contrast to iter, 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.

Examples

use dync::SliceCopy;
let vec = vec![1.0_f32, 23.0, 0.01, 42.0, 11.43];
let buf: SliceCopy = SliceCopy::from(vec.as_slice());
for (i, val) in buf.iter().enumerate() {
    assert_eq!(val.downcast::<f32>().unwrap(), &vec[i]);
}

pub fn into_iter(self) -> impl Iterator<Item = CopyValueRef<'a, V>>

where V: Clone,

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

pub fn split_at(&self, mid: usize) -> (SliceCopy<'_, V>, SliceCopy<'_, V>)

pub fn get(&self, i: usize) -> CopyValueRef<'_, V>

Get a immutable value reference to the element at index i.

pub fn subslice<I>(&self, i: I) -> SliceCopy<'_, V>

where I: SliceIndex<[MaybeUninit<u8>], Output = [MaybeUninit<u8>]> + ScaleRange,

Get an immutable subslice representing the given range of indices.

pub fn into_subslice<I>(self, i: I) -> SliceCopy<'a, V>

where I: SliceIndex<[MaybeUninit<u8>], Output = [MaybeUninit<u8>]> + ScaleRange,

Conver this slice into a mutable subslice representing the given range of indices.

Trait Implementations

impl<'a, V> Clone for SliceCopy<'a, V>

where V: ?Sized + Clone,

fn clone(&self) -> SliceCopy<'a, V>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, T, V> From<&'a [T]> for SliceCopy<'a, V>

where T: CopyElem, V: VTable<T>,

Convert a &[T] to a SliceCopy.

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

Converts to this type from the input type.

impl<'b, 'a: 'b, V: ?Sized> From<&'b SliceCopyMut<'a, V>> for SliceCopy<'b, V>

fn from(s: &'b SliceCopyMut<'a, V>) -> SliceCopy<'b, V>

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<'a, V: ?Sized> From<SliceCopyMut<'a, V>> for SliceCopy<'a, V>

fn from(s: SliceCopyMut<'a, V>) -> SliceCopy<'a, V>

Converts to this type from the input type.