builtBy(writeFuturePluginVersions)
        }
    }
}

// Workaround for https://github.com/gradle/gradlecom/issues/627
configurations.archives.get().allArtifacts.removeIf {
    it.name != "plugins"
}

val pgpSigningKey: Provider<String> = providers.environmentVariable("PGP_SIGNING_KEY")

        // Clean up old failure records
        long now = System.currentTimeMillis();
        lastFailureTimes.entrySet().removeIf(entry -> now - entry.getValue() > FAILURE_RECOVERY_TIME * 2);

        // Clean up old consecutive failure counters
        consecutiveFailures.entrySet().removeIf(entry -> {
            String key = entry.getKey();
            Long lastFailure = lastFailureTimes.get(key);

                  return map.entrySet().remove(o);
                }

                @Override
                public boolean removeIf(Predicate<? super Entry<String, String>> filter) {
                  return map.entrySet().removeIf(filter);
                }

                @Override
                public boolean containsAll(Collection<?> c) {

            throw uoe();
        }

        @Override
        public void clear() {
            throw uoe();
        }

        @Override
        public boolean removeIf(Predicate<? super E> filter) {
            throw uoe();
        }
    }

    private static UnsupportedOperationException uoe() {
        return new UnsupportedOperationException();
    }

                    }
                }
                return dependency;
            });
            // Only keep transitive scopes (null/empty => COMPILE)
            directDependencies.values().removeIf(DefaultConsumerPomBuilder::hasDependencyScope);
            managedDependencies.keySet().removeAll(directDependencies.keySet());

            model = model.withDependencyManagement(

        T transform(@ParametricNullness F from) {
          return function.apply(from);
        }
      };
    }

    @Override
    public boolean removeIf(Predicate<? super T> filter) {
      checkNotNull(filter);
      return fromList.removeIf(element -> filter.test(function.apply(element)));
    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;
  }

  /**

    } catch (UnsupportedOperationException expected) {
    }
    assertCollectionsAreEquivalent(multiset, copy);

    try {
      multiset.removeIf(x -> false);
      fail("removeIf(Predicate) succeeded on unmodifiable collection");
    } catch (UnsupportedOperationException expected) {
    }
    assertCollectionsAreEquivalent(multiset, copy);

                props.put(overrideName, substVars(value, name, props, callback));
            } else {
                props.put(name, substVars(value, name, props, callback));
            }
        }
        props.keySet().removeIf(k -> k.startsWith(OVERRIDE_PREFIX));
    }

    private static MavenProperties loadPropertiesFile(Path path, boolean failIfNotFound, UnaryOperator<String> callback)
            throws IOException {

   * @since 2.0
   */
  @CanIgnoreReturnValue
  public static <T extends @Nullable Object> boolean removeIf(
      Iterable<T> removeFrom, Predicate<? super T> predicate) {
    if (removeFrom instanceof Collection) {
      return ((Collection<T>) removeFrom).removeIf(predicate);
    }
    return Iterators.removeIf(removeFrom.iterator(), predicate);
  }

        if (shutdown) {
            return;
        }

        lock.writeLock().lock();
        try {
            // Clean up expired handles
            handles.entrySet().removeIf(entry -> {
                HandleInfo info = entry.getValue();
                if (info.isExpired() && !info.isReconnecting()) {
                    guidToHandle.remove(info.getCreateGuid());