// only called when there's no child.
      if ((minChildIndex > 0) && (ordering.compare(elementData(minChildIndex), x) < 0)) {
        queue[index] = elementData(minChildIndex);
        queue[minChildIndex] = x;
        return minChildIndex;
      }
      return crossOverUp(index, x);
    }

    /**

    internal `DiskLruCache` assumes an inode-like file system, where it's fine to delete files that
    are currently being read or written. On Windows the file system forbids this so we must be more
    careful when deleting and renaming files.

 *  Fix: Don't crash on Java 8u252 which introduces an API previously found only on Java 9 and

import org.codelibs.fess.opensearch.log.cbean.ca.SearchLogCA;
import org.codelibs.fess.opensearch.log.cbean.cq.SearchLogCQ;
import org.codelibs.fess.opensearch.log.cbean.cq.bs.BsSearchLogCQ;
import org.opensearch.search.aggregations.bucket.filter.FilterAggregationBuilder;
import org.opensearch.search.aggregations.bucket.global.GlobalAggregationBuilder;
import org.opensearch.search.aggregations.bucket.histogram.DateHistogramAggregationBuilder;

 *   <li>Or, to avoid storing up all the data first, create a {@link StatsAccumulator} instance,
 *       feed values to it as you get them, then call {@link StatsAccumulator#snapshot}.
 * </ul>
 *
 * <p>Static convenience methods called {@code meanOf} are also provided for users who wish to
 * calculate <i>only</i> the mean.
 *
 * <p><b>Java 8+ users:</b> If you are not using any of the variance statistics, you may wish to use

      void set(T value) {
        this.set = true;
        this.value = value;
      }

      T get() {
        /*
         * requireNonNull is safe because we call get() only if we've previously called set().
         *
         * (For further discussion of nullness, see the comment above the method.)
         */
        return requireNonNull(value);
      }
    }

     * nextItem holds on to item fields because once we claim that an element exists in hasNext(),
     * we must return it in the following next() call even if it was in the process of being removed
     * when hasNext() was called.
     */
    private @Nullable E nextItem;

    /**
     * Index of element returned by most recent call to next. Reset to -1 if this element is deleted
     * by a call to remove.
     */

   * Iterables#filter(Iterable, Class)} for related functionality.)
   *
   * <p><b>{@code Stream} equivalent:</b> {@link java.util.stream.Stream#filter Stream.filter}.
   */
  public static <E extends @Nullable Object> Collection<E> filter(
      Collection<E> unfiltered, Predicate<? super E> predicate) {
    if (unfiltered instanceof FilteredCollection) {

  * Now the command will succeed even if the sort-by field is missing from one or more of the objects
* Fixed issue with kubectl proxy so it will now proxy an empty path - e.g. http://localhost:8001 ([#39226](https://github.com/kubernetes/kubernetes/pull/39226), [@luksa](https://github.com/luksa))

    /** Maximum number of entries to return in list operations */
    protected int smbListCount = 200;
    /** Time in milliseconds before cached file attributes expire */
    protected long smbAttributeExpiration = 5000L;
    /** Whether to ignore exceptions during file copy operations */
    protected boolean ignoreCopyToException = false;
    /** Maximum number of request retries on failure */

   */
  @SuppressWarnings("unchecked") // can cast to <T> because non-Ts are removed
  @GwtIncompatible // Class.isInstance
  public static <T> UnmodifiableIterator<T> filter(Iterator<?> unfiltered, Class<T> desiredType) {
    return (UnmodifiableIterator<T>) filter(unfiltered, instanceOf(desiredType));
  }

  /**
   * Returns {@code true} if one or more elements returned by {@code iterator} satisfy the given
   * predicate.
   */