moq-net 0.2.20

The networking layer for Media over QUIC: real-time pub/sub with built-in caching, fan-out, and prioritization.
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

//! Receive-side ownership: cancelled handlers explicitly abort unfinished groups and frames.

use std::ops::{Deref, DerefMut};

use crate::{Error, frame, group};

/// A received group that aborts if its handler is cancelled before finishing or handing it off.
pub(crate) struct Group(Option<group::Producer>);

impl Group {
	/// Own a group for the lifetime of its receive handler.
	pub fn new(producer: group::Producer) -> Self {
		Self(Some(producer))
	}

	/// Hand ownership to the next receive stage without closing the group.
	pub fn into_inner(mut self) -> group::Producer {
		self.0.take().expect("group owned until consumed")
	}

	/// Finish receiving without running cancellation cleanup.
	pub fn finish(mut self) -> Result<(), Error> {
		self.deref_mut().finish()?;
		self.0.take();
		Ok(())
	}

	/// Abort with the receive error instead of cancellation.
	pub fn abort(self, err: Error) -> Result<(), Error> {
		self.into_inner().abort(err)
	}
}

impl Deref for Group {
	type Target = group::Producer;

	fn deref(&self) -> &Self::Target {
		self.0.as_ref().expect("group owned until consumed")
	}
}

impl DerefMut for Group {
	fn deref_mut(&mut self) -> &mut Self::Target {
		self.0.as_mut().expect("group owned until consumed")
	}
}

impl Drop for Group {
	fn drop(&mut self) {
		if let Some(producer) = self.0.take() {
			let _ = producer.abort(Error::Cancel);
		}
	}
}

/// A received frame that aborts before its borrowed group is released on cancellation.
pub(crate) struct Frame<'a>(Option<frame::Producer<'a>>);

impl<'a> Frame<'a> {
	/// Own a frame for the lifetime of its receive handler.
	pub fn new(producer: frame::Producer<'a>) -> Self {
		Self(Some(producer))
	}

	/// Finish receiving without running cancellation cleanup.
	pub fn finish(mut self) -> Result<(), Error> {
		self.0.take().expect("frame owned until consumed").finish()
	}

	/// Abort with the receive error instead of cancellation.
	pub fn abort(mut self, err: Error) -> Result<(), Error> {
		self.0.take().expect("frame owned until consumed").abort(err)
	}
}

impl<'a> Deref for Frame<'a> {
	type Target = frame::Producer<'a>;

	fn deref(&self) -> &Self::Target {
		self.0.as_ref().expect("frame owned until consumed")
	}
}

impl DerefMut for Frame<'_> {
	fn deref_mut(&mut self) -> &mut Self::Target {
		self.0.as_mut().expect("frame owned until consumed")
	}
}

impl Drop for Frame<'_> {
	fn drop(&mut self) {
		if let Some(producer) = self.0.take() {
			let _ = producer.abort(Error::Cancel);
		}
	}
}