/// <summary>
/// Attach a callback that runs when an error (other than a cancellation error) occurs
/// </summary>
public static IPromise <T> Error <T>(this IPromise <T> promise, Action <Exception> callback)
{
return(promise.Fail(ex => { if (!(ex is OperationCanceledException))
{
callback.Invoke(ex);
}
}));
}
public static IPromise <D> Convert <S, D>(this IPromise <S> ext, Func <S, D> transform)
{
Deferred <D> def = new Deferred <D>();
IPromise <D> res = new PromiseImpl <D>();
ext.Done((value) => def.Resolve(transform(value)));
ext.Fail((e) => def.Reject(e));
return(res);
}
/// <summary>
/// Attach a callback that runs when the promise is canceled
/// </summary>
public static IPromise <T> Cancelled <T>(this IPromise <T> promise, Action <OperationCanceledException> callback)
{
return(promise.Fail(ex =>
{
var cancel = ex as OperationCanceledException;
if (cancel != null)
{
callback.Invoke(cancel);
}
}));
}
/// <summary>
/// Attach a callback that runs when an error (other than a cancellation error) occurs
/// </summary>
public static IPromise <T> Error <TErr, T>(this IPromise <T> promise, Action <TErr> callback) where TErr : Exception
{
return(promise.Fail(ex =>
{
var err = ex as TErr;
if (err != null)
{
callback.Invoke(err);
}
}));
}
public static IPromise <T> Then <T>(this IPromise <T> ext, Func <T, IPromise <T> > success, Action <Exception> fail)
{
Deferred <T> def = new Deferred <T>();
IPromise <T> res = def.Promise();
if (fail != null)
{
res.Fail(fail);
}
ext.Done((value) => success(value).Done(p => def.Resolve(p)).Fail(e => def.Reject(e)));
ext.Fail((e) => def.Reject(e));
return(res);
}
/// <summary>
/// adds new promise constructor to current promise and returns wrapper that resolves with added promise
/// A.Then(B) - returns promise that resolves when promise from B is resolved
/// </summary>
/// <param name="next">constructor for next promise</param>
/// <returns>Promise</returns>
public IPromise Then(Func <IPromise> next)
{
Deferred deferred = Deferred.GetFromPool();
Done(() =>
{
IPromise promise = next();
promise.Done(() => deferred.Resolve());
promise.Fail(ex => deferred.Reject(ex));
});
Fail(ex => deferred.Reject(ex));
return(deferred);
}
public IPromise All(IEnumerable <IPromise> promises)
{
IPromise returnPromise = this;
int promiseCount = promises.Count();
int resolved = 0;
foreach (IPromise promise in promises)
{
promise.Then(delegate
{
resolved++;
if (resolved == promiseCount && returnPromise.State == PromiseState.Pending)
{
returnPromise.Resolve();
}
});
promise.Catch(delegate(Exception e)
{
if (returnPromise.State == PromiseState.Pending)
{
returnPromise.Fail(e);
}
});
}
if (promiseCount == 0)
{
returnPromise.Resolve();
}
// Add request cancellation
returnPromise.CancelRequested += delegate(object sender, PromiseCancelRequestedEventArgs e)
{
foreach (var activePromise in promises)
{
if (activePromise.State == PromiseState.Pending)
{
activePromise.RequestCancel();
}
}
};
return(returnPromise);
}
public IPromise Any(IEnumerable <IPromise> promises)
{
IPromise returnPromise = this;
bool didResolveOrFail = false;
foreach (IPromise promise in promises)
{
promise.Then(delegate
{
if (!didResolveOrFail)
{
didResolveOrFail = true;
returnPromise.Resolve();
}
});
promise.Catch(delegate(Exception e)
{
if (!didResolveOrFail)
{
didResolveOrFail = true;
returnPromise.Fail(e);
}
});
}
if (promises.Count() == 0)
{
returnPromise.Resolve();
}
// Add request cancellation
returnPromise.CancelRequested += delegate(object sender, PromiseCancelRequestedEventArgs e)
{
foreach (var activePromise in promises)
{
if (activePromise.State == PromiseState.Pending)
{
activePromise.RequestCancel();
}
}
};
return(returnPromise);
}
public static IPromise <T> AddTimeout <T>(IPromise <T> promise, ITimers timers, float timeout)
{
var result = new Deferred <T>();
var status = EStatus.Pending;
var timeoutPromise = timers.Wait(timeout);
promise.Done(r =>
{
if (status == EStatus.Pending)
{
status = EStatus.Resolved;
result.Resolve(r);
}
});
promise.Fail(() =>
{
if (status == EStatus.Pending)
{
status = EStatus.Rejected;
result.Reject();
}
});
timeoutPromise.Done(() =>
{
if (status == EStatus.Pending)
{
status = EStatus.Rejected;
result.Reject();
}
});
return(result);
}
public void TestErrorFirst()
{
promiseOneArg.ReportFail(new Exception(exceptionStr));
promiseOneArg.Fail(FailCallback);
Assert.AreEqual(currentException.Message, exceptionStr);
}
public IPromise Sequence(IEnumerable <Func <IPromise> > promises)
{
List <IPromise> actingPromises = new List <IPromise>();
int promiseCount = promises.Count();
int index = 0;
IPromise returnPromise = this;
IPromise firstPromise = promises.First()?.Invoke();
actingPromises.Add(firstPromise);
Action resolveCallback = null;
resolveCallback = delegate
{
index++;
if (index < promiseCount)
{
IPromise currentPromise = promises.ElementAt(index)?.Invoke();
actingPromises.Add(currentPromise);
currentPromise.Then(resolveCallback);
currentPromise.Catch(delegate(Exception e)
{
if (returnPromise.State == PromiseState.Pending)
{
returnPromise.Fail(e);
}
});
}
else
{
returnPromise.Resolve();
}
};
firstPromise.Then(resolveCallback);
firstPromise.Catch(delegate(Exception e)
{
if (returnPromise.State == PromiseState.Pending)
{
returnPromise.Fail(e);
}
});
if (promiseCount == 0)
{
returnPromise.Resolve();
}
// Add request cancellation
returnPromise.CancelRequested += delegate(object sender, PromiseCancelRequestedEventArgs e)
{
IPromise currentPromise = actingPromises.ElementAt(index);
if (currentPromise.State == PromiseState.Pending)
{
currentPromise.RequestCancel();
}
};
return(returnPromise);
}
public IPromise <D, F, P> Fail(Action <F> failCallback)
{
return(promise.Fail(failCallback));
}
