Struct lunatic_twitchax_patch::ap::ProcessRef

pub struct ProcessRef<T>
where
    T: AbstractProcess,
{ /* private fields */ }

A reference to a running AbstractProcess.

ProcessRef<T> is different from a Process in the ability to handle messages of different types, as long as the traits MessageHandler<Message>, RequestHandler<Request> or DeferredRequestHandler<Request> are implemented for T.

Implementations

impl<T> ProcessRef<T>

where T: AbstractProcess,

pub unsafe fn new(node_id: u64, process_id: u64) -> Self

Construct a process from a raw ID.

pub fn id(&self) -> u64

Returns the process ID.

pub fn node_id(&self) -> u64

Returns the node ID.

pub fn lookup<N: ProcessName + ?Sized>(name: &N) -> Option<Self>

Returns a process registered under name if it exists and the signature matches.

pub fn register<N: ProcessName>(&self, name: &N)

Registers process under name.

pub fn is_alive(&self) -> bool

Returns true for processes on the local node that are running.

Panics if called on a remote process.

pub fn link(&self)

Link process to the one currently running.

pub fn link_with(&self, tag: Tag)

Link process to the one currently running with tag.

pub fn unlink(&self)

Unlink processes from the caller.

pub fn kill(&self)

Kill process

pub fn shutdown(&self)

where T::Serializer: CanSerialize<ShutdownMessage<T::Serializer>> + CanSerialize<()>,

Shuts the AbstractProcess down.

pub fn shutdown_timeout(&self, timeout: Option<Duration>) -> Result<(), Timeout>

where T::Serializer: CanSerialize<ShutdownMessage<T::Serializer>> + CanSerialize<()>,

Shuts the AbstractProcess down.

If a timeout is specified the function will only block for the timeout period before returning Err(Timeout).

pub fn send<M: 'static>(&self, message: M)

where T::Serializer: CanSerialize<M>,

Send message to the process.

pub fn request<R: 'static>(&self, request: R) -> T::Response

where T: RequestHandler<R>, T::Serializer: CanSerialize<R> + CanSerialize<T::Response> + CanSerialize<RequestMessage<R, T::Response, T::Serializer>>,

Make a request to the process.

pub fn deferred_request<R: 'static>(&self, request: R) -> T::Response

where T: DeferredRequestHandler<R>, T::Serializer: CanSerialize<R> + CanSerialize<T::Response> + CanSerialize<RequestMessage<R, T::Response, T::Serializer>>,

Make a deferred request to the process.

pub fn with_timeout(self, timeout: Duration) -> WithTimeout<ProcessRef<T>>

Set a timeout on the next action performed on this process.

Timeouts affect ProcessRef::shutdown, ProcessRef::request and ProcessRef::deferred_request functions.

pub fn with_delay(self, timeout: Duration) -> WithDelay<ProcessRef<T>>

Set a delay on the next ProcessRef::send performed on this process.

This is a non-blocking function, meaning that send is going to be performed in the background while the execution continues. The send call will return a reference to the timer allowing you to cancel it.

impl<T> ProcessRef<T>

where T: Supervisor + AbstractProcess<State = SupervisorConfig<T>, Serializer = Bincode>,

pub fn wait_on_shutdown(&self)

Blocks until the Supervisor shuts down.

This function will not request a shutdown, just wait until someone else shuts the supervisor down.

A tagged message will be sent to the supervisor process as a request and the subscription will be registered. When the supervisor process shuts down, the subscribers will be each notified by a response message and therefore be unblocked after having received the awaited message.

impl<T> ProcessRef<T>

where T: Supervisor + AbstractProcess<State = SupervisorConfig<T>, Serializer = Bincode>,

pub fn children( &self ) -> <<T as Supervisor>::Children as Supervisable<T>>::Processes

Trait Implementations

impl<T> Clone for ProcessRef<T>

where T: AbstractProcess,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for ProcessRef<T>

where T: AbstractProcess,

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for ProcessRef<T>

where T: AbstractProcess,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> PartialEq for ProcessRef<T>

where T: AbstractProcess,

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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for ProcessRef<T>

where T: AbstractProcess,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: AbstractProcess> Copy for ProcessRef<T>

impl<T> Eq for ProcessRef<T>

where T: AbstractProcess,