mosaik 0.3.17

A Rust runtime for building self-organizing, leaderless distributed systems.
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

use {
	core::task::{Context, Poll},
	tokio::sync::mpsc,
};

/// A simple unbounded channel wrapper around Tokio's mpsc unbounded channel.
/// This is used internally for various message passing needs to hold the sender
/// and receiver together.
#[derive(Debug)]
pub struct UnboundedChannel<T> {
	sender: mpsc::UnboundedSender<T>,
	receiver: mpsc::UnboundedReceiver<T>,
}

impl<T> Default for UnboundedChannel<T> {
	fn default() -> Self {
		let (sender, receiver) = mpsc::unbounded_channel();
		Self { sender, receiver }
	}
}

impl<T> UnboundedChannel<T> {
	#[allow(dead_code)]
	pub const fn sender(&self) -> &mpsc::UnboundedSender<T> {
		&self.sender
	}

	#[allow(dead_code)]
	pub const fn receiver(&mut self) -> &mut mpsc::UnboundedReceiver<T> {
		&mut self.receiver
	}

	pub fn send(&self, message: T) {
		let _ = self.sender.send(message);
	}

	pub async fn recv(&mut self) -> Option<T> {
		self.receiver.recv().await
	}

	/// Checks if the receiver has no messages pending.
	pub fn is_empty(&self) -> bool {
		self.receiver.is_empty()
	}

	/// Returns the number of messages currently pending in the receiver.
	pub fn len(&self) -> usize {
		self.receiver.len()
	}

	/// Polls the channel for available messages.
	///
	/// This is used when the channel is polled inside a `Future` implementation
	/// to check for new messages without blocking.
	#[allow(dead_code)]
	pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<T>> {
		self.receiver.poll_recv(cx)
	}

	/// Polls the channel for multiple available messages at once.
	///
	/// This is a convenience method that repeatedly polls the channel until no
	/// more messages are available, collecting them into a vector. This can be
	/// more efficient than polling for one message at a time when we expect
	/// multiple messages to arrive together. Returns `Poll::Ready(Vec<T>)` if
	/// one or more messages are available or `Poll::Pending` if no messages are
	/// currently available.
	pub fn poll_recv_many(
		&mut self,
		cx: &mut Context<'_>,
		buffer: &mut Vec<T>,
		limit: usize,
	) -> Poll<usize> {
		self.receiver.poll_recv_many(cx, buffer, limit)
	}
}