public IPromise Catch(Predicate <RejectReason> match, Func <RejectReason, IPromise> recover)
{
var deferred = new Deferred();
AssignDisposer(deferred, Disposer);
Done(() =>
{
deferred.Resolve();
});
Fail(error =>
{
if (match(error))
{
var promise = recover(error);
AssignDisposer((BaseDeferred)promise, Disposer);
promise.Done(() => deferred.Resolve());
promise.Fail(e => deferred.Reject(e));
}
else
{
deferred.Reject(error);
}
});
return(deferred);
}
//First will be Resolved, others well be Reseted
public static IPromise Race(params IPromise[] collection)
{
var race = new Deferred();
var promises = Array.ConvertAll(collection, promice => promice as BaseDeferred);
BaseDeferred last = null;
for (int i = 0; i < promises.Length; i++)
{
var promise = promises[i];
last = promise;
var self = promise;
if (IsResolved(last))
{
break;
}
promise.Done(() =>
{
for (int j = 0; j < promises.Length; j++)
{
var item = promises[j];
if (IsPending(item) && item != self) // TODO: item != self is always true because done
{
Reset(item);
}
}
race.Resolve();
});
promise.Fail(() =>
{
if (promises.All(p => IsRejected(p)))
{
race.Reject();
}
});
}
if (IsResolved(last))
{
for (int i = 0; i < promises.Length; i++)
{
var item = promises[i];
if (IsPending(item) && item != last)
{
Reset(item);
}
}
race.Resolve();
}
return(race);
}
public static IPromise All(params IPromise[] collection)
{
var deferred = new Deferred();
var promises = Array.ConvertAll(collection, promice => promice as BaseDeferred);
if (collection.Length == 0)
{
deferred.Resolve();
}
for (int i = 0; i < promises.Length; i++)
{
var promise = promises[i];
promise.Done(() =>
{
if (deferred.State == Status.Pending && promises.All(p => IsResolved(p)))
{
deferred.Resolve();
}
});
promise.Fail(() =>
{
if (deferred.State == Status.Pending)
{
deferred.Reject();
}
});
}
return(deferred);
}
public IPromise Clone()
{
var clone = new Deferred();
AssignDisposer(clone, Disposer);
Done(() => clone.Resolve());
Fail(() => clone.Reject());
return(clone);
}
public IPromise AddDisposer(IDisposer disposer)
{
var deferred = new Deferred();
AssignDisposer(deferred, disposer);
Done(() => deferred.Resolve());
Fail(() => deferred.Reject());
return(deferred);
}
public IPromise <TNext> Then <TNext>(Func <IPromise <TNext> > next)
{
var deferred = new Deferred <TNext>();
AssignDisposer(deferred, Disposer);
Done(() =>
{
var promise = next();
AssignDisposer((BaseDeferred)promise, Disposer);
promise.Done(res => deferred.Resolve(res));
promise.Fail(() => deferred.Reject());
});
Fail(() => deferred.Reject());
return(deferred);
}
