}
        }
      }
    }

    override fun priority(
      streamId: Int,
      streamDependency: Int,
      weight: Int,
      exclusive: Boolean,
    ) {
      // TODO: honor priority.
    }

    override fun pushPromise(
      streamId: Int,
      promisedStreamId: Int,
      requestHeaders: List<Header>,
    ) {

 * sequences, accessible as streams or files. Each value must be between `0` and `Int.MAX_VALUE`
 * bytes in length.
 *
 * The cache stores its data in a directory on the filesystem. This directory must be exclusive to
 * the cache; the cache may delete or overwrite files from its directory. It is an error for
 * multiple processes to use the same cache directory at the same time.
 *

 *
 * <p>While {@code ReadWriteLock} instances have different properties and can form cycles without
 * potential deadlock, this class treats {@code ReadWriteLock} instances as equivalent to
 * traditional exclusive locks. Although this increases the false positives that the locks detect
 * (i.e. cycles that will not actually result in deadlock), it simplifies the algorithm and

   *
   * <p>See http://en.wikipedia.org/wiki/File:Bloom_filter_fp_probability.svg for the formula.
   *
   * @param p desired false positive probability (must be between 0 and 1, exclusive)
   */
  @VisibleForTesting
  static int optimalNumOfHashFunctions(double p) {
    // -log(p) / log(2), ensuring the result is rounded to avoid truncation.
    return max(1, (int) Math.round(-Math.log(p) / LOG_TWO));

    return indexOf(object) >= 0;
  }

  // constrain the return type to ImmutableList<E>

  /**
   * Returns an immutable list of the elements between the specified {@code fromIndex}, inclusive,
   * and {@code toIndex}, exclusive. (If {@code fromIndex} and {@code toIndex} are equal, the empty
   * immutable list is returned.)
   *
   * <p><b>Note:</b> in almost all circumstances, the returned {@link ImmutableList} retains a

      if (digit < 0) {
        return -1;
      }
      decimal += digit;
    }
    return decimal;
  }

  // Parse a hextet out of the ipString from start (inclusive) to end (exclusive)
  private static short parseHextet(String ipString, int start, int end) {
    // Note: we already verified that this string contains only hex digits.
    int length = end - start;

purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.

  Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.

 *
 * <p>While {@code ReadWriteLock} instances have different properties and can form cycles without
 * potential deadlock, this class treats {@code ReadWriteLock} instances as equivalent to
 * traditional exclusive locks. Although this increases the false positives that the locks detect
 * (i.e. cycles that will not actually result in deadlock), it simplifies the algorithm and

        }
        return name;
    }

    /**
     * Sets whether this file should use an exclusive (non-pooled) connection
     *
     * @param nonPooled
     *            whether this file will use an exclusive connection
     */
    protected void setNonPooled(final boolean nonPooled) {
        this.treeConnection.setNonPooled(nonPooled);
    }

    /**

      if (digit < 0) {
        return -1;
      }
      decimal += digit;
    }
    return decimal;
  }

  // Parse a hextet out of the ipString from start (inclusive) to end (exclusive)
  private static short parseHextet(String ipString, int start, int end) {
    // Note: we already verified that this string contains only hex digits.
    int length = end - start;