Struct lunatic::process::Process

pub struct Process<T: Serialize + DeserializeOwned> { /* private fields */ }

A sandboxed computation.

Processes are fundamental building blocks of Lunatic applications. Each of them has their own memory space. The only way for processes to interact is trough [Serialize + DeserializeOwned] passing.

Safety:

It’s not safe to use mutable static variables to share data between processes, because each of them is going to see a separate heap and a unique static variable.

Implementations

impl<T: Serialize + DeserializeOwned> Process<T>

pub fn id(&self) -> u128

pub fn send(&self, message: T)

Send message to process.

pub fn tag_send(&self, tag: Tag, message: T)

Tag a message and send it to a process.

pub fn link(&self) -> Tag

Links the current process with another one.

pub fn unlink(&self)

Unlinks the current process from another one.

impl<T, U> Process<Request<T, U>> where
    T: Serialize + DeserializeOwned,
    U: Serialize + DeserializeOwned, 

pub fn request(&self, message: T) -> Result<U, Error>

pub fn request_timeout(&self, message: T, timeout: Duration) -> Result<U, Error>

Trait Implementations

impl<T: Serialize + DeserializeOwned> Clone for Process<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Serialize + DeserializeOwned> Debug for Process<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, T: Serialize + DeserializeOwned> Deserialize<'de> for Process<T>

fn deserialize<D>(deserializer: D) -> Result<Process<T>, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T: Serialize + DeserializeOwned> Drop for Process<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Serialize + DeserializeOwned> PartialEq<Process<T>> for Process<T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: Serialize + DeserializeOwned> Serialize for Process<T>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.