* List, which is _even more likely_ to have size() implemented to be fast and side-effect-free.
     *
     * We could consider recognizing specific other collections as safe (like ImmutableCollection,
     * except ContiguousSet!) or as not worth this optimization (CopyOnWriteArrayList?).
     */
    if (parts instanceof List) {
      int size = ((List<?>) parts).size();

      policy.scheduleOpener()
    }
  }

  /**
   * Performs maintenance on this pool, evicting the connection that has been idle the longest if
   * either it has exceeded the keep alive limit or the idle connections limit.
   *
   * Returns the duration in nanoseconds to sleep until the next scheduled call to this method.
   * Returns -1 if no further cleanups are required.
   */
  fun closeConnections(now: Long): Long {

    }

    public void test_deleteOldDocuments() {
        documentSizeByQuery = 0L;
        final List<String> deletedDocIdList = new ArrayList<>();
        final List<Map<String, Object>> oldDocList = new ArrayList<>();
        final SearchEngineClient client = new SearchEngineClient() {
            @Override
            public List<Map<String, Object>> getDocumentList(final String index, final SearchCondition<SearchRequestBuilder> condition) {

  }

  // Fast path: no characters in [pos..limit) required encoding.
  return substring(pos, limit)
}

internal fun Buffer.writePercentDecoded(
  encoded: String,
  pos: Int,
  limit: Int,
  plusIsSpace: Boolean,
) {
  var codePoint: Int
  var i = pos
  while (i < limit) {
    codePoint = encoded.codePointAt(i)
    if (codePoint == '%'.code && i + 2 < limit) {
      val d1 = encoded[i + 1].parseHexDigit()

          array[i] = null; // for GWT
        }

        List<@Nullable T> list = unmodifiableList(asList(array));
        // TODO(b/192579700): Use a ternary once it no longer confuses our nullness checker.
        if (pad || count == size) {
          return list;
        } else {
          return list.subList(0, count);
        }
      }
    };
  }

  /**

   * target} object, enforcing the specified time limit on each call. This time-limited delegation
   * is also performed for calls to {@link Object#equals}, {@link Object#hashCode}, and {@link
   * Object#toString}.
   *
   * <p>If the target method call finishes before the limit is reached, the return value or
   * exception is propagated to the caller exactly as-is. If, on the other hand, the time limit is

          visitedNodes.addAll(reachableNodes);
          int pairwiseMatch = 1; // start at 1 to include self-loops
          for (N nodeU : reachableNodes) {
            for (N nodeV : Iterables.limit(reachableNodes, pairwiseMatch++)) {
              transitiveClosure.putEdge(nodeU, nodeV);
            }
          }
        }
      }
    }

    return transitiveClosure.build();
  }

  /**

          visitedNodes.addAll(reachableNodes);
          int pairwiseMatch = 1; // start at 1 to include self-loops
          for (N nodeU : reachableNodes) {
            for (N nodeV : Iterables.limit(reachableNodes, pairwiseMatch++)) {
              transitiveClosure.putEdge(nodeU, nodeV);
            }
          }
        }
      }
    }

    return transitiveClosure.build();
  }

  /**

 */
package org.codelibs.core.collection;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * {@link HashMap} with an upper limit on the number of entries. When a new entry is added, the oldest entry is discarded using LRU if the limit is exceeded.
 *
 * @author koichik
 * @param <K> the key type
 * @param <V> the value type
 */
public class LruHashMap<K, V> extends LinkedHashMap<K, V> {

      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