Struct ThreadedActor

pub struct ThreadedActor<T> { /* private fields */ }

An actor that uses an OS thread-per-instance.

This may be useful if the application only needs a few actors and doesn’ otherwise use an async runtime. Or it can be used in an async context if an actor needs to block or is compute intensive and requires its own thread.

Implementations

impl<T> ThreadedActor<T>

where T: Default + Send + 'static,

pub fn new() -> Self

Creates an actor with a default initial state.

This requires the state type to implement the Default trait.

Examples found in repository

examples/threaded_keyval.rs (line 29)

    pub fn new() -> Self {
        Self { actor: ThreadedActor::new() }
    }

impl<T> ThreadedActor<T>

where T: Send + 'static,

pub fn from_state(state: T) -> Self

Creates a threaded actor with the specified initial state.

pub fn cast<F>(&self, f: F)

where F: FnOnce(&mut T) + Send + 'static,

Send an asynchronous request to the actor.

This queues the request and returns immediately.

Examples found in repository

examples/threaded_keyval.rs (lines 41-43)

    pub fn insert<K,V>(&self, key: K, val: V)
    where
        K: Into<String>,
        V: Into<String>,
    {
        let key = key.into();
        let val = val.into();

        self.actor.cast(move |state| {
            state.insert(key, val);
        });
    }

pub fn call<F, R>(&self, f: F) -> R

where F: FnOnce(&mut T) -> R + Send + 'static, R: Send + 'static,

Examples found in repository

examples/threaded_keyval.rs (lines 51-53)

    pub fn get<K: Into<String>>(&self, key: K) -> Option<String> {
        let key = key.into();
        self.actor.call(move |state| {
            state.get(&key).map(|v| v.to_string())
        })
    }

Trait Implementations

impl<T: Clone> Clone for ThreadedActor<T>

fn clone(&self) -> ThreadedActor<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.