Struct UnalignedSlice 

pub struct UnalignedSlice<'a, T> { /* private fields */ }

A minimally functional span over a potentially unaligned slice of elements of type T.

Like &[T], this type guarantees that the memory [self.as_ptr(), self.as_ptr().add(self.len())) is valid for reads.

However, unlike &[T], the pointer Self::as_ptr is not guaranteed to be aligned to std::mem::align_of::<T>().

If the type T is Copy, then std::ptr::read_unaligned can be used on the valid memory region for this slice to access values of type T.

Implementations

impl<'a, T> UnalignedSlice<'a, T>

pub const unsafe fn new(ptr: *const T, len: usize) -> Self

Construct a new UnalignedSlice over the region [ptr, ptr.add(len)).

Safety

The provided memory region must be valid for reading via std::ptr::read_unaligned for the duration of the associated lifetime.

Note that ptr need not be aligned to std::mem::align_of::<T>().

Argument ptr may be null if len == 0.

pub const fn len(&self) -> usize

Return the number of elements of type T available for reading from Self::as_ptr.

pub const fn is_empty(&self) -> bool

Return true only if the associated slice is empty.

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

Return the base pointer of the slice.

NOTE: It is not guaranteed that the returned pointer is aligned!

Trait Implementations

impl<T> AsUnaligned for UnalignedSlice<'_, T>

type Element = T

The element type of the slice.

fn as_unaligned(&self) -> UnalignedSlice<'_, T>

Return an UnalignedSlice view of self.

impl<T> Clone for UnalignedSlice<'_, T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Copy for UnalignedSlice<'_, T>

impl<'a, T: Debug> Debug for UnalignedSlice<'a, T>

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

Formats the value using the given formatter.

impl<T, U> DistanceFunction<UnalignedSlice<'_, T>, UnalignedSlice<'_, U>> for Distance<T, U>

where T: 'static, U: 'static,

fn evaluate_similarity( &self, x: UnalignedSlice<'_, T>, y: UnalignedSlice<'_, U>, ) -> f32

Perform a distance computation between the left-hand and right-hand arguments.

impl<A, T, L, R, const N: usize, F> FTarget2<A, T, UnalignedSlice<'_, L>, UnalignedSlice<'_, R>> for Specialize<N, F>

where A: Architecture, F: for<'a, 'b> Target2<A, T, UnalignedSlice<'a, L>, UnalignedSlice<'b, R>> + Default,

fn run(arch: A, x: UnalignedSlice<'_, L>, y: UnalignedSlice<'_, R>) -> T

impl<'a, T, const N: usize> From<&'a [T; N]> for UnalignedSlice<'a, T>

fn from(slice: &'a [T; N]) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<T> Send for UnalignedSlice<'_, T>

where T: Sync,

SAFETY: UnalignedSlice is like a &[T]: it can be sent to other threads when &T: Send, which holds iff T: Sync.

impl<T> Sync for UnalignedSlice<'_, T>

where T: Sync,

SAFETY: UnalignedSlice is like a &[T]: it can be shared with other threads when &T is send, implying the bound T: Sync.