Struct Anchor

pub struct Anchor<'a, T: ?Sized> { /* private fields */ }

An !Send immutable anchor.
Use this to capture shared references in a single-threaded environment.

Deadlocks

On drop, if any associated Portals exist:

use ref_portals::rc::Anchor;

let mut x = "Scoped".to_owned();
let anchor = Anchor::new(&mut x);
let portal = anchor.portal();

assert_deadlock!(drop(anchor), Duration::from_secs(1));

Implementations

impl<'a, T: ?Sized> Anchor<'a, T>

pub fn new(reference: &'a T) -> Anchor<'a, T>

Creates a new Anchor instance, capturing reference.

pub fn portal(&self) -> Portal<T>

Creates an infallible portal of indefinite lifetime associated with this anchor.

Example

let x = "Scoped".to_owned();
let anchor = Anchor::new(&x);
let self_owned: Box<dyn Fn() + 'static> = Box::new({
    let portal = anchor.portal();
    move || println!("{}", *portal)
});

self_owned(); // Scoped

pub fn weak_portal(&self) -> WeakPortal<T>

Creates a weak portal of indefinite lifetime associated with this anchor.
Dropping an anchor doesn’t panic if only weak portals exist.

Trait Implementations

impl<'a, T: Debug + ?Sized> Debug for Anchor<'a, T>

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

Formats the value using the given formatter.

impl<'a, T: ?Sized> Drop for Anchor<'a, T>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T> UnwindSafe for Anchor<'a, T>

where T: RefUnwindSafe + ?Sized,

Safety:

use ref_portals::rc::Anchor;

let mut x = "Scoped".to_owned();
let anchor = Anchor::new(&mut x);
let portal = anchor.portal();

assert_deadlock!(
    drop(anchor),
    Duration::from_secs(1),
);