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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use crate::*;

#[derive(Clone, Debug)]
/// Asynchronous handler to execute jobs on the thread pool
pub struct ThreadPoolAsyncHandler<Shared: 'static + Clone + Send> {
    sender: Sender<MsgForWorker<Shared>>,
}

impl<Shared: 'static + Clone + Send> ThreadPoolAsyncHandler<Shared> {
    pub(crate) fn new(sender: Sender<MsgForWorker<Shared>>) -> ThreadPoolAsyncHandler<Shared> {
        ThreadPoolAsyncHandler { sender }
    }
    /// Execute the given closure and return a Future that output closure return type
    pub async fn execute<F, R>(&self, f: F) -> Result<R, ThreadPoolDisconnected>
    where
        F: 'static + Send + FnOnce(&Shared) -> R,
        R: 'static + Send,
    {
        let (s, r) = oneshot::channel();
        self.sender
            .send_async(MsgForWorker::NewJob(Box::new(move |shared| {
                let _ = s.send(f(shared));
            })))
            .await
            .map_err(|_| ThreadPoolDisconnected)?;

        r.await.map_err(|_| ThreadPoolDisconnected)
    }
}

#[derive(Clone, Debug)]
/// Synchronous handler to execute jobs on the thread pool
pub struct ThreadPoolSyncHandler<Shared: 'static + Clone + Send> {
    sender: Sender<MsgForWorker<Shared>>,
}

impl<Shared: 'static + Clone + Send> ThreadPoolSyncHandler<Shared> {
    pub(crate) fn new(sender: Sender<MsgForWorker<Shared>>) -> ThreadPoolSyncHandler<Shared> {
        ThreadPoolSyncHandler { sender }
    }
    /// Execute the given job and block the current thread until finished.
    /// If you need a non blocking method, see `ThreadPoolAsyncHandler`.
    pub fn execute<F, R>(&self, f: F) -> Result<R, ThreadPoolDisconnected>
    where
        F: 'static + Send + FnOnce(&Shared) -> R,
        R: 'static + Send,
    {
        let (s, r) = oneshot::channel();
        self.sender
            .send(MsgForWorker::NewJob(Box::new(move |shared| {
                let _ = s.send(f(shared));
            })))
            .map_err(|_| ThreadPoolDisconnected)?;

        r.recv().map_err(|_| ThreadPoolDisconnected)
    }
    /// Launch the given job and return a oneshot receiver that listen job result.
    /// If you need a non blocking method, see `ThreadPoolAsyncHandler`.
    pub fn launch<F, R>(&self, f: F) -> Result<OneshotReceiver<R>, ThreadPoolDisconnected>
    where
        F: 'static + Send + FnOnce(&Shared) -> R,
        R: 'static + Send,
    {
        let (s, r) = oneshot::channel();
        self.sender
            .send(MsgForWorker::NewJob(Box::new(move |shared| {
                let _ = s.send(f(shared));
            })))
            .map_err(|_| ThreadPoolDisconnected)?;

        Ok(r)
    }
}