Struct tiny_actor::actor::Child

pub struct Child<E, C = dyn AnyChannel> where
    E: Send + 'static,
    C: DynChannel + ?Sized, { /* private fields */ }

A child is the non clone-able reference to an actor with a single process.

Children can be of two forms:

• Child<E, Channel<M>>: This is the default form, it can be transformed into a Child<E> using Child::into_dyn.
• Child<E>: This form is a dynamic child, it can be transformed back into a Child<E, Channel<M>> using Child::downcast::.

A child can be transformed into a ChildPool using Child::into_pool().

A child can be awaited which returns the parameter E once the actor exits.

Implementations

impl<E, C> Child<E, C> where
    E: Send + 'static,
    C: DynChannel + ?Sized, 

pub fn into_tokio_joinhandle(self) -> JoinHandle<E>

Get the underlying JoinHandle.

This will not run the drop, and therefore the actor will not be halted/aborted.

pub fn abort(&mut self) -> bool

Abort the actor.

Returns true if this is the first abort.

pub fn is_finished(&self) -> bool

Whether the task is finished.

pub fn into_pool(self) -> ChildPool<E, C>

Convert the Child into a ChildPool.

pub fn downcast<M: Send + 'static>(self) -> Result<Child<E, Channel<M>>, Self> where
    C: AnyChannel, 

Downcast the Child<E> to a Child<E, Channel<M>>.

pub async fn shutdown(self, timeout: Duration) -> Result<E, ExitError>

Halts the actor, and then waits for it to exit.

If the timeout expires before the actor has exited, the actor will be aborted.

pub fn get_address(&self) -> Address<C>

Get a new Address to the Channel.

pub fn attach(&mut self, duration: Duration) -> Option<Duration>

Attach the actor.

Returns the old abort-timeout if it was already attached.

pub fn detach(&mut self) -> Option<Duration>

Detach the actor.

Returns the old abort-timeout if it was attached before.

pub fn is_aborted(&self) -> bool

Whether the actor is aborted.

pub fn is_attached(&self) -> bool

Whether the actor is attached.

pub fn link(&self) -> &Link

Get a reference to the current Link of the actor.

pub fn close(&self) -> bool

Close the Channel.

pub fn halt(&self)

Halt the actor.

pub fn halt_some(&self, n: u32)

Halt n processes.

pub fn process_count(&self) -> usize

Get the amount of processes.

pub fn msg_count(&self) -> usize

Get the amount of messages in the Channel.

pub fn address_count(&self) -> usize

Get the amount of Addresses of the Channel.

pub fn is_closed(&self) -> bool

Whether the Channel is closed.

pub fn is_bounded(&self) -> bool

pub fn capacity(&self) -> &Capacity

Get the Capacity of the Channel.

pub fn has_exited(&self) -> bool

Whether all processes have exited.

pub fn actor_id(&self) -> u64

Get the actor’s id.

impl<E, M> Child<E, Channel<M>> where
    E: Send + 'static,
    M: Send + 'static, 

pub fn into_dyn(self) -> Child<E>

Convert the Child<T, Channel<M>> into a Child<T>

pub fn try_send(&self, msg: M) -> Result<(), TrySendError<M>>

Attempt to send a message to the actor.

• In the case of an unbounded Channel, when BackPressure returns a timeout this fails.
• In the case of a bounded Channel, when it is full this fails.

For bounded channels, this method is the same as send_now.

pub fn send_now(&self, msg: M) -> Result<(), TrySendError<M>>

Attempt to send a message to the actor.

• In the case of an unbounded Channel, any BackPressure is ignored.
• In the case of a bounded Channel, when it is full this fails.

For bounded channels, this method is the same as try_send.

pub fn send(&self, msg: M) -> Snd<'_, M>

Attempt to send a message to the actor.

• In the case of an unbounded Channel, when BackPressure returns a timeout this waits untill the timeout is over.
• In the case of a bounded Channel, when it is full this waits untill space is available.

pub fn send_blocking(&self, msg: M) -> Result<(), SendError<M>>

Same as send but it blocking the OS-thread.

Trait Implementations

impl<E: Debug, C: Debug> Debug for Child<E, C> where
    E: Send + 'static,
    C: DynChannel + ?Sized, 

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

Formats the value using the given formatter.

impl<E: Send + 'static, C: DynChannel + ?Sized> Drop for Child<E, C>

fn drop(&mut self)

Executes the destructor for this type.

impl<E: Send + 'static, C: DynChannel + ?Sized> Future for Child<E, C>

type Output = Result<E, ExitError>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<E: Send + 'static, C: DynChannel + ?Sized> Unpin for Child<E, C>