# 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:PublicProtectedPrivate

## 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.

code » isPending ( ) ⇒ `boolean`

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.

code » `<R>` thenCatch ( errback ) ⇒ `!webdriver.promise.Promise.<R>`

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.

code » `<R>` thenFinally ( callback ) ⇒ `!webdriver.promise.Promise.<R>`

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.