}
    }

    // ===================================================================================================
    /**
     * Helper class to traverse graph. Required to make the containing method thread-safe
     * and yet use class level data to lessen stack usage in recursion
     */
    private class ClasspathGraphVisitor {
        MetadataGraph graph;

        ClasspathContainer cpc;

 *
 * <p>One {@code Type} is visited at most once. The second time the same type is visited, it's
 * ignored by {@link #visit}. This avoids infinite recursion caused by recursive type bounds.
 *
 * <p>This class is not thread safe.
 *
 * @author Ben Yu
 */
@ElementTypesAreNonnullByDefault
abstract class TypeVisitor {

  private final Set<Type> visited = Sets.newHashSet();

  /**

        failureUrl.setErrorName(errorName);
        failureUrl.setErrorLog(getStackTrace(e));
        failureUrl.setLastAccessTime(ComponentUtil.getSystemHelper().getCurrentTimeAsLong());
        failureUrl.setThreadName(Thread.currentThread().getName());

        bhv.insertOrUpdate(failureUrl, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });
        return failureUrl;
    }

import org.eclipse.aether.transfer.TransferEvent;
import org.eclipse.aether.transfer.TransferResource;

/**
 * Console download progress meter.
 * <p>
 * This listener is not thread-safe and should be wrapped in the {@link SimplexTransferListener} in a multi-threaded scenario.
 */
public class ConsoleMavenTransferListener extends AbstractMavenTransferListener {

import java.util.concurrent.atomic.AtomicInteger;
import junit.framework.TestCase;

/**
 * Basher test for {@link ConcurrentHashMultiset}: start a bunch of threads, have each of them do
 * operations at random. Each thread keeps track of the per-key deltas that it's directly
 * responsible for; after all threads have completed, we sum the per-key deltas and compare to the
 * existing multiset values.
 *
 * @author mike nonemacher
 */

    @Nonnull
    Optional<Boolean> alsoMakeDependents();

    /**
     * Returns the number of threads used for parallel builds.
     *
     * @return an {@link Optional} containing the number of threads (or "1C" for one thread per CPU core), or empty if not specified
     */
    @Nonnull
    Optional<String> threads();

    /**
     * Returns the id of the build strategy to use.
     *

    protected long maxAccessCount = Long.MAX_VALUE;

    protected long crawlingExecutionInterval = Constants.DEFAULT_CRAWLING_EXECUTION_INTERVAL;

    protected int indexUpdaterPriority = Thread.MAX_PRIORITY;

    protected int crawlerPriority = Thread.NORM_PRIORITY;

    protected final List<Crawler> crawlerList = Collections.synchronizedList(new ArrayList<>());

import java.io.File;
import java.io.FilenameFilter;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

/**
 * File name filter that only accepts files matching a regular expression. This class is thread-safe
 * and immutable.
 *
 * @author Apple Chow
 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible
@ElementTypesAreNonnullByDefault
public final class PatternFilenameFilter implements FilenameFilter {

 * possibly run in another thread. That cause should itself be an {@code Error}; if not, use {@code
 * ExecutionException} or {@link UncheckedExecutionException}. This allows the client code to
 * continue to distinguish between exceptions and errors, even when they come from other threads.
 *
 * @author Chris Povirk
 * @since 10.0
 */
@GwtCompatible

 * memorized and kept as long as supplier instance is kept open.
 * <p>
 * This class is not thread safe and must be used from one thread only, while the constructed {@link RepositorySystem}
 * is thread safe.
 * <p>
 * Important: Given the instance of supplier memorizes the supplier {@link RepositorySystem} instance it supplies,