         public var isReadable : Bool {
             return cbCharacteristic?.properties.contains(CBCharacteristicProperties.read) ?? false
         }
-        
+
         public func read(_ completionHandler: @escaping ReadCompletionHandler) -> PeripheralStatus {
+            guard let characteristic = cbCharacteristic else { return .failure(.cbAttributeIsNil) }
+
             guard isReadable else { return .failure(.notReadable) }
 
             guard readCompletionHandler == nil else { return .failure(.readInProgress) }
-
-            guard let characteristic = cbCharacteristic else { return .failure(.cbAttributeIsNil) }
-
             readCompletionHandler = completionHandler
-
             parent.parent.cbPeripheral.readValue(for: characteristic)
 
             return .success
         }
         
         // The Central Manager will call this method when an asynchronous read has completed.
-        // The Central Manager will also call this method when a notification is received.
+        // The Central Manager also calls this method when a notification is received.
+        // AFAIK CoreBluetooth does not provide a way to distinguish between a read completed
+        // and a notification.
         //
-        // I wish that there were a way to distingush read completion from notification.
+        // If notifications are enabled then performing a read will result in the notification
+        // handler being invoked even though the peripheral has not produced a new value. This
+        // method takes steps to handle that situation.
         func readCompleted(_ value : Data?, cbError: Error?) {
-            guard readCompletionHandler != nil || notificationHandler != nil else {
-                fatalError("Read completed method invoked but both completion handlers are nil???")
-            }
-            
+
             let result: ReadResult
             if let error = cbError {
                 result = .failure(.characteristicReadError(self, cbError: error))

}

// TODO: Get rid of parent

extension CentralManager {


                result = .success(value!)
            }

            // TODO: Reconsider whether or not the following logic works if a read is issued
            // by the central "at the same time" that a notification is being produced by the
            // peripheral. The assumption is that two events will produced. Consider that the
            // timing is such that the read completion handler receives the notification data
            // and the notification handler receives the read result.
            if let handler = readCompletionHandler {
                readCompletionHandler = nil // Do this first so that the handler can initiate a new read if desired.
                handler(result)
            }
            else if let handler = notificationHandler {
                handler(result)
            }
            else {
                fatalError("Read completed method invoked but both completion handlers are nil???")
            }
        }
        
