/// <summary> /// Invoke a single progress handler. /// </summary> private void InvokeProgressHandler(Action <float> callback, IRejectable rejectable, float progress) { // Argument.NotNull(() => callback); // Argument.NotNull(() => rejectable); try { callback(progress); } catch (Exception ex) { rejectable.Reject(ex); } }
/// <summary> /// Invoke a single handler. /// </summary> private void InvokeHandler <T>(Action <T> callback, IRejectable rejectable, T value) { // Argument.NotNull(() => callback); // Argument.NotNull(() => rejectable); try { callback(value); } catch (Exception ex) { rejectable.Reject(ex); } }
/// <summary> /// Invoke a single resolve handler. /// </summary> private void InvokeResolveHandler(Action callback, IRejectable rejectable) { // Argument.NotNull(() => callback); // Argument.NotNull(() => rejectable); try { callback(); } catch (Exception ex) { rejectable.Reject(ex); } }
/// <summary> /// Add a progress handler for this promise. /// </summary> private void AddProgressHandler(Action <float> onProgress, IRejectable rejectable) { lock (this) { if (progressHandlers == null) { progressHandlers = new List <ProgressHandler>(); } progressHandlers.Add(new ProgressHandler { callback = onProgress, rejectable = rejectable }); } }
/// <summary> /// Invoke a single error handler. /// </summary> private void InvokeRejectHandler(Action <Exception> callback, IRejectable rejectable, Exception value) { Argument.NotNull(() => callback); Argument.NotNull(() => rejectable); try { callback(value); } catch (Exception ex) { rejectable.Reject(ex); } }
private void ActionHandlers(IRejectable resultPromise, Action <PromisedT> resolveHandler, Action <Exception> rejectHandler) { if (CurState == PromiseState.Resolved) { InvokeHandler(resolveHandler, resultPromise, resolveValue); return; } if (CurState == PromiseState.Rejected) { InvokeHandler(rejectHandler, resultPromise, rejectionException); return; } AddResolveHandler(resolveHandler, resultPromise); AddRejectHandler(rejectHandler, resultPromise); }
/// <summary> /// Invoke a single error handler. /// </summary> private void InvokeRejectHandler(Action <Exception> callback, IRejectable rejectable, Exception value) { // Argument.NotNull(() => callback); // Argument.NotNull(() => rejectable); try { callback(value); } catch (Exception ex) { RSGUtil.LogCaughtException(ex); rejectable.Reject(ex); } }
/// <summary> /// Add a resolve handler for this promise. /// </summary> private void AddResolveHandler(Action <PromisedT> onResolved, IRejectable rejectable) { if (resolveCallbacks == null) { resolveCallbacks = new List <Action <PromisedT> >(); } if (resolveRejectables == null) { resolveRejectables = new List <IRejectable>(); } resolveCallbacks.Add(onResolved); resolveRejectables.Add(rejectable); }
/// <summary> /// Add a resolve handler for this promise. /// </summary> private void AddResolveHandler(Action onResolved, IRejectable rejectable) { lock (this) { if (resolveHandlers == null) { resolveHandlers = new List <ResolveHandler>(); } resolveHandlers.Add(new ResolveHandler { callback = onResolved, rejectable = rejectable }); } }
/// <summary> /// Helper function to invoke or register resolve/reject handlers. /// </summary> private void ActionHandlers(IRejectable resultPromise, Action resolveHandler, Action <Exception> rejectHandler) { if (CurState == PromiseState.Resolved) { InvokeResolveHandler(resolveHandler, resultPromise); } else if (CurState == PromiseState.Rejected) { InvokeRejectHandler(rejectHandler, resultPromise, rejectionException); } else { AddResolveHandler(resolveHandler, resultPromise); AddRejectHandler(rejectHandler, resultPromise); } }
/// <summary> /// Invoke a single handler. /// </summary> private void InvokeHandler <T>(Action <T> callback, IRejectable rejectable, T value) { // Argument.NotNull(() => callback); // Argument.NotNull(() => rejectable); try { callback(value); } catch (Exception ex) { Debug.LogError("PROMISE ERROR: " + ex); rejectable.Reject(ex); throw; } }
/// <summary> /// Helper function to invoke or register resolve/reject handlers. /// </summary> void ActionHandlers(IRejectable resultPromise, Action <PromisedT> resolveHandler, Action <Exception> rejectHandler) { if (CurrentState.Equals(PromiseState.Resolved)) { InvokeHandler(resolveHandler, resultPromise, resolveValue); } else if (CurrentState.Equals(PromiseState.Rejected)) { InvokeHandler(rejectHandler, resultPromise, rejectionException); } else { AddResolveHandler(resolveHandler, resultPromise); AddRejectHandler(rejectHandler, resultPromise); } }
/// <summary> /// Helper function to invoke or register resolve/reject handlers. /// </summary> void ActionHandlers(IRejectable resultPromise, Action resolveHandler, Action <Exception> rejectHandler) { if (this.CurState == PromiseState.Resolved) { this.InvokeResolveHandler(resolveHandler, resultPromise); } else if (this.CurState == PromiseState.Rejected) { this.InvokeRejectHandler(rejectHandler, resultPromise, this.rejectionException); } else { this.AddResolveHandler(resolveHandler, resultPromise); this.AddRejectHandler(rejectHandler, resultPromise); } }
private void actionHandlers(IRejectable resultPromise, Action resolveHandler, Action <Exception> rejectHandler) { if (this.curState == PromiseState.Resolved) { this.executeResolveHandler(resolveHandler, resultPromise); } else if (this.curState == PromiseState.Rejected) { this.executeRejectHandler(rejectHandler, resultPromise, this.rejectionException); } else { this.addResolveHandler(resolveHandler, resultPromise); this.addRejectHandler(rejectHandler, resultPromise); } }
/// <summary> /// Initializes a new instance of the ResultSummaryRecord class. /// </summary> /// <param name="verb"> /// The verb whose execution this is the result of. /// </param> /// <param name="disposition"> /// The disposition of the verb execution. /// </param> /// <param name="outputs"> /// The build objects that were produced by this verb execution. /// </param> /// <param name="isRejectableFailure"> /// Whether this result is a rejectable failure. /// </param> internal ResultSummaryRecord( IVerb verb, Disposition disposition, IEnumerable <BuildObjectValuePointer> outputs, bool isRejectableFailure) { this.verb = verb; this.disposition = disposition; this.outputs = new List <BuildObjectValuePointer>(outputs); this.isRejectableFailure = isRejectableFailure; IRejectable rejectableVerb = verb as IRejectable; if (rejectableVerb != null) { this.isRejectableFailure = rejectableVerb.resultWasRejectableFailure(); } }
/// <summary> /// Invoke a single handler. /// </summary> private void InvokeHandler <T>(Action <T> callback, IRejectable rejectable, T value) { // Argument.NotNull(() => callback); // Argument.NotNull(() => rejectable); try { callback(value); } catch (Exception ex) { if (Promise.DoNotHandleExceptions && !(ex is RejectableException)) { throw; } rejectable.Reject(ex); } }
/// <summary> /// Invoke a single handler. /// </summary> private void InvokeHandler <T>(Action <T> callback, IRejectable rejectable, T value) { // Argument.NotNull(() => callback); // Argument.NotNull(() => rejectable); lock (this) { try { callback(value); } catch (Exception ex) { Log.Error("Promise {promise} rejected due to unhandled exception: {exception}", this, ex); rejectable.Reject(ex); } } }
public ResolveHandler(IRejectable rejectable, Action callback) { Rejectable = rejectable; Callback = callback; }
private void ActionHandlers(IRejectable resultPromise, Action <PromisedT> resolveHandler, Action <Exception> rejectHandler) { }
private void InvokeHandler <T>(Action <T> callback, IRejectable rejectable, T value) { }
private void AddResolveHandler(Action <PromisedT> onResolved, IRejectable rejectable) { }
public void AddResolver(Action onResolved, IRejectable rejectable) { _resolvers.Add(new AsyncHandler { Callback = onResolved, Rejectable = rejectable }); }
} // 0x00525770-0x00525800 // Methods private void InvokeRejectHandler(Action <Exception> callback, IRejectable rejectable, Exception value) { } // 0x00525140-0x00525240
public void AddRejector(Action <Exception> onRejected, IRejectable rejectable) { _rejectors.Add(new AsyncHandler <Exception> { Callback = onRejected, Rejectable = rejectable }); }
public RejectHandler(IRejectable rejectable, Action <Exception> callback) { Rejectable = rejectable; Callback = callback; }
public void AddRejector(Action<Exception> onRejected, IRejectable rejectable) { _rejectors.Add(new AsyncHandler<Exception> { Callback = onRejected, Rejectable = rejectable }); }
// Methods private void AddRejectHandler(Action <Exception> onRejected, IRejectable rejectable) { }
protected void InvokeReject(Action <Exception> callback, Exception exception, IRejectable rejectable) { Argument.NotNull(rejectable); try { callback.SafeInvoke(exception); } catch (Exception ex) { if (rejectable != this) { rejectable.Reject(ex); } } }