override fun contentLength(): Long = delegate.contentLength()

  @Throws(IOException::class)
  override fun writeTo(sink: BufferedSink) {
    delegate.writeTo(sink)
  }

  override fun isDuplex(): Boolean = delegate.isDuplex()

  override fun toString(): String = javaClass.simpleName + "(" + delegate.toString() + ")"

  init {
    requireNotNull(delegate) { "delegate == null" }
    this.delegate = delegate
  }

/**
 * Handles a call's request and response streams directly. Use this instead of [MockResponseBody] to
 * begin sending response data before all request data has been received.
 *
 * See [okhttp3.RequestBody.isDuplex].
 */
public interface SocketHandler {
  public fun handle(socket: Socket)

  internal val eventListener: EventListener,
  internal val finder: ExchangeFinder,
  private val codec: ExchangeCodec,
) {
  /** True if the request body need not complete before the response body starts. */
  internal var isDuplex: Boolean = false
    private set

  /** True if there was an exception on the connection to the peer. */
  internal var hasFailure: Boolean = false
    private set

  internal val connection: RealConnection

          exchange.responseHeadersStart()
          invokeStartEvent = false
        }
        if (responseBuilder == null) {
          if (requestBody.isDuplex()) {
            // Prepare a duplex body so that the application can send a request body later.
            exchange.flushRequest()
            val bufferedRequestBody = exchange.createRequestBody(request, true).buffer()

  override fun contentType(): MediaType? = null

  override fun writeTo(sink: BufferedSink) {
    requestBodySinks.add(sink)
  }

  override fun isDuplex(): Boolean = true

  @Throws(InterruptedException::class)
  fun takeSink(): BufferedSink = requestBodySinks.poll(5, SECONDS) ?: throw AssertionError("no sink to take")

  fun assertNoMoreSinks() {

          logger.log("--> END ${request.method}")
        } else if (bodyHasUnknownEncoding(request.headers)) {
          logger.log("--> END ${request.method} (encoded body omitted)")
        } else if (requestBody.isDuplex()) {
          logger.log("--> END ${request.method} (duplex request body omitted)")
        } else if (requestBody.isOneShot()) {
          logger.log("--> END ${request.method} (one-shot body omitted)")
        } else {

   * quickly, possibly by handing off the provided request body to another thread to perform
   * writing.
   *
   * [grpc]: https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md
   */
  open fun isDuplex(): Boolean = false

  /**
   * Returns true if this body expects at most one call to [writeTo] and can be transmitted
   * at most once. This is typically used when writing the request body is destructive and it is not

            .build()

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

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

  override val isResponseComplete: Boolean
    get() = state == STATE_CLOSED

  override fun createRequestBody(
    request: Request,
    contentLength: Long,
  ): Sink =
    when {
      request.body?.isDuplex() == true -> throw ProtocolException(
        "Duplex connections are not supported for HTTP/1",
      )
      request.isChunked -> newChunkedSink() // Stream a request body of unknown length.

 *
 * This nesting is typical but not strict. For example, when calls use "Expect: continue" the
 * request body start and end events occur within the response header events. Similarly,
 * [duplex calls][RequestBody.isDuplex] interleave the request and response bodies.
 *
 * Since connections may be reused, the proxy selection, DNS, and connect events may not be present