Class webdriver.promise.Promise.<T>

code »

Represents the eventual value of a completed operation. Each promise may be in one of three states: pending, resolved, or rejected. Each promise starts in the pending state and may make a single transition to either a fulfilled or failed state.

This class is based on the Promise/A proposal from CommonJS. Additional functions are provided for API compatibility with Dojo Deferred objects.

Constructor

webdriver.promise.Promise ( )
Show:

Instance Methods

code »cancel ( reason )

Cancels the computation of this promise's value, rejecting the promise in the process.

Parameters
reason: *
The reason this promise is being cancelled. If not an Error, one will be created using the value's string representation.
Returns
Whether this promise's value is still being computed.
code »<R> then ( opt_callback, opt_errback )!webdriver.promise.Promise.<R>

Registers listeners for when this instance is resolved. This function most overridden by subtypes.

Parameters
opt_callback: ?(function(T): (R|webdriver.promise.Promise.<R>))=
The function to call if this promise is successfully resolved. The function should expect a single argument: the promise's resolved value.
opt_errback: ?(function(*): (R|webdriver.promise.Promise.<R>))=
The function to call if this promise is rejected. The function should expect a single argument: the rejection reason.
Returns
A new promise which will be resolved with the result of the invoked callback.

Registers a listener for when this promise is rejected. This is synonymous with the catch clause in a synchronous API:


   // Synchronous API:
   try {
     doSynchronousWork();
   } catch (ex) {
     console.error(ex);
   }

   // Asynchronous promise API:
   doAsynchronousWork().thenCatch(function(ex) {
     console.error(ex);
   });
 
Parameters
errback: function(*): (R|webdriver.promise.Promise.<R>)
The function to call if this promise is rejected. The function should expect a single argument: the rejection reason.
Returns
A new promise which will be resolved with the result of the invoked callback.

Registers a listener to invoke when this promise is resolved, regardless of whether the promise's value was successfully computed. This function is synonymous with the finally clause in a synchronous API:


   // Synchronous API:
   try {
     doSynchronousWork();
   } finally {
     cleanUp();
   }

   // Asynchronous promise API:
   doAsynchronousWork().thenFinally(cleanUp);
 
Note: similar to the finally clause, if the registered callback returns a rejected promise or throws an error, it will silently replace the rejection error (if any) from this promise:

   try {
     throw Error('one');
   } finally {
     throw Error('two');  // Hides Error: one
   }

   webdriver.promise.rejected(Error('one'))
       .thenFinally(function() {
         throw Error('two');  // Hides Error: one
       });
 
Parameters
callback: function(): (R|webdriver.promise.Promise.<R>)
The function to call when this promise is resolved.
Returns
A promise that will be fulfilled with the callback result.