actor12 0.0.9

A lightweight actor framework for Rust with async support
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use std::fmt::Debug;
use std::future::Future;

use tokio::sync::oneshot;

use crate::actor::Actor;
use crate::actor::ActorMessage;
use crate::handler::Exec;

pub struct Envelope<T, R> {
	pub value: T,
	pub reply: oneshot::Sender<R>,
}

impl<T: Debug, R> Debug for Envelope<T, R> {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		Debug::fmt(&self.value, f)
	}
}

impl<T, R> Envelope<T, R> {
	pub fn new(value: T) -> (Self, oneshot::Receiver<R>) {
		let (reply, rx) = oneshot::channel();
		(Self { value, reply }, rx)
	}



	pub fn relay(value: T, reply: oneshot::Sender<R>) -> Self {
		Self { value, reply }
	}

	pub fn send(self, value: R) -> Result<(), R> {
		self.reply.send(value)
	}

	pub fn split(self) -> (T, oneshot::Sender<R>) {
		let value = self.value;
		let reply = self.reply;
		(value, reply)
	}

	pub fn map<U>(self, func: impl FnOnce(T) -> U) -> Envelope<U, R> {
		Envelope {
			value: func(self.value),
			reply: self.reply,
		}
	}

	pub async fn reply_fut<F: Future<Output = R>>(self, fut: F)
	where
		T: Send + 'static,
		R: Send + 'static,
		F: Send + 'static,
	{
		let value = fut.await;
		let _ = self.reply.send(value);
	}

	pub async fn reply<F: Future<Output = R>>(self, func: impl Fn(T) -> F + Send + 'static)
	where
		T: Send + 'static,
		R: Send + 'static,
		F: Send,
	{
		let value = func(self.value).await;
		let _ = self.reply.send(value);
	}
}

impl<T, R, A: Actor> ActorMessage<A> for Envelope<T, R>
where
	T: Send + Sync + 'static,
	R: Send + Sync + 'static,
{
	fn handle(self, _: &mut A, _: Exec<A>) -> impl Future<Output = ()> + Send {
		futures::future::ready(())
	}
}

pub struct NoReply<T>(pub T);

impl<T> NoReply<T> {
	pub fn new(value: T) -> Self {
		Self(value)
	}
}

impl<T: Debug> Debug for NoReply<T> {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		Debug::fmt(&self.0, f)
	}
}
impl<T, A: Actor> ActorMessage<A> for NoReply<T>
where
	T: Send + Sync + 'static,
{
	fn handle(self, _: &mut A, _: Exec<A>) -> impl Future<Output = ()> + Send {
		futures::future::ready(())
	}
}