Struct UnsafeSlice

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

This struct serves as a wrapper around unsafe accesses to a vector of elements.

This can be used if (and only if) we know (and the compiler doesn’t) that threads do not access the same index during the concurrent processing.

DO NOT REUSE IN YOUR PROJECTS!

Implementations

impl<'a, T> UnsafeSlice<'a, T>

pub fn new(slice: &'a mut [T]) -> Self

pub unsafe fn get_mut(&self, index: usize) -> &mut T

Safety

Two threads concurrently writing to the same location will cause UB!!

pub fn get(&self, index: usize) -> &T

Returns a shared reference to the element at the given index.

This function is safe to call because it returns an immutable reference, which can be shared between multiple threads. However, it’s important to note that this safety relies on the exclusive access guarantee provided by the mutable reference passed to UnsafeSlice::new().

Arguments

• index - Position of the element to access

Returns

Reference to the element at index

Panics

Panics if index is out of bounds

Examples

let mut data = vec![1, 2, 3];
let slice = UnsafeSlice::new(&mut data);
assert_eq!(*slice.get(0), 1);

Trait Implementations

impl<'a, T: Clone> Clone for UnsafeSlice<'a, T>

fn clone(&self) -> UnsafeSlice<'a, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, T: Copy> Copy for UnsafeSlice<'a, T>

impl<T: Send + Sync> Send for UnsafeSlice<'_, T>

impl<T: Send + Sync> Sync for UnsafeSlice<'_, T>