jlrs 0.23.0

jlrs provides bindings to the Julia C API that enable Julia code to be called from Rust and more.
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

//! Dispatch a task to the async runtime.

use std::fmt;

use async_channel::{SendError, Sender, TrySendError};

use super::channel::OneshotReceiver;
use crate::{
    error::{JlrsError, RuntimeError},
    prelude::JlrsResult,
};

/// Dispatch a task to the async runtime.
pub struct Dispatch<'a, M, T> {
    msg: M,
    sender: &'a Sender<M>,
    receiver: OneshotReceiver<T>,
}

impl<'a, M, T> Dispatch<'a, M, T> {
    #[inline]
    pub(crate) const fn new(msg: M, sender: &'a Sender<M>, receiver: OneshotReceiver<T>) -> Self {
        Dispatch {
            msg,
            sender,
            receiver,
        }
    }

    /// Dispatch the task.
    pub async fn dispatch(self) -> JlrsResult<OneshotReceiver<T>> {
        match self.sender.send(self.msg).await {
            Ok(_) => Ok(self.receiver),
            Err(SendError(_)) => Err(RuntimeError::ChannelClosed)?,
        }
    }

    /// Try to dispatch the task.
    ///
    /// If the channel is full, the dispatcher is returned to allow retrying.
    pub fn try_dispatch(self) -> Result<OneshotReceiver<T>, JlrsResult<Self>> {
        match self.sender.try_send(self.msg) {
            Ok(_) => Ok(self.receiver),
            Err(TrySendError::Closed(_)) => Err(Err(Box::new(JlrsError::RuntimeError(
                RuntimeError::ChannelClosed,
            )))),
            Err(TrySendError::Full(msg)) => Err(Ok(Dispatch {
                msg,
                sender: self.sender,
                receiver: self.receiver,
            })),
        }
    }
}

impl<'a, M, T> fmt::Debug for Dispatch<'a, M, T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Dispatch").finish()
    }
}