Swift 3.0, nouv, fixed null current loop

Author: dileping

RunLoop/CurrentRunLoop.swift

@@ -17,7 +17,7 @@
 import Foundation
 import Boilerplate
 
-public typealias RunLoopFactory = () -> RunLoopProtocol
+public typealias RunLoopFactory = () -> RunLoopProtocol?
 
 private class RunLoopData {
     private var _loop:RunLoopProtocol?
@@ -27,27 +27,32 @@ private class RunLoopData {
         self.factory = factory
     }
 
-    var loop:RunLoopProtocol {
+    var loop:RunLoopProtocol? {
         get {
             if nil == _loop {
                 _loop = factory()
             }
             // yes, it's always value
-            return _loop!
+            return _loop
         }
     }
 }
 
 private let _runLoopData = try! ThreadLocal<RunLoopData>()
 
-private func defaultRunLoopFactory() -> RunLoopProtocol {
-    return Thread.isMain ? RunLoop.main : RunLoop()
+private func defaultRunLoopFactory() -> RunLoopProtocol? {
+    if Thread.isMain {
+        return RunLoop.main
+    }
+    
+    return nil
 }
 
 public extension RunLoopProtocol {
-    public static var current:RunLoopProtocol {
+    public static var current:RunLoopProtocol? {
         get {
             var value = _runLoopData.value
+            
             if nil == value {
                 value = RunLoopData(factory: defaultRunLoopFactory)
                 _runLoopData.value = value

RunLoop/DispatchRunLoop.swift

@@ -85,6 +85,10 @@
             self.init(queue: queue)
         }
 
+        public class func makeSemaphore(value:Int?, loop:RunLoopProtocol?) -> SemaphoreProtocol {
+            return value.map({DispatchSemaphore(value: $0)}) ?? DispatchSemaphore()
+        }
+        
         public func semaphore() -> SemaphoreProtocol {
             return DispatchSemaphore()
         }

RunLoop/RunLoop.swift

@@ -24,8 +24,8 @@ public protocol Settled {
 public protocol RunLoopProtocol : NonStrictEquatable {
     init()
 
-    func semaphore() -> SemaphoreProtocol
-    func semaphore(value:Int) -> SemaphoreProtocol
+    //for private use
+    static func makeSemaphore(value:Int?, loop:RunLoopProtocol?) -> SemaphoreProtocol
 
     /// tries to execute before other tasks
     func urgent(task:SafeTask)
@@ -41,6 +41,16 @@ public protocol RunLoopProtocol : NonStrictEquatable {
     static var main:RunLoopProtocol {get}
 }
 
+public extension RunLoopProtocol {
+    static func semaphore(value:Int? = nil, loop:RunLoopProtocol? = RunLoop.current) -> SemaphoreProtocol {
+        guard let semaClass = loop.flatMap({type(of: $0)}) else {
+            return self.makeSemaphore(value: value, loop: loop)
+        }
+        
+        return semaClass.makeSemaphore(value: value, loop: loop)
+    }
+}
+
 public extension RunLoopProtocol {
     public static var reactive:Self.Type {
         get {

RunLoop/Semaphore.swift

@@ -134,15 +134,29 @@ func ==<T>(lhs:HashableAnyContainer<T>, rhs:HashableAnyContainer<T>) -> Bool {
 
 private enum Wakeable {
     case Loop(loop:RunnableRunLoopProtocol)
-    case Sema(loop:RunLoopProtocol, sema:SemaphoreProtocol)
+    case LoopedSema(loop:RunLoopProtocol, sema:SemaphoreProtocol)
+    case Sema(sema:SemaphoreProtocol, leftovers:Array<SafeTask>)
 }
 
 private extension Wakeable {
-    init(loop:RunLoopProtocol) {
+    init(loop:RunLoopProtocol?) {
+        guard let loop = loop else {
+            self = .Sema(sema: RunLoop.semaphore(loop: nil), leftovers:[])
+            return
+        }
+        
         if let loop = loop as? RunnableRunLoopProtocol {
             self = .Loop(loop: loop)
         } else {
-            self = .Sema(loop:loop, sema: loop.semaphore())
+            self = .LoopedSema(loop:loop, sema: type(of: loop).semaphore(loop: loop))
+        }
+    }
+    
+    private static func wait(sema:SemaphoreProtocol, until:Date?) -> Bool {
+        if let until = until {
+            return sema.wait(until: until)
+        } else {
+            return sema.wait()
         }
     }
 
@@ -154,12 +168,11 @@ private extension Wakeable {
             } else {
                 return loop.run()
             }
-        case .Sema(_, let sema):
-            if let until = until {
-                return sema.wait(until: until)
-            } else {
-                return sema.wait()
-            }
+            //SWIFT BUG: crash
+        case .Sema(let sema, _)/*, .LoopedSema(_, let sema)*/:
+            return Wakeable.wait(sema: sema, until: until)
+        case .LoopedSema(_, let sema):
+            return Wakeable.wait(sema: sema, until: until)
         }
     }
 
@@ -170,11 +183,25 @@ private extension Wakeable {
                 task()
                 loop.stop()
             }
-        case .Sema(let loop, let sema):
+        case .LoopedSema(let loop, let sema):
             loop.execute {
                 task()
                 let _ = sema.signal()
             }
+        case .Sema(let sema, var leftovers):
+            leftovers.append(task)
+            let _ = sema.signal()
+        }
+    }
+    
+    func afterwake() {
+        switch self {
+        case .Sema(_, var leftovers):
+            while !leftovers.isEmpty {
+                leftovers.removeFirst()()
+            }
+        default:
+            break
         }
     }
 }
@@ -230,6 +257,7 @@ public class RunLoopSemaphore : SemaphoreProtocol {
             //}
             while !signaled && !timedout {
                 timedout = wakeable.waitWithConditionalDate(until: until)
+                wakeable.afterwake()
                 signaled = self.signaled.value ?? false
             }
             self.signaled.value = false

RunLoop/Sync.swift

@@ -27,7 +27,11 @@ public extension RunLoopProtocol {
 
         var result:Result<ReturnType, AnyError>?
 
-        let sema = RunLoop.current.semaphore()
+        let sema = RunLoop.current.map { loop in
+            type(of: loop).semaphore(loop: loop)
+        }.getOr {
+            RunLoop.reactive.semaphore(loop: nil)
+        }
 
         self.execute {
             defer {

Tests/RunLoop/RunLoopTests.swift

@@ -12,6 +12,25 @@ import Boilerplate
 @testable import RunLoop
 
 class RunLoopTests: XCTestCase {
+    #if !os(Linux) || dispatch
+        func freshLoop() -> RunLoopProtocol {
+            let queue = DispatchQueue.global()
+            let loop = DispatchRunLoop(queue: queue)
+            return loop
+        }
+    #else
+        //FIXME
+        func freshLoop() -> RunLoopProtocol {
+            var loop = RunLoop.reactive.current
+            let sema = RunLoop.semaphore(loop: loop)
+            let thread = try! Boilerplate.Thread {
+                loop = RunLoop.current
+                sema.signal()
+                loop.flatMap({$0 as? RunnableRunLoopProtocol})?.run()
+            }
+            sema.wait()
+        }
+    #endif
 
     #if (os(Linux) && !nouv) || uv
     func testUVExecute() {
@@ -74,24 +93,20 @@ class RunLoopTests: XCTestCase {
 
     func testImmediateTimeout() {
         let expectation = self.expectation(description: "OK TIMER")
-        let loop = RunLoop.reactive.current
+        let loop = RunLoop.reactive.current!
         loop.execute(delay: .Immediate) {
             expectation.fulfill()
-            #if os(Linux)
-                (loop as? RunnableRunLoopType)?.stop()
-            #endif
+            (loop as? RunnableRunLoopProtocol)?.stop()
         }
-        #if os(Linux)
-            (loop as? RunnableRunLoopType)?.run()
-        #endif
+        let _ = (loop as? RunnableRunLoopProtocol)?.run()
         self.waitForExpectations(timeout: 2, handler: nil)
     }
 
     func testNested() {
         #if os(Linux)
-            let rl = RunLoop.current as? RunnableRunLoopType // will be main
+            let rl = RunLoop.current.flatMap({$0 as? RunnableRunLoopProtocol}) // will be main
         #else
-            let rl = Optional<RunLoopProtocol>(RunLoop.current) // will be main too.
+            let rl = RunLoop.reactive.current // will be main too.
         #endif
 
         print("Current run loop: \(rl)")
@@ -102,21 +117,21 @@ class RunLoopTests: XCTestCase {
             rl?.execute {
                 print("Inner execute called")
                 inner.fulfill()
-                #if os(Linux) && !dispatch
+                #if (os(Linux) && !dispatch) || uv
                     rl?.stop()
                 #endif
             }
-            #if os(Linux) && !dispatch
+            #if (os(Linux) && !dispatch) || uv
                 rl?.run()
             #endif
             print("Execute called")
             outer.fulfill()
-            #if os(Linux) && !dispatch
+            #if (os(Linux) && !dispatch) || uv
                 rl?.stop()
             #endif
         }
 
-        #if os(Linux) && !dispatch
+        #if (os(Linux) && !dispatch) || uv
             rl?.run(.In(timeout: 2))
         #endif
 
@@ -157,16 +172,9 @@ class RunLoopTests: XCTestCase {
     #endif
 
     func testSyncToRunLoop() {
-        let sema = RunLoop.current.semaphore()
-        var loop:RunLoopProtocol = RunLoop.current
-        let thread = try! Boilerplate.Thread {
-            loop = RunLoop.current
-            sema.signal()
-            (loop as? RunnableRunLoopProtocol)?.run()
-        }
-        sema.wait()
+        var loop = freshLoop()
 
-        XCTAssertFalse(loop.isEqual(to: RunLoop.current))
+        XCTAssertFalse(RunLoop.reactive.current.map({$0.isEqual(to: loop)}) ?? false)
 
         let result = loop.sync {
             return "result"
@@ -191,8 +199,6 @@ class RunLoopTests: XCTestCase {
             XCTFail("shoud not reach this")
         }
 
-        try! thread.join()
-        
         self.waitForExpectations(timeout: 0.1, handler: nil)
     }