fun noNewExchangesOnConnection() {
    codec.carrier.noNewExchanges()
  }

  fun cancel() {
    codec.cancel()
  }

  /**
   * Revoke this exchange's access to streams. This is necessary when a follow-up request is
   * required but the preceding exchange hasn't completed yet.
   */
  fun detachWithViolence() {
    codec.cancel()
    call.messageDone(this, requestDone = true, responseDone = true, e = null)
  }

    private void put(TransferEvent event, boolean last) {
        try {
            Exchange exchange;
            if (blockOnLastEvent && last) {
                exchange = new BlockingExchange(event);
            } else {
                exchange = new Exchange(event);
            }
            eventQueue.put(exchange);
            exchange.waitForProcessed();
        } catch (InterruptedException e) {

  private val index: Int,
  internal val exchange: Exchange?,
  internal val request: Request,
  internal val connectTimeoutMillis: Int,
  internal val readTimeoutMillis: Int,
  internal val writeTimeoutMillis: Int,
) : Interceptor.Chain {
  private var calls: Int = 0

  internal fun copy(
    index: Int = this.index,
    exchange: Exchange? = this.exchange,
    request: Request = this.request,

      apply {
        this.receivedResponseAtMillis = receivedResponseAtMillis
      }

    internal fun initExchange(exchange: Exchange) {
      this.exchange = exchange
      this.trailersFn = { exchange.trailers() }
    }

    open fun build(): Response {
      check(code >= 0) { "code < 0: $code" }
      return Response(

      if (shouldIgnoreAndWaitForRealResponse(code, exchange)) {
        responseBuilder = exchange.readResponseHeaders(expectContinue = false)!!
        if (invokeStartEvent) {
          exchange.responseHeadersStart()
        }
        response =
          responseBuilder
            .request(request)
            .handshake(exchange.connection.handshake())
            .sentRequestAtMillis(sentRequestMillis)

    exchange: Exchange,
    requestDone: Boolean,
    responseDone: Boolean,
    e: E,
  ): E {
    if (exchange != this.exchange) return e // This exchange was detached violently!

    var bothStreamsDone = false
    var callDone = false
    this.withLock {
      if (requestDone && requestBodyOpen || responseDone && responseBodyOpen) {
        if (requestDone) requestBodyOpen = false

}

internal var RealConnection.idleAtNsAccessor: Long
  get() = idleAtNs
  set(value) {
    idleAtNs = value
  }

internal val Response.exchangeAccessor: Exchange?
  get() = this.exchange

internal val Exchange.connectionAccessor: RealConnection
  get() = this.connection

            .request(request)
            .priorResponse(priorResponse?.stripBody())
            .build()

        val exchange = call.interceptorScopedExchange
        val followUp = followUpRequest(response, exchange)

        if (followUp == null) {
          if (exchange != null && exchange.isDuplex) {
            call.timeoutEarlyExit()
          }
          closeActiveExchange = false
          return response

  @Throws(IOException::class)
  override fun intercept(chain: Interceptor.Chain): Response {
    val realChain = chain as RealInterceptorChain
    val exchange = realChain.call.initExchange(realChain)
    val connectedChain = realChain.copy(exchange = exchange)
    return connectedChain.proceed(realChain.request)
  }

          response: Response,
        ) {
          val exchange = response.exchange
          val streams: Streams
          try {
            checkUpgradeSuccess(response, exchange)
            streams = exchange!!.newWebSocketStreams()
          } catch (e: IOException) {
            failWebSocket(e, response)
            response.closeQuietly()
            exchange?.webSocketUpgradeFailed()
            return
          }