t.Once.Do(func() {
		t.ttl = ttl
		t.updateFn = update
		t.opts = opts
	})
}

// GetWithCtx will return a cached value or fetch a new one.
// passes a caller context, if caller context cancels nothing
// is cached.
// If the Update function returns an error the value is forwarded as is and not cached.
func (t *Cache[T]) GetWithCtx(ctx context.Context) (T, error) {
	v := t.val.Load()
	ttl := t.ttl

/**
 * A {@link ListenableFuture} whose result can be set by a {@link #set(Object)}, {@link
 * #setException(Throwable)} or {@link #setFuture(ListenableFuture)} call. It can also, like any
 * other {@code Future}, be {@linkplain #cancel cancelled}.
 *
 * <p>{@code SettableFuture} is the recommended {@code ListenableFuture} implementation when your
 * task cannot be implemented with {@link ListeningExecutorService}, the various {@link Futures}

	public fun cacheMiss (Lokhttp3/Call;)V
	public fun callEnd (Lokhttp3/Call;)V
	public fun callFailed (Lokhttp3/Call;Ljava/io/IOException;)V
	public fun callStart (Lokhttp3/Call;)V
	public fun canceled (Lokhttp3/Call;)V
	public fun connectEnd (Lokhttp3/Call;Ljava/net/InetSocketAddress;Ljava/net/Proxy;Lokhttp3/Protocol;)V

		},
		HeaderSize: headerSize,
	}
	newCtx := ctx
	if globalBucketMonitor.IsThrottled(bucket, tgt.ARN) && objInfo.Size < minLargeObjSize {
		var cancel context.CancelFunc
		newCtx, cancel = context.WithTimeout(ctx, throttleDeadline)
		defer cancel()
	}
	r := bandwidth.NewMonitoredReader(newCtx, globalBucketMonitor, gr, opts)
	if objInfo.isMultipart() {

    apply {
      actions += { stream ->
        if (!stream.requestBody.exhausted()) throw AssertionError("expected exhausted")
      }
    }

  fun cancelStream() =
    apply {
      actions += { stream -> stream.cancel() }
    }

  fun requestIOException() =
    apply {
      actions += { stream ->
        try {
          stream.requestBody.exhausted()
          throw AssertionError("expected IOException")

    assertThatFutureBecomesCancelled(closingFuture.finishToFuture());
  }

  @Override
  void cancelFinalStepAndWait(ClosingFuture<TestCloseable> closingFuture) {
    assertThat(closingFuture.finishToFuture().cancel(false)).isTrue();
    waitUntilClosed(closingFuture);
    futureCancelled.countDown();
  }

        if ( this.ptype == 2 || this.ptype == 3 ) { /* Response or Fault */
            this.alloc_hint = buf.dec_ndr_long();
            buf.dec_ndr_short(); /* context id */
            buf.dec_ndr_short(); /* cancel count */
        }
        if ( this.ptype == 3 || this.ptype == 13 ) { /* Fault */
            this.result = buf.dec_ndr_long();
        }
        else { /* Bind_ack or Response */
            decode_out(buf);

        throw IllegalStateException(
          "Cannot stream a request body without chunked encoding or a known content length!",
        )
    }
  }

  override fun cancel() {
    carrier.cancel()
  }

  /**
   * Prepares the HTTP headers and sends them to the server.
   *
   * For streaming requests with a body, headers must be prepared **before** the output stream has

    // Play it back.
    connect(peer, PushObserver.CANCEL, Http2Connection.Listener.REFUSE_INCOMING_STREAMS)

    // Verify the peer received what was expected.
    val rstStream = peer.takeFrame()
    assertThat(rstStream.type).isEqualTo(Http2.TYPE_RST_STREAM)
    assertThat(rstStream.streamId).isEqualTo(2)
    assertThat(rstStream.errorCode).isEqualTo(ErrorCode.CANCEL)
  }

  /**

labels.crawling_info_created_time=Created
labels.crawling_info_delete_all_link=Delete All
labels.crawling_info_delete_all_confirmation=Do you really want to delete all?
labels.crawling_info_delete_all_cancel=Cancel
labels.crawling_info_thread_dump=Thread Dump
labels.crawling_info_CrawlerStartTime=Crawler start time
labels.crawling_info_CrawlerEndTime=Crawler end time
labels.crawling_info_CrawlerExecTime=Crawler exec time