compio-actor 0.1.0

Actors for Compio
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
61
62
63
64
65
66
67
68
69
70
71
72
73

use std::{error::Error, fmt};

use super::Call;
use crate::Message;

/// A message rejected by a mailbox or broker.
#[derive(Debug, PartialEq, Eq)]
pub enum DeliverError<M: Message> {
    /// The mailbox is at capacity.
    Full(M),
    /// The actor is stopping or has exited.
    Closed(M),
}

impl<M: Message> DeliverError<M> {
    /// Recovers the rejected message.
    pub fn into_inner(self) -> M {
        match self {
            Self::Full(message) | Self::Closed(message) => message,
        }
    }
}

impl<M: Message> fmt::Display for DeliverError<M> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Full(_) => f.write_str("actor mailbox is full"),
            Self::Closed(_) => f.write_str("actor mailbox is closed"),
        }
    }
}

impl<M: Message + fmt::Debug> Error for DeliverError<M> {}

/// A call that could not be delivered or answered.
#[derive(Debug, PartialEq, Eq)]
pub enum CallError<M: Message> {
    /// The mailbox was at capacity.
    Full(M),
    /// The actor was stopping or had exited.
    Closed(M),
    /// The actor handled the request without replying.
    NoReply,
}

impl<M: Message> CallError<M> {
    pub(super) fn from_deliver<R: Message>(error: DeliverError<Call<M, R>>) -> Self {
        match error {
            DeliverError::Full(call) => Self::Full(call.into_message()),
            DeliverError::Closed(call) => Self::Closed(call.into_message()),
        }
    }

    /// Recovers a request that was not delivered.
    pub fn into_inner(self) -> Option<M> {
        match self {
            Self::Full(message) | Self::Closed(message) => Some(message),
            Self::NoReply => None,
        }
    }
}

impl<M: Message> fmt::Display for CallError<M> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Full(_) => f.write_str("actor mailbox is full"),
            Self::Closed(_) => f.write_str("actor mailbox is closed"),
            Self::NoReply => f.write_str("actor did not reply"),
        }
    }
}

impl<M: Message + fmt::Debug> Error for CallError<M> {}