Merge pull request #6 from novasamatech/feature/call-store

Added CancellableCallStore

Author: sergkononenko

Operation-iOS/Classes/Helpers/BaseOperationExtensions.swift

@@ -21,4 +21,22 @@ public extension BaseOperation {
             throw error
         }
     }
+    
+    func extractNoCancellableResultData() throws -> ResultType {
+        try extractResultData(throwing: BaseOperationError.parentOperationCancelled)
+    }
+}
+
+extension BaseOperation {
+    public static func createWithError(_ error: Error) -> BaseOperation<ResultType> {
+        let operation = BaseOperation<ResultType>()
+        operation.result = .failure(error)
+        return operation
+    }
+
+    public static func createWithResult(_ result: ResultType) -> BaseOperation<ResultType> {
+        let operation = BaseOperation<ResultType>()
+        operation.result = .success(result)
+        return operation
+    }
 }

Operation-iOS/Classes/Helpers/CancellableCallHelper.swift

@@ -0,0 +1,134 @@
+import Foundation
+
+public final class CancellableCallStore {
+    private var cancellableCall: CancellableCall?
+    
+    public init() {}
+
+    public var hasCall: Bool {
+        cancellableCall != nil
+    }
+
+    public func cancel() {
+        let copy = cancellableCall
+        cancellableCall = nil
+        copy?.cancel()
+    }
+
+    func store(call: CancellableCall) {
+        cancellableCall = call
+    }
+
+    func clear() {
+        cancellableCall = nil
+    }
+    
+    func clearIfMatches(call: CancellableCall) -> Bool {
+        guard matches(call: call) else {
+            return false
+        }
+
+        cancellableCall = nil
+
+        return true
+    }
+
+    func matches(call: CancellableCall) -> Bool {
+        cancellableCall === call
+    }
+}
+
+public func execute<T>(
+    wrapper: CompoundOperationWrapper<T>,
+    inOperationQueue operationQueue: OperationQueue,
+    runningCallbackIn callbackQueue: DispatchQueue?,
+    callbackClosure: @escaping (Result<T, Error>) -> Void
+) {
+    wrapper.targetOperation.completionBlock = {
+        dispatchInQueueWhenPossible(callbackQueue) {
+            do {
+                let value = try wrapper.targetOperation.extractNoCancellableResultData()
+                callbackClosure(.success(value))
+            } catch {
+                callbackClosure(.failure(error))
+            }
+        }
+    }
+
+    operationQueue.addOperations(wrapper.allOperations, waitUntilFinished: false)
+}
+
+public func executeCancellable<T>(
+    wrapper: CompoundOperationWrapper<T>,
+    inOperationQueue operationQueue: OperationQueue,
+    backingCallIn callStore: CancellableCallStore,
+    runningCallbackIn callbackQueue: DispatchQueue?,
+    mutex: NSLock? = nil,
+    callbackClosure: @escaping (Result<T, Error>) -> Void
+) {
+    wrapper.targetOperation.completionBlock = {
+        dispatchInQueueWhenPossible(callbackQueue, locking: mutex) {
+            guard callStore.clearIfMatches(call: wrapper) else {
+                return
+            }
+
+            do {
+                let value = try wrapper.targetOperation.extractNoCancellableResultData()
+                callbackClosure(.success(value))
+            } catch {
+                callbackClosure(.failure(error))
+            }
+        }
+    }
+
+    callStore.store(call: wrapper)
+
+    operationQueue.addOperations(wrapper.allOperations, waitUntilFinished: false)
+}
+
+public func execute<T>(
+    operation: BaseOperation<T>,
+    inOperationQueue operationQueue: OperationQueue,
+    runningCallbackIn callbackQueue: DispatchQueue?,
+    callbackClosure: @escaping (Result<T, Error>) -> Void
+) {
+    operation.completionBlock = {
+        dispatchInQueueWhenPossible(callbackQueue) {
+            do {
+                let value = try operation.extractNoCancellableResultData()
+                callbackClosure(.success(value))
+            } catch {
+                callbackClosure(.failure(error))
+            }
+        }
+    }
+
+    operationQueue.addOperations([operation], waitUntilFinished: false)
+}
+
+public func execute<T>(
+    operation: BaseOperation<T>,
+    inOperationQueue operationQueue: OperationQueue,
+    backingCallIn callStore: CancellableCallStore,
+    runningCallbackIn callbackQueue: DispatchQueue?,
+    callbackClosure: @escaping (Result<T, Error>) -> Void
+) {
+    operation.completionBlock = {
+        dispatchInQueueWhenPossible(callbackQueue) {
+            guard callStore.clearIfMatches(call: operation) else {
+                return
+            }
+
+            do {
+                let value = try operation.extractNoCancellableResultData()
+                callbackClosure(.success(value))
+            } catch {
+                callbackClosure(.failure(error))
+            }
+        }
+    }
+
+    callStore.store(call: operation)
+
+    operationQueue.addOperations([operation], waitUntilFinished: false)
+}

Operation-iOS/Classes/Helpers/DispatchQueueHelper.swift

@@ -1,9 +1,19 @@
 import Foundation
 
-func dispatchInQueueWhenPossible(_ queue: DispatchQueue?, block: @escaping () -> Void ) {
-    if let queue = queue {
-        queue.async(execute: block)
+public func dispatchInQueueWhenPossible(
+    _ queue: DispatchQueue?,
+    locking mutex: NSLock? = nil,
+    block: @escaping () -> Void
+) {
+    if let queue {
+        queue.async {
+            mutex?.lock()
+            block()
+            mutex?.unlock()
+        }
     } else {
+        mutex?.lock()
         block()
+        mutex?.unlock()
     }
 }

Operation-iOS/Classes/Operations/Base/BaseOperation.swift

@@ -194,3 +194,5 @@ open class BaseOperation<ResultType>: Operation {
         isFinished = true
     }
 }
+
+extension BaseOperation: CancellableCall {}