DefferedFuture.swift

DefferedFuture.swift

import FutureKit

private var startPromiseHandler = ExtensionVarHandler()
public extension Future {
    fileprivate var startPromise : Promise<Void>? {
        set(p) {
            startPromiseHandler.setValueOn(self, value: p)
        }
        get {
            return startPromiseHandler.getValueFrom(self)
        }
    }
    
    public func start() throws {
        
        if let p = self.startPromise {
            p.completeWithSuccess(())
        }
        else {
            throw FutureKitError(genericError: "deferUsing was not called on this future's promise")
        }
    }
}

extension Promise {
    
    public func deferUsing<C: CompletionType>(_ onStartHandler: @escaping () throws -> C) where C.T == T {
        
        let startPromise = Promise<Void>()
        
        startPromise.future.onComplete { result in
            switch result {
            case .success:
                self.complete(try onStartHandler().completion)
            case .cancelled:
                self.completeWithCancel()
            case let .fail(error):
                self.completeWithFail(error)
            }
        }
    
        self.future.startPromise = startPromise // retain loop issues?  
    }
    
    
    public func deferUsing(_ onStartHandler: @escaping () throws -> T) {
        
        self.deferUsing { () -> Completion<T> in
            return .success(try onStartHandler())
        }
        
    }

}


    func returnDefferred() -> Future<Int> {
        
        let p = Promise<Int>()
        
        p.deferUsing { () -> Future<Int> in
            return Executor.background.execute {
                return 5
            }
        }
        
        return p.future
    }
    
    func checkDeffered() throws {
        
        let f = self.returnDefferred().onSuccess { val in
            print(val)
        }
        
        try f.start()
        
    }