Struct RefOnce

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

Implementations

impl<'a, T> RefOnce<'a, T>

pub fn new(value: T, slot: &'a mut MaybeUninit<T>) -> Self

Examples found in repository

examples/ref_once.rs (lines 13-20)

fn main() {
    let mut a = vec![1, 2, 3];
    let mut x = 0;

    let mut slots = (MaybeUninit::uninit(), MaybeUninit::uninit());

    scope_lock::lock_scope(|e| {
        thread::spawn({
            let f = e.fn_(RefOnce::new(
                |()| {
                    println!("hello from the first scoped thread");
                    // We can borrow `a` here.
                    dbg!(&a);
                },
                &mut slots.0,
            ));
            move || f(())
        });
        thread::spawn({
            let mut f = e.fn_mut(RefOnce::new(
                |()| {
                    println!("hello from the second scoped thread");
                    // We can even mutably borrow `x` here,
                    // because no other threads are using it.
                    x += a[0] + a[2];
                },
                &mut slots.1,
            ));
            move || f(())
        });
        println!("hello from the main thread");
    });

    // After the scope, we can modify and access our variables again:
    a.push(4);
    assert_eq!(x, a.len());
}

pub fn into_inner(this: Self) -> T

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

pub fn into_raw(this: Self) -> *mut T

Essentially leaks object as a pointer until the original RefOnce is restored via Self::from_raw.

pub unsafe fn from_raw(ptr: *mut T) -> Self

Convert pointer returned from Self::into_raw back into RefOnce.

Safety

ptr must have been returned from Self::into_raw. New lifetime argument 'a of RefOnce should not outlive old lifetime not to cause any undefined behaviour.

Trait Implementations

impl<T: ?Sized> Borrow<T> for RefOnce<'_, T>

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T: ?Sized> BorrowMut<T> for RefOnce<'_, T>

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value.

impl<T: ?Sized> Deref for RefOnce<'_, T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: ?Sized> DerefMut for RefOnce<'_, T>

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

Mutably dereferences the value.

impl<T: ?Sized> Drop for RefOnce<'_, T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> PointerIntoInner for RefOnce<'_, T>

fn into_inner(self) -> Self::Pointee

impl<'a, T> PointerLike for RefOnce<'a, T>

type Pointee = T

The type our pointer points at.

fn into_ptr(self) -> *mut Self::Pointee

Convert smart pointer into a raw pointer, possibly leaking it.

unsafe fn from_ptr(ptr: *mut Self::Pointee) -> Self

Convert a raw pointer back into a smart pointer.

impl<T> PointerDeref for RefOnce<'_, T>

impl<T> PointerDerefMut for RefOnce<'_, T>

impl<T> PointerPinUnforgotten for RefOnce<'_, T>

Note that RefOnce::into_pin implementation, mimicking the Box::into_pin would be unsound because RefOnce stores object within the std::mem::MaybeUninit slot allocated somewhere (including on a stack) which would allow us to deallocate pinned object without first calling drop on it, thus violating the pin’s drop guarantee. However we can safely assume that this pointer won’t be forgotten and drop will “eventually” run, so we are safe here.