Struct mischief::In

pub struct In<P, R: Region> { /* private fields */ }

A pointer which has its pointee in a specific memory region.

Implementations

impl<P: Pointer, R: Region> In<P, R>where
    P::Target: Pointee,

pub fn new(ptr: P) -> Selfwhere
    P: Within<R>,

Creates a new In from a pointer.

pub unsafe fn new_unchecked(ptr: P) -> Self

Creates a new In from a pointer.

Safety

The pointee of ptr must be contained in R.

pub fn map<F, Q>(self, f: F) -> In<Q, R>where
    F: FnOnce(P) -> Q,
    Q: Pointer + Within<R>,
    Q::Target: Pointee,

Maps this In to another pointer in its region.

pub unsafe fn map_unchecked<F, Q>(self, f: F) -> In<Q, R>where
    F: FnOnce(P) -> Q,
    Q: Pointer,
    Q::Target: Pointee,

Maps this In to another pointer in its region.

Safety

The pointer returned by f must be completely contained in R.

pub fn as_raw(&self) -> In<*mut P::Target, R>

Gets a raw In from this pointer.

impl<P, R: Region> In<P, R>

pub fn into_inner(this: Self) -> P

Unwraps an In, returning the underlying pointer.

pub fn ptr(&self) -> &P

Returns a reference to the pointer of this In.

pub unsafe fn ptr_mut(&mut self) -> &mut P

Returns a mutable reference to the pointer of this In.

Safety

The pointer must not be mutated to point outside of R.

impl<T: Pointee + ?Sized, A: RegionalAllocator> In<Frame<T, A>, A::Region>where
    <T as Pointee>::Metadata: Metadata<T>,

pub fn slot(&mut self) -> In<Slot<'_, T>, A::Region>

Returns a Slot of the internal contents.

impl<'a, T: Pointee + ?Sized, R: Region> In<Slot<'a, T>, R>

pub fn as_mut<'b>(&'b mut self) -> In<Slot<'b, T>, R>where
    'a: 'b,

Gets a mutable borrow from this slot.

Trait Implementations

impl<P: Clone, R: Clone + Region> Clone for In<P, R>

fn clone(&self) -> In<P, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: Deref, R: Region> Deref for In<P, R>

type Target = <P as Deref>::Target

The resulting type after dereferencing.

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

Dereferences the value.

impl<P: DerefMut, R: Region> DerefMut for In<P, R>

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

Mutably dereferences the value.

impl<P: Destructure, R: Region> Destructure for In<P, R>

type Underlying = <P as Destructure>::Underlying

The underlying type that is destructured.

type Destructuring = <P as Destructure>::Destructuring

The type of destructuring to perform.

fn underlying(&mut self) -> *mut Self::Underlying

Returns a mutable pointer to the underlying type.

impl<P, R: Region, U> Restructure<U> for In<P, R>where
    P: RestructurablePointer + Restructure<U>,
    <P as Restructure<U>>::Restructured: Pointer,
    <<P as Restructure<U>>::Restructured as Pointer>::Target: Pointee,

type Restructured = In<<P as Restructure<U>>::Restructured, R>

The restructured version of this type.

unsafe fn restructure(&self, ptr: *mut U) -> Self::Restructured

Restructures a pointer to this type into the target type.

impl<P: Copy, R: Copy + Region> Copy for In<P, R>