import java.io.Closeable
import java.util.concurrent.ConcurrentHashMap

internal abstract class NullawayStatusService : BuildService<BuildServiceParameters.None>, Closeable {
    private val projectsWithNullAwayEnabled = ConcurrentHashMap.newKeySet<String>()
    private val projectsWithUncheckedDeps = ConcurrentHashMap.newKeySet<String>()
    private val projectsToEnableNullaway = ConcurrentHashMap.newKeySet<String>()

        val rootProjectDir: DirectoryProperty
    }

    @get:Inject
    abstract val execOperations: ExecOperations

    private
    val suspiciousDaemons = ConcurrentHashMap<String, MutableSet<String>>()

    private
    val daemonPids = ConcurrentHashMap.newKeySet<String>()

    private
    val logger = Logging.getLogger(DaemonTracker::class.java)

    override fun close() {

    /**
     * Creates and returns a new instance of {@link ConcurrentHashMap}.
     *
     * @param <K> the key type of {@link ConcurrentHashMap}
     * @param <V> the value type of {@link ConcurrentHashMap}
     * @return a new instance of {@link ConcurrentHashMap}
     * @see ConcurrentHashMap#ConcurrentHashMap()
     */
    public static <K, V> ConcurrentHashMap<K, V> newConcurrentHashMap() {
        return new ConcurrentHashMap<>();

 */
public class LeaseManager {

    private static final Logger log = LoggerFactory.getLogger(LeaseManager.class);

    private final ConcurrentHashMap<Smb2LeaseKey, LeaseEntry> leases;
    private final ConcurrentHashMap<String, Smb2LeaseKey> pathToLease;
    private final ConcurrentHashMap<String, WeakReference<SmbFile>> fileCache;
    private final ReadWriteLock lock;
    private final CIFSContext context;

    // GWT's ConcurrentHashMap is a wrapper around HashMap, but it rejects null keys, which matches
    // the behaviour of the non-GWT implementation of newConcurrentHashSet().
    // On the other hand HashSet might be better for code size if apps aren't
    // already using Collections.newSetFromMap and ConcurrentHashMap.
    return Collections.newSetFromMap(new ConcurrentHashMap<E, Boolean>());
  }

    private final TypeRegistry typeRegistry;

    private final ConcurrentHashMap<String, ArtifactHandler> allHandlers;

    @Inject
    public DefaultArtifactHandlerManager(TypeRegistry typeRegistry) {
        this.typeRegistry = requireNonNull(typeRegistry, "null typeRegistry");
        this.allHandlers = new ConcurrentHashMap<>();
    }

    @Override
    public void onEvent(Object event) {

  private final OkHttpClient client;
  private final Set<HttpUrl> fetchedUrls = Collections.synchronizedSet(new LinkedHashSet<>());
  private final BlockingQueue<HttpUrl> queue;
  private final ConcurrentHashMap<String, AtomicInteger> hostnames = new ConcurrentHashMap<>();
  private final int hostLimit;

  public Crawler(OkHttpClient client, int queueLimit, int hostLimit) {
    this.client = client;
    this.queue = new LinkedBlockingQueue<>(queueLimit);

     * @param value the value to be added to the <code>Map</code>
     * @return a {@literal Maps} for constructing a {@link ConcurrentHashMap} with the specified key and value
     */
    public static <KEY, VALUE> Maps<KEY, VALUE> concurrentHashMap(final KEY key, final VALUE value) {
        return new Maps<>(new ConcurrentHashMap<KEY, VALUE>()).$(key, value);
    }

    /**

    private final CIFSContext context;
    private final LeaseManager baseLeaseManager;
    private final ConcurrentHashMap<String, DirectoryCacheEntry> directoryCache;
    private final ConcurrentHashMap<Smb2LeaseKey, String> leaseToPath;
    private final ScheduledExecutorService scheduler;
    private final DirectoryChangeNotifier changeNotifier;

    /**

   * figure out what to do with <a
   * href="https://github.com/openjdk/jdk/blob/c25c4896ad9ef031e3cddec493aef66ff87c48a7/src/java.base/share/classes/java/util/concurrent/ConcurrentHashMap.java#L4830">{@code
   * ConcurrentHashMap} support for {@code entrySet().add()}</a>.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static Method getAddAllUnsupportedNonePresentMethod() {