Struct ste::Tagged

pub struct Tagged<T> { /* fields omitted */ }

An object T which can only be used on the thread with the corresponding tag.

Dropping tagged elements

Dropping a tagged container outside of its thread and the underlying T implements Drop will cause it to panic.

The correct way to drop it is to move it back onto the thread, use use the provided Thread::drop.

Examples

// Ensure that `Foo` is `!Send` and `!Sync`.
struct Foo(*mut ());

impl Foo {
    fn test(&self) -> u32 {
        42
    }
}

impl Drop for Foo {
    fn drop(&mut self) {
        println!("Foo was dropped");
    }
}

let thread = ste::Thread::new()?;

let value = thread.submit(|| ste::Tagged::new(Foo(0 as *mut ())))?;
let out = thread.submit(|| value.test())?;
assert_eq!(42, out);

thread.drop(value)?;
thread.join()?;

Implementations

impl<T> Tagged<T>

pub fn new(target: T) -> Self

Construct a new container tagged with the current thread.

Trait Implementations

impl<T> Deref for Tagged<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for Tagged<T>

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

Mutably dereferences the value.

impl<T> Drop for Tagged<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Send for Tagged<T>

impl<T> Sync for Tagged<T>