chore: run rustfmt

Author: qdot

examples/lights.rs

@@ -68,7 +68,15 @@ async fn main() -> anyhow::Result<()> {
     // dance party
     let mut rng = rng();
     for _ in 0..20 {
-        let color_cmd = vec![0x56, rng.random(), rng.random(), rng.random(), 0x00, 0xF0, 0xAA];
+        let color_cmd = vec![
+            0x56,
+            rng.random(),
+            rng.random(),
+            rng.random(),
+            0x00,
+            0xF0,
+            0xAA,
+        ];
         light
             .write(&cmd_char, &color_cmd, WriteType::WithoutResponse)
             .await?;

src/bluez/peripheral.rs

@@ -97,8 +97,7 @@ impl Peripheral {
     }
 
     fn characteristic_info(&self, characteristic: &Characteristic) -> Result<CharacteristicInfo> {
-        let services = self.services.lock()
-            .map_err(Into::<Error>::into)?;
+        let services = self.services.lock().map_err(Into::<Error>::into)?;
         get_characteristic(
             &services,
             &characteristic.service_uuid,
@@ -109,8 +108,7 @@ impl Peripheral {
     }
 
     fn descriptor_info(&self, descriptor: &Descriptor) -> Result<DescriptorInfo> {
-        let services = self.services.lock()
-            .map_err(Into::<Error>::into)?;
+        let services = self.services.lock().map_err(Into::<Error>::into)?;
         let characteristic = get_characteristic(
             &services,
             &descriptor.service_uuid,
@@ -224,8 +222,7 @@ impl api::Peripheral for Peripheral {
                 },
             );
         }
-        *(self.services.lock()
-            .map_err(Into::<Error>::into)?) = services_internal;
+        *(self.services.lock().map_err(Into::<Error>::into)?) = services_internal;
         Ok(())
     }
 

src/corebluetooth/peripheral.rs

@@ -213,7 +213,7 @@ impl api::Peripheral for Peripheral {
                 .properties
                 .lock()
                 .map_err(Into::<Error>::into)?
-                .clone()
+                .clone(),
         ))
     }
 
@@ -252,10 +252,7 @@ impl api::Peripheral for Peripheral {
             .await?;
         match fut.await {
             CoreBluetoothReply::Connected(services) => {
-                *(self.shared
-                    .services
-                    .lock()
-                    .map_err(Into::<Error>::into)?) = services;
+                *(self.shared.services.lock().map_err(Into::<Error>::into)?) = services;
                 self.shared
                     .emit_event(CentralEvent::DeviceConnected(self.shared.uuid.into()));
             }

src/droidplug/peripheral.rs

@@ -218,8 +218,7 @@ impl api::Peripheral for Peripheral {
     }
 
     async fn properties(&self) -> Result<Option<PeripheralProperties>> {
-        let guard = self.shared.lock()
-            .map_err(Into::<Error>::into)?;
+        let guard = self.shared.lock().map_err(Into::<Error>::into)?;
         Ok((&guard.properties).clone())
     }
 
@@ -305,8 +304,7 @@ impl api::Peripheral for Peripheral {
                     characteristics,
                 })
             }
-            let mut guard = self.shared.lock()
-                .map_err(Into::<Error>::into)?;
+            let mut guard = self.shared.lock().map_err(Into::<Error>::into)?;
             guard.services = BTreeSet::from_iter(peripheral_services.clone());
             guard.characteristics = BTreeSet::from_iter(peripheral_characteristics.clone());
             Ok(())

src/winrtble/adapter.rs

@@ -87,8 +87,7 @@ impl Central for Adapter {
     }
 
     async fn start_scan(&self, filter: ScanFilter) -> Result<()> {
-        let watcher = self.watcher.lock()
-            .map_err(Into::<Error>::into)?;
+        let watcher = self.watcher.lock().map_err(Into::<Error>::into)?;
         let manager = self.manager.clone();
         watcher.start(
             filter,
@@ -110,8 +109,7 @@ impl Central for Adapter {
     }
 
     async fn stop_scan(&self) -> Result<()> {
-        let watcher = self.watcher.lock()
-            .map_err(Into::<Error>::into)?;
+        let watcher = self.watcher.lock().map_err(Into::<Error>::into)?;
         watcher.stop()?;
         Ok(())
     }

src/winrtble/ble/characteristic.rs

@@ -19,8 +19,9 @@ use crate::{
 };
 
 use log::{debug, trace};
-use std::{future::IntoFuture, collections::HashMap};
+use std::{collections::HashMap, future::IntoFuture};
 use uuid::Uuid;
+use windows::core::Ref;
 use windows::{
     Devices::Bluetooth::{
         BluetoothCacheMode,
@@ -32,7 +33,6 @@ use windows::{
     Foundation::TypedEventHandler,
     Storage::Streams::{DataReader, DataWriter},
 };
-use windows::core::Ref;
 
 pub type NotifiyEventHandler = Box<dyn Fn(Vec<u8>) + Send>;
 

src/winrtble/ble/device.rs

@@ -41,7 +41,9 @@ impl BLEDevice {
     ) -> Result<Self> {
         let async_op = BluetoothLEDevice::FromBluetoothAddressAsync(address.into())
             .map_err(|_| Error::DeviceNotFound)?;
-        let device = async_op.into_future().await
+        let device = async_op
+            .into_future()
+            .await
             .map_err(|_| Error::DeviceNotFound)?;
         let connection_status_handler =
             TypedEventHandler::new(move |sender: Ref<BluetoothLEDevice>, _| {
@@ -76,8 +78,7 @@ impl BLEDevice {
             .device
             .GetGattServicesWithCacheModeAsync(cache_mode)
             .map_err(winrt_error)?;
-        let service_result = async_op.into_future().await
-            .map_err(winrt_error)?;
+        let service_result = async_op.into_future().await.map_err(winrt_error)?;
         Ok(service_result)
     }
 

src/winrtble/ble/watcher.rs

@@ -12,9 +12,10 @@
 // Copyright (c) 2014 The Rust Project Developers
 
 use crate::{api::ScanFilter, Error, Result};
-use windows::{Devices::Bluetooth::Advertisement::*, core::Ref, Foundation::TypedEventHandler};
+use windows::{core::Ref, Devices::Bluetooth::Advertisement::*, Foundation::TypedEventHandler};
 
-pub type AdvertisementEventHandler = Box<dyn Fn(&BluetoothLEAdvertisementReceivedEventArgs)-> windows::core::Result<()> + Send>;
+pub type AdvertisementEventHandler =
+    Box<dyn Fn(&BluetoothLEAdvertisementReceivedEventArgs) -> windows::core::Result<()> + Send>;
 
 #[derive(Debug)]
 pub struct BLEWatcher {
@@ -36,15 +37,11 @@ impl BLEWatcher {
 
     pub fn start(&self, filter: ScanFilter, on_received: AdvertisementEventHandler) -> Result<()> {
         let ScanFilter { services } = filter;
-        let ad = self
-            .watcher
-            .AdvertisementFilter()?
-            .Advertisement()?;
+        let ad = self.watcher.AdvertisementFilter()?.Advertisement()?;
         let ad_services = ad.ServiceUuids()?;
         ad_services.Clear()?;
         for service in services {
-            ad_services
-                .Append(windows::core::GUID::from(service.as_u128()))?;
+            ad_services.Append(windows::core::GUID::from(service.as_u128()))?;
         }
         self.watcher
             .SetScanningMode(BluetoothLEScanningMode::Active)?;

src/winrtble/manager.rs

@@ -13,8 +13,8 @@
 
 use super::adapter::Adapter;
 use crate::{api, Result};
-use std::future::IntoFuture;
 use async_trait::async_trait;
+use std::future::IntoFuture;
 use windows::Devices::Radios::{Radio, RadioKind};
 
 /// Implementation of [api::Manager](crate::api::Manager).
@@ -32,8 +32,7 @@ impl api::Manager for Manager {
     type Adapter = Adapter;
 
     async fn adapters(&self) -> Result<Vec<Adapter>> {
-        let radios = Radio::GetRadiosAsync()?
-            .into_future().await?;
+        let radios = Radio::GetRadiosAsync()?.into_future().await?;
         radios
             .into_iter()
             .filter(|radio| radio.Kind() == Ok(RadioKind::Bluetooth))