spawned-concurrency 0.5.0

Spawned Concurrency
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

use std::thread::JoinHandle;

use crate::message::Message;

use super::actor::{Actor, Context, Handler};

/// Forward items from an iterator to an actor as messages.
///
/// Stops when the iterator is exhausted, the actor stops, or sending fails.
pub fn spawn_listener<A, M, I>(ctx: Context<A>, stream: I) -> JoinHandle<()>
where
    A: Actor + Handler<M>,
    M: Message,
    I: IntoIterator<Item = M>,
    <I as IntoIterator>::IntoIter: std::marker::Send + 'static,
{
    let mut iter = stream.into_iter();
    let cancellation_token = ctx.cancellation_token();
    let join_handle = spawned_rt::threads::spawn(move || loop {
        match iter.next() {
            Some(msg) => match ctx.send(msg) {
                Ok(_) => {}
                Err(e) => {
                    tracing::error!("Failed to send message: {e:?}");
                    break;
                }
            },
            None => {
                tracing::trace!("Stream finished");
                break;
            }
        }
        if cancellation_token.is_cancelled() {
            tracing::trace!("Actor stopped");
            break;
        }
    });
    join_handle
}