libptp/
data_type.rs

1use super::{Error, Read};
2use byteorder::{LittleEndian, WriteBytesExt};
3use std::io::Write;
4
5#[allow(non_snake_case)]
6#[derive(Debug, PartialEq, Clone)]
7pub enum DataType {
8    UNDEF,
9    INT8(i8),
10    UINT8(u8),
11    INT16(i16),
12    UINT16(u16),
13    INT32(i32),
14    UINT32(u32),
15    INT64(i64),
16    UINT64(u64),
17    INT128(i128),
18    UINT128(u128),
19    AINT8(Vec<i8>),
20    AUINT8(Vec<u8>),
21    AINT16(Vec<i16>),
22    AUINT16(Vec<u16>),
23    AINT32(Vec<i32>),
24    AUINT32(Vec<u32>),
25    AINT64(Vec<i64>),
26    AUINT64(Vec<u64>),
27    AINT128(Vec<i128>),
28    AUINT128(Vec<u128>),
29    STR(String),
30}
31
32impl DataType {
33    pub fn encode(&self) -> Vec<u8> {
34        use self::DataType::*;
35        let mut out = vec![];
36        match self {
37            // UNDEF => {},
38            INT8(val) => {
39                out.write_i8(*val).ok();
40            }
41            UINT8(val) => {
42                out.write_u8(*val).ok();
43            }
44            INT16(val) => {
45                out.write_i16::<LittleEndian>(*val).ok();
46            }
47            UINT16(val) => {
48                out.write_u16::<LittleEndian>(*val).ok();
49            }
50            INT32(val) => {
51                out.write_i32::<LittleEndian>(*val).ok();
52            }
53            UINT32(val) => {
54                out.write_u32::<LittleEndian>(*val).ok();
55            }
56            INT64(val) => {
57                out.write_i64::<LittleEndian>(*val).ok();
58            }
59            UINT64(val) => {
60                out.write_u64::<LittleEndian>(*val).ok();
61            }
62            INT128(val) => {
63                out.write_i128::<LittleEndian>(*val).ok();
64            }
65            UINT128(val) => {
66                out.write_u128::<LittleEndian>(*val).ok();
67            }
68            AINT8(val) => {
69                out.write_u32::<LittleEndian>(val.len() as u32).ok();
70                for item in val {
71                    out.write_i8(*item).ok();
72                }
73            }
74            AUINT8(val) => {
75                out.write_u32::<LittleEndian>(val.len() as u32).ok();
76                for item in val {
77                    out.write_u8(*item).ok();
78                }
79            }
80            AINT16(val) => {
81                out.write_u32::<LittleEndian>(val.len() as u32).ok();
82                for item in val {
83                    out.write_i16::<LittleEndian>(*item).ok();
84                }
85            }
86            AUINT16(val) => {
87                out.write_u32::<LittleEndian>(val.len() as u32).ok();
88                for item in val {
89                    out.write_u16::<LittleEndian>(*item).ok();
90                }
91            }
92            AINT32(val) => {
93                out.write_u32::<LittleEndian>(val.len() as u32).ok();
94                for item in val {
95                    out.write_i32::<LittleEndian>(*item).ok();
96                }
97            }
98            AUINT32(val) => {
99                out.write_u32::<LittleEndian>(val.len() as u32).ok();
100                for item in val {
101                    out.write_u32::<LittleEndian>(*item).ok();
102                }
103            }
104            AINT64(val) => {
105                out.write_u32::<LittleEndian>(val.len() as u32).ok();
106                for item in val {
107                    out.write_i64::<LittleEndian>(*item).ok();
108                }
109            }
110            AUINT64(val) => {
111                out.write_u32::<LittleEndian>(val.len() as u32).ok();
112                for item in val {
113                    out.write_u64::<LittleEndian>(*item).ok();
114                }
115            }
116            AINT128(val) => {
117                out.write_u32::<LittleEndian>(val.len() as u32).ok();
118                for item in val {
119                    out.write_i128::<LittleEndian>(*item).ok();
120                }
121            }
122            AUINT128(val) => {
123                out.write_u32::<LittleEndian>(val.len() as u32).ok();
124                for item in val {
125                    out.write_u128::<LittleEndian>(*item).ok();
126                }
127            }
128            STR(val) => {
129                out.write_u8(((val.len() as u8) * 2) + 1).ok();
130                if !val.is_empty() {
131                    for e in val.encode_utf16() {
132                        out.write_u16::<LittleEndian>(e).ok();
133                    }
134                    out.write_all(b"\0\0").ok();
135                }
136            }
137            _ => {}
138        }
139        out
140    }
141
142    pub fn read_type<T: Read>(kind: u16, reader: &mut T) -> Result<DataType, Error> {
143        use self::DataType::*;
144        Ok(match kind {
145            // 0x0000 => UNDEF,
146            0x0001 => INT8(reader.read_ptp_i8()?),
147            0x0002 => UINT8(reader.read_ptp_u8()?),
148            0x0003 => INT16(reader.read_ptp_i16()?),
149            0x0004 => UINT16(reader.read_ptp_u16()?),
150            0x0005 => INT32(reader.read_ptp_i32()?),
151            0x0006 => UINT32(reader.read_ptp_u32()?),
152            0x0007 => INT64(reader.read_ptp_i64()?),
153            0x0008 => UINT64(reader.read_ptp_u64()?),
154            0x0009 => INT128(reader.read_ptp_i128()?),
155            0x000A => UINT128(reader.read_ptp_u128()?),
156            0x4001 => AINT8(reader.read_ptp_i8_vec()?),
157            0x4002 => AUINT8(reader.read_ptp_u8_vec()?),
158            0x4003 => AINT16(reader.read_ptp_i16_vec()?),
159            0x4004 => AUINT16(reader.read_ptp_u16_vec()?),
160            0x4005 => AINT32(reader.read_ptp_i32_vec()?),
161            0x4006 => AUINT32(reader.read_ptp_u32_vec()?),
162            0x4007 => AINT64(reader.read_ptp_i64_vec()?),
163            0x4008 => AUINT64(reader.read_ptp_u64_vec()?),
164            0x4009 => AINT128(reader.read_ptp_i128_vec()?),
165            0x400A => AUINT128(reader.read_ptp_u128_vec()?),
166            0xFFFF => STR(reader.read_ptp_str()?),
167            _ => UNDEF,
168        })
169    }
170}
171
172impl From<i8> for DataType {
173    fn from(value: i8) -> Self {
174        DataType::INT8(value)
175    }
176}
177
178impl From<u8> for DataType {
179    fn from(value: u8) -> Self {
180        DataType::UINT8(value)
181    }
182}
183
184impl From<i16> for DataType {
185    fn from(value: i16) -> Self {
186        DataType::INT16(value)
187    }
188}
189
190impl From<u16> for DataType {
191    fn from(value: u16) -> Self {
192        DataType::UINT16(value)
193    }
194}
195
196impl From<i32> for DataType {
197    fn from(value: i32) -> Self {
198        DataType::INT32(value)
199    }
200}
201
202impl From<u32> for DataType {
203    fn from(value: u32) -> Self {
204        DataType::UINT32(value)
205    }
206}
207
208impl From<i64> for DataType {
209    fn from(value: i64) -> Self {
210        DataType::INT64(value)
211    }
212}
213
214impl From<u64> for DataType {
215    fn from(value: u64) -> Self {
216        DataType::UINT64(value)
217    }
218}
219
220impl From<&str> for DataType {
221    fn from(value: &str) -> Self {
222        DataType::STR(value.to_owned())
223    }
224}
225
226impl From<String> for DataType {
227    fn from(value: String) -> Self {
228        DataType::STR(value)
229    }
230}
231
232#[derive(Debug)]
233pub enum FormData {
234    None,
235    Range {
236        min_value: DataType,
237        max_value: DataType,
238        step: DataType,
239    },
240    Enumeration {
241        array: Vec<DataType>,
242    },
243}
libptp/data_type.rs

libptp/
data_type.rs
