private static void SubscribeProgressToChain(Promise promise, Internal.IProgressListener progressListener, ref ValueLinkedStack <Internal.PromisePassThrough> passThroughs) { Promise next; // If the promise is not waiting on another promise (is the root), it sets next to null, does not add the listener, and returns false. // If the promise is waiting on another promise that is not its previous, it adds the listener, transforms progresslistener, sets next to the one it's waiting on, and returns true. // Otherwise, it sets next to its previous, adds the listener only if it is a WaitPromise, and returns true. while (promise.SubscribeProgressIfWaiterAndContinueLoop(ref progressListener, out next, ref passThroughs)) { promise = next; } // promise is the root of the promise tree. switch (promise._state) { case State.Pending: { progressListener.SetInitialAmount(promise._waitDepthAndProgress); break; } case State.Resolved: { progressListener.SetInitialAmount(promise._waitDepthAndProgress.GetIncrementedWholeTruncated()); break; } default: // Rejected or Canceled: { progressListener.Retain(); progressListener.CancelOrIncrementProgress(promise, promise._waitDepthAndProgress.GetIncrementedWholeTruncated().ToUInt32()); break; } } }
protected void SubscribeProgress <TCapture>(TCapture capturedValue, Action <TCapture, float> onProgress, int skipFrames) { ValidateOperation(this, skipFrames + 1); ValidateArgument(onProgress, "onProgress", skipFrames + 1); if (_state == State.Pending) { Internal.IProgressListener progressListener = Internal.ProgressDelegateCapture <TCapture> .GetOrCreate(capturedValue, onProgress, this, skipFrames + 1); // Directly add to listeners for this promise. // Sets promise to the one this is waiting on. Returns false if not waiting on another promise. Promise promise; if (!SubscribeProgressAndContinueLoop(ref progressListener, out promise)) { // This is the root of the promise tree. progressListener.SetInitialAmount(_waitDepthAndProgress); return; } SubscribeProgressToBranchesAndRoots(promise, progressListener); } else if (_state == State.Resolved) { AddToHandleQueueBack(Internal.ProgressDelegateCapture <TCapture> .GetOrCreate(capturedValue, onProgress, this, skipFrames + 1)); } // Don't report progress if the promise is canceled or rejected. }
private static void SubscribeProgressToBranchesAndRoots(Promise promise, Internal.IProgressListener progressListener) { // This allows us to subscribe progress to AllPromises and RacePromises iteratively instead of recursively ValueLinkedStack <Internal.PromisePassThrough> passThroughs = new ValueLinkedStack <Internal.PromisePassThrough>(); Repeat: SubscribeProgressToChain(promise, progressListener, ref passThroughs); if (passThroughs.IsNotEmpty) { // passThroughs are removed from their targets before adding to passThroughs. Add them back here. var passThrough = passThroughs.Pop(); promise = passThrough.Owner; progressListener = passThrough; passThrough.Target.ReAdd(passThrough); goto Repeat; } }
protected virtual bool SubscribeProgressIfWaiterAndContinueLoop(ref Internal.IProgressListener progressListener, out Promise previous, ref ValueLinkedStack <Internal.PromisePassThrough> passThroughs) { return((previous = _valueOrPrevious as Promise) != null); }
protected virtual bool SubscribeProgressAndContinueLoop(ref Internal.IProgressListener progressListener, out Promise previous) { progressListener.Retain(); _progressListeners.Push(progressListener); return((previous = _valueOrPrevious as Promise) != null); }