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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

//! Types representing ASCII settings.

use crate::ascii::chain::{
	data_type::DataType,
	scope::{AxisScope, DeviceScope},
};
pub mod data_types;

/// Define a type representing an ASCII setting.
macro_rules! define_settings {
    (
        $(
            $(#[$metadata:meta])*
            $visibility:vis struct $setting:ident : Setting<Type = $data_type:path, Name = $name:literal>, $scope:ident;
        )+
    ) => {
        $(
        $(#[$metadata])*
        #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
        $visibility struct $setting;
        impl $setting {
            /// Returns the name of the setting.
            pub const fn name(&self) -> &'static str {
                $name
            }
        }
        impl crate::ascii::setting::Setting for $setting {
            type Type = $data_type;
            fn name(&self) -> &str {
                self.name()
            }
        }
        impl $scope for $setting {}
        impl std::convert::AsRef<str> for $setting {
            /// Return the name of the setting.
            fn as_ref(&self) -> &str {
                self.name()
            }
        }
        impl std::str::FromStr for $setting {
            type Err = ();
            fn from_str(s: &str) -> Result<Self, Self::Err> {
                if s == $setting.name() {
                    Ok($setting)
                } else {
                    Err(())
                }
            }
        }
        )+
    };
}

/// Define an enum that represents multiple ASCII settings. Each variant `$setting`
/// must also be the name for another type that implements [`Setting`].
///
/// This macro will automatically defined [`Setting`], the scope, and conversion
/// traits between it and the setting types it maps to.
macro_rules! define_any_setting {
    (
        $(#[$any_setting_meta:meta])*
        $visibility:vis enum $any_setting:ident {
            $(
                $(#[$setting_meta:meta])*
                $setting:ident
            ),+
            $(,)?
        }
    ) => {
        $(#[$any_setting_meta])*
        #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
        $visibility enum $any_setting {
            $(
                $(#[$setting_meta])*
                $setting
            ),+
        }
        impl crate::ascii::setting::Setting for $any_setting {
            type Type = String;
            fn name(&self) -> &str {
                match self {
                    $(
                        Self::$setting => $setting.name()
                    ),+
                }
            }
        }
        impl crate::ascii::chain::scope::AxisScope for $any_setting {}
        impl crate::ascii::chain::scope::DeviceScope for $any_setting {}
        impl std::convert::AsRef<str> for $any_setting {
            fn as_ref(&self) -> &str {
                self.name()
            }
        }
        impl std::str::FromStr for $any_setting {
            type Err = ();
            fn from_str(s: &str) -> Result<Self, Self::Err> {
                Err(())
                $(
                    .or_else(|_| s.parse::<$setting>().map(From::from))
                )+
            }
        }
        $(
            impl std::convert::From<$setting> for $any_setting {
                fn from(_: $setting) -> Self {
                    Self::$setting
                }
            }
        )+
    };
}

include!("setting/mod.inc");

/// Any type that represents a setting
pub trait Setting {
	/// The setting's datatype.
	///
	/// This is used to convert the data to and from values in an ASCII protocol message.
	type Type: DataType;

	/// Get the name of the setting.
	fn name(&self) -> &str;
}

impl<T> Setting for &T
where
	T: Setting,
{
	type Type = T::Type;
	fn name(&self) -> &str {
		(*self).name()
	}
}

// Allow &str and String to be used as axis- or device-scope `Setting`s
impl Setting for &str {
	type Type = String;
	fn name(&self) -> &str {
		self
	}
}
impl DeviceScope for &str {}
impl AxisScope for &str {}

impl Setting for String {
	type Type = String;
	fn name(&self) -> &str {
		self.as_str()
	}
}
impl DeviceScope for String {}
impl AxisScope for String {}