xio_base_datatypes/
parameter_value.rs

1use std::io;
2use try_from::TryFrom;
3use {
4    DataType, DataValue, HasDataType, HasStorageType,
5    IsModuleChannelReference, IsParameterMask, ModuleChannelReference,
6    StorageType,
7};
8
9#[derive(Clone, Debug, PartialEq)]
10pub enum ParameterValue<M: IsParameterMask, R: IsModuleChannelReference> {
11    Boolean(bool),
12    Int8(i8),
13    Int16(i16),
14    Int32(i32),
15    Int64(i64),
16    UInt8(u8),
17    UInt16(u16),
18    UInt32(u32),
19    UInt64(u64),
20    ParameterMask(M),
21    BooleanChannel(R),
22    Int8Channel(R),
23    Int16Channel(R),
24    Int32Channel(R),
25    Int64Channel(R),
26    UInt8Channel(R),
27    UInt16Channel(R),
28    UInt32Channel(R),
29    UInt64Channel(R),
30    ParameterMaskChannel(R),
31}
32
33impl TryFrom<(u8, u64)> for ParameterValueRaw {
34    type Err = io::Error;
35    fn try_from(value: (u8, u64)) -> io::Result<Self> {
36        let (tag, data) = value;
37        match tag {
38            0x00 => Ok(ParameterValue::Boolean(data > 0u64)),
39            0x01 => Ok(ParameterValue::Int8(data as i8)),
40            0x02 => Ok(ParameterValue::Int16(data as i16)),
41            0x03 => Ok(ParameterValue::Int32(data as i32)),
42            0x04 => Ok(ParameterValue::Int64(data as i64)),
43            0x05 => Ok(ParameterValue::UInt8(data as u8)),
44            0x06 => Ok(ParameterValue::UInt16(data as u16)),
45            0x07 => Ok(ParameterValue::UInt32(data as u32)),
46            0x08 => Ok(ParameterValue::UInt64(data as u64)),
47            0x09 => Ok(ParameterValue::ParameterMask(data as u64)),
48            0x10 => Ok(ParameterValue::BooleanChannel(data.into())),
49            0x11 => Ok(ParameterValue::Int8Channel(data.into())),
50            0x12 => Ok(ParameterValue::Int16Channel(data.into())),
51            0x13 => Ok(ParameterValue::Int32Channel(data.into())),
52            0x14 => Ok(ParameterValue::Int64Channel(data.into())),
53            0x15 => Ok(ParameterValue::UInt8Channel(data.into())),
54            0x16 => Ok(ParameterValue::UInt16Channel(data.into())),
55            0x17 => Ok(ParameterValue::UInt32Channel(data.into())),
56            0x18 => Ok(ParameterValue::UInt64Channel(data.into())),
57            0x19 => Ok(ParameterValue::ParameterMaskChannel(data.into())),
58            _ => Err(io::Error::new(
59                io::ErrorKind::InvalidData,
60                format!("Invalid ParameterValue enum tag {}", tag),
61            )),
62        }
63    }
64}
65
66impl<M: IsParameterMask, R: IsModuleChannelReference> From<DataValue<M>>
67    for ParameterValue<M, R>
68{
69    fn from(v: DataValue<M>) -> ParameterValue<M, R> {
70        use ParameterValue::*;
71        match v {
72            DataValue::Boolean(v) => Boolean(v),
73            DataValue::Int8(v) => Int8(v),
74            DataValue::Int16(v) => Int16(v),
75            DataValue::Int32(v) => Int32(v),
76            DataValue::Int64(v) => Int64(v),
77            DataValue::UInt8(v) => UInt8(v),
78            DataValue::UInt16(v) => UInt16(v),
79            DataValue::UInt32(v) => UInt32(v),
80            DataValue::UInt64(v) => UInt64(v),
81            DataValue::ParameterMask(v) => ParameterMask(v),
82        }
83    }
84}
85
86pub type ParameterValueRaw = ParameterValue<u64, ModuleChannelReference>;
87
88impl<M: IsParameterMask, R: IsModuleChannelReference> HasDataType
89    for ParameterValue<M, R>
90{
91    fn data_type(&self) -> DataType {
92        use ParameterValue::*;
93
94        match *self {
95            Boolean(_) | BooleanChannel(_) => DataType::Boolean,
96            Int8(_) | Int8Channel(_) => DataType::Int8,
97            Int16(_) | Int16Channel(_) => DataType::Int16,
98            Int32(_) | Int32Channel(_) => DataType::Int32,
99            Int64(_) | Int64Channel(_) => DataType::Int64,
100            UInt8(_) | UInt8Channel(_) => DataType::UInt8,
101            UInt16(_) | UInt16Channel(_) => DataType::UInt16,
102            UInt32(_) | UInt32Channel(_) => DataType::UInt32,
103            UInt64(_) | UInt64Channel(_) => DataType::UInt64,
104            ParameterMask(_) | ParameterMaskChannel(_) => {
105                DataType::ParameterMask
106            }
107        }
108    }
109}
110
111impl<M: IsParameterMask, R: IsModuleChannelReference> HasStorageType
112    for ParameterValue<M, R>
113{
114    fn storage_type(&self) -> StorageType {
115        use ParameterValue::*;
116        use StorageType::*;
117        match *self {
118            Boolean(_) | Int8(_) | Int16(_) | Int32(_) | Int64(_)
119            | UInt8(_) | UInt16(_) | UInt32(_) | UInt64(_)
120            | ParameterMask(_) => Fixed,
121            BooleanChannel(_)
122            | Int8Channel(_)
123            | Int16Channel(_)
124            | Int32Channel(_)
125            | Int64Channel(_)
126            | UInt8Channel(_)
127            | UInt16Channel(_)
128            | UInt32Channel(_)
129            | UInt64Channel(_)
130            | ParameterMaskChannel(_) => Channel,
131        }
132    }
133}
134
135impl<M: IsParameterMask, R: IsModuleChannelReference> From<bool>
136    for ParameterValue<M, R>
137{
138    fn from(v: bool) -> ParameterValue<M, R> {
139        ParameterValue::Boolean(v)
140    }
141}
142
143impl<M: IsParameterMask, R: IsModuleChannelReference> From<i8>
144    for ParameterValue<M, R>
145{
146    fn from(v: i8) -> ParameterValue<M, R> {
147        ParameterValue::Int8(v)
148    }
149}
150
151impl<M: IsParameterMask, R: IsModuleChannelReference> From<i16>
152    for ParameterValue<M, R>
153{
154    fn from(v: i16) -> ParameterValue<M, R> {
155        ParameterValue::Int16(v)
156    }
157}
158
159impl<M: IsParameterMask, R: IsModuleChannelReference> From<i32>
160    for ParameterValue<M, R>
161{
162    fn from(v: i32) -> ParameterValue<M, R> {
163        ParameterValue::Int32(v)
164    }
165}
166
167impl<M: IsParameterMask, R: IsModuleChannelReference> From<i64>
168    for ParameterValue<M, R>
169{
170    fn from(v: i64) -> ParameterValue<M, R> {
171        ParameterValue::Int64(v)
172    }
173}
174
175impl<M: IsParameterMask, R: IsModuleChannelReference> From<u8>
176    for ParameterValue<M, R>
177{
178    fn from(v: u8) -> ParameterValue<M, R> {
179        ParameterValue::UInt8(v)
180    }
181}
182
183impl<M: IsParameterMask, R: IsModuleChannelReference> From<u16>
184    for ParameterValue<M, R>
185{
186    fn from(v: u16) -> ParameterValue<M, R> {
187        ParameterValue::UInt16(v)
188    }
189}
190
191impl<M: IsParameterMask, R: IsModuleChannelReference> From<u32>
192    for ParameterValue<M, R>
193{
194    fn from(v: u32) -> ParameterValue<M, R> {
195        ParameterValue::UInt32(v)
196    }
197}
198
199impl<M: IsParameterMask, R: IsModuleChannelReference> From<u64>
200    for ParameterValue<M, R>
201{
202    fn from(v: u64) -> ParameterValue<M, R> {
203        ParameterValue::UInt64(v)
204    }
205}
xio_base_datatypes/parameter_value.rs

xio_base_datatypes/
parameter_value.rs
