Trait CreateHandle 

pub unsafe trait CreateHandle<ProxyTiming: Timing>: PlaceProxy {
    type Handle: PlaceHandle<Target = Self::Target>;

    const ACCESS: AccessKind;

    // Required method
    unsafe fn handle_from_raw(this: *const Self) -> Self::Handle;
}

TODO: Defines creation of handles.

A handle to the represented place can be obtained from a value of this type by calling Self::handle_from_raw.

The timing of the access permissions of Self::handle_from_raw is ProxyTiming.

The Self::ACCESS constant specifies what type of permission is required for creating a handle this way. The ProxyTiming argument specifies for how long that permission must be granted; it must be one of the types in the borrowck module. Any compiler-generated handle creations automatically honor these requirements via the borrow checker.

Required Associated Constants

const ACCESS: AccessKind

The access permissions required by Self::handle_from_raw.

Required Associated Types

type Handle: PlaceHandle<Target = Self::Target>

The handle that’s used for operating on the represented place.

This type controls which place operations are available on the represented place. For example, if this implements ReadPlace, then writing *self is allowed and yields a value of type Self::Handle::Target (where self: Self).

Required Methods

unsafe fn handle_from_raw(this: *const Self) -> Self::Handle

Create a handle to the pointee of the raw pointer.

Safety

• this must be a valid pointer for as long as the return value lives,
• *this must be handle-valid with permissions Self::ACCESS for ProxyTiming.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<'a, T: ?Sized> CreateHandle<Instant> for &'a T

const ACCESS: AccessKind = AccessKind::Shared

type Handle = RefHandle<'a, T>

unsafe fn handle_from_raw(this: *const Self) -> Self::Handle

impl<'a, T: ?Sized> CreateHandle<Instant> for &'a mut T

const ACCESS: AccessKind = AccessKind::Shared

type Handle = MutHandle<'a, T>

unsafe fn handle_from_raw(this: *const Self) -> Self::Handle

impl<'b, T> CreateHandle<Instant> for RefMut<'b, T>

const ACCESS: AccessKind = AccessKind::Shared

type Handle = CellMutHandle<'b, T>

unsafe fn handle_from_raw(_this: *const Self) -> Self::Handle

impl<ProxyTiming, P> CreateHandle<ProxyTiming> for Pin<P>

where ProxyTiming: Timing, P: CreateHandle<ProxyTiming>,

const ACCESS: AccessKind = P::ACCESS

type Handle = PinnedHandle<<P as CreateHandle<ProxyTiming>>::Handle>

unsafe fn handle_from_raw(this: *const Self) -> Self::Handle

impl<T: ?Sized> CreateHandle<Instant> for *const T

const ACCESS: AccessKind = AccessKind::Untracked

type Handle = *const T

unsafe fn handle_from_raw(this: *const Self) -> Self::Handle

impl<T: ?Sized> CreateHandle<Instant> for *mut T

const ACCESS: AccessKind = AccessKind::Untracked

type Handle = *mut T

unsafe fn handle_from_raw(this: *const Self) -> Self::Handle

impl<T: ?Sized> CreateHandle<Instant> for Arc<T>

const ACCESS: AccessKind = AccessKind::Shared

type Handle = ArcHandle<T>

unsafe fn handle_from_raw(this: *const Self) -> Self::Handle

impl<T: ?Sized> CreateHandle<Instant> for Box<T>

const ACCESS: AccessKind = AccessKind::Shared

type Handle = BoxHandle<T>

unsafe fn handle_from_raw(this: *const Self) -> Self::Handle

impl<T: ?Sized> CreateHandle<Instant> for NonNull<T>

const ACCESS: AccessKind = AccessKind::Untracked

type Handle = NonNull<T>

unsafe fn handle_from_raw(this: *const Self) -> Self::Handle

impl<T> CreateHandle<Instant> for Vec<T>

const ACCESS: AccessKind = AccessKind::Shared

type Handle = VecHandle<T>

unsafe fn handle_from_raw(this: *const Self) -> Self::Handle

Implementors

impl<T: ?Sized> CreateHandle<Instant> for ArcRef<T>

const ACCESS: AccessKind = AccessKind::Shared

type Handle = ArcRefHandle<T>