     public func unregisterAll() {
         
         notifyList.removeAll()
+        
         disconnectList.removeAll()
     }
     
     /// Adds a PDU to the queue to send.
     ///
     /// - Returns: Identifier of queued send operation or `nil` if the PDU cannot be sent.
-    public func send<T: ATTProtocolDataUnit>(PDU: T, response: ATTResponseCallback? = nil) -> UInt? {
+    public func send<T: ATTProtocolDataUnit>(PDU: T, response: T -> ()) -> UInt? {
         
         let attributeOpcode = T.attributeOpcode
         
         let type = attributeOpcode.type
-        
-        /* If the opcode corresponds to an operation type that does not elicit a
-        * response from the remote end, then no callback should have been
-        * provided, since it will never be called.
-        */
-        guard (response != nil && type != .Request && type != .Response) == false
-            else { return nil }
-        
-        /* Similarly, if the operation does elicit a response then a callback
-        * must be provided.
-        */
-        guard (response == nil && (type == .Request || type == .Indication)) == false
-            else { return nil }
         
         guard let encodedPDU = encodePDU(PDU)
             else { return nil }
         
         let identifier = nextSendOpcodeID
         
-        let sendOpcode = ATTSendOpcode(identifier: identifier, opcode: attributeOpcode, PDU: encodedPDU, response: response)
+        let sendOpcode = ATTSendOpcode(identifier: identifier, opcode: attributeOpcode, data: encodedPDU, response: response)
         
         // increment ID
         nextSendOpcodeID += 1

            else { return false }
    }*/
    
    private func pickNextSendOpcode() -> ATTSendOpcode? {
        
        // See if any operations are already in the write queue
        if let sendOpcode = writeQueue.popFirst() {

    // MARK: - Methods
    
    /// Performs the actual IO for recieving data.
    public func read() throws {
        
        let recievedData = try self.socket.recieve(maximumTransmissionUnit)
        
        // valid PDU data length
        guard recievedData.byteValue.count >= ATT.MinimumPDULength
            else { throw Error.GarbageResponse(recievedData) }
        
        let opcodeByte = recievedData.byteValue[0]
        
        // valid opcode
        guard let opcode = ATT.Opcode(rawValue: opcodeByte)
            else { throw Error.GarbageResponse(recievedData) }
        
        // Act on the received PDU based on the opcode type
        switch opcode.type {
            
        case .Response: try handleResponse(recievedData, opcode: opcode)
        }
        
        
