boudhayan · June 6, 2017 10:27 · Apr 11, 2017 · Apr 10, 2017 · Dec 8, 2016 · Dec 8, 2016
diff --git a/ConcurrentOperation.swift → AsynchronousOperation.swift b/ConcurrentOperation.swift → AsynchronousOperation.swift
diff --git a/ConcurrentOperation.swift b/ConcurrentOperation.swift
@@ -4,7 +4,7 @@ import Foundation
 /// Subclasses must implement `execute()` to perform any work and call
 /// `finish()` when they are done. All `NSOperation` work will be handled
 /// automatically.
-open class Operation: Foundation.Operation {
+open class AsynchronousOperation: Operation {
 
     // MARK: - Properties
 
@@ -38,6 +38,10 @@ open class Operation: Foundation.Operation {
     public final override var isFinished: Bool {
         return state == .finished
     }
+
+    public final override var isAsynchronous: Bool {
+        return true
+    }
 
 
     // MARK: - NSObject

diff --git a/ConcurrentOperation.swift b/ConcurrentOperation.swift
@@ -8,7 +8,9 @@ open class Operation: Foundation.Operation {
 
     // MARK: - Properties
 
-    private let stateQueue = DispatchQueue(label: "com.calebd.operation.state")
+    private let stateQueue = DispatchQueue(
+        label: "com.calebd.operation.state",
+        attributes: .concurrent)
 
     private var rawState = OperationState.ready
 
@@ -18,7 +20,9 @@ open class Operation: Foundation.Operation {
         }
         set {
             willChangeValue(forKey: "state")
-            stateQueue.sync(execute: { rawState = newValue })
+            stateQueue.sync(
+                flags: .barrier,
+                execute: { rawState = newValue })
             didChangeValue(forKey: "state")
         }
     }

diff --git a/ConcurrentOperation.swift b/ConcurrentOperation.swift
@@ -71,7 +71,9 @@ open class Operation: Foundation.Operation {
     /// Subclasses must implement this to perform their work and they must not
     /// call `super`. The default implementation of this function throws an
     /// exception.
-    open func execute() {}
+    open func execute() {
+        fatalError("Subclasses must implement `execute`.")
+    }
 
     /// Call this function after any work is done or after a call to `cancel()`
     /// to move the operation into a completed state.

diff --git a/ConcurrentOperation.swift b/ConcurrentOperation.swift
@@ -8,7 +8,7 @@ open class Operation: Foundation.Operation {
 
     // MARK: - Properties
 
-    private let stateQueue = DispatchQueue(label: "com.courtneycircle.radiant.operation.state")
+    private let stateQueue = DispatchQueue(label: "com.calebd.operation.state")
 
     private var rawState = OperationState.ready
 

diff --git a/ConcurrentOperation.swift b/ConcurrentOperation.swift
@@ -1,60 +1,87 @@
-//
-//  ConcurrentOperation.swift
-//
-//  Created by Caleb Davenport on 7/7/14.
-//
-//  Learn more at http://blog.calebd.me/swift-concurrent-operations
-//
-
 import Foundation
 
-class ConcurrentOperation: NSOperation {
-
-    // MARK: - Types
-
-    enum State {
-        case Ready, Executing, Finished
-        func keyPath() -> String {
-            switch self {
-            case Ready:
-                return "isReady"
-            case Executing:
-                return "isExecuting"
-            case Finished:
-                return "isFinished"
-            }
-        }
-    }
-
+/// An abstract class that makes building simple asynchronous operations easy.
+/// Subclasses must implement `execute()` to perform any work and call
+/// `finish()` when they are done. All `NSOperation` work will be handled
+/// automatically.
+open class Operation: Foundation.Operation {
+
     // MARK: - Properties
-
-    var state = State.Ready {
-        willSet {
-            willChangeValueForKey(newValue.keyPath())
-            willChangeValueForKey(state.keyPath())
+
+    private let stateQueue = DispatchQueue(label: "com.courtneycircle.radiant.operation.state")
+
+    private var rawState = OperationState.ready
+
+    @objc private dynamic var state: OperationState {
+        get {
+            return stateQueue.sync(execute: { rawState })
         }
-        didSet {
-            didChangeValueForKey(oldValue.keyPath())
-            didChangeValueForKey(state.keyPath())
+        set {
+            willChangeValue(forKey: "state")
+            stateQueue.sync(execute: { rawState = newValue })
+            didChangeValue(forKey: "state")
         }
     }
-
-    // MARK: - NSOperation
-
-    override var ready: Bool {
-        return super.ready && state == .Ready
+
+    public final override var isReady: Bool {
+        return state == .ready && super.isReady
+    }
+
+    public final override var isExecuting: Bool {
+        return state == .executing
     }
-    
-    override var executing: Bool {
-        return state == .Executing
+
+    public final override var isFinished: Bool {
+        return state == .finished
     }
-
-    override var finished: Bool {
-        return state == .Finished
+
+
+    // MARK: - NSObject
+
+    @objc private dynamic class func keyPathsForValuesAffectingIsReady() -> Set<String> {
+        return ["state"]
     }
-    
-    override var asynchronous: Bool {
-        return true
+
+    @objc private dynamic class func keyPathsForValuesAffectingIsExecuting() -> Set<String> {
+        return ["state"]
     }
-
+
+    @objc private dynamic class func keyPathsForValuesAffectingIsFinished() -> Set<String> {
+        return ["state"]
+    }
+
+
+    // MARK: - Foundation.Operation
+
+    public override final func start() {
+        super.start()
+
+        if isCancelled {
+            finish()
+            return
+        }
+
+        state = .executing
+        execute()
+    }
+
+
+    // MARK: - Public
+
+    /// Subclasses must implement this to perform their work and they must not
+    /// call `super`. The default implementation of this function throws an
+    /// exception.
+    open func execute() {}
+
+    /// Call this function after any work is done or after a call to `cancel()`
+    /// to move the operation into a completed state.
+    public final func finish() {
+        state = .finished
+    }
+}
+
+@objc private enum OperationState: Int {
+    case ready
+    case executing
+    case finished
 }
diff --git a/ConcurrentOperation.swift b/ConcurrentOperation.swift
@@ -42,7 +42,7 @@ class ConcurrentOperation: NSOperation {
     // MARK: - NSOperation
 
     override var ready: Bool {
-        return state == .Ready
+        return super.ready && state == .Ready
     }
 
     override var executing: Bool {

diff --git a/ConcurrentOperation.swift b/ConcurrentOperation.swift
@@ -28,7 +28,7 @@ class ConcurrentOperation: NSOperation {
 
     // MARK: - Properties
 
-    var state: State {
+    var state = State.Ready {
         willSet {
             willChangeValueForKey(newValue.keyPath())
             willChangeValueForKey(state.keyPath())
@@ -39,13 +39,6 @@ class ConcurrentOperation: NSOperation {
         }
     }
 
-    // MARK: - Initializers
-
-    init() {
-        state = State.Ready
-        super.init()
-    }
-
     // MARK: - NSOperation
 
     override var ready: Bool {

diff --git a/ConcurrentOperation.swift b/ConcurrentOperation.swift
@@ -64,4 +64,4 @@ class ConcurrentOperation: NSOperation {
         return true
     }
 
-}
+}
diff --git a/ConcurrentOperation.swift b/ConcurrentOperation.swift
@@ -60,7 +60,7 @@ class ConcurrentOperation: NSOperation {
         return state == .Finished
     }
 
-    override var concurrent: Bool {
+    override var asynchronous: Bool {
         return true
     }
 

diff --git a/gistfile1.txt → ConcurrentOperation.swift b/gistfile1.txt → ConcurrentOperation.swift
@@ -3,7 +3,7 @@
 //
 //  Created by Caleb Davenport on 7/7/14.
 //
-//  Learn more at <link>
+//  Learn more at http://blog.calebd.me/swift-concurrent-operations
 //
 
 import Foundation

diff --git a/gistfile1.txt b/gistfile1.txt
@@ -1,5 +1,5 @@
 //
-//  Operation.swift
+//  ConcurrentOperation.swift
 //
 //  Created by Caleb Davenport on 7/7/14.
 //
@@ -8,7 +8,7 @@
 
 import Foundation
 
-class Operation: NSOperation {
+class ConcurrentOperation: NSOperation {
 
     // MARK: - Types
 
@@ -60,4 +60,8 @@ class Operation: NSOperation {
         return state == .Finished
     }
 
+    override var concurrent: Bool {
+        return true
+    }
+
 }
diff --git a/gistfile1.txt b/gistfile1.txt
@@ -0,0 +1,63 @@
+//
+//  Operation.swift
+//
+//  Created by Caleb Davenport on 7/7/14.
+//
+//  Learn more at <link>
+//
+
+import Foundation
+
+class Operation: NSOperation {
+
+    // MARK: - Types
+
+    enum State {
+        case Ready, Executing, Finished
+        func keyPath() -> String {
+            switch self {
+            case Ready:
+                return "isReady"
+            case Executing:
+                return "isExecuting"
+            case Finished:
+                return "isFinished"
+            }
+        }
+    }
+
+    // MARK: - Properties
+
+    var state: State {
+        willSet {
+            willChangeValueForKey(newValue.keyPath())
+            willChangeValueForKey(state.keyPath())
+        }
+        didSet {
+            didChangeValueForKey(oldValue.keyPath())
+            didChangeValueForKey(state.keyPath())
+        }
+    }
+
+    // MARK: - Initializers
+
+    init() {
+        state = State.Ready
+        super.init()
+    }
+
+    // MARK: - NSOperation
+
+    override var ready: Bool {
+        return state == .Ready
+    }
+
+    override var executing: Bool {
+        return state == .Executing
+    }
+
+    override var finished: Bool {
+        return state == .Finished
+    }
+
+}
No results found