zproto 0.4.2

A library from communicating with Zaber products in Rust.
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

//! Handlers for events on a port.
#[cfg(doc)]
use super::Port;
use super::{Alert, Direction};

/// A callback that is called after a packet is either transmitted or received.
///
/// See [`Port::set_packet_handler`] for more details.
pub type PacketHandler<'a> = Box<dyn FnMut(&[u8], Direction) + 'a>;

impl<'a, F> crate::convert::From<F> for PacketHandler<'a>
where
	F: FnMut(&[u8], Direction) + 'a,
{
	fn from(value: F) -> Self {
		Box::new(value)
	}
}

/// The same as [`PacketHandler`] but also implements `Send`.
///
/// See [`Port::set_packet_handler`] for more details.
pub type SendPacketHandler<'a> = Box<dyn FnMut(&[u8], Direction) + Send + 'a>;

impl<'a, F> crate::convert::From<F> for SendPacketHandler<'a>
where
	F: FnMut(&[u8], Direction) + Send + 'a,
{
	fn from(value: F) -> Self {
		Box::new(value)
	}
}

/// A callback that is called when an unexpected Alert is received.
///
/// See [`Port::set_unexpected_alert_handler`] for more details.
pub type UnexpectedAlertHandler<'a> = Box<dyn FnMut(Alert) -> Result<(), Alert> + 'a>;

impl<'a, F> crate::convert::From<F> for UnexpectedAlertHandler<'a>
where
	F: FnMut(Alert) -> Result<(), Alert> + 'a,
{
	fn from(value: F) -> Self {
		Box::new(value)
	}
}

/// The same as [`UnexpectedAlertHandler`] but also implements `Send`.
///
/// See [`Port::set_unexpected_alert_handler`] for more details.
pub type SendUnexpectedAlertHandler<'a> = Box<dyn FnMut(Alert) -> Result<(), Alert> + Send + 'a>;

impl<'a, F> crate::convert::From<F> for SendUnexpectedAlertHandler<'a>
where
	F: FnMut(Alert) -> Result<(), Alert> + Send + 'a,
{
	fn from(value: F) -> Self {
		Box::new(value)
	}
}

/// Collection of event handlers that can only be used in the local thread.
#[derive(Default)]
pub struct LocalHandlers<'a> {
	pub(super) packet: Option<PacketHandler<'a>>,
	pub(super) unexpected_alert: Option<UnexpectedAlertHandler<'a>>,
}

impl std::fmt::Debug for LocalHandlers<'_> {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		f.debug_struct("LocalHandlers").finish_non_exhaustive()
	}
}

impl<'a> Handlers for LocalHandlers<'a> {
	type PacketHandler = PacketHandler<'a>;
	type UnexpectedAlertHandler = UnexpectedAlertHandler<'a>;
	fn packet(&mut self) -> &mut Option<Self::PacketHandler> {
		&mut self.packet
	}
	fn unexpected_alert(&mut self) -> &mut Option<Self::UnexpectedAlertHandler> {
		&mut self.unexpected_alert
	}
}

impl private::Sealed for LocalHandlers<'_> {}

/// Collection of event handlers that can be sent to other threads (i.e. they implement `Send`).
#[derive(Default)]
pub struct SendHandlers<'a> {
	pub(super) packets: Option<SendPacketHandler<'a>>,
	pub(super) unexpected_alerts: Option<SendUnexpectedAlertHandler<'a>>,
}

impl std::fmt::Debug for SendHandlers<'_> {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		f.debug_struct("SendHandlers").finish_non_exhaustive()
	}
}

impl<'a> Handlers for SendHandlers<'a> {
	type PacketHandler = SendPacketHandler<'a>;
	type UnexpectedAlertHandler = SendUnexpectedAlertHandler<'a>;
	fn packet(&mut self) -> &mut Option<Self::PacketHandler> {
		&mut self.packets
	}
	fn unexpected_alert(&mut self) -> &mut Option<Self::UnexpectedAlertHandler> {
		&mut self.unexpected_alerts
	}
}

impl private::Sealed for SendHandlers<'_> {}

/// Any type that defines event handlers for a [`Port`].
pub trait Handlers: Default + private::Sealed {
	/// The type of function called when a packet is sent/received.
	type PacketHandler;
	/// The type of function called when an unexpected alert message is received.
	type UnexpectedAlertHandler;

	/// Get the packet handler, if configured.
	fn packet(&mut self) -> &mut Option<Self::PacketHandler>;
	/// Get the unexpected alert handler, if configured.
	fn unexpected_alert(&mut self) -> &mut Option<Self::UnexpectedAlertHandler>;
}

mod private {
	pub trait Sealed {}
}