Struct UnsafeLock 

pub struct UnsafeLock<T: ?Sized> { /* private fields */ }

Implementations

impl<T> UnsafeLock<T>

pub unsafe fn new(value: T) -> Self

Safety

There must be no copies of the value. See Send implementation.

impl<T: ?Sized> UnsafeLock<T>

pub unsafe fn lock(&self) -> NonNull<T>

Safety

• Do not dereference to the returned pointer after unlock.
• Do not make copies of T from the returned pointer. See Send implementation.

pub unsafe fn unlock(&self)

Safety

Must follow lock.

Trait Implementations

impl<T: Clone + ?Sized> Clone for UnsafeLock<T>

fn clone(&self) -> UnsafeLock<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for UnsafeLock<T>

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

Formats the value using the given formatter.

impl<T: ?Sized> Send for UnsafeLock<T>

Unlike Mutex, this lock is Send and Sync regardless of whether T is Send or not. That’s because T is always under the protection of this lock whenever clients uphold the safety of the lock.

Safety

There must be no copies of the value inside this lock. Clients must not have copies before and after creation of this lock. Because this lock assumes that the value inside the lock has no copies, so the lock is Send and Sync even if T isn’t.
For example, imagine that you have multiple Rc<T>, which is not Send, and make UnsafeLock<Rc<T>> from one copy of them, then you send the lock to another thread. It can cause data race because of Rc<T> outside this lock.
But if you have only one T and wrap it within UnsafeLock, then T is guaranteed to be protected by this lock. Making copies of UnsafeLock<T>, sending it to another thread, and accessing it from another thread does not break the guarantee. But you still can make copies of T from its pointer, but you shouldn’t.

impl<T: ?Sized> Sync for UnsafeLock<T>