)
    val call =
      client.newCall(
        Request.Builder()
          .url(server.url("/"))
          .build(),
      )
    val completionLatch = CountDownLatch(1)
    val callback: Callback =
      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          completionLatch.countDown()
        }

        override fun onResponse(

ne();
L1142:                this.endDate = this.oldEndDate.clone();
L1143:            }
L1144:
L1145:            //if a new date range was selected, invoke the user callback function
L1146:            if (!this.startDate.isSame(this.oldStartDate) || !this.endDate.isSame(this.oldEndDate))
L1147:                this.callback(this.startDate.clone(), this.endDate.clone(), this.chosenLabel);
L1148:
L1149:            //if picker is attached to a text input, update it
L1150:            this.updateElement();
...

    }

    protected void writeJsonResponse(final int status, final String body) {
        final String callback = LaRequestUtil.getOptionalRequest().map(req -> req.getParameter("callback")).orElse(null);
        final boolean isJsonp = ComponentUtil.getFessConfig().isApiJsonpEnabled() && StringUtil.isNotBlank(callback);

        final HttpServletResponse response = LaResponseUtil.getResponse();
        response.setStatus(status);

_2016-01-13_

This release commits to a stable 3.0 API. Read the 3.0.0-RC1 changes for advice
on upgrading from 2.x to 3.x.

 *  **The `Callback` interface now takes a `Call`**. This makes it easier to
    check if the call was canceled from within the callback. When migrating
    async calls to this new API, `Call` is now the first parameter for both
    `onResponse()` and `onFailure()`.

        then:
        noExceptionThrown()

        where:
        methods << getQueryMethods() + getMutatingMethods()
    }

    def "fires build operation when emitting added callback and reestablishes user code context"() {
        given:
        containerSupportsBuildOperations()

        UserCodeApplicationId id1 = null
        userCodeApplicationContext.apply(Stub(UserCodeSource)) {

            }
            callback.run();
            break;
        default:
            ComponentUtil.getCurlHelper().post("/_configsync/flush").execute(response -> {
                if (logger.isDebugEnabled()) {
                    logger.debug("Flushed config files: {} => {}", fesenType, response.getContentAsString());
                }
                callback.run();
            }, e -> {

	arg := "0"
	if len(paramnames) > 0 {
		arg = "uintptr(unsafe.Pointer(&p0))"
	} else if !void {
		arg = "uintptr(unsafe.Pointer(&r1))"
	}

	noCallback := p.noCallbacks[n.C]
	if noCallback {
		// disable cgocallback, will check it in runtime.
		fmt.Fprintf(fgo2, "\t_Cgo_no_callback(true)\n")
	}

	prefix := ""
	if n.AddError {
		prefix = "errno := "
	}

	return func(o *frameworkOptions) {
		o.parallelizer = parallelize.NewParallelizer(parallelism)
	}
}

// CaptureProfile is a callback to capture a finalized profile.
type CaptureProfile func(config.KubeSchedulerProfile)

// WithCaptureProfile sets a callback to capture the finalized profile.
func WithCaptureProfile(c CaptureProfile) Option {
	return func(o *frameworkOptions) {
		o.captureProfile = c
	}
}

	}

	if test.validate != nil {
		if err := test.validate(connState); err != nil {
			t.Fatalf("validate callback returned error: %s", err)
		}
	}

	if write {
		path := test.dataPath()
		out, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
		if err != nil {

	public static final field TYPE_A I
	public static final field TYPE_AAAA I
	public abstract fun query (Ljava/lang/String;Lokhttp3/AsyncDns$Callback;)V
}

public abstract interface class okhttp3/AsyncDns$Callback {
	public abstract fun onFailure (Ljava/lang/String;Ljava/io/IOException;)V
	public abstract fun onResponse (Ljava/lang/String;Ljava/util/List;)V
}