Struct dyn_slice::DynSlice

pub struct DynSlice<'a, Dyn: ?Sized + Pointee<Metadata = DynMetadata<Dyn>>> { /* private fields */ }

&dyn [Trait]

A type erased slice of elements that implement a trait.

Example

use dyn_slice::standard::debug;

let slice = debug::new(&[1, 2, 3, 4, 5]);
println!("{slice:?}"); // [1, 2, 3, 4, 5]

Implementations

impl<'a, Dyn: ?Sized + Pointee<Metadata = DynMetadata<Dyn>>> DynSlice<'a, Dyn>

pub const unsafe fn with_vtable_ptr<DynSliceFromType>( value: &'a [DynSliceFromType], vtable_ptr: *const () ) -> Self

Construct a dyn slice given a slice and a vtable pointer.

Safety

Caller must ensure that vtable_ptr is a valid instance of DynMetadata for DynSliceFromType and Dyn transmuted, or optionally, a null pointer if value.len() == 0.

pub const unsafe fn with_metadata<DynSliceFromType>( value: &'a [DynSliceFromType], metadata: DynMetadata<Dyn> ) -> Self

Construct a dyn slice given a slice and a DynMetadata instance.

Safety

Caller must ensure that metadata is a valid instance of DynMetadata for DynSliceFromType and Dyn.

pub const unsafe fn from_parts( vtable_ptr: *const (), len: usize, data: *const () ) -> Self

Construct a dyn slice from raw parts.

Safety

Caller must ensure that:

• vtable_ptr is a valid instance of DynMetadata transmuted, or optionally, a null pointer if len == 0,
• len <= the length of the slice in memory from the data pointer,
• data is a valid pointer to the slice,
• the underlying slice is the same layout as [T]

pub unsafe fn from_parts_with_metadata( metadata: DynMetadata<Dyn>, len: usize, data: *const () ) -> Self

Construct a dyn slice from raw parts with a DynMetadata instance rather than a vtable pointer.

Safety

Caller must ensure that:

• metadata is a valid instance of DynMetadata,
• len <= the length of the slice in memory from the data pointer,
• data is a valid pointer to the slice,
• the underlying slice is the same layout as [T]

pub const fn vtable_ptr(&self) -> *const ()

Get the vtable pointer, which may be null if the slice is empty.

pub fn metadata(&self) -> Option<DynMetadata<Dyn>>

Get the metadata component of the element’s pointers, or possibly None if the slice is empty.

pub const fn len(&self) -> usize

Returns the number of elements in the slice.

Example

use dyn_slice::standard::debug;

let slice = debug::new(&[1, 2, 3, 4, 5]);
assert_eq!(slice.len(), 5);

pub const fn as_ptr(&self) -> *const ()

Returns a pointer to the underlying slice, which may be null if the slice is empty.

pub const fn is_empty(&self) -> bool

Returns true if the slice has a length of 0.

Example

use dyn_slice::standard::debug;

let slice = debug::new(&[1, 2, 3, 4, 5]);
assert!(!slice.is_empty());

let empty_slice = debug::new::<u8>(&[]);
assert!(empty_slice.is_empty());

pub unsafe fn first_unchecked(&self) -> &Dyn

Returns a reference to the first element, without doing bounds checking.

Safety

The caller must ensure that !self.is_empty() Calling this on an empty DynSlice will result in a segfault!

pub fn first(&self) -> Option<&Dyn>

Returns a reference to the first element of the slice, or None if it is empty.

Example

use dyn_slice::standard::debug;

let slice = debug::new(&[1, 2, 3, 4, 5]);
println!("{:?}", slice.first()); // Some(1)

let empty_slice = debug::new::<u8>(&[]);
println!("{:?}", empty_slice.first()); // None

pub fn last(&self) -> Option<&Dyn>

Returns a reference to the last element of the slice, or None if it is empty.

Example

use dyn_slice::standard::debug;

let slice = debug::new(&[1, 2, 3, 4, 5]);
println!("{:?}", slice.last()); // Some(5)

let empty_slice = debug::new::<u8>(&[]);
println!("{:?}", empty_slice.last()); // None

pub fn get(&self, index: usize) -> Option<&Dyn>

Returns a reference to the element at the given index or None if the index is out of bounds.

Example

use dyn_slice::standard::debug;

let slice = debug::new(&[1, 2, 3, 4, 5]);
println!("{:?}", slice.get(2)); // Some(3)
println!("{:?}", slice.get(5)); // None

pub unsafe fn get_unchecked(&self, index: usize) -> &Dyn

Returns a reference to the element at the given index, without doing bounds checking.

Safety

The caller must ensure that index < self.len() Calling this on an empty dyn Slice will result in a segfault!

pub unsafe fn slice_unchecked( &self, start: usize, len: usize ) -> DynSlice<'_, Dyn>

Get a sub-slice from the start index with the len, without doing bounds checking.

Safety

Caller must ensure that:

• start < self.len()
• len <= self.len() - start

pub fn slice<R: RangeBounds<usize>>( &self, range: R ) -> Option<DynSlice<'_, Dyn>>

Returns a sub-slice from the start index with the len or None if the slice is out of bounds.

Example

use dyn_slice::standard::debug;

let slice = debug::new(&[1, 2, 3, 4, 5]);
println!("{slice:?}"); // [1, 2, 3, 4, 5]
println!("{:?}", slice.slice(1..4)); // Some([2, 3, 4])
println!("{:?}", slice.slice(2..)); // Some([3, 4, 5])
println!("{:?}", slice.slice(5..)); // Some([])
println!("{:?}", slice.slice(6..)); // None

pub const unsafe fn downcast_unchecked<T>(&self) -> &[T]

Returns the underlying slice as &[T].

Safety

The caller must ensure that the underlying slice is of type [T].

pub const fn iter(&self) -> Iter<'_, Dyn>

Returns an iterator over the slice.

Example

use dyn_slice::standard::debug;

let slice = debug::new(&[1, 2, 3, 4, 5]);
let iter = slice.iter().map(|x| format!("{:?}!", x));
println!("{:?}", iter.collect::<Vec<String>>()); // ["1!", "2!", "3!", "4!", "5!"]

impl<'a> DynSlice<'a, dyn Any>

pub fn is<T: 'static>(&self) -> bool

Returns true if the underlying slice is of type T.

pub fn downcast<T: 'static>(&self) -> Option<&[T]>

Returns the underlying slice as &[T], or None if the underlying slice is not of type T.

impl<'a> DynSlice<'a, dyn Any + Send>

pub fn is<T: 'static>(&self) -> bool

Returns true if the underlying slice is of type T.

pub fn downcast<T: 'static>(&self) -> Option<&[T]>

Returns the underlying slice as &[T], or None if the underlying slice is not of type T.

impl<'a> DynSlice<'a, dyn Any + Sync + Send>

pub fn is<T: 'static>(&self) -> bool

Returns true if the underlying slice is of type T.

pub fn downcast<T: 'static>(&self) -> Option<&[T]>

Returns the underlying slice as &[T], or None if the underlying slice is not of type T.

Trait Implementations

impl<'a, Dyn: ?Sized + Pointee<Metadata = DynMetadata<Dyn>>> AsRef<DynSlice<'a, Dyn>> for DynSliceMut<'a, Dyn>

fn as_ref(&self) -> &DynSlice<'a, Dyn>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a, Dyn: ?Sized + Pointee<Metadata = DynMetadata<Dyn>>> Clone for DynSlice<'a, Dyn>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, Dyn: Pointee<Metadata = DynMetadata<Dyn>> + Debug + ?Sized> Debug for DynSlice<'a, Dyn>

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

Formats the value using the given formatter.

impl<'a, Dyn: ?Sized + Pointee<Metadata = DynMetadata<Dyn>>> Index<usize> for DynSlice<'a, Dyn>

type Output = Dyn

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, 'b, Dyn: ?Sized + Pointee<Metadata = DynMetadata<Dyn>>> IntoIterator for &'b DynSlice<'a, Dyn>

type IntoIter = Iter<'b, Dyn>

Which kind of iterator are we turning this into?

type Item = &'b Dyn

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, Dyn: ?Sized + Pointee<Metadata = DynMetadata<Dyn>>> IntoIterator for DynSlice<'a, Dyn>

type IntoIter = Iter<'a, Dyn>

Which kind of iterator are we turning this into?

type Item = &'a Dyn

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, Dyn: Pointee<Metadata = DynMetadata<Dyn>> + PartialEq<Rhs> + ?Sized, Rhs> PartialEq<&[Rhs]> for DynSlice<'a, Dyn>

fn eq(&self, other: &&[Rhs]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, Dyn: Pointee<Metadata = DynMetadata<Dyn>> + PartialEq<Rhs> + ?Sized, Rhs> PartialEq<[Rhs]> for DynSlice<'a, Dyn>

fn eq(&self, other: &[Rhs]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, Dyn: Pointee<Metadata = DynMetadata<Dyn>> + PartialOrd<Rhs> + ?Sized, Rhs> PartialOrd<&[Rhs]> for DynSlice<'a, Dyn>

Implements comparison of slices lexicographically.

fn partial_cmp(&self, other: &&[Rhs]) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, Dyn: Pointee<Metadata = DynMetadata<Dyn>> + PartialOrd<Rhs> + ?Sized, Rhs> PartialOrd<[Rhs]> for DynSlice<'a, Dyn>

Implements comparison of slices lexicographically.

fn partial_cmp(&self, other: &[Rhs]) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, Dyn: Pointee<Metadata = DynMetadata<Dyn>> + ?Sized> Pointer for DynSlice<'a, Dyn>

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

Formats the value using the given formatter.

impl<'a, Dyn: ?Sized + Pointee<Metadata = DynMetadata<Dyn>>> Copy for DynSlice<'a, Dyn>