Struct Pierce 

pub struct Pierce<T>
where
    T: StableDeref,
    T::Target: StableDeref,
{ /* private fields */ }

Cache doubly-nested pointers.

A Pierce<T> stores T along with a cached pointer to <T::Target as Deref>::Target.

Implementations

impl<T> Pierce<T>

where T: StableDeref, T::Target: StableDeref,

pub fn new(outer: T) -> Self

Create a new Pierce.

Create a Pierce out of the given nested pointer. This method derefs T twice and cache the address where the inner pointer points to.

Deref-ing the created Pierce returns the cached reference directly. deref is not called on T.

pub fn borrow_outer(&self) -> &T

Borrow the outer pointer T.

You can then call the methods on &T.

You can even call deref twice on &T yourself to bypass Pierce’s cache:

use std::ops::Deref;
let pierce = Pierce::new(Box::new(Box::new(5)));
let outer: &Box<Box<i32>> = pierce.borrow_outer();
let inner: &Box<i32> = outer.deref();
let target: &i32 = inner.deref();
assert_eq!(*target, 5);

pub fn into_outer(self) -> T

Get the outer pointer T out.

Like into_inner() elsewhere, this consumes the Pierce and return the wrapped pointer.

Trait Implementations

impl<T> AsRef<<<T as Deref>::Target as Deref>::Target> for Pierce<T>

where T: StableDeref, T::Target: StableDeref,

fn as_ref(&self) -> &<T::Target as Deref>::Target

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> Clone for Pierce<T>

where T: StableDeref + Clone, T::Target: StableDeref,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Default for Pierce<T>

where T: StableDeref + Default, T::Target: StableDeref,

fn default() -> Self

Returns the “default value” for a type.

impl<T> Deref for Pierce<T>

where T: StableDeref, T::Target: StableDeref,

type Target = <<T as Deref>::Target as Deref>::Target

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> Send for Pierce<T>

where T: StableDeref + Send, T::Target: StableDeref, <T::Target as Deref>::Target: Sync,

impl<T> StableDeref for Pierce<T>

where T: StableDeref, T::Target: StableDeref,

impl<T> Sync for Pierce<T>

where T: StableDeref + Sync, T::Target: StableDeref, <T::Target as Deref>::Target: Sync,