* There are a number of ways to solve this, none of which are very pretty, and it is currently
   * believed to be a purely theoretical problem (since the other actions should supply sufficient
   * write-barriers).
   */

  @LazyInit private @Nullable ListenableFuture<V> delegateRef;
  @LazyInit private @Nullable ScheduledFuture<?> timer;

  private TimeoutFuture(ListenableFuture<V> delegate) {

    if (seenExceptionsLocal == null) {
      // TODO(cpovirk): Should we use a simpler (presumably cheaper) data structure?
      /*
       * Using weak references here could let us release exceptions earlier, but:
       *
       * 1. On Android, querying a WeakReference blocks if the GC is doing an otherwise-concurrent
       * pass.
       *

    recurrence: Boolean,
  ): Boolean {
    task.initQueue(this)

    val now = taskRunner.backend.nanoTime()
    val executeNanoTime = now + delayNanos

    // If the task is already scheduled, take the earlier of the two times.
    val existingIndex = futureTasks.indexOf(task)
    if (existingIndex != -1) {
      if (task.nextExecuteNanoTime <= executeNanoTime) {
        taskRunner.logger.taskLog(task, this) { "already scheduled" }

    if (!disjoint(newFeatures, earlierFeatures)) {
      throw new ConflictingRequirementsException(
          String.format(
              Locale.ROOT,
              "Annotation requires to be %s features that earlier "
                  + "annotations required to be %s.",
              newRequirement,
              earlierRequirement),
          intersection(newFeatures, earlierFeatures),
          source);
    }
  }

  /** Returns the HTTP status message. */
  @get:JvmName("message") val message: String,
  /** Returns the HTTP status code. */
  @get:JvmName("code") val code: Int,
  /**
   * Returns the TLS handshake of the connection that carried this response, or null if the
   * response was received without TLS.
   */
  @get:JvmName("handshake") val handshake: Handshake?,
  /** Returns the HTTP headers. */
  @get:JvmName("headers") val headers: Headers,
  /**

 * Not invoked for cached responses that short-circuit the network.
 * Observe the data just as it will be transmitted over the network.
 * Access to the `Connection` that carries the request.

### Rewriting Requests

         *
         * @param h1 the first hour
         * @param m1 the first minute
         * @param h2 the second hour
         * @param m2 the second minute
         * @return positive if first time is earlier, 0 if equal, negative if later
         */
        protected int compareTime(final int h1, final int m1, final int h2, final int m2) {
            if (h1 < h2) {
                return 1;
            }

        assertEquals(data2.getUrl(), data3.getUrl());
        assertEquals(data2.getWeight(), data3.getWeight(), 0.001f);
    }

    public void test_overwritingValues() {
        // Test that later values overwrite earlier ones
        RequestData data = RequestDataBuilder.newRequestData()
                .get()
                .post()
                .url("https://first.com")
                .url("https://second.com")

  //    (hypothetical) unsafe read by our caller. Note: adding 'volatile' does not fix this issue,
  //    it would just add an edge such that if done() observed non-null, then it would also
  //    definitely observe all earlier writes, but we still have no guarantee that done() would see
  //    the initial write (just stronger guarantees if it does).
  //
  // See: http://cs.oswego.edu/pipermail/concurrency-interest/2015-January/013800.html

   * request, and ensure that (1/QPS) seconds have elapsed since then. For example, for a rate of
   * QPS=5 (5 tokens per second), if we ensure that a request isn't granted earlier than 200ms after
   * the last one, then we achieve the intended rate. If a request comes and the last request was
   * granted only 100ms ago, then we wait for another 100ms. At this rate, serving 15 fresh permits