Struct ChildPool 

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

A child-pool is the non clone-able reference to an actor with a multiple processes.

child-pools can be of two forms:

• ChildPool<E, Channel<M>>: This is the default form, it can be transformed into a ChildPool<E> using ChildPool::into_dyn. Additional processes can be spawned using ChildPool::spawn.
• ChildPool<E>: This form is a dynamic child-pool, it can be transformed back into a ChildPool<E, Channel<M>> using ChildPool::downcast::. Additional processes can be spawned using ChildPool::try_spawn.

A child-pool can be streamed which returns values of E when the processes exit.

Implementations

impl<E, C> ChildPool<E, C>

where E: Send + 'static, C: DynChannel + ?Sized,

pub fn into_joinhandles(self) -> Vec<JoinHandle<E>>

Get the underlying JoinHandles. The order does not necessarily reflect the order in which processes were spawned.

This will not run 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 all tasks have finished.

pub fn task_count(&self) -> usize

The amount of tasks that are alive.

This should give the same result as ChildPool::process_count, as long as an inbox is only dropped whenever it’s task finishes.

pub fn handle_count(&self) -> usize

The amount of handles to processes that this pool contains. This can be bigger than the process_count or task_count if processes have exited.

pub fn try_spawn<M, Fun, Fut>( &mut self, fun: Fun, ) -> Result<(), TrySpawnError<Fun>>

where Fun: FnOnce(Inbox<M>) -> Fut + Send + 'static, Fut: Future<Output = E> + Send + 'static, M: Send + 'static, E: Send + 'static, C: AnyChannel,

Attempt to spawn an additional process on the channel.

This method can fail if

• the message-type does not match that of the channel.
• the channel has already exited.

pub fn downcast<M>(self) -> Result<ChildPool<E, Channel<M>>, Self>

where M: Send + 'static, C: AnyChannel,

Downcast the ChildPool<E> to a ChildPool<E, Channel<M>>

pub fn shutdown(&mut self, timeout: Duration) -> ShutdownStream<'_, E, C>

Halts the actor, and then returns a stream that waits for exits.

If the timeout expires before all processes have exited, the actor will be aborted.

Examples

use futures::StreamExt;

let mut pool: ChildPool<()> = todo!();
let exits: Vec<_> = pool.shutdown(Duration::from_secs(1)).collect().await;

pub fn close(&self) -> bool

Close the Channel.

pub fn halt(&self)

Halt the actor.

This also closes the Inbox.

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.

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.

impl<E, M> ChildPool<E, Channel<M>>

where E: Send + 'static,

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

where M: Send + 'static,

Convert the ChildPool<E, Channel<M> into a ChildPool<E>.

pub fn spawn<Fun, Fut>(&mut self, fun: Fun) -> Result<(), SpawnError<Fun>>

where Fun: FnOnce(Inbox<M>) -> Fut + Send + 'static, Fut: Future<Output = E> + Send + 'static, E: Send + 'static, M: Send + 'static,

Attempt to spawn an additional process on the channel.

This method fails if the channel has already exited.

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) -> SendFut<'_, 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, C> Debug for ChildPool<E, C>

where E: Send + 'static + Debug, C: DynChannel + ?Sized + Debug,

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

Formats the value using the given formatter.

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

fn drop(&mut self)

Executes the destructor for this type.

impl<E: Send + 'static, C: DynChannel + ?Sized> Stream for ChildPool<E, C>

type Item = Result<E, ExitError>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.