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

//! Iterators over `Chain`s and `Device`s.

use super::{info::ChainInfo, Axis, Device};
use std::num::NonZeroU8;

/// An iterator of the devices in a [`Chain`](super::Chain).
///
/// Created via [`Chain::iter()`](super::Chain::iter).
pub struct IterDevices<'a, Tag> {
	info: &'a ChainInfo,
	next_index: usize,
	tag: std::marker::PhantomData<Tag>,
}

impl<'a, Tag> IterDevices<'a, Tag> {
	/// Create an new iterator over the devices in the chain.
	pub(super) fn new(info: &'a ChainInfo) -> Self {
		IterDevices {
			info,
			next_index: 0,
			tag: std::marker::PhantomData,
		}
	}
}

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

impl<'a, Tag> std::iter::Iterator for IterDevices<'a, Tag> {
	type Item = Device<'a, Tag>;
	fn next(&mut self) -> Option<Self::Item> {
		let address = self
			.info
			.devices
			.values()
			.nth(self.next_index)
			.map(|device_info| device_info.address);
		if let Some(address) = address {
			self.next_index += 1;
			Some(Device::new(self.info, address))
		} else {
			None
		}
	}
}

/// An iterator over the axes of a [`Device`].
///
/// Created via [`Device::iter()`].
pub struct IterAxes<'a, Tag> {
	info: &'a ChainInfo,
	address: NonZeroU8,
	next_axis_index: usize,
	tag: std::marker::PhantomData<Tag>,
}

impl<'a, Tag> IterAxes<'a, Tag> {
	pub(super) fn new(info: &'a ChainInfo, address: NonZeroU8) -> Self {
		IterAxes {
			info,
			address,
			next_axis_index: 0,
			tag: std::marker::PhantomData,
		}
	}
}

impl<'a, Tag> std::iter::Iterator for IterAxes<'a, Tag> {
	type Item = Axis<'a, Tag>;

	fn next(&mut self) -> Option<Self::Item> {
		#![allow(clippy::cast_possible_truncation)]
		assert!(self.next_axis_index < u8::MAX as usize - 1);
		let axis_number = self
			.info
			.devices
			.get(&self.address)
			.and_then(|device_info| {
				if self.next_axis_index < device_info.axes.len() {
					Some(NonZeroU8::new(self.next_axis_index as u8 + 1).unwrap())
				} else {
					None
				}
			});
		if let Some(axis_number) = axis_number {
			self.next_axis_index += 1;
			Some(Axis::new(self.info, self.address, axis_number))
		} else {
			None
		}
	}
}

impl<Tag> std::fmt::Debug for IterAxes<'_, Tag> {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		f.debug_struct("IterAxes")
			.field("address", &self.address)
			.finish()
	}
}

/// A by-value iterator over the axes of a [`Device`].
///
/// Created via [`Device::into_iter()`].
#[derive(Debug)]
pub struct IntoIterAxes<'a, Tag> {
	iter: IterAxes<'a, Tag>,
}

impl<'a, Tag> IntoIterAxes<'a, Tag> {
	pub(super) fn new(info: &'a ChainInfo, address: NonZeroU8) -> Self {
		IntoIterAxes {
			iter: IterAxes::new(info, address),
		}
	}
}

impl<'a, Tag> std::iter::Iterator for IntoIterAxes<'a, Tag> {
	type Item = Axis<'a, Tag>;

	fn next(&mut self) -> Option<Self::Item> {
		self.iter.next()
	}
}