Interface webdriver.promise.Thenable.<T>

code »

Thenable is a promise-like object with a then method which may be used to schedule callbacks on a promised value.

Show:

Instance Methods

code »cancel ( opt_reason )

Cancels the computation of this promise's value, rejecting the promise in the process. This method is a no-op if the promise has alreayd been resolved.

Parameters
opt_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.

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.

Global Functions

Adds a property to a class prototype to allow runtime checks of whether instances of that class implement the Thenable interface. This function will also ensure the prototype's then function is exported from compiled code.

Parameters
ctor: function(new: webdriver.promise.Thenable, ?)
The constructor whose prototype to modify.

Checks if an object has been tagged for implementing the Thenable interface as defined by webdriver.promise.Thenable.addImplementation.

Parameters
object: *
The object to test.
Returns
Whether the object is an implementation of the Thenable interface.

Global Properties

Property used to flag constructor's as implementing the Thenable interface for runtime type checking.