Method callback

src/Deferred.java:977–1003

Starts running the callback chain. This posts the initial result that will be passed to the first callback in the callback chain. If the argument is an Exception then the "errback" chain will be triggered instead. This method will not let any Exception thrown by a callback p

(final Object initresult)

   * @throws AssertionError if {@code initresult == this}.
   */
  public void callback(final Object initresult) {
    if (!casState(PENDING, RUNNING)) {
      throw new AssertionError("This Deferred was already called!"
        + "  New result=" + initresult + ", this=" + this);
    }
    result = initresult;
    if (initresult instanceof Deferred) {
      // Twisted doesn't allow a callback chain to start with another Deferred
      // but I don't see any reason.  Maybe it was to help prevent people from
      // creating recursive callback chains that would never terminate?  We
      // already check for the obvious in handleContinuation by preventing
      // this Deferred from depending on itself, but there's no way to prevent
      // people from building mutually dependant Deferreds or complex cyclic
      // chains of Deferreds, unless we keep track in a set of all the
      // Deferreds we go through while executing a callback chain, which seems
      // like an unnecessary complication for uncommon cases (bad code). Plus,
      // when that actually happens and people write buggy code that creates
      // cyclic chains, they will quickly get a CallbackOverflowError.
      final Deferred d = (Deferred) initresult;
      if (this == d) {
        throw new AssertionError("A Deferred cannot be given to itself"
                                 + " as a result.  this=" + this);
      }
      handleContinuation(d, null);
    }
    runCallbacks();
  }

  /**
   * Synchronously waits until this Deferred is called back.