kameo 0.20.0

Fault-tolerant Async Actors Built on Tokio
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
74
75
76
77
78
79

//! Types for sending requests including messages and queries to actors.

use std::time::Duration;

mod ask;
mod tell;

#[cfg(feature = "remote")]
pub use ask::RemoteAskRequest;

#[cfg(feature = "remote")]
pub use tell::RemoteTellRequest;

pub use ask::{AskRequest, BlockingPendingReply, PendingReply, ReplyRecipientAskRequest};
pub use tell::{RecipientTellRequest, ReplyRecipientTellRequest, TellRequest};

/// A type for requests without any timeout set.
#[derive(Clone, Copy, Debug, Default)]
pub struct WithoutRequestTimeout;

/// A type for timeouts in actor requests.
#[derive(Clone, Copy, Debug, Default)]
pub struct WithRequestTimeout(Option<Duration>);

/// A type which might contain a request timeout.
///
/// This type is used internally for remote messaging and will panic if used incorrectly with any MessageSend trait.
#[derive(Clone, Copy, Debug)]
pub enum MaybeRequestTimeout {
    /// No timeout set.
    NoTimeout,
    /// A timeout with a duration.
    Timeout(Duration),
}

impl From<Option<Duration>> for MaybeRequestTimeout {
    fn from(timeout: Option<Duration>) -> Self {
        match timeout {
            Some(timeout) => MaybeRequestTimeout::Timeout(timeout),
            None => MaybeRequestTimeout::NoTimeout,
        }
    }
}

impl From<WithoutRequestTimeout> for MaybeRequestTimeout {
    fn from(_: WithoutRequestTimeout) -> Self {
        MaybeRequestTimeout::NoTimeout
    }
}

impl From<WithRequestTimeout> for MaybeRequestTimeout {
    fn from(WithRequestTimeout(timeout): WithRequestTimeout) -> Self {
        match timeout {
            Some(timeout) => MaybeRequestTimeout::Timeout(timeout),
            None => MaybeRequestTimeout::NoTimeout,
        }
    }
}

impl From<WithoutRequestTimeout> for Option<Duration> {
    fn from(_: WithoutRequestTimeout) -> Self {
        None
    }
}

impl From<WithRequestTimeout> for Option<Duration> {
    fn from(WithRequestTimeout(duration): WithRequestTimeout) -> Self {
        duration
    }
}

impl From<MaybeRequestTimeout> for Option<Duration> {
    fn from(timeout: MaybeRequestTimeout) -> Self {
        match timeout {
            MaybeRequestTimeout::NoTimeout => None,
            MaybeRequestTimeout::Timeout(duration) => Some(duration),
        }
    }
}