Class AbstractPromise<D,F,P>

java.lang.Object
org.jdeferred2.impl.AbstractPromise<D,F,P>
All Implemented Interfaces:
Promise<D,F,P>
Direct Known Subclasses:
DeferredObject
public abstract class AbstractPromise<D,F,P> extends Object implements Promise<D,F,P>
See Also:

  • Field Details

    • log

      protected final org.slf4j.Logger log

    • state

      protected volatile Promise.State state

    • doneCallbacks

      protected final List<DoneCallback<? super D>> doneCallbacks

    • failCallbacks

      protected final List<FailCallback<? super F>> failCallbacks

    • progressCallbacks

      protected final List<ProgressCallback<? super P>> progressCallbacks

    • alwaysCallbacks

      protected final List<AlwaysCallback<? super D, ? super F>> alwaysCallbacks

    • resolveResult

      protected D resolveResult

    • rejectResult

      protected F rejectResult

  • Constructor Details

    • AbstractPromise

      public AbstractPromise()

  • Method Details

    • state

      public Promise.State state()
      Specified by:
      state in interface Promise<D,F,P>
      Returns:
      the state of this promise.

    • done

      public Promise<D,F,P> done(DoneCallback<? super D> callback)
      Description copied from interface: Promise
      This method will register DoneCallback so that when a Deferred object is resolved (Deferred.resolve(Object)), DoneCallback will be triggered. If the Deferred object is already resolved then the DoneCallback is triggered immediately. You can register multiple DoneCallback by calling the method multiple times. The order of callback trigger is based on the order they have been registered. 
      
promise.progress(new DoneCallback(){
  public void onDone(Object done) {
    ...
  }
});
      Specified by:
      done in interface Promise<D,F,P>
      Parameters:
      callback - the callback to be triggered
      Returns:
      this for chaining more calls
      See Also:

    • fail

      public Promise<D,F,P> fail(FailCallback<? super F> callback)
      Description copied from interface: Promise
      This method will register FailCallback so that when a Deferred object is rejected (Deferred.reject(Object)), FailCallback will be triggered. If the Deferred object is already rejected then the FailCallback is triggered immediately. You can register multiple FailCallback by calling the method multiple times. The order of callback trigger is based on the order they have been registered. 
      
promise.fail(new FailCallback(){
  public void onFail(Object rejection) {
    ...
  }
});
      Specified by:
      fail in interface Promise<D,F,P>
      Parameters:
      callback - the callback to be triggered
      Returns:
      this for chaining more calls
      See Also:

    • always

      public Promise<D,F,P> always(AlwaysCallback<? super D, ? super F> callback)
      Description copied from interface: Promise
      This method will register AlwaysCallback so that when a Deferred object is either resolved (Deferred.resolve(Object)) or rejected (Deferred.reject(Object)), AlwaysCallback will be triggered. If the Deferred object is already resolved or rejected then the AlwaysCallback is triggered immediately. You can register multiple AlwaysCallback by calling the method multiple times. The order of callback trigger is based on the order they have been registered. AlwaysCallbacks are triggered after any DoneCallback or FailCallback respectively. 
      
promise.always(new AlwaysCallback(){
  public void onAlways(State state, Object result, Object rejection) {
    if (state == State.RESOLVED) {
      // do something with result
    } else {
      // do something with rejection
    }
  }
});
      Specified by:
      always in interface Promise<D,F,P>
      Parameters:
      callback - the callback to be triggered
      Returns:
      this for chaining more calls
      See Also:

    • triggerDone

      protected void triggerDone(D resolved)

    • triggerDone

      protected void triggerDone(DoneCallback<? super D> callback, D resolved)

    • triggerFail

      protected void triggerFail(F rejected)

    • triggerFail

      protected void triggerFail(FailCallback<? super F> callback, F rejected)

    • triggerProgress

      protected void triggerProgress(P progress)

    • triggerProgress

      protected void triggerProgress(ProgressCallback<? super P> callback, P progress)

    • triggerAlways

      protected void triggerAlways(Promise.State state, D resolve, F reject)

    • triggerAlways

      protected void triggerAlways(AlwaysCallback<? super D, ? super F> callback, Promise.State state, D resolve, F reject)

    • progress

      public Promise<D,F,P> progress(ProgressCallback<? super P> callback)
      Description copied from interface: Promise
      This method will register ProgressCallback so that when a Deferred object is notified of progress (Deferred.notify(Object)), ProgressCallback will be triggered. You can register multiple ProgressCallback by calling the method multiple times. The order of callback trigger is based on the order they have been registered. 
      
promise.progress(new ProgressCallback(){
  public void onProgress(Object progress) {
    // e.g., update progress in the GUI while the background task is still running.
  }
});
      Specified by:
      progress in interface Promise<D,F,P>
      Parameters:
      callback - the callback to be triggered
      Returns:
      this for chaining more calls
      See Also:

    • then

      public Promise<D,F,P> then(DoneCallback<? super D> callback)
      Description copied from interface: Promise
      Equivalent to Promise.done(DoneCallback)
      Specified by:
      then in interface Promise<D,F,P>
      Parameters:
      callback - see Promise.done(DoneCallback)
      Returns:
      this for chaining more calls

    • then

      public Promise<D,F,P> then(DoneCallback<? super D> doneCallback, FailCallback<? super F> failCallback)
      Description copied from interface: Promise
      Equivalent to Promise.done(DoneCallback).Promise.fail(FailCallback)
      Specified by:
      then in interface Promise<D,F,P>
      Parameters:
      doneCallback - see Promise.done(DoneCallback)
      failCallback - see Promise.fail(FailCallback)
      Returns:
      this for chaining more calls

    • then

      public Promise<D,F,P> then(DoneCallback<? super D> doneCallback, FailCallback<? super F> failCallback, ProgressCallback<? super P> progressCallback)
      Description copied from interface: Promise
      Equivalent to Promise.done(DoneCallback).Promise.fail(FailCallback).Promise.progress(ProgressCallback)
      Specified by:
      then in interface Promise<D,F,P>
      Parameters:
      doneCallback - see Promise.done(DoneCallback)
      failCallback - see Promise.fail(FailCallback)
      progressCallback - see Promise.progress(ProgressCallback)
      Returns:
      this for chaining more calls

    • filter

      public <D_OUT> Promise<D_OUT,F,P> filter(DoneFilter<? super D, ? extends D_OUT> doneFilter)
      Description copied from interface: Promise
      Equivalent to filter(doneFilter, null, null)
      Specified by:
      filter in interface Promise<D,F,P>
      Parameters:
      doneFilter - the filter to execute when a result is available
      Returns:
      a new promise for the filtered result
      See Also:

    • filter

      public <D_OUT,F_OUT> Promise<D_OUT,F_OUT,P> filter(DoneFilter<? super D, ? extends D_OUT> doneFilter, FailFilter<? super F, ? extends F_OUT> failFilter)
      Description copied from interface: Promise
      Equivalent to filter(doneFilter, failFilter, null)
      Specified by:
      filter in interface Promise<D,F,P>
      Parameters:
      doneFilter - the filter to execute when a result is available
      failFilter - the filter to execute when a failure is available
      Returns:
      a new promise for the filtered result and failure.
      See Also:

    • filter

      public <D_OUT,F_OUT,P_OUT> Promise<D_OUT,F_OUT,P_OUT> filter(DoneFilter<? super D, ? extends D_OUT> doneFilter, FailFilter<? super F, ? extends F_OUT> failFilter, ProgressFilter<? super P, ? extends P_OUT> progressFilter)
      Description copied from interface: Promise
      This method will register filters such that when a Deferred object is either resolved (Deferred.resolve(Object)), rejected (Deferred.reject(Object)) or is notified of progress (Deferred.notify(Object)), the corresponding filter will be invoked. The result of the filter will be used to invoke the same action on the returned promise. DoneFilter and FailFilter will be triggered at the time the Deferred object is resolved or rejected. If the Deferred object is already resolved or rejected the filter is triggered immediately. Filters allow to transform the outcome of a promise into something else. This concept is equivalent to the map() method of the java stream API. If any of the filter is not specified (null), a default No Op filter is used. If your filter is returning a Promise consider using Promise.pipe(DonePipe, FailPipe, ProgressPipe). 
      
Deferred deferred = new DeferredObject();
Promise promise = deferred.promise();
Promise filtered = promise.filter(new DoneFilterinvalid input: '<'Integer, Integer>() {
  Integer filterDone(Integer result) {
    return result * 10;
  }
});

filtered.then(new DoneCallback() {
  void onDone(Integer result) {
    System.out.println(result);
  }
});

deferred.resolve(1); // prints 10
      Specified by:
      filter in interface Promise<D,F,P>
      Parameters:
      doneFilter - the filter to execute when a result is available. If null, use FilteredPromise.NoOpDoneFilter
      failFilter - the filter to execute when a failure is available. If null, use FilteredPromise.NoOpFailFilter
      progressFilter - the filter to execute when progress info is available. If null, use FilteredPromise.NoOpProgressFilter
      Returns:
      a new promise for the filtered result, failure and progress.

    • pipe

      public <D_OUT> Promise<D_OUT,F,P> pipe(DonePipe<? super D, ? extends D_OUT, ? extends F, ? extends P> donePipe)
      Description copied from interface: Promise
      Equivalent to {#code pipe(DonePipe, null, null)}
      Specified by:
      pipe in interface Promise<D,F,P>
      Parameters:
      donePipe - the pipe to invoke when a result is available
      Returns:
      a new promise for the piped result.
      See Also:

    • pipe

      public <D_OUT,F_OUT> Promise<D_OUT,F_OUT,P> pipe(DonePipe<? super D, ? extends D_OUT, ? extends F_OUT, ? extends P> donePipe, FailPipe<? super F, ? extends D_OUT, ? extends F_OUT, ? extends P> failPipe)
      Description copied from interface: Promise
      Equivalent to pipe(DonePipe, FailPipe, null)
      Specified by:
      pipe in interface Promise<D,F,P>
      Parameters:
      donePipe - the pipe to invoke when a result is available
      failPipe - the pipe to invoke when a failure is available
      Returns:
      a new promise for the piped result and failure.
      See Also:

    • pipe

      public <D_OUT,F_OUT,P_OUT> Promise<D_OUT,F_OUT,P_OUT> pipe(DonePipe<? super D, ? extends D_OUT, ? extends F_OUT, ? extends P_OUT> donePipe, FailPipe<? super F, ? extends D_OUT, ? extends F_OUT, ? extends P_OUT> failPipe, ProgressPipe<? super P, ? extends D_OUT, ? extends F_OUT, ? extends P_OUT> progressPipe)
      Description copied from interface: Promise
      This method will register pipes such that when a Deferred object is either resolved (Deferred.resolve(Object)), rejected (Deferred.reject(Object)) or is notified of progress (Deferred.notify(Object)), the corresponding pipe will be invoked. DonePipe and FailPipe will be triggered at the time the Deferred object is resolved or rejected. If the Deferred object is already resolved or rejected the filter is triggered immediately. This method is similar to JQuery's pipe() method, where a new Promise is returned by the the pipe filter instead of the original. This is useful to handle return values and then rewiring it to different callbacks. Pipes start a new Deferred object. This allows to chain asynchronous calls. If your pipe does not do any asynchronous work consider using Promise.filter(DoneFilter, FailFilter, ProgressFilter) 
      
promise.pipe(new DonePipeinvalid input: '<'Integer, Integer, String, Void>() {
  @Override
  Deferredinvalid input: '<'Integer, Void, Void> pipeDone(Integer result) {
    // Reject values greater than 100
    if (result > 100) {
      return new DeferredObjectinvalid input: '<'Integer, Void, Void>().reject("Failed");
    } else {
      return new DeferredObjectinvalid input: '<'Integer, Void, Void>().resolve(result);
    }
  }
}).done(...)
.fail(...);
      Specified by:
      pipe in interface Promise<D,F,P>
      Parameters:
      donePipe - the pipe to invoke when a result is available. If null, result is piped unchanged
      failPipe - the pipe to invoke when a failure is available. If null, failure is piped unchanged
      progressPipe - the pipe to execute when progress info is available. If null, progress is piped unchanged
      Returns:
      a new promise for the piped result, failure and progress.

    • pipeAlways

      public <D_OUT,F_OUT> Promise<D_OUT,F_OUT,P> pipeAlways(AlwaysPipe<? super D, ? super F, ? extends D_OUT, ? extends F_OUT, ? extends P> alwaysPipe)
      Description copied from interface: Promise
      This method will register a pipe such that when a Deferred object is either resolved (Deferred.resolve(Object)) or rejected (Deferred.reject(Object)) the pipe will be invoked. AlwaysPipe will be triggered at the time the Deferred object is resolved or rejected. If the Deferred object is already resolved or rejected the filter is triggered immediately. This method is similar to JQuery's pipe() method, where a new Promise is returned by the the pipe filter instead of the original. This is useful to handle return values and then rewiring it to different callbacks. Pipes start a new Deferred object. This allows to chain asynchronous calls. 
      
promise.pipeAlways(new pipeinvalid input: '<'Integer, Integer, String, String, Void>() {
  @Override
  Promiseinvalid input: '<'Integer, Void, Void> pipeAlways(State state, Integer resolved, Integer rejected) {
    if (state == State.RESOLVED) {
      return new DeferredObjectinvalid input: '<'String, String, Void>().resolve("Success");
    } else {
      return new DeferredObjectinvalid input: '<'String, String, Void>().reject("Failed");
    }
  }
}).done(...)
.fail(...);
      Specified by:
      pipeAlways in interface Promise<D,F,P>
      Parameters:
      alwaysPipe - the pipe to invoke when a result or failure is available.
      Returns:
      a new promise for the piped result or failure.

    • isPending

      public boolean isPending()
      Description copied from interface: Promise
      Queries the state of this promise, returning true iff it is State.PENDING.
      Specified by:
      isPending in interface Promise<D,F,P>
      Returns:
      true if the current state of this promise is State.PENDING, false otherwise.
      See Also:

    • isResolved

      public boolean isResolved()
      Description copied from interface: Promise
      Queries the state of this promise, returning true iff it is State.RESOLVED.
      Specified by:
      isResolved in interface Promise<D,F,P>
      Returns:
      true if the current state of this promise is State.RESOLVED, false otherwise.
      See Also:

    • isRejected

      public boolean isRejected()
      Description copied from interface: Promise
      Queries the state of this promise, returning true iff it is State.REJECTED.
      Specified by:
      isRejected in interface Promise<D,F,P>
      Returns:
      true if the current state of this promise is State.REJECTED, false otherwise.
      See Also:

    • waitSafely

      public void waitSafely() throws InterruptedException
      Description copied from interface: Promise
      This method will wait as long as the State is Pending. This method will return fast when State is not Pending.
      Specified by:
      waitSafely in interface Promise<D,F,P>
      Throws:
      InterruptedException - if thread is interrupted while waiting

    • waitSafely

      public void waitSafely(long timeout) throws InterruptedException
      Description copied from interface: Promise
      This method will wait when the State is Pending, and return when timeout has reached. This method will return fast when State is not Pending.
      Specified by:
      waitSafely in interface Promise<D,F,P>
      Parameters:
      timeout - the maximum time to wait in milliseconds
      Throws:
      InterruptedException - if thread is interrupted while waiting

    • handleException

      protected void handleException(CallbackExceptionHandler.CallbackType callbackType, Exception e)