Improve _Atomic.

Author: inamiy

SwiftTask/_Atomic.swift

@@ -13,49 +13,42 @@ internal final class _Atomic<T>
     private var _spinlock = OS_SPINLOCK_INIT
     private var _rawValue: T
 
-    internal var rawValue: T
-    {
-        get {
-            self._lock()
-            let rawValue = self._rawValue
-            self._unlock()
-            
-            return rawValue
-        }
-        
-        set(newValue) {
-            self._lock()
-            self._rawValue = newValue
-            self._unlock()
-        }
-    }
-    
     internal init(_ rawValue: T)
     {
         self._rawValue = rawValue
     }
 
-    internal func update(f: T -> T) -> T
+    internal func withRawValue<U>(@noescape f: T -> U) -> U
     {
         self._lock()
-        let oldValue = self._rawValue
-        self._rawValue = f(oldValue)
-        self._unlock()
+        defer { self._unlock() }
 
-        return oldValue
+        return f(self._rawValue)
+    }
+    
+    internal func update(@noescape f: T -> T) -> T
+    {
+        return self.updateIf { f($0) }!
     }
 
-    internal func tryUpdate(f: T -> (T, Bool)) -> (T, Bool)
+    internal func updateIf(@noescape f: T -> T?) -> T?
+    {
+        return self.modify { value in f(value).map { ($0, value) } }
+    }
+    
+    internal func modify<U>(@noescape f: T -> (T, U)?) -> U?
     {
         self._lock()
+        defer { self._unlock() }
+        
         let oldValue = self._rawValue
-        let (newValue, shouldUpdate) = f(oldValue)
-        if shouldUpdate {
+        if let (newValue, retValue) = f(oldValue) {
             self._rawValue = newValue
+            return retValue
+        }
+        else {
+            return nil
         }
-        self._unlock()
-        
-        return (oldValue, shouldUpdate)
     }
 
     private func _lock()
@@ -69,6 +62,31 @@ internal final class _Atomic<T>
     }
 }
 
+extension _Atomic: RawRepresentable
+{
+    internal convenience init(rawValue: T)
+    {
+        self.init(rawValue)
+    }
+    
+    internal var rawValue: T
+    {
+        get {
+            self._lock()
+            defer { self._unlock() }
+            
+            return self._rawValue
+        }
+        
+        set(newValue) {
+            self._lock()
+            defer { self._unlock() }
+            
+            self._rawValue = newValue
+        }
+    }
+}
+
 extension _Atomic: CustomStringConvertible
 {
     internal var description: String

SwiftTask/_StateMachine.swift

@@ -124,8 +124,8 @@ internal class _StateMachine<Progress, Value, Error>
         self._lock.lock()
         defer { self._lock.unlock() }
 
-        let (_, updated) = self.state.tryUpdate { $0 == .Running ? (.Fulfilled, true) : ($0, false) }
-        if updated {
+        let newState = self.state.updateIf { $0 == TaskState.Running ? .Fulfilled : nil }
+        if let _ = newState {
             self.value.rawValue = value
             self._finish()
         }
@@ -137,8 +137,8 @@ internal class _StateMachine<Progress, Value, Error>
         defer { self._lock.unlock() }
 
         let toState = errorInfo.isCancelled ? TaskState.Cancelled : .Rejected
-        let (_, updated) = self.state.tryUpdate { $0 == .Running || $0 == .Paused ? (toState, true) : ($0, false) }
-        if updated {
+        let newState = self.state.updateIf { $0 == TaskState.Running || $0 == .Paused ? toState : nil }
+        if let _ = newState {
             self.errorInfo.rawValue = errorInfo
             self._finish()
         }
@@ -149,8 +149,8 @@ internal class _StateMachine<Progress, Value, Error>
         self._lock.lock()
         defer { self._lock.unlock() }
 
-        let (_, updated) = self.state.tryUpdate { $0 == .Running ? (.Paused, true) : ($0, false) }
-        if updated {
+        let newState = self.state.updateIf { $0 == TaskState.Running ? .Paused : nil }
+        if let _ = newState {
             self.configuration.pause?()
             return true
         }
@@ -193,8 +193,8 @@ internal class _StateMachine<Progress, Value, Error>
 
     private func _handleResume() -> Bool
     {
-        let (_, updated) = self.state.tryUpdate { $0 == .Paused ? (.Running, true) : ($0, false) }
-        if updated {
+        let newState = self.state.updateIf { $0 == TaskState.Paused ? .Running : nil }
+        if let _ = newState {
             self.configuration.resume?()
             return true
         }
@@ -208,8 +208,8 @@ internal class _StateMachine<Progress, Value, Error>
         self._lock.lock()
         defer { self._lock.unlock() }
 
-        let (_, updated) = self.state.tryUpdate { $0 == .Running || $0 == .Paused ? (.Cancelled, true) : ($0, false) }
-        if updated {
+        let newState = self.state.updateIf { $0 == TaskState.Running || $0 == .Paused ? .Cancelled : nil }
+        if let _ = newState {
             self.errorInfo.rawValue = ErrorInfo(error: error, isCancelled: true)
             self._finish()
             return true