Implemented async with delay

Author: dileping

ExecutionContext/DispatchExecutionContext.swift

@@ -41,6 +41,17 @@
             }
         }
 
+        public func async(after:Double, task:SafeTask) {
+            if after > 0 {
+                let time = dispatch_time(DISPATCH_TIME_NOW, Int64(after * NSTimeInterval(NSEC_PER_SEC)))
+                dispatch_after(time, queue) {
+                    task()
+                }
+            } else {
+                async(task)
+            }
+        }
+        
         public func sync<ReturnType>(task:() throws -> ReturnType) throws -> ReturnType {
             if dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL) == dispatch_queue_get_label(queue) {
                 return try task()

ExecutionContext/ExecutionContext.swift

@@ -38,6 +38,10 @@ public protocol TaskSchedulerType {
     func async(task:Task)
     func async(task:SafeTask)
 
+    //after is in seconds
+    func async(after:Double, task:Task)
+    func async(after:Double, task:SafeTask)
+    
     func sync<ReturnType>(task:() throws -> ReturnType) throws -> ReturnType
     func sync<ReturnType>(task:() -> ReturnType) -> ReturnType
 }
@@ -82,6 +86,18 @@ public extension ErrorHandlerRegistryType where Self : TaskSchedulerType {
             }
         }
     }
+    
+    //after is in seconds
+    func async(after:Double, task:Task) {
+        //specify explicitely, that it's safe task
+        async(after) { () -> Void in
+            do {
+                try task()
+            } catch let e {
+                self.handleError(e)
+            }
+        }
+    }
 }
 
 public extension TaskSchedulerType {

ExecutionContext/ImmediateExecutionContext.swift

@@ -21,6 +21,15 @@ public class ImmediateExecutionContext : ExecutionContextBase, TaskSchedulerType
         task()
     }
 
+    public func async(after:Double, task:SafeTask) {
+        let sec = time_t(after)
+        let nsec = Int((after - Double(sec)) * 1000 * 1000 * 1000)//nano seconds
+        var time = timespec(tv_sec:sec, tv_nsec: nsec)
+        
+        nanosleep(&time, nil)
+        async(task)
+    }
+    
     public func sync<ReturnType>(task:() throws -> ReturnType) throws -> ReturnType {
         return try task()
     }

Tests/ExecutionContext/ExecutionContextTests.swift

@@ -44,32 +44,67 @@ class ExecutionContextTests: XCTestCase {
         self.waitForExpectationsWithTimeout(2, handler: nil)
     }
 
+    func afterTest(context:ExecutionContextType) {
+        let expectation = self.expectationWithDescription("OK AFTER")
+        
+        context.async(0.5) {
+            sleep(1)
+            expectation.fulfill()
+        }
+        
+        self.waitForExpectationsWithTimeout(2, handler: nil)
+    }
+    
+    func afterTestAdvanced(context:ExecutionContextType) {
+        var ok = true
+        
+        context.async(3) {
+            ok = false
+        }
+        
+        sleep(2)
+        
+        XCTAssert(ok)
+        
+        sleep(2)
+        
+        XCTAssertFalse(ok)
+    }
+    
     func testSerial() {
         let context:ExecutionContextType = DefaultExecutionContext(kind: .Serial)
 
         syncTest(context)
         asyncTest(context)
+        afterTest(context)
+        afterTestAdvanced(context)
     }
 
     func testParallel() {
         let context:ExecutionContextType = DefaultExecutionContext(kind: .Parallel)
 
         syncTest(context)
         asyncTest(context)
+        afterTest(context)
+        afterTestAdvanced(context)
     }
 
     func testGlobal() {
         let context:ExecutionContextType = DefaultExecutionContext.global
 
         syncTest(context)
         asyncTest(context)
+        afterTest(context)
+        afterTestAdvanced(context)
     }
 
     func testMain() {
         let context:ExecutionContextType = DefaultExecutionContext.main
 
         syncTest(context)
         asyncTest(context)
+        afterTest(context)
+        //afterTestAdvanced - no it will not work here
     }
 }