ashv2 6.0.2

Implementation of the Asynchronous Serial Host (ASH) protocol.
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

use std::sync::Arc;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering::Relaxed;

use either::{Either, Left, Right};
use serialport::SerialPort;
use tokio::spawn;
use tokio::sync::mpsc::Sender;
use tokio::sync::mpsc::error::SendError;
use tokio::task::{JoinError, JoinHandle};

use crate::actor::message::Message;
use crate::actor::{Receiver, Transmitter};

/// Sender and receiver tasks wrapper to allow termination.
#[derive(Debug)]
pub struct Tasks<T> {
    transmitter: JoinHandle<T>,
    receiver: JoinHandle<()>,
    sender: Sender<Message>,
    running: Arc<AtomicBool>,
}

impl<T> Tasks<T>
where
    T: SerialPort + Sync + 'static,
{
    /// Crate new tasks.
    pub(crate) fn spawn(
        transmitter: Transmitter<T>,
        receiver: Receiver<T>,
        sender: Sender<Message>,
    ) -> Self {
        let running = Arc::new(AtomicBool::new(true));
        Self {
            transmitter: spawn(transmitter.run()),
            receiver: spawn(receiver.run(running.clone())),
            sender,
            running,
        }
    }
}

impl<T> Tasks<T> {
    /// Terminate the tasks.
    ///
    /// # Errors
    ///
    /// Returns either
    /// - a [`SendError`] if sending the termination message fails, or
    /// - a [`JoinError`] if joining either task fails.
    pub async fn terminate(self) -> Result<T, Either<SendError<Message>, JoinError>> {
        self.running.store(false, Relaxed);
        self.sender.send(Message::Terminate).await.map_err(Left)?;
        let serial_port = self.transmitter.await.map_err(Right)?;
        self.receiver.await.map_err(Right)?;
        Ok(serial_port)
    }
}