|
package async |
|
{ |
|
public class Deferred implements Promise |
|
{ |
|
|
|
private const pending:Array = []; |
|
|
|
private var processed:Boolean; |
|
|
|
private var completed:Boolean; |
|
|
|
private var completionAction:String; |
|
|
|
private var completionValue:*; |
|
|
|
private var onResolved:Function; |
|
|
|
private var onRejected:Function; |
|
|
|
public function Deferred(onResolved:Function = null, onRejected:Function = null) |
|
{ |
|
this.onResolved = onResolved; |
|
this.onRejected = onRejected || throwError; |
|
} |
|
|
|
public function resolve(result:*):void |
|
{ |
|
processed || process(onResolved, result); |
|
} |
|
|
|
public function reject(error:*):void |
|
{ |
|
processed || process(onRejected, error); |
|
} |
|
|
|
public function then(onResolved:Function = null, onRejected:Function = null):Promise |
|
{ |
|
if (onResolved || onRejected) |
|
{ |
|
const deferred:Deferred = new Deferred(onResolved, onRejected); |
|
NextTick.call(schedule, [deferred]); |
|
return deferred; |
|
} |
|
return this; |
|
} |
|
|
|
private function throwError(error:*):void |
|
{ |
|
throw error; |
|
} |
|
|
|
private function schedule(deferred:Deferred):void |
|
{ |
|
pending.push(deferred); |
|
completed && propagate(); |
|
} |
|
|
|
private function propagate():void |
|
{ |
|
for each (var deferred:Deferred in pending) |
|
deferred[completionAction](completionValue); |
|
pending.length = 0; |
|
} |
|
|
|
private function complete(action:String, value:*):void |
|
{ |
|
onResolved = null; |
|
onRejected = null; |
|
completionAction = action; |
|
completionValue = value; |
|
completed = true; |
|
propagate(); |
|
} |
|
|
|
private function completeResolved(result:*):void |
|
{ |
|
complete('resolve', result); |
|
} |
|
|
|
private function completeRejected(error:*):void |
|
{ |
|
complete('reject', error); |
|
} |
|
|
|
private function process(closure:Function, value:*):void |
|
{ |
|
processed = true; |
|
try |
|
{ |
|
closure && (value = closure(value)); |
|
value is Promise |
|
? Promise(value).then(completeResolved, completeRejected) |
|
: completeResolved(value); |
|
} |
|
catch (error:*) |
|
{ |
|
completeRejected(error); |
|
} |
|
} |
|
} |
|
} |
This comment has been minimized.
Hi, I'm looking to use it in a commercial environment and wondered if like the promise.coffee from which it was ported, it could be licensed under MIT so that we could use it?