import CoreBluetooth
            class BLEManager: NSObject, CBCentralManagerDelegate, CBPeripheralDelegate {
                var centralManager: CBCentralManager!
                var discoveredPeripheral: CBPeripheral?
                override init() {
                    super.init()
                    centralManager = CBCentralManager(delegate: self, queue: nil)
                }
                func centralManagerDidUpdateState(_ central: CBCentralManager) {
                    if central.state == .poweredOn {
                        // Start scanning for peripherals
                        centralManager.scanForPeripherals(withServices: nil, options: nil)
                    }
                }
                func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {
                    // Cache the peripheral
                    discoveredPeripheral = peripheral
                    centralManager.connect(peripheral, options: nil)
                }
                func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
                    peripheral.delegate = self
                    // Discover services after connecting
                    peripheral.discoverServices(nil)
                }
                func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
                    for service in peripheral.services! {
                        peripheral.discoverCharacteristics(nil, for: service)
                    }
                }
                func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
                    for characteristic in service.characteristics! {
                        // Set notification or read value
                        peripheral.setNotifyValue(true, for: characteristic)
                        peripheral.readValue(for: characteristic)
                    }
                }
                func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
                    if let data = characteristic.value {
                        // Process the data received from the characteristic
                        print("Received data: \(data)")
                    }
                }
            }
        
    
													How do I avoid rehashing overhead with std::set in multithreaded code?
														
													How do I find elements with custom comparators with std::set for embedded targets?
														
													How do I erase elements while iterating with std::set for embedded targets?
														
													How do I provide stable iteration order with std::unordered_map for large datasets?
														
													How do I reserve capacity ahead of time with std::unordered_map for large datasets?
														
													How do I erase elements while iterating with std::unordered_map in multithreaded code?
														
													How do I provide stable iteration order with std::map for embedded targets?
														
													How do I provide stable iteration order with std::map in multithreaded code?
														
													How do I avoid rehashing overhead with std::map in performance-sensitive code?
														
													How do I merge two containers efficiently with std::map for embedded targets?