goog.async.Deferred<VALUE>

Registers one function as both a callback and errback.

Register a callback function to be called with a successful result. If no value is returned by the callback function, the result value is unchanged. If a new value is returned, it becomes the Deferred result and will be passed to the next callback in the execution sequence.

If the function throws an error, the error becomes the new result and will be passed to the next errback in the execution chain.

If the function returns a Deferred, the execution sequence will be blocked until that Deferred fires. Its result will be passed to the next callback (or errback if it is an error result) in this Deferred's execution sequence.

Registers a callback function and an errback function at the same position in the execution sequence. Only one of these functions will execute, depending on the error state during the execution sequence.

NOTE: This is not equivalent to def.addCallback().addErrback()! If the callback is invoked, the errback will be skipped, and vice versa.

Register a callback function to be called with an error result. If no value is returned by the function, the error result is unchanged. If a new error value is returned or thrown, that error becomes the Deferred result and will be passed to the next errback in the execution sequence.

If the errback function handles the error by returning a non-error value, that result will be passed to the next normal callback in the sequence.

If the function returns a Deferred, the execution sequence will be blocked until that Deferred fires. Its result will be passed to the next callback (or errback if it is an error result) in this Deferred's execution sequence.

Like addBoth, but propagates uncaught exceptions in the errback.

Makes this Deferred wait for another Deferred's execution sequence to complete before continuing.

This is equivalent to adding a callback that returns otherDeferred, but doesn't prevent additional callbacks from being added to otherDeferred.

Creates a branch off this Deferred's execution sequence, and returns it as a new Deferred. The branched Deferred's starting result will be shared with the parent at the point of the branch, even if further callbacks are added to the parent.

All branches at the same stage in the execution sequence will receive the same starting value.

Fire the execution sequence for this Deferred by passing the starting result to the first registered callback.

Cancels a Deferred that has not yet been fired, or is blocked on another deferred operation. If this Deferred is waiting for a blocking Deferred to fire, the blocking Deferred will also be canceled.

If this Deferred was created by calling branch() on a parent Deferred with opt_propagateCancel set to true, the parent may also be canceled. If opt_deepCancel is set, cancel() will be called on the parent (as well as any other ancestors if the parent is also a branch). If one or more branches were created with opt_propagateCancel set to true, the parent will be canceled if cancel() is called on all of those branches.

Links another Deferred to the end of this Deferred's execution sequence. The result of this execution sequence will be passed as the starting result for the chained Deferred, invoking either its first callback or errback.

Fire the execution sequence for this Deferred by passing the starting error result to the first registered errback.

Return the most recent value fired.

Implements goog.Thenable for seamless integration with goog.Promise. Deferred results are mutable and may represent multiple values over their lifetime. Calling then on a Deferred returns a Promise with the result of the Deferred at that point in its callback chain. Note that if the Deferred result is never mutated, and only then calls are made, the Deferred will behave like a Promise.

Asserts that there are no pending deferred errors. If there are any scheduled errors, one will be thrown immediately to make this function fail.

Creates a Deferred that has already been canceled.

Creates a Deferred that has an initial error result.

Creates a Deferred that fires when the given promise resolves. Use only during migration to Promises.

Note: If the promise resolves to a thenable value (which is not allowed by conforming promise implementations), then the deferred may behave unexpectedly as it tries to wait on it. This should not be a risk when using goog.Promise, goog.async.Deferred, or native Promise objects.

Creates a Deferred that has an initial result.

Normalizes values that may or may not be Deferreds.

If the input value is a Deferred, the Deferred is branched (so the original execution sequence is not modified) and the input callback added to the new branch. The branch is returned to the caller.

If the input value is not a Deferred, the callback will be executed immediately and an already firing Deferred will be returned to the caller.

In the following (contrived) example, if isImmediate is true then 3 is alerted immediately, otherwise 6 is alerted after a 2-second delay.

 var value;
 if (isImmediate) {
   value = 3;
 } else {
   value = new goog.async.Deferred();
   setTimeout(function() { value.callback(6); }, 2000);
 }

 var d = goog.async.Deferred.when(value, alert);
 

Whether to attempt to make stack traces long. Defaults to false.

Whether unhandled errors should always get rethrown to the global scope. Defaults to false.

NOTE(user): This has a surprising side effect that when STRICT_ERRORS is true, successfully resolving a Deferred with a value that is instanceof Error (other than CanceledError, which is treated as not an error for this purpose) will actually cause the Deferred to end up in a rejected state. Thus, Deferred.succeed(new Error()).addErrback(f) will actually call f. This is similar to existing behavior where (independent of STRICT_ERRORS) errbacks that return (rather than throw) any Error (including CanceledError) will cause a rejection. We believe this behavior is unintended and will try to fix it in the future to be more consistent.