Struct guard_trait::AssertSafe

#[repr(transparent)]pub struct AssertSafe<T> { /* fields omitted */ }

A type for pointers that cannot uphold the necessary guard invariants at the type level, but which can be assumed to behave properly by unsafe code.

Implementations

impl<T> AssertSafe<T> where
    T: Deref, 

pub unsafe fn new_unchecked(inner: T) -> Self

Wrap a general-purpose pointer into a wrapper that implements the Guarded (and potentially GuardedMut) traits, provided that the pointer upholds this invariants anyway.

Safety

For the guard invariants to be upheld, the pointer must:

• dereference into a stable location. This forbids types that implement Deref by borrowing data that they own without a heap-based container in between;
• be owned. Any type that has a shorter lifetime than 'static, may have its borrow cancelled at any time, with the original borrowed data accessible again.

Trait Implementations

impl<T: Debug> Debug for AssertSafe<T>

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

Formats the value using the given formatter.

impl<T, U> Guarded for AssertSafe<T> where
    T: Deref<Target = U>,
    U: ?Sized, 

type Target = U

The target pointee that this pointer may dereference into. There are no real restrictions to what this type can be. However, the user must not assume that simply because a &Target reference is protected, that references indirectly derived (via Deref and other traits) would also be protected.

fn borrow_guarded(&self) -> &Self::Target

Borrow the pointee, into a fixed reference that can be sent directly and safely to e.g. memory-sharing completion-based I/O interfaces.

impl<T, U> GuardedMut for AssertSafe<T> where
    T: Deref<Target = U> + DerefMut,
    U: ?Sized, 

fn borrow_guarded_mut(&mut self) -> &mut Self::Target

Borrow the pointee mutably, into a fixed reference that can be sent directly and safely to e.g. memory-sharing completion-based I/O interfaces.