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.
···186186 // If we've gotten this far, we can expect we have a serial port definition.
187187 let mut port_def = None;
188188 for specifier in specifiers {
189189- if let ProtocolCommunicationSpecifier::Serial(serial) = specifier {
190190- if port_info.port_name == *serial.port() {
191191- port_def = Some(serial.clone());
189189+ if let ProtocolCommunicationSpecifier::Serial(serial_list) = specifier {
190190+ for serial in serial_list.ports() {
191191+ if port_info.port_name == *serial.port() {
192192+ port_def = Some(serial.clone());
193193+ break;
194194+ }
195195+ }
196196+ if port_def.is_some() {
192197 break;
193198 }
194199 }
+10-88
buttplug/src/util/device_configuration.rs
···1111 server::device::configuration::{
1212 BaseDeviceDefinition,
1313 BaseDeviceIdentifier,
1414- BluetoothLESpecifier,
1514 DeviceConfigurationManager,
1615 DeviceConfigurationManagerBuilder,
1717- HIDSpecifier,
1818- LovenseConnectServiceSpecifier,
1916 ProtocolCommunicationSpecifier,
2020- SerialSpecifier,
2121- USBSpecifier,
2222- UserDeviceCustomization,
2317 UserDeviceDefinition,
2418 UserDeviceIdentifier,
2525- WebsocketSpecifier,
2626- XInputSpecifier,
2719 },
2820};
2921use getset::{CopyGetters, Getters, MutGetters, Setters};
···7870#[derive(Deserialize, Serialize, Debug, Clone, Default, Getters, Setters, MutGetters)]
7971#[getset(get = "pub", set = "pub", get_mut = "pub(crate)")]
8072struct ProtocolDefinition {
8181- // Can't get serde flatten specifiers into a String/DeviceSpecifier map, so
8282- // they're kept separate here, and we return them in specifiers(). Feels
8383- // very clumsy, but we really don't do this a bunch during a session.
8473 #[serde(skip_serializing_if = "Option::is_none")]
8585- usb: Option<Vec<USBSpecifier>>,
7474+ pub communication: Option<Vec<ProtocolCommunicationSpecifier>>,
8675 #[serde(skip_serializing_if = "Option::is_none")]
8787- btle: Option<BluetoothLESpecifier>,
8888- #[serde(skip_serializing_if = "Option::is_none")]
8989- serial: Option<Vec<SerialSpecifier>>,
9090- #[serde(skip_serializing_if = "Option::is_none")]
9191- hid: Option<Vec<HIDSpecifier>>,
9292- #[serde(skip_serializing_if = "Option::is_none")]
9393- xinput: Option<XInputSpecifier>,
9494- #[serde(skip_serializing_if = "Option::is_none")]
9595- websocket: Option<WebsocketSpecifier>,
9696- #[serde(skip_serializing_if = "Option::is_none")]
9797- #[serde(rename = "lovense-connect-service")]
9898- lovense_connect_service: Option<LovenseConnectServiceSpecifier>,
9999- #[serde(skip_serializing_if = "Option::is_none")]
100100- defaults: Option<ProtocolAttributes>,
7676+ pub defaults: Option<ProtocolAttributes>,
10177 #[serde(default)]
102102- configurations: Vec<ProtocolAttributes>,
7878+ pub configurations: Vec<ProtocolAttributes>,
10379}
10480105105-#[derive(Deserialize, Serialize, Debug, Clone, Default, Getters, Setters, MutGetters)]
8181+#[derive(Deserialize, Serialize, Debug, Clone, Getters, Setters, MutGetters)]
10682#[getset(get = "pub", set = "pub", get_mut = "pub(crate)")]
10783struct UserDeviceConfigPair {
108108- identifier: UserConfigDeviceIdentifier,
109109- config: UserDeviceConfig,
8484+ identifier: UserDeviceIdentifier,
8585+ config: UserDeviceDefinition,
11086}
1118711288#[derive(Deserialize, Serialize, Debug, Clone, Default, Getters, Setters, MutGetters)]
···128104129105impl From<ProtocolDefinition> for ProtocolDeviceConfiguration {
130106 fn from(protocol_def: ProtocolDefinition) -> Self {
131131- // Make a vector out of the protocol definition specifiers
132132- let mut specifiers = vec![];
133133- if let Some(usb_vec) = &protocol_def.usb {
134134- usb_vec
135135- .iter()
136136- .for_each(|spec| specifiers.push(ProtocolCommunicationSpecifier::USB(*spec)));
137137- }
138138- if let Some(serial_vec) = &protocol_def.serial {
139139- serial_vec
140140- .iter()
141141- .for_each(|spec| specifiers.push(ProtocolCommunicationSpecifier::Serial(spec.clone())));
142142- }
143143- if let Some(hid_vec) = &protocol_def.hid {
144144- hid_vec
145145- .iter()
146146- .for_each(|spec| specifiers.push(ProtocolCommunicationSpecifier::HID(*spec)));
147147- }
148148- if let Some(btle) = &protocol_def.btle {
149149- specifiers.push(ProtocolCommunicationSpecifier::BluetoothLE(btle.clone()));
150150- }
151151- if let Some(xinput) = &protocol_def.xinput {
152152- specifiers.push(ProtocolCommunicationSpecifier::XInput(*xinput));
153153- }
154154- if let Some(websocket) = &protocol_def.websocket {
155155- specifiers.push(ProtocolCommunicationSpecifier::Websocket(websocket.clone()));
156156- }
157157- if let Some(lcs) = &protocol_def.lovense_connect_service {
158158- specifiers.push(ProtocolCommunicationSpecifier::LovenseConnectService(
159159- lcs.clone(),
160160- ));
161161- }
162162-163107 let mut configurations = HashMap::new();
164108165109 if let Some(defaults) = protocol_def.defaults() {
···194138 }
195139 }
196140197197- Self::new(specifiers, configurations)
141141+ Self::new(protocol_def.communication.unwrap_or_default(), configurations)
198142 }
199143}
200144···211155 continue;
212156 }
213157214214- let base_protocol_def = external_config
158158+ external_config
215159 .protocol_specifiers
216160 .get_mut(user_config_protocol)
217217- .unwrap();
218218-219219- // Make a vector out of the protocol definition specifiers
220220- if let Some(usb_vec) = &protocol_def.usb {
221221- usb_vec
222222- .iter()
223223- .for_each(|spec| base_protocol_def.push(ProtocolCommunicationSpecifier::USB(*spec)));
224224- }
225225- if let Some(serial_vec) = &protocol_def.serial {
226226- serial_vec.iter().for_each(|spec| {
227227- base_protocol_def.push(ProtocolCommunicationSpecifier::Serial(spec.clone()))
228228- });
229229- }
230230- if let Some(hid_vec) = &protocol_def.hid {
231231- hid_vec
232232- .iter()
233233- .for_each(|spec| base_protocol_def.push(ProtocolCommunicationSpecifier::HID(*spec)));
234234- }
235235- if let Some(btle) = &protocol_def.btle {
236236- base_protocol_def.push(ProtocolCommunicationSpecifier::BluetoothLE(btle.clone()));
237237- }
238238- if let Some(websocket) = &protocol_def.websocket {
239239- base_protocol_def.push(ProtocolCommunicationSpecifier::Websocket(websocket.clone()));
240240- }
161161+ .unwrap()
162162+ .extend(protocol_def.communication.clone().unwrap_or_default().iter().cloned())
241163 }
242164 }
243165 if let Some(user_device_configs) = user_config_def.user_device_configs() {