chore: run rustfmt

crates/buttplug/src/lib.rs

···
 pub use buttplug_client::*;
-pub use buttplug_transport_websocket_tungstenite::*;
+pub use buttplug_transport_websocket_tungstenite::*;

crates/buttplug_client/src/device/command.rs

···
 }
 
 impl ClientDeviceOutputCommand {
-  pub fn from_command_value_float(output_type: OutputType, value: f64) -> Result<Self, ButtplugClientError> {
+  pub fn from_command_value_float(
+    output_type: OutputType,
+    value: f64,
+  ) -> Result<Self, ButtplugClientError> {
     match output_type {
       OutputType::Vibrate => Ok(ClientDeviceOutputCommand::VibrateFloat(value)),
       OutputType::Oscillate => Ok(ClientDeviceOutputCommand::OscillateFloat(value)),
···
       OutputType::Led => Ok(ClientDeviceOutputCommand::LedFloat(value)),
       OutputType::Spray => Ok(ClientDeviceOutputCommand::SprayFloat(value)),
       OutputType::Position => Ok(ClientDeviceOutputCommand::PositionFloat(value)),
-      _ => Err(ButtplugClientError::ButtplugOutputCommandConversionError("Cannot use PositionWithDuration with this method".to_owned()))
+      _ => Err(ButtplugClientError::ButtplugOutputCommandConversionError(
+        "Cannot use PositionWithDuration with this method".to_owned(),
+      )),
     }
   }
 }
···
 impl Into<OutputType> for &ClientDeviceOutputCommand {
   fn into(self) -> OutputType {
     match self {
-      ClientDeviceOutputCommand::Vibrate(_) | ClientDeviceOutputCommand::VibrateFloat(_) => OutputType::Vibrate,
-      ClientDeviceOutputCommand::Oscillate(_) | ClientDeviceOutputCommand::OscillateFloat(_) => OutputType::Oscillate,
-      ClientDeviceOutputCommand::Rotate(_) | ClientDeviceOutputCommand::RotateFloat(_) => OutputType::Rotate,
-      ClientDeviceOutputCommand::Constrict(_) | ClientDeviceOutputCommand::ConstrictFloat(_) => OutputType::Constrict,
-      ClientDeviceOutputCommand::Heater(_) | ClientDeviceOutputCommand::HeaterFloat(_) => OutputType::Heater,
+      ClientDeviceOutputCommand::Vibrate(_) | ClientDeviceOutputCommand::VibrateFloat(_) => {
+        OutputType::Vibrate
+      }
+      ClientDeviceOutputCommand::Oscillate(_) | ClientDeviceOutputCommand::OscillateFloat(_) => {
+        OutputType::Oscillate
+      }
+      ClientDeviceOutputCommand::Rotate(_) | ClientDeviceOutputCommand::RotateFloat(_) => {
+        OutputType::Rotate
+      }
+      ClientDeviceOutputCommand::Constrict(_) | ClientDeviceOutputCommand::ConstrictFloat(_) => {
+        OutputType::Constrict
+      }
+      ClientDeviceOutputCommand::Heater(_) | ClientDeviceOutputCommand::HeaterFloat(_) => {
+        OutputType::Heater
+      }
       ClientDeviceOutputCommand::Led(_) | ClientDeviceOutputCommand::LedFloat(_) => OutputType::Led,
       ClientDeviceOutputCommand::Spray(_) | ClientDeviceOutputCommand::SprayFloat(_) => {
         OutputType::Spray

crates/buttplug_client/src/device/feature.rs

···
       ))
     } else {
       let mut val = float_amt * feature_output.step_count() as f64;
-      val = if val > 0.000001f64 { val.ceil() } else { val.floor() };
+      val = if val > 0.000001f64 {
+        val.ceil()
+      } else {
+        val.floor()
+      };
       Ok(val as i32)
     }
   }
···
   pub fn subscribe_sensor(&self, sensor_type: InputType) -> ButtplugClientResultFuture {
     if let Some(sensor_map) = self.feature.input()
       && let Some(sensor) = sensor_map.get(sensor_type)
-        && sensor
-          .input_commands()
-          .contains(&InputCommandType::Subscribe)
-        {
-          let msg = InputCmdV4::new(
-            self.device_index,
-            self.feature_index,
-            sensor_type,
-            InputCommandType::Subscribe,
-          )
-          .into();
-          return self.event_loop_sender.send_message_expect_ok(msg);
-        }
+      && sensor
+        .input_commands()
+        .contains(&InputCommandType::Subscribe)
+    {
+      let msg = InputCmdV4::new(
+        self.device_index,
+        self.feature_index,
+        sensor_type,
+        InputCommandType::Subscribe,
+      )
+      .into();
+      return self.event_loop_sender.send_message_expect_ok(msg);
+    }
     create_boxed_future_client_error(
       ButtplugDeviceError::MessageNotSupported(ButtplugDeviceMessageNameV4::InputCmd.to_string())
         .into(),
···
   pub fn unsubscribe_sensor(&self, sensor_type: InputType) -> ButtplugClientResultFuture {
     if let Some(sensor_map) = self.feature.input()
       && let Some(sensor) = sensor_map.get(sensor_type)
-        && sensor
-          .input_commands()
-          .contains(&InputCommandType::Subscribe)
-        {
-          let msg = InputCmdV4::new(
-            self.device_index,
-            self.feature_index,
-            sensor_type,
-            InputCommandType::Unsubscribe,
-          )
-          .into();
-          return self.event_loop_sender.send_message_expect_ok(msg);
-        }
+      && sensor
+        .input_commands()
+        .contains(&InputCommandType::Subscribe)
+    {
+      let msg = InputCmdV4::new(
+        self.device_index,
+        self.feature_index,
+        sensor_type,
+        InputCommandType::Unsubscribe,
+      )
+      .into();
+      return self.event_loop_sender.send_message_expect_ok(msg);
+    }
     create_boxed_future_client_error(
       ButtplugDeviceError::MessageNotSupported(ButtplugDeviceMessageNameV4::InputCmd.to_string())
         .into(),
···
   fn read_sensor(&self, sensor_type: InputType) -> ButtplugClientResultFuture<InputTypeData> {
     if let Some(sensor_map) = self.feature.input()
       && let Some(sensor) = sensor_map.get(sensor_type)
-        && sensor.input_commands().contains(&InputCommandType::Read) {
-          let msg = InputCmdV4::new(
-            self.device_index,
-            self.feature_index,
-            sensor_type,
-            InputCommandType::Read,
-          )
-          .into();
-          let reply = self.event_loop_sender.send_message(msg);
-          return async move {
-            if let ButtplugServerMessageV4::InputReading(data) = reply.await? {
-              if sensor_type == data.data().as_input_type() {
-                Ok(data.data())
-              } else {
-                Err(
-                  ButtplugError::ButtplugMessageError(ButtplugMessageError::UnexpectedMessageType(
-                    "InputReading".to_owned(),
-                  ))
-                  .into(),
-                )
-              }
-            } else {
-              Err(
-                ButtplugError::ButtplugMessageError(ButtplugMessageError::UnexpectedMessageType(
-                  "InputReading".to_owned(),
-                ))
-                .into(),
-              )
-            }
+      && sensor.input_commands().contains(&InputCommandType::Read)
+    {
+      let msg = InputCmdV4::new(
+        self.device_index,
+        self.feature_index,
+        sensor_type,
+        InputCommandType::Read,
+      )
+      .into();
+      let reply = self.event_loop_sender.send_message(msg);
+      return async move {
+        if let ButtplugServerMessageV4::InputReading(data) = reply.await? {
+          if sensor_type == data.data().as_input_type() {
+            Ok(data.data())
+          } else {
+            Err(
+              ButtplugError::ButtplugMessageError(ButtplugMessageError::UnexpectedMessageType(
+                "InputReading".to_owned(),
+              ))
+              .into(),
+            )
           }
-          .boxed();
+        } else {
+          Err(
+            ButtplugError::ButtplugMessageError(ButtplugMessageError::UnexpectedMessageType(
+              "InputReading".to_owned(),
+            ))
+            .into(),
+          )
         }
+      }
+      .boxed();
+    }
     create_boxed_future_client_error(
       ButtplugDeviceError::MessageNotSupported(ButtplugDeviceMessageNameV4::InputCmd.to_string())
         .into(),

crates/buttplug_core/src/message/device_feature.rs

···
 use serde::{Deserialize, Serialize, Serializer, ser::SerializeSeq};
 use std::{collections::HashSet, hash::Hash, ops::RangeInclusive};
 
-#[derive(Debug, Display, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Hash, EnumIter, EnumString)]
+#[derive(
+  Debug, Display, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Hash, EnumIter, EnumString,
+)]
 pub enum OutputType {
   Unknown,
   #[serde(alias = "vibrate")]

crates/buttplug_core/src/message/serializer/json_serializer.rs

···
     match msg {
       Ok(json_msg) => {
         if let Some(validator) = validator
-          && !validator.is_valid(&json_msg) {
-            // If is_valid fails, re-run validation to get our error message.
-            let e = validator
-              .validate(&json_msg)
-              .expect_err("We can't get here without validity checks failing.");
-            return Err(ButtplugSerializerError::JsonSerializerError(format!(
-              "Error during JSON Schema Validation - Message: {json_msg} - Error: {e:?}"
-            )));
-          }
+          && !validator.is_valid(&json_msg)
+        {
+          // If is_valid fails, re-run validation to get our error message.
+          let e = validator
+            .validate(&json_msg)
+            .expect_err("We can't get here without validity checks failing.");
+          return Err(ButtplugSerializerError::JsonSerializerError(format!(
+            "Error during JSON Schema Validation - Message: {json_msg} - Error: {e:?}"
+          )));
+        }
         match serde_json::from_value::<Vec<T>>(json_msg) {
           Ok(mut msg_vec) => {
             for msg in msg_vec.iter_mut() {

crates/buttplug_core/src/message/v4/mod.rs

···
   device_message_info::DeviceMessageInfoV4,
   input_cmd::{InputCmdV4, InputCommandType},
   input_reading::{InputData, InputReadingV4, InputTypeData},
-  output_cmd::{
-    OutputCmdV4,
-    OutputCommand,
-    OutputPositionWithDuration,
-    OutputValue,
-  },
+  output_cmd::{OutputCmdV4, OutputCommand, OutputPositionWithDuration, OutputValue},
   request_server_info::RequestServerInfoV4,
   server_info::ServerInfoV4,
   spec_enums::{ButtplugClientMessageV4, ButtplugDeviceMessageNameV4, ButtplugServerMessageV4},

crates/buttplug_core/src/message/v4/spec_enums.rs

···
 
 impl ButtplugMessageFinalizer for ButtplugServerMessageV4 {
   fn finalize(&mut self) {
-    if let ButtplugServerMessageV4::DeviceList(dl) = self { dl.finalize() }
+    if let ButtplugServerMessageV4::DeviceList(dl) = self {
+      dl.finalize()
+    }
   }
 }
 

crates/buttplug_core/src/util/range_serialize.rs

···
 use std::ops::RangeInclusive;
 
-use serde::{Serializer, Serialize, ser::SerializeSeq};
+use serde::{Serialize, Serializer, ser::SerializeSeq};
 
-pub fn option_range_serialize<S, T>(range: &Option<RangeInclusive<T>>, serializer: S) -> Result<S::Ok, S::Error>
+pub fn option_range_serialize<S, T>(
+  range: &Option<RangeInclusive<T>>,
+  serializer: S,
+) -> Result<S::Ok, S::Error>
 where
   S: Serializer,
-  T: Serialize
+  T: Serialize,
 {
   if let Some(r) = range {
     range_serialize(r, serializer)
···
 pub fn range_serialize<S, T>(range: &RangeInclusive<T>, serializer: S) -> Result<S::Ok, S::Error>
 where
   S: Serializer,
-  T: Serialize
+  T: Serialize,
 {
   let mut seq = serializer.serialize_seq(Some(2))?;
   seq.serialize_element(&range.start())?;
···
   seq.end()
 }
 
-pub fn range_sequence_serialize<S,T>(
+pub fn range_sequence_serialize<S, T>(
   range_vec: &Vec<RangeInclusive<T>>,
   serializer: S,
 ) -> Result<S::Ok, S::Error>

crates/buttplug_server/src/device/protocol.rs

···
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
     let output_command = cmd.output_command();
     match output_command {
-      OutputCommand::Constrict(x) => {
-        self.handle_output_constrict_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?)
-      }
-      OutputCommand::Spray(x) => {
-        self.handle_output_spray_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?)
-      }
-      OutputCommand::Oscillate(x) => {
-        self.handle_output_oscillate_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?)
-      }
+      OutputCommand::Constrict(x) => self.handle_output_constrict_cmd(
+        cmd.feature_index(),
+        cmd.feature_id(),
+        x.value()
+          .try_into()
+          .map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?,
+      ),
+      OutputCommand::Spray(x) => self.handle_output_spray_cmd(
+        cmd.feature_index(),
+        cmd.feature_id(),
+        x.value()
+          .try_into()
+          .map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?,
+      ),
+      OutputCommand::Oscillate(x) => self.handle_output_oscillate_cmd(
+        cmd.feature_index(),
+        cmd.feature_id(),
+        x.value()
+          .try_into()
+          .map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?,
+      ),
       OutputCommand::Rotate(x) => {
         self.handle_output_rotate_cmd(cmd.feature_index(), cmd.feature_id(), x.value())
       }
-      OutputCommand::Vibrate(x) => {
-        self.handle_output_vibrate_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?)
-      }
-      OutputCommand::Position(x) => {
-        self.handle_output_position_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?)
-      }
-      OutputCommand::Heater(x) => {
-        self.handle_output_heater_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?)
-      }
-      OutputCommand::Led(x) => {
-        self.handle_output_led_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?)
-      }
+      OutputCommand::Vibrate(x) => self.handle_output_vibrate_cmd(
+        cmd.feature_index(),
+        cmd.feature_id(),
+        x.value()
+          .try_into()
+          .map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?,
+      ),
+      OutputCommand::Position(x) => self.handle_output_position_cmd(
+        cmd.feature_index(),
+        cmd.feature_id(),
+        x.value()
+          .try_into()
+          .map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?,
+      ),
+      OutputCommand::Heater(x) => self.handle_output_heater_cmd(
+        cmd.feature_index(),
+        cmd.feature_id(),
+        x.value()
+          .try_into()
+          .map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?,
+      ),
+      OutputCommand::Led(x) => self.handle_output_led_cmd(
+        cmd.feature_index(),
+        cmd.feature_id(),
+        x.value()
+          .try_into()
+          .map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?,
+      ),
       OutputCommand::PositionWithDuration(x) => self.handle_position_with_duration_cmd(
         cmd.feature_index(),
         cmd.feature_id(),

crates/buttplug_server/src/device/protocol_impl/fredorch.rs

···
 }
 
 const SPEED_MATRIX: [[u32; 20]; 15] = [
-// distance, speed 1-20
-/*      1     2     3     4     5     6     7     8     9    10   11   12   13   14   15   16   17   18   19   20 */
-/* 1*/ [1000, 800,  400,  235,  200,  172,  155,  92,   60,  45,  38,  34,  32,  28,  27,  26,  25,  24,  23,  22 ],
-/* 2*/ [1500, 1000, 800,  680,  600,  515,  425,  265,  165, 115, 80,  70,  50,  48,  45,  35,  34,  33,  32,  30 ],
-/* 3*/ [2500, 2310, 1135, 925,  792,  695,  565,  380,  218, 155, 105, 82,  70,  68,  65,  60,  48,  45,  43,  40 ],
-/* 4*/ [3000, 2800, 1500, 1155, 965,  810,  690,  465,  260, 195, 140, 110, 85,  75,  74,  73,  70,  65,  60,  55 ],
-/* 5*/ [3400, 3232, 2305, 1380, 1200, 1165, 972,  565,  328, 235, 162, 132, 98,  78,  75,  74,  73,  72,  71,  70 ],
-/* 6*/ [3500, 3350, 2500, 1640, 1250, 1210, 1010, 645,  385, 275, 175, 160, 115, 95,  91,  90,  85,  80,  77,  75 ],
-/* 7*/ [3600, 3472, 2980, 2060, 1560, 1275, 1132, 738,  430, 310, 230, 170, 128, 122, 110, 108, 105, 103, 101, 100],
-/* 8*/ [3800, 3500, 3055, 2105, 1740, 1370, 1290, 830,  490, 355, 235, 195, 150, 140, 135, 132, 130, 125, 120, 119],
-/* 9*/ [3900, 3518, 3190, 2315, 2045, 1510, 1442, 1045, 552, 392, 280, 225, 172, 145, 140, 138, 135, 134, 132, 130],
-/*10*/ [6000, 5755, 3240, 2530, 2135, 1605, 1500, 1200, 595, 425, 285, 245, 175, 170, 160, 155, 150, 145, 142, 140],
-/*11*/ [6428, 5872, 3335, 2780, 2270, 1782, 1590, 1310, 648, 470, 315, 255, 182, 180, 175, 172, 170, 162, 160, 155],
-/*12*/ [6730, 5950, 3490, 2995, 2395, 1890, 1650, 1350, 700, 500, 350, 290, 220, 190, 185, 180, 175, 170, 165, 160],
-/*13*/ [6962, 6122, 3880, 3205, 2465, 1900, 1700, 1400, 835, 545, 375, 310, 228, 195, 190, 185, 182, 181, 180, 175],
-/*14*/ [7945, 6365, 4130, 3470, 2505, 1910, 1755, 1510, 855, 580, 400, 330, 235, 210, 205, 200, 195, 190, 185, 180],
-/*15*/ [8048, 7068, 4442, 3708, 2668, 1930, 1800, 1520, 878, 618, 428, 365, 260, 255, 250, 240, 230, 220, 210, 200],
+  // distance, speed 1-20
+  /*      1     2     3     4     5     6     7     8     9    10   11   12   13   14   15   16   17   18   19   20 */
+  /* 1*/
+  [
+    1000, 800, 400, 235, 200, 172, 155, 92, 60, 45, 38, 34, 32, 28, 27, 26, 25, 24, 23, 22,
+  ],
+  /* 2*/
+  [
+    1500, 1000, 800, 680, 600, 515, 425, 265, 165, 115, 80, 70, 50, 48, 45, 35, 34, 33, 32, 30,
+  ],
+  /* 3*/
+  [
+    2500, 2310, 1135, 925, 792, 695, 565, 380, 218, 155, 105, 82, 70, 68, 65, 60, 48, 45, 43, 40,
+  ],
+  /* 4*/
+  [
+    3000, 2800, 1500, 1155, 965, 810, 690, 465, 260, 195, 140, 110, 85, 75, 74, 73, 70, 65, 60, 55,
+  ],
+  /* 5*/
+  [
+    3400, 3232, 2305, 1380, 1200, 1165, 972, 565, 328, 235, 162, 132, 98, 78, 75, 74, 73, 72, 71,
+    70,
+  ],
+  /* 6*/
+  [
+    3500, 3350, 2500, 1640, 1250, 1210, 1010, 645, 385, 275, 175, 160, 115, 95, 91, 90, 85, 80, 77,
+    75,
+  ],
+  /* 7*/
+  [
+    3600, 3472, 2980, 2060, 1560, 1275, 1132, 738, 430, 310, 230, 170, 128, 122, 110, 108, 105,
+    103, 101, 100,
+  ],
+  /* 8*/
+  [
+    3800, 3500, 3055, 2105, 1740, 1370, 1290, 830, 490, 355, 235, 195, 150, 140, 135, 132, 130,
+    125, 120, 119,
+  ],
+  /* 9*/
+  [
+    3900, 3518, 3190, 2315, 2045, 1510, 1442, 1045, 552, 392, 280, 225, 172, 145, 140, 138, 135,
+    134, 132, 130,
+  ],
+  /*10*/
+  [
+    6000, 5755, 3240, 2530, 2135, 1605, 1500, 1200, 595, 425, 285, 245, 175, 170, 160, 155, 150,
+    145, 142, 140,
+  ],
+  /*11*/
+  [
+    6428, 5872, 3335, 2780, 2270, 1782, 1590, 1310, 648, 470, 315, 255, 182, 180, 175, 172, 170,
+    162, 160, 155,
+  ],
+  /*12*/
+  [
+    6730, 5950, 3490, 2995, 2395, 1890, 1650, 1350, 700, 500, 350, 290, 220, 190, 185, 180, 175,
+    170, 165, 160,
+  ],
+  /*13*/
+  [
+    6962, 6122, 3880, 3205, 2465, 1900, 1700, 1400, 835, 545, 375, 310, 228, 195, 190, 185, 182,
+    181, 180, 175,
+  ],
+  /*14*/
+  [
+    7945, 6365, 4130, 3470, 2505, 1910, 1755, 1510, 855, 580, 400, 330, 235, 210, 205, 200, 195,
+    190, 185, 180,
+  ],
+  /*15*/
+  [
+    8048, 7068, 4442, 3708, 2668, 1930, 1800, 1520, 878, 618, 428, 365, 260, 255, 250, 240, 230,
+    220, 210, 200,
+  ],
 ];
 
 fn calculate_speed(distance: u32, duration: u32) -> u8 {
-  let distance = distance.clamp(0,15);
-  if distance == 0  {return 0;}
+  let distance = distance.clamp(0, 15);
+  if distance == 0 {
+    return 0;
+  }
 
-  let mut speed= 1;
+  let mut speed = 1;
   while speed < 20 {
     if SPEED_MATRIX[distance as usize - 1][speed as usize - 1] < duration {
       return speed;
···
     let crc = crc16(&data);
     data.push(crc[0]);
     data.push(crc[1]);
-    self.previous_position.store(position as u8, Ordering::Relaxed);
-    Ok(vec![HardwareWriteCmd::new(
-      &[FREDORCH_PROTOCOL_UUID],
-      Endpoint::Tx,
-      data,
-      false,
-    )
-    .into()])
+    self
+      .previous_position
+      .store(position as u8, Ordering::Relaxed);
+    Ok(vec![
+      HardwareWriteCmd::new(&[FREDORCH_PROTOCOL_UUID], Endpoint::Tx, data, false).into(),
+    ])
   }
-  
+
   // TODO: Something is off... I think we need to program in both directions independently
-  fn handle_output_oscillate_cmd(&self, _feature_index: u32, _feature_id: Uuid, speed: u32) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
+  fn handle_output_oscillate_cmd(
+    &self,
+    _feature_index: u32,
+    _feature_id: Uuid,
+    speed: u32,
+  ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
     // If we ever get oscillate with range, these should be loaded from the last set range
     let min_pos = if speed == 0 { 0 } else { 0 };
     let max_pos = if speed == 0 { 0 } else { 15 };
     let mut data: Vec<u8> = vec![
-      0x01, 0x10, 0x00, 0x6B, 0x00, 0x05, 0x0a, 0x00, speed as u8, 0x00, speed as u8, 0x00, min_pos * 15, 0x00, max_pos * 15,
-      0x00, 0x01,
+      0x01,
+      0x10,
+      0x00,
+      0x6B,
+      0x00,
+      0x05,
+      0x0a,
+      0x00,
+      speed as u8,
+      0x00,
+      speed as u8,
+      0x00,
+      min_pos * 15,
+      0x00,
+      max_pos * 15,
+      0x00,
+      0x01,
     ];
     let crc = crc16(&data);
     data.push(crc[0]);
     data.push(crc[1]);
-    Ok(vec![HardwareWriteCmd::new(
-      &[FREDORCH_PROTOCOL_UUID],
-      Endpoint::Tx,
-      data,
-      false,
-    )
-        .into()])
+    Ok(vec![
+      HardwareWriteCmd::new(&[FREDORCH_PROTOCOL_UUID], Endpoint::Tx, data, false).into(),
+    ])
   }
 }

crates/buttplug_server/src/device/protocol_impl/galaku.rs

···
     if hardware.name() == "AC695X_1(BLE)" {
       protocol.is_caiping_pump_device = true;
     }
-    for _ in 0..def.features().iter().filter(|f| f.output().is_some()).count() {
-          protocol.speeds.push(AtomicU8::new(0));
-      }
+    for _ in 0..def
+      .features()
+      .iter()
+      .filter(|f| f.output().is_some())
+      .count()
+    {
+      protocol.speeds.push(AtomicU8::new(0));
+    }
     Ok(Arc::new(protocol))
   }
 }
···
 }
 
 impl Default for Galaku {
-    fn default() -> Self {
-        Self {
-            is_caiping_pump_device: false,
-            speeds: vec![],
-        }
+  fn default() -> Self {
+    Self {
+      is_caiping_pump_device: false,
+      speeds: vec![],
     }
+  }
 }
 impl Galaku {
-    fn handle_local_output_cmd(
-        &self,
-        feature_index: u32,
-        _feature_id: Uuid,
-        speed: u32,
-    ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-        if self.speeds.len() == 1 {
-            if self.is_caiping_pump_device {
-                let data: Vec<u8> = vec![
-                    0xAA,
-                    1,
-                    10,
-                    3,
-                    speed as u8,
-                    if speed == 0 { 0 } else { 1 },
-                    0,
-                    0,
-                    0,
-                    0,
-                    0,
-                    0,
-                    0,
-                    0,
-                    0,
-                    0,
-                ];
-                Ok(vec![HardwareWriteCmd::new(
-                    &[GALAKU_PROTOCOL_UUID],
-                    Endpoint::Tx,
-                    data,
-                    false,
-                )
-                    .into()])
-            } else {
-                let data = vec![90, 0, 0, 1, 49, speed, 0, 0, 0, 0];
+  fn handle_local_output_cmd(
+    &self,
+    feature_index: u32,
+    _feature_id: Uuid,
+    speed: u32,
+  ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
+    if self.speeds.len() == 1 {
+      if self.is_caiping_pump_device {
+        let data: Vec<u8> = vec![
+          0xAA,
+          1,
+          10,
+          3,
+          speed as u8,
+          if speed == 0 { 0 } else { 1 },
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+        ];
+        Ok(vec![
+          HardwareWriteCmd::new(&[GALAKU_PROTOCOL_UUID], Endpoint::Tx, data, false).into(),
+        ])
+      } else {
+        let data = vec![90, 0, 0, 1, 49, speed, 0, 0, 0, 0];
 
-                Ok(vec![HardwareWriteCmd::new(
-                    &[GALAKU_PROTOCOL_UUID],
-                    Endpoint::Tx,
-                    send_bytes(data),
-                    false,
-                )
-                    .into()])
-            }
-        } else {
-            if feature_index < self.speeds.len() as u32 {
-                self.speeds[feature_index as usize].store(speed as u8, Ordering::Relaxed);
-            } else {
-                error!("Tried to set value on out-of-bounds index {} (size {})", feature_index, self.speeds.len());
-            }
+        Ok(vec![
+          HardwareWriteCmd::new(
+            &[GALAKU_PROTOCOL_UUID],
+            Endpoint::Tx,
+            send_bytes(data),
+            false,
+          )
+          .into(),
+        ])
+      }
+    } else {
+      if feature_index < self.speeds.len() as u32 {
+        self.speeds[feature_index as usize].store(speed as u8, Ordering::Relaxed);
+      } else {
+        error!(
+          "Tried to set value on out-of-bounds index {} (size {})",
+          feature_index,
+          self.speeds.len()
+        );
+      }
 
-            let data: Vec<u32> = vec![
-                90,
-                0,
-                0,
-                1,
-                64,
-                3,
-                self.speeds[0].load(Ordering::Relaxed) as u32,
-                self.speeds[1].load(Ordering::Relaxed) as u32,
-                0,
-                0,
-            ];
-            Ok(vec![HardwareWriteCmd::new(
-                &[GALAKU_PROTOCOL_UUID],
-                Endpoint::Tx,
-                send_bytes(data),
-                false,
-            )
-                .into()])
-        }
+      let data: Vec<u32> = vec![
+        90,
+        0,
+        0,
+        1,
+        64,
+        3,
+        self.speeds[0].load(Ordering::Relaxed) as u32,
+        self.speeds[1].load(Ordering::Relaxed) as u32,
+        0,
+        0,
+      ];
+      Ok(vec![
+        HardwareWriteCmd::new(
+          &[GALAKU_PROTOCOL_UUID],
+          Endpoint::Tx,
+          send_bytes(data),
+          false,
+        )
+        .into(),
+      ])
     }
+  }
 }
 
 impl ProtocolHandler for Galaku {
-    fn handle_output_oscillate_cmd(&self, feature_index: u32, feature_id: Uuid, speed: u32) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-        self.handle_local_output_cmd(feature_index, feature_id, speed)
-    }
-    fn handle_output_vibrate_cmd(&self, feature_index: u32, feature_id: Uuid, speed: u32) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-        self.handle_local_output_cmd(feature_index, feature_id, speed)
-    }
-    fn handle_output_constrict_cmd(&self, feature_index: u32, feature_id: Uuid, level: u32) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-        self.handle_local_output_cmd(feature_index, feature_id, level)
-    }
+  fn handle_output_oscillate_cmd(
+    &self,
+    feature_index: u32,
+    feature_id: Uuid,
+    speed: u32,
+  ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
+    self.handle_local_output_cmd(feature_index, feature_id, speed)
+  }
+  fn handle_output_vibrate_cmd(
+    &self,
+    feature_index: u32,
+    feature_id: Uuid,
+    speed: u32,
+  ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
+    self.handle_local_output_cmd(feature_index, feature_id, speed)
+  }
+  fn handle_output_constrict_cmd(
+    &self,
+    feature_index: u32,
+    feature_id: Uuid,
+    level: u32,
+  ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
+    self.handle_local_output_cmd(feature_index, feature_id, level)
+  }
 
   fn handle_input_subscribe_cmd(
     &self,

crates/buttplug_server/src/device/protocol_impl/hgod.rs

···
           false,
         ))
         .await
-      {
-        error!(
-          "Got an error from a hgod device, exiting control loop: {:?}",
-          e
-        );
-        break;
-      }
+    {
+      error!(
+        "Got an error from a hgod device, exiting control loop: {:?}",
+        e
+      );
+      break;
+    }
     sleep(Duration::from_millis(HGOD_COMMAND_DELAY_MS)).await;
   }
 }

crates/buttplug_server/src/device/protocol_impl/hismith_mini.rs

···
       HardwareWriteCmd::new(
         &[feature_id],
         Endpoint::Tx,
-        vec![0xCC, 0x03, speed.unsigned_abs() as u8, speed.unsigned_abs() as u8 + 3],
+        vec![
+          0xCC,
+          0x03,
+          speed.unsigned_abs() as u8,
+          speed.unsigned_abs() as u8 + 3,
+        ],
         false,
       )
       .into(),

crates/buttplug_server/src/device/protocol_impl/kgoal_boost.rs

···
               return;
             }
             if let HardwareEvent::Notification(_, endpoint, data) = info
-              && endpoint == Endpoint::RxPressure {
-                if data.len() < 7 {
-                  // Not even sure how this would happen, error and continue on.
-                  error!("KGoal Boost data not expected length!");
-                  continue;
-                }
-                // Extract our two pressure values.
-                let normalized = (data[3] as u32) << 8 | data[4] as u32;
-                let unnormalized = (data[5] as u32) << 8 | data[6] as u32;
-                if stream_sensors.contains(&0)
-                  && sender
-                    .send(
-                      InputReadingV4::new(
-                        device_index,
-                        feature_index,
-                        buttplug_core::message::InputTypeData::Pressure(InputData::new(normalized)),
-                      )
-                      .into(),
+              && endpoint == Endpoint::RxPressure
+            {
+              if data.len() < 7 {
+                // Not even sure how this would happen, error and continue on.
+                error!("KGoal Boost data not expected length!");
+                continue;
+              }
+              // Extract our two pressure values.
+              let normalized = (data[3] as u32) << 8 | data[4] as u32;
+              let unnormalized = (data[5] as u32) << 8 | data[6] as u32;
+              if stream_sensors.contains(&0)
+                && sender
+                  .send(
+                    InputReadingV4::new(
+                      device_index,
+                      feature_index,
+                      buttplug_core::message::InputTypeData::Pressure(InputData::new(normalized)),
                     )
-                    .is_err()
-                {
-                  debug!(
-                    "Hardware device listener for KGoal Boost shut down, returning from task."
-                  );
-                  return;
-                }
-                if stream_sensors.contains(&1)
-                  && sender
-                    .send(
-                      InputReadingV4::new(
-                        device_index,
-                        feature_index,
-                        buttplug_core::message::InputTypeData::Pressure(InputData::new(
-                          unnormalized,
-                        )),
-                      )
-                      .into(),
+                    .into(),
+                  )
+                  .is_err()
+              {
+                debug!("Hardware device listener for KGoal Boost shut down, returning from task.");
+                return;
+              }
+              if stream_sensors.contains(&1)
+                && sender
+                  .send(
+                    InputReadingV4::new(
+                      device_index,
+                      feature_index,
+                      buttplug_core::message::InputTypeData::Pressure(InputData::new(unnormalized)),
                     )
-                    .is_err()
-                {
-                  debug!(
-                    "Hardware device listener for KGoal Boost shut down, returning from task."
-                  );
-                  return;
-                }
+                    .into(),
+                  )
+                  .is_err()
+              {
+                debug!("Hardware device listener for KGoal Boost shut down, returning from task.");
+                return;
               }
+            }
           }
         });
       }

crates/buttplug_server/src/device/protocol_impl/kiiroo_powershot.rs

···
 
 use crate::device::{
   hardware::{Hardware, HardwareCommand, HardwareReadCmd, HardwareWriteCmd},
-  protocol::{generic_protocol_setup, ProtocolHandler},
+  protocol::{ProtocolHandler, generic_protocol_setup},
 };
 use buttplug_core::{
   errors::ButtplugDeviceError,
   message::{self, InputData, InputReadingV4, InputTypeData},
 };
 use buttplug_server_device_config::Endpoint;
-use futures::{future::BoxFuture, FutureExt};
-use std::{default::Default, sync::Arc};
+use futures::{FutureExt, future::BoxFuture};
 use std::sync::atomic::{AtomicU8, Ordering};
-use uuid::{uuid, Uuid};
+use std::{default::Default, sync::Arc};
+use uuid::{Uuid, uuid};
 const KIIROO_POWERSHUOT_PROTOCOL_UUID: Uuid = uuid!("06f49eb9-0dca-42a8-92f0-58634cc017d0");
 
 generic_protocol_setup!(KiirooPowerShot, "kiiroo-powershot");
 
 #[derive(Default)]
 pub struct KiirooPowerShot {
-  last_cmds: [AtomicU8; 2]
+  last_cmds: [AtomicU8; 2],
 }
 
 impl KiirooPowerShot {
-  fn form_hardware_command(&self, index: u32, speed: u32) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
+  fn form_hardware_command(
+    &self,
+    index: u32,
+    speed: u32,
+  ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
     self.last_cmds[index as usize].store(speed as u8, Ordering::Relaxed);
-    Ok(vec![HardwareWriteCmd::new(
-      &[KIIROO_POWERSHUOT_PROTOCOL_UUID],
-      Endpoint::Tx,
-      vec![
-        0x01,
-        0x00,
-        0x00,
-        self.last_cmds[0].load(Ordering::Relaxed),
-        self.last_cmds[1].load(Ordering::Relaxed),
-        0x00,
-      ],
-      true,
-    ).into()])
+    Ok(vec![
+      HardwareWriteCmd::new(
+        &[KIIROO_POWERSHUOT_PROTOCOL_UUID],
+        Endpoint::Tx,
+        vec![
+          0x01,
+          0x00,
+          0x00,
+          self.last_cmds[0].load(Ordering::Relaxed),
+          self.last_cmds[1].load(Ordering::Relaxed),
+          0x00,
+        ],
+        true,
+      )
+      .into(),
+    ])
   }
 }
 
···
       let battery_reading = message::InputReadingV4::new(
         device_index,
         feature_index,
-        InputTypeData::Battery(InputData::new(data[0]))
+        InputTypeData::Battery(InputData::new(data[0])),
       );
       debug!("Got battery reading: {}", data[0]);
       Ok(battery_reading)

crates/buttplug_server/src/device/protocol_impl/kiiroo_v3.rs

···
 use crate::device::{
   hardware::Hardware,
   protocol::{
-    generic_protocol_initializer_setup,
     ProtocolHandler,
     ProtocolIdentifier,
     ProtocolInitializer,
+    generic_protocol_initializer_setup,
   },
   protocol_impl::kiiroo_v21::KiirooV21,
 };
 use async_trait::async_trait;
 use buttplug_core::errors::ButtplugDeviceError;
 use buttplug_server_device_config::{
-  ServerDeviceDefinition,
   ProtocolCommunicationSpecifier,
+  ServerDeviceDefinition,
   UserDeviceIdentifier,
 };
-use std::sync::{
-  Arc,
-};
+use std::sync::Arc;
 
 generic_protocol_initializer_setup!(KiirooV3, "kiiroo-v3");
 

crates/buttplug_server/src/device/protocol_impl/lovense/lovense_multi_actuator.rs

···
     feature_id: Uuid,
     speed: u32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-    debug!("Lovense multi-actuator command: {}", format!("Vibrate{}:{};", feature_index + 1, speed));
+    debug!(
+      "Lovense multi-actuator command: {}",
+      format!("Vibrate{}:{};", feature_index + 1, speed)
+    );
     let lovense_cmd = format!("Vibrate{}:{};", feature_index + 1, speed)
       .as_bytes()
       .to_vec();

crates/buttplug_server/src/device/protocol_impl/lovense/mod.rs

···
       .into(),
     );
   }
-    let lovense_cmd = format!("Rotate:{speed};").as_bytes().to_vec();
-    hardware_cmds
-        .push(HardwareWriteCmd::new(&[LOVENSE_ROTATE_UUID], Endpoint::Tx, lovense_cmd, false).into());
+  let lovense_cmd = format!("Rotate:{speed};").as_bytes().to_vec();
+  hardware_cmds
+    .push(HardwareWriteCmd::new(&[LOVENSE_ROTATE_UUID], Endpoint::Tx, lovense_cmd, false).into());
   trace!("{:?}", hardware_cmds);
   Ok(hardware_cmds)
 }

crates/buttplug_server/src/device/protocol_impl/luvmazer.rs

···
     feature_id: Uuid,
     speed: u32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-    Ok(vec![HardwareWriteCmd::new(
-      &[feature_id],
-      Endpoint::Tx,
-      vec![0xa0, 0x01, 0x00, feature_index as u8, 0x64, speed as u8],
-      false,
-    )
-    .into()])
+    Ok(vec![
+      HardwareWriteCmd::new(
+        &[feature_id],
+        Endpoint::Tx,
+        vec![0xa0, 0x01, 0x00, feature_index as u8, 0x64, speed as u8],
+        false,
+      )
+      .into(),
+    ])
   }
 
   fn handle_output_rotate_cmd(
···
     feature_id: Uuid,
     speed: u32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-    Ok(vec![HardwareWriteCmd::new(
-      &[feature_id],
-      Endpoint::Tx,
-      vec![0xa0, 0x06, 0x01, 0x00, 0x64, speed as u8],
-      false,
-    )
-        .into()])
+    Ok(vec![
+      HardwareWriteCmd::new(
+        &[feature_id],
+        Endpoint::Tx,
+        vec![0xa0, 0x06, 0x01, 0x00, 0x64, speed as u8],
+        false,
+      )
+      .into(),
+    ])
   }
 
   fn handle_output_constrict_cmd(
···
     feature_id: Uuid,
     speed: u32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-    Ok(vec![HardwareWriteCmd::new(
-      &[feature_id],
-      Endpoint::Tx,
-      vec![0xa0, 0x0d, 0x00, 0x00, if speed == 0 { 0x00} else { 0x14 }, speed as u8],
-      false,
-    )
-        .into()])
+    Ok(vec![
+      HardwareWriteCmd::new(
+        &[feature_id],
+        Endpoint::Tx,
+        vec![
+          0xa0,
+          0x0d,
+          0x00,
+          0x00,
+          if speed == 0 { 0x00 } else { 0x14 },
+          speed as u8,
+        ],
+        false,
+      )
+      .into(),
+    ])
   }
 }

crates/buttplug_server/src/device/protocol_impl/mod.rs

···
 pub mod kiiroo_prowand;
 pub mod kiiroo_spot;
 pub mod kiiroo_v2;
-pub mod kiiroo_v3;
 pub mod kiiroo_v21;
 pub mod kiiroo_v21_initialized;
 pub mod kiiroo_v2_vibrator;
+pub mod kiiroo_v3;
 pub mod kizuna;
 pub mod lelo_harmony;
 pub mod lelof1s;
···
     &mut map,
     sexverse_lg389::setup::SexverseLG389IdentifierFactory::default(),
   );
-    add_to_protocol_map(
-        &mut map,
-        sexverse_v1::setup::SexverseV1IdentifierFactory::default(),
-    );
-    add_to_protocol_map(
-        &mut map,
-        sexverse_v2::setup::SexverseV2IdentifierFactory::default(),
-    );
-    add_to_protocol_map(
-        &mut map,
-        sexverse_v3::setup::SexverseV3IdentifierFactory::default(),
-    );
-    add_to_protocol_map(
-        &mut map,
-        sexverse_v4::setup::SexverseV4IdentifierFactory::default(),
-    );
-    add_to_protocol_map(
-        &mut map,
-        sexverse_v5::setup::SexverseV5IdentifierFactory::default(),
-    );
+  add_to_protocol_map(
+    &mut map,
+    sexverse_v1::setup::SexverseV1IdentifierFactory::default(),
+  );
+  add_to_protocol_map(
+    &mut map,
+    sexverse_v2::setup::SexverseV2IdentifierFactory::default(),
+  );
+  add_to_protocol_map(
+    &mut map,
+    sexverse_v3::setup::SexverseV3IdentifierFactory::default(),
+  );
+  add_to_protocol_map(
+    &mut map,
+    sexverse_v4::setup::SexverseV4IdentifierFactory::default(),
+  );
+  add_to_protocol_map(
+    &mut map,
+    sexverse_v5::setup::SexverseV5IdentifierFactory::default(),
+  );
   add_to_protocol_map(&mut map, serveu::setup::ServeUIdentifierFactory::default());
   add_to_protocol_map(
     &mut map,

crates/buttplug_server/src/device/protocol_impl/motorbunny.rs

···
       command_vec = vec![0xa0, 0x00, 0x00, 0x00, 0x00, 0xec];
     } else {
       command_vec = vec![0xaf];
-      let mut rotate_command = [if speed >= 0 { 0x2a } else { 0x29 }, speed.unsigned_abs() as u8].repeat(7);
+      let mut rotate_command = [
+        if speed >= 0 { 0x2a } else { 0x29 },
+        speed.unsigned_abs() as u8,
+      ]
+      .repeat(7);
       let crc = rotate_command
         .iter()
         .fold(0u8, |a, b| a.overflowing_add(*b).0);

crates/buttplug_server/src/device/protocol_impl/nexus_revo.rs

···
   }
 
   fn handle_output_rotate_cmd(
-      &self,
-      _feature_index: u32,
-      feature_id: Uuid,
-      speed: i32,
-    ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
+    &self,
+    _feature_index: u32,
+    feature_id: Uuid,
+    speed: i32,
+  ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
     Ok(vec![
       HardwareWriteCmd::new(
         &[feature_id],

crates/buttplug_server/src/device/protocol_impl/nintendo_joycon.rs

···
   },
 };
 use async_trait::async_trait;
-use buttplug_core::{
-  errors::ButtplugDeviceError,
-  util::async_manager,
-};
+use buttplug_core::{errors::ButtplugDeviceError, util::async_manager};
 use buttplug_server_device_config::{
   Endpoint,
   ProtocolCommunicationSpecifier,

crates/buttplug_server/src/device/protocol_impl/sensee_v2.rs

···
         .enumerate()
         .for_each(|(i, x)| {
           if let Some(output_map) = x.output()
-            && output_map.contains(output_type) {
-              map.insert(i as u32, AtomicU8::new(0));
-            }
+            && output_map.contains(output_type)
+          {
+            map.insert(i as u32, AtomicU8::new(0));
+          }
         });
       map
     };

crates/buttplug_server/src/device/protocol_impl/sexverse_v1.rs

···
     }
     data.push(crc);
 
-    Ok(vec![HardwareWriteCmd::new(
-      &[SEXVERSE_PROTOCOL_UUID],
-      Endpoint::Tx,
-      data,
-      false,
-    )
-    .into()])
+    Ok(vec![
+      HardwareWriteCmd::new(&[SEXVERSE_PROTOCOL_UUID], Endpoint::Tx, data, false).into(),
+    ])
   }
 }
 

crates/buttplug_server/src/device/protocol_impl/synchro.rs

···
 
 impl ProtocolHandler for Synchro {
   fn handle_output_rotate_cmd(
-      &self,
-      _feature_index: u32,
-      feature_id: Uuid,
-      speed: i32,
-    ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
+    &self,
+    _feature_index: u32,
+    feature_id: Uuid,
+    speed: i32,
+  ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
     Ok(vec![
       HardwareWriteCmd::new(
         &[feature_id],

crates/buttplug_server/src/device/protocol_impl/tryfun_meta2.rs

···
   }
 
   fn handle_output_rotate_cmd(
-      &self,
-      _feature_index: u32,
-      feature_id: Uuid,
-      speed: i32,
-    ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
+    &self,
+    _feature_index: u32,
+    feature_id: Uuid,
+    speed: i32,
+  ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
     let mut speed = speed as i8;
     if speed >= 0 {
       speed += 1;

crates/buttplug_server/src/device/protocol_impl/vorze_sa/dual_rotator.rs

···
 
 impl ProtocolHandler for VorzeSADualRotator {
   fn handle_output_rotate_cmd(
-      &self,
-      feature_index: u32,
-      _feature_id: Uuid,
-      speed: i32,
-    ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
+    &self,
+    feature_index: u32,
+    _feature_id: Uuid,
+    speed: i32,
+  ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
     self.speeds[feature_index as usize].store(speed as i8, Ordering::Relaxed);
     let speed_left = self.speeds[0].load(Ordering::Relaxed);
     let data_left = ((speed_left >= 0) as u8) << 7 | (speed_left.unsigned_abs());

crates/buttplug_server/src/device/protocol_impl/vorze_sa/piston.rs

···
 
     let speed = get_piston_speed(distance, duration as f64);
 
-    self
-      .previous_position
-      .store(position, Ordering::Relaxed);
+    self.previous_position.store(position, Ordering::Relaxed);
 
     Ok(vec![
       HardwareWriteCmd::new(

crates/buttplug_server/src/device/protocol_impl/vorze_sa/single_rotator.rs

···
 
 impl ProtocolHandler for VorzeSASingleRotator {
   fn handle_output_rotate_cmd(
-      &self,
-      _feature_index: u32,
-      feature_id: uuid::Uuid,
-      speed: i32,
-    ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-    let clockwise = if speed >=0 { 1u8 } else { 0 };
+    &self,
+    _feature_index: u32,
+    feature_id: uuid::Uuid,
+    speed: i32,
+  ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
+    let clockwise = if speed >= 0 { 1u8 } else { 0 };
     let data: u8 = (clockwise) << 7 | (speed.unsigned_abs() as u8);
     Ok(vec![
       HardwareWriteCmd::new(

crates/buttplug_server/src/device/server_device.rs

···
         strategy,
         ProtocolKeepaliveStrategy::RepeatLastPacketStrategyWithTiming(_)
       ))
-      && let Err(e) = device.handle_stop_device_cmd().await {
-        return Err(ButtplugDeviceError::DeviceConnectionError(format!(
-          "Error setting up keepalive: {e}"
-        )));
-      }
+      && let Err(e) = device.handle_stop_device_cmd().await
+    {
+      return Err(ButtplugDeviceError::DeviceConnectionError(format!(
+        "Error setting up keepalive: {e}"
+      )));
+    }
 
     Ok(device)
   }
···
               strategy,
               ProtocolKeepaliveStrategy::RepeatLastPacketStrategyWithTiming(_)
             ))
-            && let HardwareCommand::Write(command) = command {
-              *keepalive_packet.lock().await = Some(command);
-            };
+            && let HardwareCommand::Write(command) = command
+          {
+            *keepalive_packet.lock().await = Some(command);
+          };
         };
         loop {
           let requires_keepalive = hardware.requires_keepalive();
···
 
   fn handle_outputcmd_v4(&self, msg: &CheckedOutputCmdV4) -> ButtplugServerResultFuture {
     if let Some(last_msg) = self.last_output_command.get(&msg.feature_id())
-      && *last_msg == *msg {
-        trace!("No commands generated for incoming device packet, skipping and returning success.");
-        return future::ready(Ok(message::OkV0::default().into())).boxed();
-      }
+      && *last_msg == *msg
+    {
+      trace!("No commands generated for incoming device packet, skipping and returning success.");
+      return future::ready(Ok(message::OkV0::default().into())).boxed();
+    }
     self
       .last_output_command
       .insert(msg.feature_id(), msg.clone());

crates/buttplug_server/src/device/server_device_manager_event_loop.rs

···
 
         // After that, we can send out to the server's event listeners to let
         // them know a device has been added.
-        if self
-          .server_sender
-          .send(device_update_message)
-          .is_err()
-        {
+        if self.server_sender.send(device_update_message).is_err() {
           debug!("Server not currently available, dropping Device Added event.");
         }
       }

crates/buttplug_server/src/message/v3/client_device_message_attributes.rs

···
   v2::{ClientDeviceMessageAttributesV2, GenericDeviceMessageAttributesV2},
 };
 use buttplug_core::message::{
-  DeviceFeature, DeviceFeatureOutputValueProperties, InputCommandType, InputType, OutputType
+  DeviceFeature,
+  DeviceFeatureOutputValueProperties,
+  InputCommandType,
+  InputType,
+  OutputType,
 };
 use getset::{Getters, MutGetters, Setters};
 use serde::{Deserialize, Serialize, Serializer, ser::SerializeSeq};
···
               };
               actuator_vec.push(attrs)
             };
-          if let Some(x) = output_map
-            .constrict()
-            .as_ref() { create_actuator(OutputType::Constrict, x) }
-          if let Some(x) = output_map
-            .heater()
-            .as_ref() { create_actuator(OutputType::Heater, x) }
-          if let Some(x) = output_map
-            .led()
-            .as_ref() { create_actuator(OutputType::Led, x) }
-          if let Some(x) = output_map
-            .oscillate()
-            .as_ref() { create_actuator(OutputType::Oscillate, x) }
-          if let Some(x) = output_map
-            .position()
-            .as_ref() { create_actuator(OutputType::Position, x) }
-          if let Some(x) = output_map
-            .rotate()
-            .as_ref() { create_actuator(OutputType::Rotate, x) }
-          if let Some(x) = output_map
-            .spray()
-            .as_ref() { create_actuator(OutputType::Spray, x) }
-          if let Some(x) = output_map
-            .vibrate()
-            .as_ref() { create_actuator(OutputType::Vibrate, x) }
+          if let Some(x) = output_map.constrict().as_ref() {
+            create_actuator(OutputType::Constrict, x)
+          }
+          if let Some(x) = output_map.heater().as_ref() {
+            create_actuator(OutputType::Heater, x)
+          }
+          if let Some(x) = output_map.led().as_ref() {
+            create_actuator(OutputType::Led, x)
+          }
+          if let Some(x) = output_map.oscillate().as_ref() {
+            create_actuator(OutputType::Oscillate, x)
+          }
+          if let Some(x) = output_map.position().as_ref() {
+            create_actuator(OutputType::Position, x)
+          }
+          if let Some(x) = output_map.rotate().as_ref() {
+            create_actuator(OutputType::Rotate, x)
+          }
+          if let Some(x) = output_map.spray().as_ref() {
+            create_actuator(OutputType::Spray, x)
+          }
+          if let Some(x) = output_map.vibrate().as_ref() {
+            create_actuator(OutputType::Vibrate, x)
+          }
         }
         actuator_vec
       })
···
       .flat_map(|feature| {
         let mut actuator_vec = vec![];
         if let Some(output_map) = feature.output()
-          && let Some(actuator) = output_map.rotate() 
-          && *actuator.value().start() < 0 {
-            let actuator_type = OutputType::Rotate;
-            let attrs = ClientGenericDeviceMessageAttributesV3 {
-              feature_descriptor: feature.description().to_owned(),
-              actuator_type,
-              step_count: actuator.step_count(),
-              index: 0,
-            };
-            actuator_vec.push(attrs)
-          }
+          && let Some(actuator) = output_map.rotate()
+          && *actuator.value().start() < 0
+        {
+          let actuator_type = OutputType::Rotate;
+          let attrs = ClientGenericDeviceMessageAttributesV3 {
+            feature_descriptor: feature.description().to_owned(),
+            actuator_type,
+            step_count: actuator.step_count(),
+            index: 0,
+          };
+          actuator_vec.push(attrs)
+        }
         actuator_vec
       })
       .collect();
···
       .flat_map(|feature| {
         let mut actuator_vec = vec![];
         if let Some(output_map) = feature.output()
-          && let Some(actuator) = output_map.position_with_duration() {
-            let actuator_type = OutputType::Position;
-            let attrs = ClientGenericDeviceMessageAttributesV3 {
-              feature_descriptor: feature.description().to_owned(),
-              actuator_type,
-              step_count: actuator.step_count(),
-              index: 0,
-            };
-            actuator_vec.push(attrs)
-          }
+          && let Some(actuator) = output_map.position_with_duration()
+        {
+          let actuator_type = OutputType::Position;
+          let attrs = ClientGenericDeviceMessageAttributesV3 {
+            feature_descriptor: feature.description().to_owned(),
+            actuator_type,
+            step_count: actuator.step_count(),
+            index: 0,
+          };
+          actuator_vec.push(attrs)
+        }
         actuator_vec
       })
       .collect();

crates/buttplug_server/src/message/v3/server_device_message_attributes.rs

···
           };
           // TODO oh come on just make a fucking iterator here. At least, once we figure out the
           // unifying trait we can use to make an iterator on this.
-          if let Some(attr) = output_map
-            .constrict()
-            .as_ref() { create_attribute(OutputType::Constrict, attr.value().step_count()) }
-          if let Some(attr) = output_map
-            .oscillate()
-            .as_ref() { create_attribute(OutputType::Oscillate, attr.value().step_count()) }
-          if let Some(attr) = output_map
-            .position()
-            .as_ref() { create_attribute(OutputType::Position, attr.position().step_count()) }
-          if let Some(attr) = output_map
-            .rotate()
-            .as_ref() { create_attribute(OutputType::Rotate, attr.value().step_count()) }
-          if let Some(attr) = output_map
-            .heater()
-            .as_ref() { create_attribute(OutputType::Heater, attr.value().step_count()) }
-          if let Some(attr) = output_map
-            .led()
-            .as_ref() { create_attribute(OutputType::Led, attr.value().step_count()) }
-          if let Some(attr) = output_map
-            .vibrate()
-            .as_ref() { create_attribute(OutputType::Vibrate, attr.value().step_count()) }
-          if let Some(attr) = output_map
-            .spray()
-            .as_ref() { create_attribute(OutputType::Spray, attr.value().step_count()) }
+          if let Some(attr) = output_map.constrict().as_ref() {
+            create_attribute(OutputType::Constrict, attr.value().step_count())
+          }
+          if let Some(attr) = output_map.oscillate().as_ref() {
+            create_attribute(OutputType::Oscillate, attr.value().step_count())
+          }
+          if let Some(attr) = output_map.position().as_ref() {
+            create_attribute(OutputType::Position, attr.position().step_count())
+          }
+          if let Some(attr) = output_map.rotate().as_ref() {
+            create_attribute(OutputType::Rotate, attr.value().step_count())
+          }
+          if let Some(attr) = output_map.heater().as_ref() {
+            create_attribute(OutputType::Heater, attr.value().step_count())
+          }
+          if let Some(attr) = output_map.led().as_ref() {
+            create_attribute(OutputType::Led, attr.value().step_count())
+          }
+          if let Some(attr) = output_map.vibrate().as_ref() {
+            create_attribute(OutputType::Vibrate, attr.value().step_count())
+          }
+          if let Some(attr) = output_map.spray().as_ref() {
+            create_attribute(OutputType::Spray, attr.value().step_count())
+          }
         }
         actuator_vec
       })
···
       .flat_map(|feature| {
         let mut actuator_vec = vec![];
         if let Some(output_map) = feature.output()
-          && let Some(actuator) = output_map.rotate() 
-          && *actuator.value().base().start() < 0 {
-            let actuator_type = OutputType::Rotate;
-            let step_count = actuator.value().step_count();
-            let attrs = ServerGenericDeviceMessageAttributesV3 {
-              feature_descriptor: feature.description().to_owned(),
-              actuator_type,
-              step_count,
-              feature: feature.clone(),
-              index: 0,
-            };
-            actuator_vec.push(attrs)
-          }
+          && let Some(actuator) = output_map.rotate()
+          && *actuator.value().base().start() < 0
+        {
+          let actuator_type = OutputType::Rotate;
+          let step_count = actuator.value().step_count();
+          let attrs = ServerGenericDeviceMessageAttributesV3 {
+            feature_descriptor: feature.description().to_owned(),
+            actuator_type,
+            step_count,
+            feature: feature.clone(),
+            index: 0,
+          };
+          actuator_vec.push(attrs)
+        }
         actuator_vec
       })
       .collect();
···
       .flat_map(|feature| {
         let mut actuator_vec = vec![];
         if let Some(output_map) = feature.output()
-          && let Some(actuator) = output_map.position_with_duration() {
-            let actuator_type = OutputType::Position;
-            let step_count = actuator.position().step_count();
-            let attrs = ServerGenericDeviceMessageAttributesV3 {
-              feature_descriptor: feature.description().to_owned(),
-              actuator_type,
-              step_count,
-              feature: feature.clone(),
-              index: 0,
-            };
-            actuator_vec.push(attrs)
-          }
+          && let Some(actuator) = output_map.position_with_duration()
+        {
+          let actuator_type = OutputType::Position;
+          let step_count = actuator.position().step_count();
+          let attrs = ServerGenericDeviceMessageAttributesV3 {
+            feature_descriptor: feature.description().to_owned(),
+            actuator_type,
+            step_count,
+            feature: feature.clone(),
+            index: 0,
+          };
+          actuator_vec.push(attrs)
+        }
         actuator_vec
       })
       .collect();
···
         .map(|feature| {
           let mut sensor_vec = vec![];
           if let Some(sensor_map) = feature.input()
-            && let Some(battery) = sensor_map.battery() {
-              // Only convert Battery backwards. Other sensors weren't really built for v3 and we
-              // never recommended using them or implemented much for them.
-              sensor_vec.push(ServerSensorDeviceMessageAttributesV3 {
-                feature_descriptor: feature.description().to_owned(),
-                sensor_type: InputType::Battery,
-                sensor_range: battery.value_range().clone(),
-                feature: feature.clone(),
-                index: 0,
-              });
-            }
+            && let Some(battery) = sensor_map.battery()
+          {
+            // Only convert Battery backwards. Other sensors weren't really built for v3 and we
+            // never recommended using them or implemented much for them.
+            sensor_vec.push(ServerSensorDeviceMessageAttributesV3 {
+              feature_descriptor: feature.description().to_owned(),
+              sensor_type: InputType::Battery,
+              sensor_range: battery.value_range().clone(),
+              feature: feature.clone(),
+              index: 0,
+            });
+          }
           sensor_vec
         })
         .flatten()

crates/buttplug_server/src/message/v4/checked_output_vec_cmd.rs

···
             ButtplugError::from(ButtplugMessageError::InvalidMessageContents(
               "Position should be 0.0 < x < 1.0".to_owned(),
             ))
-          })? as i32 * (if cmd.clockwise() { 1 } else { -1 })
+          })? as i32
+            * (if cmd.clockwise() { 1 } else { -1 }),
         )),
       ));
     }

crates/buttplug_server/src/server_message_conversion.rs

···
         .collect();
       self.device_indexes.remove(&disconnected_indexes[0]);
       match version {
-        ButtplugMessageSpecVersion::Version0 => {
-          ButtplugServerMessageVariant::V0(ButtplugServerMessageV0::DeviceRemoved(
-            DeviceRemovedV0::new(disconnected_indexes[0]),
-          ))
-        }
+        ButtplugMessageSpecVersion::Version0 => ButtplugServerMessageVariant::V0(
+          ButtplugServerMessageV0::DeviceRemoved(DeviceRemovedV0::new(disconnected_indexes[0])),
+        ),
         ButtplugMessageSpecVersion::Version1 => {
-          ButtplugServerMessageVariant::V1(
-            DeviceRemovedV0::new(disconnected_indexes[0]).into(),
-          )
+          ButtplugServerMessageVariant::V1(DeviceRemovedV0::new(disconnected_indexes[0]).into())
         }
         ButtplugMessageSpecVersion::Version2 => {
-          ButtplugServerMessageVariant::V2(
-            DeviceRemovedV0::new(disconnected_indexes[0]).into(),
-          )
+          ButtplugServerMessageVariant::V2(DeviceRemovedV0::new(disconnected_indexes[0]).into())
         }
         ButtplugMessageSpecVersion::Version3 => {
-          ButtplugServerMessageVariant::V3(
-            DeviceRemovedV0::new(disconnected_indexes[0]).into(),
-          )
+          ButtplugServerMessageVariant::V3(DeviceRemovedV0::new(disconnected_indexes[0]).into())
         }
         ButtplugMessageSpecVersion::Version4 => {
           ButtplugServerMessageVariant::V4(list.clone().into())

crates/buttplug_server_device_config/src/device_config_file/feature.rs

···
   ServerDeviceFeatureOutputPositionWithDurationProperties,
   ServerDeviceFeatureOutputValueProperties,
 };
-use buttplug_core::{message::InputCommandType, util::range_serialize::{range_serialize, range_sequence_serialize, option_range_serialize}};
+use buttplug_core::{
+  message::InputCommandType,
+  util::range_serialize::{option_range_serialize, range_sequence_serialize, range_serialize},
+};
 use getset::{CopyGetters, Getters, MutGetters, Setters};
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
···
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
 struct BaseDeviceFeatureOutputValueProperties {
-  #[serde(serialize_with="range_serialize")]
+  #[serde(serialize_with = "range_serialize")]
   value: RangeInclusive<i32>,
 }
 
···
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
 struct BaseDeviceFeatureOutputPositionProperties {
-  #[serde(serialize_with="range_serialize")]
+  #[serde(serialize_with = "range_serialize")]
   value: RangeInclusive<i32>,
 }
 
···
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
 struct BaseDeviceFeatureOutputPositionWithDurationProperties {
-  #[serde(serialize_with="range_serialize")]
+  #[serde(serialize_with = "range_serialize")]
   position: RangeInclusive<i32>,
-  #[serde(serialize_with="range_serialize")]
+  #[serde(serialize_with = "range_serialize")]
   duration: RangeInclusive<i32>,
 }
 
···
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
 struct UserDeviceFeatureOutputValueProperties {
-  #[serde(skip_serializing_if = "Option::is_none", serialize_with="option_range_serialize")]
+  #[serde(
+    skip_serializing_if = "Option::is_none",
+    serialize_with = "option_range_serialize"
+  )]
   value: Option<RangeInclusive<u32>>,
   #[serde(default)]
   disabled: bool,
···
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
 struct UserDeviceFeatureOutputPositionProperties {
-  #[serde(skip_serializing_if = "Option::is_none", serialize_with="option_range_serialize")]
+  #[serde(
+    skip_serializing_if = "Option::is_none",
+    serialize_with = "option_range_serialize"
+  )]
   value: Option<RangeInclusive<u32>>,
   #[serde(default)]
   disabled: bool,
···
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
 struct UserDeviceFeatureOutputPositionWithDurationProperties {
-  #[serde(skip_serializing_if = "Option::is_none", serialize_with="option_range_serialize")]
+  #[serde(
+    skip_serializing_if = "Option::is_none",
+    serialize_with = "option_range_serialize"
+  )]
   position: Option<RangeInclusive<u32>>,
-  #[serde(skip_serializing_if = "Option::is_none", serialize_with="option_range_serialize")]
+  #[serde(
+    skip_serializing_if = "Option::is_none",
+    serialize_with = "option_range_serialize"
+  )]
   duration: Option<RangeInclusive<u32>>,
   #[serde(default)]
   disabled: bool,
···
   fn from(value: &ServerDeviceFeature) -> Self {
     Self {
       id: value.id(),
-      base_id: value.base_id().expect(&format!("Should have base id: {:?}", value)),
+      base_id: value
+        .base_id()
+        .expect(&format!("Should have base id: {:?}", value)),
       output: value.output().as_ref().map(|x| x.into()),
     }
   }

crates/buttplug_server_device_config/src/device_config_file/mod.rs

···
 
 use base::BaseConfigFile;
 
-use crate::{device_config_file::{
+use crate::device_config_file::{
   protocol::ProtocolDefinition,
   user::{UserConfigDefinition, UserConfigFile, UserDeviceConfigPair},
-}};
+};
 
 use super::{BaseDeviceIdentifier, DeviceConfigurationManager, DeviceConfigurationManagerBuilder};
 use buttplug_core::{
···
 };
 use dashmap::DashMap;
 use getset::CopyGetters;
-use serde::{
-  Deserialize,
-  Serialize
-};
+use serde::{Deserialize, Serialize};
 use std::fmt::Display;
 
 pub static DEVICE_CONFIGURATION_JSON: &str =
···
     //let ident = BaseDeviceIdentifier::new(user_device_config_pair.identifier().protocol(), &None);
     // Use device UUID instead of identifier to match here, otherwise we have to do really weird stuff with identifier hashes.
     // TODO How do we deal with user configs derived from default here? We don't handle loading this correctly?
-    if let Some(base_config) = base_dcm.base_device_definitions().iter().find(|x| x.1.id() == user_device_config_pair.config().base_id())
+    if let Some(base_config) = base_dcm
+      .base_device_definitions()
+      .iter()
+      .find(|x| x.1.id() == user_device_config_pair.config().base_id())
     {
       if let Ok(loaded_user_config) = user_device_config_pair
         .config()
-        .build_from_base_definition(base_config.1) {
-        if let Err(e) =
-          dcm_builder.user_device_definition(user_device_config_pair.identifier(), &loaded_user_config)
+        .build_from_base_definition(base_config.1)
+      {
+        if let Err(e) = dcm_builder
+          .user_device_definition(user_device_config_pair.identifier(), &loaded_user_config)
         {
           error!(
             "Device definition not valid, skipping:\n{:?}\n{:?}",

crates/buttplug_server_device_config/src/device_config_file/protocol.rs

···
-
 use getset::{Getters, MutGetters, Setters};
 use serde::{Deserialize, Serialize};
 

crates/buttplug_server_device_config/src/device_config_manager.rs

···
     }
   }
 
-  pub fn add_user_device_definition(&self, identifier: &UserDeviceIdentifier, definition: &ServerDeviceDefinition) {
+  pub fn add_user_device_definition(
+    &self,
+    identifier: &UserDeviceIdentifier,
+    definition: &ServerDeviceDefinition,
+  ) {
     // TODO we should actually check validity of the definition we're adding here, i.e. does it have
     // a base id, is that ID in our base selections, etc...
-    self.user_device_definitions.insert(identifier.clone(), definition.clone());
+    self
+      .user_device_definitions
+      .insert(identifier.clone(), definition.clone());
   }
 
   pub fn remove_user_device_definition(&self, identifier: &UserDeviceIdentifier) {

crates/buttplug_server_device_config/src/device_definitions.rs

···
     value.base_id = Some(value.id);
     value.id = id;
     if with_features {
-      value.features = value.features().iter().map(|x| x.as_new_user_feature()).collect();
+      value.features = value
+        .features()
+        .iter()
+        .map(|x| x.as_new_user_feature())
+        .collect();
     } else {
-      value.features = vec!();
+      value.features = vec![];
     }
     ServerDeviceDefinitionBuilder { def: value }
   }
···
   }
 
   pub fn replace_feature(&mut self, feature: &ServerDeviceFeature) -> &mut Self {
-    if let Some(f) = self.def.features.iter_mut().find(|x| x.id() == feature.id()) {
+    if let Some(f) = self
+      .def
+      .features
+      .iter_mut()
+      .find(|x| x.id() == feature.id())
+    {
       *f = feature.clone();
     }
     self

crates/buttplug_server_hwmgr_hid/src/hidapi_async.rs

···
 
         // Wait for the reader thread to finish
         if let Some(jh) = guard.read_thread.take()
-          && jh.join().is_ok() {
-            info!("device read thread joined")
-          }
+          && jh.join().is_ok()
+        {
+          info!("device read thread joined")
+        }
       } else {
         //error!("Failed to take lock on device");
       }

crates/buttplug_server_hwmgr_lovense_dongle/src/lovense_dongle_state_machine.rs

···
         IncomingMessage::Dongle(device_msg) => match device_msg.func {
           LovenseDongleMessageFunc::IncomingStatus => {
             if let Some(incoming_data) = device_msg.data
-              && let Some(status) = incoming_data.status {
-                match status {
-                  LovenseDongleResultCode::DeviceConnectSuccess => {
-                    info!("Lovense dongle already connected to a device, registering in system.");
-                    return Some(Box::new(LovenseDongleDeviceLoop::new(
-                      self.hub,
-                      incoming_data
-                        .id
-                        .expect("Dongle protocol shouldn't change, message always has ID."),
-                    )));
-                  }
-                  _ => warn!(
-                    "LovenseDongleIdle State cannot handle dongle status {:?}",
-                    status
-                  ),
+              && let Some(status) = incoming_data.status
+            {
+              match status {
+                LovenseDongleResultCode::DeviceConnectSuccess => {
+                  info!("Lovense dongle already connected to a device, registering in system.");
+                  return Some(Box::new(LovenseDongleDeviceLoop::new(
+                    self.hub,
+                    incoming_data
+                      .id
+                      .expect("Dongle protocol shouldn't change, message always has ID."),
+                  )));
                 }
+                _ => warn!(
+                  "LovenseDongleIdle State cannot handle dongle status {:?}",
+                  status
+                ),
               }
+            }
           }
           LovenseDongleMessageFunc::Search => {
             if let Some(result) = device_msg.result {
···
           match device_msg.func {
             LovenseDongleMessageFunc::IncomingStatus => {
               if let Some(incoming_data) = device_msg.data
-                && let Some(status) = incoming_data.status {
-                  match status {
-                    LovenseDongleResultCode::DeviceConnectSuccess => {
-                      info!("Lovense dongle already connected to a device, registering in system.");
-                      return Some(Box::new(LovenseDongleDeviceLoop::new(
-                        self.hub,
-                        incoming_data
-                          .id
-                          .expect("Dongle protocol shouldn't change, message always has ID."),
-                      )));
-                    }
-                    _ => {
-                      warn!(
-                        "LovenseDongleScanning state cannot handle dongle status {:?}",
-                        status
-                      )
-                    }
+                && let Some(status) = incoming_data.status
+              {
+                match status {
+                  LovenseDongleResultCode::DeviceConnectSuccess => {
+                    info!("Lovense dongle already connected to a device, registering in system.");
+                    return Some(Box::new(LovenseDongleDeviceLoop::new(
+                      self.hub,
+                      incoming_data
+                        .id
+                        .expect("Dongle protocol shouldn't change, message always has ID."),
+                    )));
+                  }
+                  _ => {
+                    warn!(
+                      "LovenseDongleScanning state cannot handle dongle status {:?}",
+                      status
+                    )
                   }
                 }
+              }
             }
             LovenseDongleMessageFunc::Search => {
               if let Some(result) = device_msg.result {
···
         IncomingMessage::Dongle(device_msg) => match device_msg.func {
           LovenseDongleMessageFunc::Search => {
             if let Some(result) = device_msg.result
-              && result == LovenseDongleResultCode::SearchStopped {
-                self.hub.set_scanning_status(false);
-                break;
-              }
+              && result == LovenseDongleResultCode::SearchStopped
+            {
+              self.hub.set_scanning_status(false);
+              break;
+            }
           }
           LovenseDongleMessageFunc::StopSearch => {
             if let Some(result) = device_msg.result
-              && result == LovenseDongleResultCode::CommandSuccess {
-                // Just log and continue here.
-                debug!("Lovense dongle stop search command succeeded.");
-              }
+              && result == LovenseDongleResultCode::CommandSuccess
+            {
+              // Just log and continue here.
+              debug!("Lovense dongle stop search command succeeded.");
+            }
           }
           _ => warn!(
             "LovenseDongleStopScanningAndConnect cannot handle dongle function {:?}",
···
           match dongle_msg.func {
             LovenseDongleMessageFunc::IncomingStatus => {
               if let Some(data) = dongle_msg.data
-                && data.status == Some(LovenseDongleResultCode::DeviceDisconnected) {
-                  // Device disconnected, emit and return to idle.
-                  return Some(Box::new(LovenseDongleIdle::new(self.hub)));
-                }
+                && data.status == Some(LovenseDongleResultCode::DeviceDisconnected)
+              {
+                // Device disconnected, emit and return to idle.
+                return Some(Box::new(LovenseDongleIdle::new(self.hub)));
+              }
             }
             _ => {
               if device_read_sender.send(dongle_msg).await.is_err() {

crates/buttplug_server_hwmgr_serial/src/serialport_hardware.rs

···
     let mut port_def = None;
     for specifier in specifiers {
       if let ProtocolCommunicationSpecifier::Serial(serial) = specifier
-        && port_info.port_name == *serial.port() {
-          port_def = Some(serial.clone());
-          break;
-        }
+        && port_info.port_name == *serial.port()
+      {
+        port_def = Some(serial.clone());
+        break;
+      }
     }
     let port_def = port_def.expect("We'll always have a port definition by this point");
 
···
           && let Err(err) = event_stream_clone.send(HardwareEvent::Disconnected(format!(
             "{:?}",
             &port_name_clone
-          ))) {
-            error!(
-              "Cannot send notification, device object disappeared: {:?}",
-              err
-            );
-          }
+          )))
+        {
+          error!(
+            "Cannot send notification, device object disappeared: {:?}",
+            err
+          );
+        }
       })
       .expect("Should always be able to create thread");
 

crates/buttplug_tests/tests/util/device_test/client/client_v4/mod.rs

···
             .map(|(_, x)| x)
             .collect();
           let f = rotate_features[cmd.index() as usize].clone();
-          f.rotate(ClientDeviceCommandValue::Float(cmd.speed() * if cmd.clockwise() { 1f64 } else { -1f64 }))
+          f.rotate(ClientDeviceCommandValue::Float(
+            cmd.speed() * if cmd.clockwise() { 1f64 } else { -1f64 },
+          ))
         })
         .collect();
       futures::future::try_join_all(fut_vec).await.unwrap();

crates/intiface_engine/src/bin/main.rs

···
   #[getset(get_copy = "pub")]
   crash_main_thread: bool,
 
-
   #[allow(dead_code)]
   #[cfg(debug_assertions)]
   /// crash the task thread (for testing logging/reporting)
···
       match fs::read_to_string(userdeviceconfig) {
         Ok(cfg) => {
           builder.user_device_config_json(&cfg);
-        },
+        }
         Err(err) => {
-          warn!("Error opening user device configuration, ignoring and creating new file: {:?}", err);
+          warn!(
+            "Error opening user device configuration, ignoring and creating new file: {:?}",
+            err
+          );
         }
       };
     }

crates/intiface_engine/src/buttplug_server.rs

···
   IntifaceEngineError, IntifaceError, remote_server::ButtplugRemoteServerEvent,
 };
 use buttplug_server::{
-  connector::ButtplugRemoteServerConnector, device::{ServerDeviceManager, ServerDeviceManagerBuilder}, message::serializer::ButtplugServerJSONSerializer, ButtplugServer, ButtplugServerBuilder
+  ButtplugServer, ButtplugServerBuilder,
+  connector::ButtplugRemoteServerConnector,
+  device::{ServerDeviceManager, ServerDeviceManagerBuilder},
+  message::serializer::ButtplugServerJSONSerializer,
 };
 use buttplug_server_device_config::{DeviceConfigurationManager, load_protocol_configs};
 use buttplug_server_hwmgr_btleplug::BtlePlugCommunicationManagerBuilder;

crates/intiface_engine/src/engine.rs

···
 use crate::{
-  ButtplugRemoteServer, ButtplugRepeater, backdoor_server::BackdoorServer, buttplug_server::{reset_buttplug_server, run_server, setup_buttplug_server}, error::IntifaceEngineError, frontend::{
+  ButtplugRemoteServer, ButtplugRepeater,
+  backdoor_server::BackdoorServer,
+  buttplug_server::{reset_buttplug_server, run_server, setup_buttplug_server},
+  error::IntifaceEngineError,
+  frontend::{
     Frontend, frontend_external_event_loop, frontend_server_event_loop,
     process_messages::EngineMessage,
-  }, mdns::IntifaceMdns, options::EngineOptions, remote_server::ButtplugRemoteServerEvent, rest_server::IntifaceRestServer
+  },
+  mdns::IntifaceMdns,
+  options::EngineOptions,
+  remote_server::ButtplugRemoteServerEvent,
+  rest_server::IntifaceRestServer,
 };
 
 use buttplug_server_device_config::{DeviceConfigurationManager, save_user_config};

crates/intiface_engine/src/lib.rs

···
 #[macro_use]
 extern crate log;
 
-
 mod backdoor_server;
 mod buttplug_server;
 mod engine;

crates/intiface_engine/src/options.rs

···
       repeater_mode: other.repeater_mode,
       repeater_local_port: other.repeater_local_port,
       repeater_remote_address: other.repeater_remote_address,
-      rest_api_port: other.rest_api_port
+      rest_api_port: other.rest_api_port,
     }
   }
 }

crates/intiface_engine/src/rest_server.rs

···
-use std::{collections::BTreeMap, convert::Infallible, io, net::SocketAddr, str::FromStr, sync::Arc};
+use std::{
+  collections::BTreeMap, convert::Infallible, io, net::SocketAddr, str::FromStr, sync::Arc,
+};
 
 use axum::{
-  extract::{rejection::JsonRejection, Path, State}, http::StatusCode, response::{sse::{Event, KeepAlive}, IntoResponse, Response, Sse}, routing::{get, put}, Json, Router
+  Json, Router,
+  extract::{Path, State, rejection::JsonRejection},
+  http::StatusCode,
+  response::{
+    IntoResponse, Response, Sse,
+    sse::{Event, KeepAlive},
+  },
+  routing::{get, put},
 };
 use buttplug_client::{
-  device::{ClientDeviceFeature, ClientDeviceOutputCommand}, ButtplugClient, ButtplugClientDevice, ButtplugClientError, ButtplugClientEvent
+  ButtplugClient, ButtplugClientDevice, ButtplugClientError, ButtplugClientEvent,
+  device::{ClientDeviceFeature, ClientDeviceOutputCommand},
 };
 use buttplug_client_in_process::ButtplugInProcessClientConnectorBuilder;
 use buttplug_core::message::{DeviceFeature, OutputType};
···
 fn get_feature(
   client: &ButtplugClient,
   index: u32,
-  feature_index: u32
+  feature_index: u32,
 ) -> Result<ClientDeviceFeature, IntifaceRestError> {
   get_device(client, index)?
     .device_features()
···
   State(client): State<Arc<ButtplugClient>>,
   Path((index, command, level)): Path<(u32, OutputType, f64)>,
 ) -> Result<(), IntifaceRestError> {
-  let cmd =  ClientDeviceOutputCommand::from_command_value_float(command, level)
+  let cmd = ClientDeviceOutputCommand::from_command_value_float(command, level)
     .map_err(|e| IntifaceRestError::ButtplugClientError(e))?;
 
   Ok(
···
   State(client): State<Arc<ButtplugClient>>,
   Path((index, feature_index, command, level)): Path<(u32, u32, OutputType, f64)>,
 ) -> Result<(), IntifaceRestError> {
-  let cmd =  ClientDeviceOutputCommand::from_command_value_float(command, level)
+  let cmd = ClientDeviceOutputCommand::from_command_value_float(command, level)
     .map_err(|e| IntifaceRestError::ButtplugClientError(e))?;
 
   Ok(
···
   Ok(())
 }
 
-async fn server_sse(State(client): State<Arc<ButtplugClient>>,) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
-    let stream = client.event_stream().map(|e| Ok(Event::default().data(format!("{:?}", e))));
+async fn server_sse(
+  State(client): State<Arc<ButtplugClient>>,
+) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
+  let stream = client
+    .event_stream()
+    .map(|e| Ok(Event::default().data(format!("{:?}", e))));
 
-    Sse::new(stream).keep_alive(KeepAlive::default())
+  Sse::new(stream).keep_alive(KeepAlive::default())
 }
 
 impl IntifaceRestServer {

examples/src/bin/device_control.rs

···
-
 use buttplug_client::{
   ButtplugClient,
   ButtplugClientError,

examples/src/bin/device_tester.rs

···
 // Licensed under the BSD 3-Clause license. See LICENSE file in the project root
 // for full license information.
 
-
 use tracing::Level;
 
 /*
···
   device_tester().await;
   */
 }
-