*
   * <p>Note that if {@code s} is a {@code Multiset<String>}, then {@code
   * ImmutableSortedMultiset.copyOf(s)} returns an {@code ImmutableSortedMultiset<String>}
   * containing each of the strings in {@code s}, while {@code ImmutableSortedMultiset.of(s)}
   * returns an {@code ImmutableSortedMultiset<Multiset<String>>} containing one element (the given
   * multiset itself).
   *

        final String repoContent = getRepositoryContent(url);
        final Matcher matcher = Pattern.compile("href=\"[^\"]*(" + artifactType.getId() + "[a-zA-Z0-9\\-]+)/?\"").matcher(repoContent);
        while (matcher.find()) {
            final String name = matcher.group(1);
            if (isExcludedName(artifactType, name)) {
                continue;
            }

    peer.play()
    val connection = connect(peer)
    val stream1 = connection.newStream(headerEntries("b", "bark"), false)
    val source = stream1.source
    val buffer = Buffer()
    while (buffer.size != 1024L) source.read(buffer, 1024)
    stream1.close(ErrorCode.CANCEL, null)
    val frame1 = peer.takeFrame()
    assertThat(frame1.type).isEqualTo(Http2.TYPE_HEADERS)
    val frame2 = peer.takeFrame()

            final Deque<CrawlRequest> requestQueue = new LinkedList<>();
            final Set<String> processedUrls = new HashSet<>();
            requestQueue.offer(new CrawlRequest(url, 0));
            while (!requestQueue.isEmpty() && (maxAccessCount < 0 || counter < maxAccessCount)) {
                final CrawlRequest crawlRequest = requestQueue.poll();

        }
        return 0.0f;
    }

    /**
     * Wrapper class for SearchRequestParams that allows overriding specific parameters.
     * This wrapper is used to modify pagination parameters while preserving all other
     * search request parameters from the parent object.
     */
    protected static class SearchRequestParamsWrapper extends SearchRequestParams {
        private final SearchRequestParams parent;

   * they are declared by the same {@link java.lang.reflect.GenericDeclaration} and have the same
   * name, even if their bounds differ.
   *
   * <p>While resolving a type variable from a {@code var -> type} map, we don't care whether the
   * type variable's bound has been partially resolved. As long as the type variable "identity"
   * matches.
   *

                                    br = new BufferedReader(new InputStreamReader(new FileInputStream(tempFile), enc));
                                }
                                String line;
                                while ((line = br.readLine()) != null) {
                                    writer.write(line);
                                }
                            } catch (final Exception e) {

      object : Comparator<String> {
        override fun compare(
          a: String,
          b: String,
        ): Int {
          var i = 4
          val limit = minOf(a.length, b.length)
          while (i < limit) {
            val charA = a[i]
            val charB = b[i]
            if (charA != charB) return if (charA < charB) -1 else 1
            i++
          }
          val lengthA = a.length

    connection.setFixedLengthStreamingMode(1024 * 1024 * 1024) // 1 GB
    connection.connect()
    val out = connection.outputStream
    val data = ByteArray(1024 * 1024)
    var i = 0
    while (i < 1024) {
      try {
        out!!.write(data)
        out.flush()
        if (i == 513) {
          // pause slightly after half way to make result more predictable
          Thread.sleep(100)
        }

 *  **Okio dependency added.** OkHttp now depends on
    [Okio](https://github.com/square/okio), an I/O library that makes it easier
    to access, store and process data. Using this library internally makes OkHttp
    faster while consuming less memory. You can write a `RequestBody` as an Okio
    `BufferedSink` and a `ResponseBody` as an Okio `BufferedSource`. Standard
    `InputStream` and `OutputStream` access is also available.