/// <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)); }