Struct LCellEnvironment

pub struct LCellEnvironment<'k, T: Opaque + 'k> { /* private fields */ }

A self-referential environment of LCells, with zero runtime cost.

Wrapper around Holder. Like Holder, the lifetime may be anything.

Examples

use qcell::LCell;
 
use selfref::srce::LCellEnvironment;
use selfref::opaque;

struct Foo<'a> {
    foo: LCell<'a, Option<&'a Foo<'a>>>,
}

struct FooKey;
opaque! {
    impl Opaque for FooKey {
        type Kind<'a> = Foo<'a>;
    }
}

fn main() {
    // We can use a closure here, but we need to give the compiler a hint.
    let holder = LCellEnvironment::<'_, FooKey>::new_with(
        |foo| foo.build(Foo { foo: LCell::new(Default::default()) })
    );
}

Implementations

impl<'k, T> LCellEnvironment<'k, T>

where T: Opaque,

pub fn new_with<F>(f: F) -> Self

where F: for<'a> FnOnce(&mut Builder<'a, T>), T::Kind<'k>: Sized,

Creates a new LCellEnvironment.

Works exactly like Holder::new_with.

Examples

use qcell::LCell;
 
use selfref::srce::LCellEnvironment;
use selfref::opaque;

struct Foo<'a> {
    foo: LCell<'a, Option<&'a Foo<'a>>>,
}

struct FooKey;
opaque! {
    impl Opaque for FooKey {
        type Kind<'a> = Foo<'a>;
    }
}

fn main() {
    // We can use a closure here, but we need to help the compiler.
    let holder = LCellEnvironment::<'_, FooKey>::new_with(
        |foo| foo.build(Foo { foo: LCell::new(Default::default()) })
    );
}

impl<'k, T> LCellEnvironment<'k, T>

where T: Opaque,

pub fn open_rw<'i, F, R>(self: Pin<&'i mut Self>, f: F) -> R

where F: for<'a, 'id> FnOnce(&'a mut LCellOwner<'id>, OperateIn<'id, T>) -> R,

Opens this LCellEnvironment for reading and writing (mutable).

Examples

use qcell::LCell;
 
use selfref::srce::LCellEnvironment;
use selfref::opaque;

struct Foo<'a> {
    foo: LCell<'a, Option<&'a Foo<'a>>>,
}

struct FooKey;
opaque! {
    impl Opaque for FooKey {
        type Kind<'a> = Foo<'a>;
    }
}

fn main() {
    let mut holder = Box::pin(LCellEnvironment::<'_, FooKey>::new_with(
        |foo| foo.build(Foo { foo: LCell::new(Default::default()) })
    ));
    // Actually making our Foo refer to itself.
    holder.as_mut().open_rw(
        |owner, foo| {
            *owner.rw(&foo.foo) = Some(foo.get_ref());
        }
    );
}

pub fn open_ro<'i, F, R>(self: Pin<&'i Self>, f: F) -> R

where F: for<'a, 'id> FnOnce(&'a LCellOwner<'id>, OperateIn<'id, T>) -> R,

Opens this LCellEnvironment for reading only (shared).

Examples

use qcell::LCell;
 
use selfref::srce::LCellEnvironment;
use selfref::opaque;

struct Foo<'a> {
    foo: LCell<'a, Option<&'a Foo<'a>>>,
}

struct FooKey;
opaque! {
    impl Opaque for FooKey {
        type Kind<'a> = Foo<'a>;
    }
}

fn main() {
    let holder = Box::pin(LCellEnvironment::<'_, FooKey>::new_with(
        |foo| foo.build(Foo { foo: LCell::new(Default::default()) })
    ));
    holder.as_ref().open_ro(
        |owner, foo| {
            // can't write to it
            assert!(owner.ro(&foo.foo).is_none());
        }
    );
}