Struct runestick::Shared[−][src]

pub struct Shared<T: ?Sized> { /* fields omitted */ }

A shared value.

Implementations

`impl<T> Shared<T>`[src]

`pub fn new(data: T) -> Self`[src]

Construct a new shared value.

`pub fn debug(&self) -> SharedDebug<'_, T>`[src]

Return a debug formatter, that when printed will display detailed diagnostics of this shared type.

`pub fn is_readable(&self) -> bool`[src]

Test if the value is sharable.

Examples

use runestick::Shared;
let shared = Shared::new(1u32);
assert!(shared.is_readable());

{
    let guard = shared.borrow_ref().unwrap();
    assert!(shared.is_readable()); // Note: still readable.
}

{
    let guard = shared.borrow_mut().unwrap();
    assert!(!shared.is_readable());
}

assert!(shared.is_readable());

Taking inner value

use runestick::Shared;
let shared = Shared::new(1u32);
let shared2 = shared.clone();
assert!(shared.is_readable());
shared.take().unwrap();
assert!(!shared2.is_readable());
assert!(shared2.take().is_err());

`pub fn is_writable(&self) -> bool`[src]

Test if the value is exclusively accessible.

Examples

use runestick::Shared;
let shared = Shared::new(1u32);
assert!(shared.is_writable());

{
    let guard = shared.borrow_ref().unwrap();
    assert!(!shared.is_writable());
}

assert!(shared.is_writable());

`pub fn take(self) -> Result<T, AccessError>`[src]

Take the interior value, if we have exlusive access to it and there are no other live exlusive or shared references.

A value that has been taken can no longer be accessed.

Examples

use runestick::Shared;

#[derive(Debug)]
struct Foo {
    counter: isize,
}

let a = Shared::new(Foo { counter: 0 });
let b = a.clone();

{
    let mut a = a.borrow_mut().unwrap();
    // NB: this is prevented since we have a live reference.
    assert!(b.take().is_err());
    a.counter += 1;
}

let a = a.take().unwrap();
assert_eq!(a.counter, 1);

`pub fn into_ref(self) -> Result<Ref<T>, AccessError>`[src]

Get a reference to the interior value while checking for shared access that holds onto a reference count of the inner value.

This prevents other exclusive accesses from being performed while the guard returned from this function is live.

Examples

use runestick::Shared;

#[derive(Debug)]
struct Foo {
    counter: isize,
}

let a = Shared::new(Foo { counter: 0 });
let b = a.clone();

b.borrow_mut().unwrap().counter += 1;

{
    // Consumes `a`.
    let mut a = a.into_ref().unwrap();
    assert_eq!(a.counter, 1);
    assert!(b.borrow_mut().is_err());
}

let mut b = b.borrow_mut().unwrap();
b.counter += 1;
assert_eq!(b.counter, 2);

`pub fn into_mut(self) -> Result<Mut<T>, AccessError>`[src]

Get a reference to the interior value while checking for exclusive access that holds onto a reference count of the inner value.

This prevents other exclusive and shared accesses from being performed while the guard returned from this function is live.

Examples

use runestick::Shared;

#[derive(Debug)]
struct Foo {
    counter: isize,
}

let a = Shared::new(Foo { counter: 0 });
let b = a.clone();

{
    // Consumes `a`.
    let mut a = a.into_mut().unwrap();
    a.counter += 1;

    assert!(b.borrow_ref().is_err());
}

assert_eq!(b.borrow_ref().unwrap().counter, 1);

`impl<T: ?Sized> Shared<T>`[src]

`pub fn borrow_ref(&self) -> Result<BorrowRef<'_, T>, AccessError>`[src]

Get a reference to the interior value while checking for shared access.

This prevents other exclusive accesses from being performed while the guard returned from this function is live.

Examples

use runestick::Shared;

#[derive(Debug)]
struct Foo {
    counter: isize,
}

let a = Shared::new(Foo { counter: 0 });

a.borrow_mut().unwrap().counter += 1;

{
    let mut a_ref = a.borrow_ref().unwrap();
    assert_eq!(a_ref.counter, 1);
    assert!(a.borrow_mut().is_err());
    assert!(a.borrow_ref().is_ok());
}

let mut a = a.borrow_mut().unwrap();
a.counter += 1;
assert_eq!(a.counter, 2);

`pub fn borrow_mut(&self) -> Result<BorrowMut<'_, T>, AccessError>`[src]

Get a reference to the interior value while checking for exclusive access.

This prevents other shared or exclusive accesses from being performed while the guard returned from this function is live.

Examples

use runestick::Shared;

#[derive(Debug)]
struct Foo {
    counter: isize,
}

let a = Shared::new(Foo { counter: 0 });

{
    let mut a_mut = a.borrow_mut().unwrap();
    a_mut.counter += 1;
    assert_eq!(a_mut.counter, 1);
    assert!(a.borrow_ref().is_err());
}

let a = a.borrow_ref().unwrap();
assert_eq!(a.counter, 1);

`impl Shared<AnyObj>`[src]

`pub unsafe fn from_ref<T>(data: &T) -> (Self, SharedPointerGuard) where T: Any,` [src]

Construct a Shared<Any> from a pointer, that will be “taken” once the returned guard is dropped.

Safety

The reference must be valid for the duration of the guard.

Examples

use runestick::{Any, Shared};

#[derive(Any)]
struct Thing(u32);

let value = Thing(10u32);

unsafe {
    let (shared, guard) = Shared::from_ref(&value);
    assert!(shared.downcast_borrow_mut::<Thing>().is_err());
    assert_eq!(10u32, shared.downcast_borrow_ref::<Thing>().unwrap().0);

    drop(guard);

    assert!(shared.downcast_borrow_mut::<Thing>().is_err());
    assert!(shared.downcast_borrow_ref::<Thing>().is_err());
}

`pub unsafe fn from_mut<T>(data: &mut T) -> (Self, SharedPointerGuard) where T: Any,` [src]

Construct a Shared<Any> from a mutable pointer, that will be “taken” once the returned guard is dropped.

Safety

The reference must be valid for the duration of the guard.

Examples

use runestick::{Any, Shared};

#[derive(Any)]
struct Thing(u32);

let mut value = Thing(10u32);

unsafe {
    let (shared, guard) = Shared::from_mut(&mut value);
    shared.downcast_borrow_mut::<Thing>().unwrap().0 = 20;

    assert_eq!(20u32, shared.downcast_borrow_mut::<Thing>().unwrap().0);
    assert_eq!(20u32, shared.downcast_borrow_ref::<Thing>().unwrap().0);

    drop(guard);

    assert!(shared.downcast_borrow_mut::<Thing>().is_err());
    assert!(shared.downcast_borrow_ref::<Thing>().is_err());
}