chore: run rustfmt

Author: qdot

examples/event_driven_discovery.rs

@@ -2,7 +2,7 @@
 // Big Sur or later.
 
 use btleplug::api::{
-    bleuuid::BleUuid, Central, CentralEvent, Manager as _, Peripheral, ScanFilter,
+    Central, CentralEvent, Manager as _, Peripheral, ScanFilter, bleuuid::BleUuid,
 };
 use btleplug::platform::{Adapter, Manager};
 use futures::stream::StreamExt;

examples/lights.rs

@@ -2,10 +2,10 @@
 // Big Sur or later.
 
 use btleplug::api::{
-    bleuuid::uuid_from_u16, Central, Manager as _, Peripheral as _, ScanFilter, WriteType,
+    Central, Manager as _, Peripheral as _, ScanFilter, WriteType, bleuuid::uuid_from_u16,
 };
 use btleplug::platform::{Adapter, Manager, Peripheral};
-use rand::{rng, RngExt};
+use rand::{RngExt, rng};
 use std::time::Duration;
 use uuid::Uuid;
 

src/bluez/manager.rs

@@ -1,5 +1,5 @@
 use super::adapter::Adapter;
-use crate::{api, Result};
+use crate::{Result, api};
 use async_trait::async_trait;
 use bluez_async::BluetoothSession;
 

src/common/adapter_manager.rs

@@ -13,7 +13,7 @@
 // Copyright (c) 2014 The Rust Project Developers
 use crate::api::{CentralEvent, Peripheral};
 use crate::platform::PeripheralId;
-use dashmap::{mapref::one::RefMut, DashMap};
+use dashmap::{DashMap, mapref::one::RefMut};
 use futures::stream::{Stream, StreamExt};
 use log::trace;
 use std::pin::Pin;

src/corebluetooth/adapter.rs

@@ -1,6 +1,6 @@
 use super::internal::{
-    run_corebluetooth_thread, CoreBluetoothEvent, CoreBluetoothMessage, CoreBluetoothReply,
-    CoreBluetoothReplyFuture,
+    CoreBluetoothEvent, CoreBluetoothMessage, CoreBluetoothReply, CoreBluetoothReplyFuture,
+    run_corebluetooth_thread,
 };
 use super::peripheral::{Peripheral, PeripheralId};
 use crate::api::{Central, CentralEvent, CentralState, ScanFilter};

src/corebluetooth/central_delegate.rs

@@ -22,13 +22,13 @@ use futures::channel::mpsc::Sender;
 use futures::sink::SinkExt;
 use log::{error, trace};
 use objc2::runtime::{AnyObject, ProtocolObject};
-use objc2::{declare_class, msg_send_id, mutability, rc::Retained, ClassType, DeclaredClass};
+use objc2::{ClassType, DeclaredClass, declare_class, msg_send_id, mutability, rc::Retained};
 use objc2_core_bluetooth::{
     CBAdvertisementDataLocalNameKey, CBAdvertisementDataManufacturerDataKey,
     CBAdvertisementDataServiceDataKey, CBAdvertisementDataServiceUUIDsKey,
-    CBAdvertisementDataTxPowerLevelKey, CBCentralManager,
-    CBCentralManagerDelegate, CBCharacteristic, CBDescriptor, CBManagerState, CBPeripheral,
-    CBPeripheralDelegate, CBService, CBUUID,
+    CBAdvertisementDataTxPowerLevelKey, CBCentralManager, CBCentralManagerDelegate,
+    CBCharacteristic, CBDescriptor, CBManagerState, CBPeripheral, CBPeripheralDelegate, CBService,
+    CBUUID,
 };
 use objc2_foundation::{
     NSArray, NSData, NSDictionary, NSError, NSNumber, NSObject, NSObjectProtocol, NSString,
@@ -936,11 +936,14 @@ fn get_descriptor_value(descriptor: &CBDescriptor) -> Vec<u8> {
 
 fn peripheral_debug(peripheral: &CBPeripheral) -> String {
     let uuid = unsafe { peripheral.identifier() }.UUIDString();
-    match unsafe { peripheral.name() } { Some(name) => {
-        format!("CBPeripheral({}, {})", name, uuid)
-    } _ => {
-        format!("CBPeripheral({})", uuid)
-    }}
+    match unsafe { peripheral.name() } {
+        Some(name) => {
+            format!("CBPeripheral({}, {})", name, uuid)
+        }
+        _ => {
+            format!("CBPeripheral({})", uuid)
+        }
+    }
 }
 
 fn service_debug(service: &CBService) -> String {

src/corebluetooth/internal.rs

@@ -17,14 +17,14 @@ use super::{
         nsuuid_to_uuid,
     },
 };
-use crate::api::{CharPropFlags, Characteristic, Descriptor, ScanFilter, Service, WriteType};
 use crate::Error;
+use crate::api::{CharPropFlags, Characteristic, Descriptor, ScanFilter, Service, WriteType};
 use futures::channel::mpsc::{self, Receiver, Sender};
 use futures::select;
 use futures::sink::SinkExt;
 use futures::stream::{Fuse, StreamExt};
 use log::{error, trace, warn};
-use objc2::{msg_send_id, ClassType};
+use objc2::{ClassType, msg_send_id};
 use objc2::{rc::Retained, runtime::AnyObject};
 use objc2_core_bluetooth::{
     CBCentralManager, CBCentralManagerScanOptionAllowDuplicatesKey, CBCharacteristic,
@@ -566,8 +566,7 @@ impl CoreBluetoothInternal {
     ) {
         trace!(
             "Got manufacturer data advertisement! {}: {:?}",
-            manufacturer_id,
-            manufacturer_data
+            manufacturer_id, manufacturer_data
         );
         if let Some(p) = self.peripherals.get_mut(&peripheral_uuid) {
             if let Err(e) = p
@@ -703,8 +702,7 @@ impl CoreBluetoothInternal {
     ) {
         trace!(
             "Found characteristics for peripheral {} service {}:",
-            peripheral_uuid,
-            service_uuid
+            peripheral_uuid, service_uuid
         );
         for id in characteristics.keys() {
             trace!("{}", id);
@@ -723,9 +721,7 @@ impl CoreBluetoothInternal {
     ) {
         trace!(
             "Found descriptors for peripheral {} service {} characteristic {}:",
-            peripheral_uuid,
-            service_uuid,
-            characteristic_uuid,
+            peripheral_uuid, service_uuid, characteristic_uuid,
         );
         for id in descriptors.keys() {
             trace!("{}", id);
@@ -1048,16 +1044,28 @@ impl CoreBluetoothInternal {
                                 CBCharacteristicWriteType::CBCharacteristicWriteWithoutResponse,
                             );
                         }
-                        pending.fut.lock().unwrap().set_reply(CoreBluetoothReply::Ok);
+                        pending
+                            .fut
+                            .lock()
+                            .unwrap()
+                            .set_reply(CoreBluetoothReply::Ok);
                     } else {
-                        pending.fut.lock().unwrap().set_reply(CoreBluetoothReply::Err(
-                            "Characteristic no longer available".into(),
-                        ));
+                        pending
+                            .fut
+                            .lock()
+                            .unwrap()
+                            .set_reply(CoreBluetoothReply::Err(
+                                "Characteristic no longer available".into(),
+                            ));
                     }
                 } else {
-                    pending.fut.lock().unwrap().set_reply(CoreBluetoothReply::Err(
-                        "Service no longer available".into(),
-                    ));
+                    pending
+                        .fut
+                        .lock()
+                        .unwrap()
+                        .set_reply(CoreBluetoothReply::Err(
+                            "Service no longer available".into(),
+                        ));
                 }
             }
         }
@@ -1187,11 +1195,7 @@ impl CoreBluetoothInternal {
         }
     }
 
-    fn read_rssi(
-        &mut self,
-        peripheral_uuid: Uuid,
-        fut: CoreBluetoothReplyStateShared,
-    ) {
+    fn read_rssi(&mut self, peripheral_uuid: Uuid, fut: CoreBluetoothReplyStateShared) {
         if let Some(peripheral) = self.peripherals.get_mut(&peripheral_uuid) {
             trace!("Reading RSSI!");
             unsafe {

src/corebluetooth/manager.rs

@@ -6,7 +6,7 @@
 // for full license information.
 
 use super::adapter::Adapter;
-use crate::{api, Result};
+use crate::{Result, api};
 use async_trait::async_trait;
 
 /// Implementation of [api::Manager](crate::api::Manager).

src/corebluetooth/peripheral.rs

@@ -9,12 +9,12 @@ use super::internal::{
     CoreBluetoothMessage, CoreBluetoothReply, CoreBluetoothReplyFuture, PeripheralEventInternal,
 };
 use crate::{
+    Error, Result,
     api::{
         self, BDAddr, CentralEvent, CharPropFlags, Characteristic, Descriptor,
         PeripheralProperties, Service, ValueNotification, WriteType,
     },
     common::{adapter_manager::AdapterManager, util::notifications_stream_from_broadcast_receiver},
-    Error, Result,
 };
 use async_trait::async_trait;
 use futures::channel::mpsc::{Receiver, SendError, Sender};
@@ -31,7 +31,7 @@ use std::{
     collections::{BTreeSet, HashMap},
     fmt::{self, Debug, Display, Formatter},
     pin::Pin,
-    sync::{atomic::AtomicU16, Arc, Mutex},
+    sync::{Arc, Mutex, atomic::AtomicU16},
 };
 use tokio::sync::broadcast;
 use tokio::task;
@@ -72,11 +72,14 @@ struct Shared {
 
 impl Shared {
     fn emit_event(&self, event: CentralEvent) {
-        match self.manager.upgrade() { Some(manager) => {
-            manager.emit(event);
-        } _ => {
-            trace!("Could not emit an event. AdapterManager has been dropped");
-        }}
+        match self.manager.upgrade() {
+            Some(manager) => {
+                manager.emit(event);
+            }
+            _ => {
+                trace!("Could not emit an event. AdapterManager has been dropped");
+            }
+        }
     }
 }
 

src/corebluetooth/utils/mod.rs

@@ -27,9 +27,11 @@ pub fn nsuuid_to_uuid(uuid: &NSUUID) -> Uuid {
     uuid.UUIDString().to_string().parse().unwrap()
 }
 
-pub unsafe fn nsstring_to_string(nsstring: *const NSString) -> Option<String> { unsafe {
-    nsstring
-        .as_ref()
-        .and_then(|ns| CStr::from_ptr(ns.UTF8String()).to_str().ok())
-        .map(String::from)
-}}
+pub unsafe fn nsstring_to_string(nsstring: *const NSString) -> Option<String> {
+    unsafe {
+        nsstring
+            .as_ref()
+            .and_then(|ns| CStr::from_ptr(ns.UTF8String()).to_str().ok())
+            .map(String::from)
+    }
+}