feat: Simplify comm info storage for de/serialization
Instead of trying to constrain types, make de/serialization for communication types look like internal storage of the data. This makes life way easier for actually writing out user configs.
···186 // If we've gotten this far, we can expect we have a serial port definition.
187 let mut port_def = None;
188 for specifier in specifiers {
189- if let ProtocolCommunicationSpecifier::Serial(serial) = specifier {
190- if port_info.port_name == *serial.port() {
191- port_def = Some(serial.clone());
00000192 break;
193 }
194 }
···186 // If we've gotten this far, we can expect we have a serial port definition.
187 let mut port_def = None;
188 for specifier in specifiers {
189+ if let ProtocolCommunicationSpecifier::Serial(serial_list) = specifier {
190+ for serial in serial_list.ports() {
191+ if port_info.port_name == *serial.port() {
192+ port_def = Some(serial.clone());
193+ break;
194+ }
195+ }
196+ if port_def.is_some() {
197 break;
198 }
199 }
+10-88
buttplug/src/util/device_configuration.rs
···11 server::device::configuration::{
12 BaseDeviceDefinition,
13 BaseDeviceIdentifier,
14- BluetoothLESpecifier,
15 DeviceConfigurationManager,
16 DeviceConfigurationManagerBuilder,
17- HIDSpecifier,
18- LovenseConnectServiceSpecifier,
19 ProtocolCommunicationSpecifier,
20- SerialSpecifier,
21- USBSpecifier,
22- UserDeviceCustomization,
23 UserDeviceDefinition,
24 UserDeviceIdentifier,
25- WebsocketSpecifier,
26- XInputSpecifier,
27 },
28};
29use getset::{CopyGetters, Getters, MutGetters, Setters};
···78#[derive(Deserialize, Serialize, Debug, Clone, Default, Getters, Setters, MutGetters)]
79#[getset(get = "pub", set = "pub", get_mut = "pub(crate)")]
80struct ProtocolDefinition {
81- // Can't get serde flatten specifiers into a String/DeviceSpecifier map, so
82- // they're kept separate here, and we return them in specifiers(). Feels
83- // very clumsy, but we really don't do this a bunch during a session.
84 #[serde(skip_serializing_if = "Option::is_none")]
85- usb: Option<Vec<USBSpecifier>>,
86 #[serde(skip_serializing_if = "Option::is_none")]
87- btle: Option<BluetoothLESpecifier>,
88- #[serde(skip_serializing_if = "Option::is_none")]
89- serial: Option<Vec<SerialSpecifier>>,
90- #[serde(skip_serializing_if = "Option::is_none")]
91- hid: Option<Vec<HIDSpecifier>>,
92- #[serde(skip_serializing_if = "Option::is_none")]
93- xinput: Option<XInputSpecifier>,
94- #[serde(skip_serializing_if = "Option::is_none")]
95- websocket: Option<WebsocketSpecifier>,
96- #[serde(skip_serializing_if = "Option::is_none")]
97- #[serde(rename = "lovense-connect-service")]
98- lovense_connect_service: Option<LovenseConnectServiceSpecifier>,
99- #[serde(skip_serializing_if = "Option::is_none")]
100- defaults: Option<ProtocolAttributes>,
101 #[serde(default)]
102- configurations: Vec<ProtocolAttributes>,
103}
104105-#[derive(Deserialize, Serialize, Debug, Clone, Default, Getters, Setters, MutGetters)]
106#[getset(get = "pub", set = "pub", get_mut = "pub(crate)")]
107struct UserDeviceConfigPair {
108- identifier: UserConfigDeviceIdentifier,
109- config: UserDeviceConfig,
110}
111112#[derive(Deserialize, Serialize, Debug, Clone, Default, Getters, Setters, MutGetters)]
···128129impl From<ProtocolDefinition> for ProtocolDeviceConfiguration {
130 fn from(protocol_def: ProtocolDefinition) -> Self {
131- // Make a vector out of the protocol definition specifiers
132- let mut specifiers = vec![];
133- if let Some(usb_vec) = &protocol_def.usb {
134- usb_vec
135- .iter()
136- .for_each(|spec| specifiers.push(ProtocolCommunicationSpecifier::USB(*spec)));
137- }
138- if let Some(serial_vec) = &protocol_def.serial {
139- serial_vec
140- .iter()
141- .for_each(|spec| specifiers.push(ProtocolCommunicationSpecifier::Serial(spec.clone())));
142- }
143- if let Some(hid_vec) = &protocol_def.hid {
144- hid_vec
145- .iter()
146- .for_each(|spec| specifiers.push(ProtocolCommunicationSpecifier::HID(*spec)));
147- }
148- if let Some(btle) = &protocol_def.btle {
149- specifiers.push(ProtocolCommunicationSpecifier::BluetoothLE(btle.clone()));
150- }
151- if let Some(xinput) = &protocol_def.xinput {
152- specifiers.push(ProtocolCommunicationSpecifier::XInput(*xinput));
153- }
154- if let Some(websocket) = &protocol_def.websocket {
155- specifiers.push(ProtocolCommunicationSpecifier::Websocket(websocket.clone()));
156- }
157- if let Some(lcs) = &protocol_def.lovense_connect_service {
158- specifiers.push(ProtocolCommunicationSpecifier::LovenseConnectService(
159- lcs.clone(),
160- ));
161- }
162-163 let mut configurations = HashMap::new();
164165 if let Some(defaults) = protocol_def.defaults() {
···194 }
195 }
196197- Self::new(specifiers, configurations)
198 }
199}
200···211 continue;
212 }
213214- let base_protocol_def = external_config
215 .protocol_specifiers
216 .get_mut(user_config_protocol)
217- .unwrap();
218-219- // Make a vector out of the protocol definition specifiers
220- if let Some(usb_vec) = &protocol_def.usb {
221- usb_vec
222- .iter()
223- .for_each(|spec| base_protocol_def.push(ProtocolCommunicationSpecifier::USB(*spec)));
224- }
225- if let Some(serial_vec) = &protocol_def.serial {
226- serial_vec.iter().for_each(|spec| {
227- base_protocol_def.push(ProtocolCommunicationSpecifier::Serial(spec.clone()))
228- });
229- }
230- if let Some(hid_vec) = &protocol_def.hid {
231- hid_vec
232- .iter()
233- .for_each(|spec| base_protocol_def.push(ProtocolCommunicationSpecifier::HID(*spec)));
234- }
235- if let Some(btle) = &protocol_def.btle {
236- base_protocol_def.push(ProtocolCommunicationSpecifier::BluetoothLE(btle.clone()));
237- }
238- if let Some(websocket) = &protocol_def.websocket {
239- base_protocol_def.push(ProtocolCommunicationSpecifier::Websocket(websocket.clone()));
240- }
241 }
242 }
243 if let Some(user_device_configs) = user_config_def.user_device_configs() {