wongzigii · March 15, 2021 02:49 · Jan 2, 2017 · Jan 2, 2017 · Jan 2, 2017 · Jan 2, 2017
diff --git a/debounce.swift b/debounce.swift
@@ -7,7 +7,7 @@ extension OperationQueue {
     ///   - underlyingQueue: An optional background queue to run the function
     ///   - action: The function to debounce.
     /// - Returns: Returns the new debounced function.
-    static func debounce(delay: TimeInterval, underlyingQueue: DispatchQueue? = nil, action: @escaping () -> Void) -> (() -> Void) {
+    open class func debounce(delay: TimeInterval, underlyingQueue: DispatchQueue? = nil, action: @escaping () -> Void) -> (() -> Void) {
         // Init a new serial queue
         let queue = OperationQueue()
         queue.maxConcurrentOperationCount = 1

diff --git a/debounce.swift b/debounce.swift
@@ -19,13 +19,13 @@ extension OperationQueue {
 
         return {
             // Check if the first not cancelled or finished operation is executing
-            var isExecuting = true
+            var isExecuting = false
             for op in queue.operations {
                 if op.isFinished || op.isCancelled {
                     continue
                 }
 
-                isExecuting = op.name == actionOpName
+                isExecuting = op.isExecuting && op.name == actionOpName
                 break
             }
             // print("isExecuting: \(isExecuting), count: \(queue.operations.count)")

diff --git a/debounce.swift b/debounce.swift
@@ -6,6 +6,7 @@ extension OperationQueue {
     ///   - delay: The number of seconds to delay.
     ///   - underlyingQueue: An optional background queue to run the function
     ///   - action: The function to debounce.
+    /// - Returns: Returns the new debounced function.
     static func debounce(delay: TimeInterval, underlyingQueue: DispatchQueue? = nil, action: @escaping () -> Void) -> (() -> Void) {
         // Init a new serial queue
         let queue = OperationQueue()

diff --git a/debounce.swift b/debounce.swift
@@ -1,14 +1,23 @@
 extension OperationQueue {
+
+    /// Creates a debounced function that delays invoking `action` until after `delay` seconds have elapsed since the last time the debounced function was invoked.
+    ///
+    /// - Parameters:
+    ///   - delay: The number of seconds to delay.
+    ///   - underlyingQueue: An optional background queue to run the function
+    ///   - action: The function to debounce.
     static func debounce(delay: TimeInterval, underlyingQueue: DispatchQueue? = nil, action: @escaping () -> Void) -> (() -> Void) {
+        // Init a new serial queue
         let queue = OperationQueue()
         queue.maxConcurrentOperationCount = 1
         queue.underlyingQueue = underlyingQueue
 
-        let sleepOpName = "__SleepOp"
-        let actionOpName = "__ActionOp"
+        let sleepOpName = "__SleepOp"   // Sleep operation name
+        let actionOpName = "__ActionOp" // Action operation name
 
 
         return {
+            // Check if the first not cancelled or finished operation is executing
             var isExecuting = true
             for op in queue.operations {
                 if op.isFinished || op.isCancelled {

diff --git a/gistfile1.txt → debounce.swift b/gistfile1.txt → debounce.swift
diff --git a/gistfile1.txt b/gistfile1.txt
@@ -0,0 +1,61 @@
+extension OperationQueue {
+    static func debounce(delay: TimeInterval, underlyingQueue: DispatchQueue? = nil, action: @escaping () -> Void) -> (() -> Void) {
+        let queue = OperationQueue()
+        queue.maxConcurrentOperationCount = 1
+        queue.underlyingQueue = underlyingQueue
+
+        let sleepOpName = "__SleepOp"
+        let actionOpName = "__ActionOp"
+
+
+        return {
+            var isExecuting = true
+            for op in queue.operations {
+                if op.isFinished || op.isCancelled {
+                    continue
+                }
+
+                isExecuting = op.name == actionOpName
+                break
+            }
+            // print("isExecuting: \(isExecuting), count: \(queue.operations.count)")
+            if !isExecuting {
+                queue.cancelAllOperations()
+            }
+
+            let sleepOp = BlockOperation(block: {
+                Thread.sleep(forTimeInterval: delay)
+            })
+            sleepOp.name = sleepOpName
+
+            let actionOp = BlockOperation(block: {
+                action()
+            })
+
+            actionOp.name = actionOpName
+
+            queue.addOperation(sleepOp)
+            queue.addOperation(actionOp)
+        }
+    }
+}
+
+func testDebounce() {
+    var gi = 0
+    let queue = DispatchQueue.global(qos: .default)
+    let debounced = OperationQueue.debounce(delay: 0.2, underlyingQueue: queue) {
+        print("Fired: \(gi)")
+    }
+
+    for i in 0...9 {
+        let r = Double(Int(arc4random()) % 2)
+        let s = 0.1 + (0.2 * r)
+        print("Run: \(i) (sleep for \(s)s)")
+
+        gi = i
+        debounced()
+        Thread.sleep(forTimeInterval: s)
+    }
+}
+
+testDebounce()