import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
@Test
public void it_should_find_handlers() throws Exception {
    TestService service = new TestService();
    service.initializeGuice();

    FastClasspathScanner scanner = new FastClasspathScanner();
    ScanResult scanResult = scanner.scan();
    List<String> rpcHandlers = scanResult.getNamesOfClassesWithAnnotation(RpcHandler.class);

    service.registerMethodHandlers(rpcHandlers);

    Map<String, ServiceMethodHandler<? extends Message, ? extends Message>> s = service.getMethodHandlers();
    assertThat(s.size() == 2);
    assertThat(s.containsKey("Test.handler1"));
    assertThat(s.containsKey("Test.handler2"));
    assertThat(s.get("Test.handler1").getClass().equals(TestHandler.class));
    assertThat(s.get("Test.handler2").getClass().equals(TestHandler2.class));
}
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
public ScanResult scanClasspath() {
    if (scanResult == null) {
        System.out.println("Scanning classpath");
        final Date scanStart = new Date();
        final ScanResult result = new FastClasspathScanner()
                .overrideClasspath((Object[])classLoader.getURLs())
                .verbose(verbose)
                .scan();
        final int count = result.getNamesOfAllClasses().size();
        final Date scanEnd = new Date();
        final double timeInSeconds = (scanEnd.getTime() - scanStart.getTime()) / 1000.0;
        System.out.println(String.format("Scanning finished in %.2f seconds. Total number of classes: %d.", timeInSeconds, count));
        scanResult = result;
    }
    return scanResult;
}
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
@Override
public Class<?> instantiate(final ScanResult scanResult) {
    switch (baseType) {
    case "byte":
        return byte.class;
    case "char":
        return char.class;
    case "double":
        return double.class;
    case "float":
        return float.class;
    case "int":
        return int.class;
    case "long":
        return long.class;
    case "short":
        return short.class;
    case "boolean":
        return boolean.class;
    case "void":
        return void.class;
    default:
        throw new RuntimeException("Unknown base type " + baseType);
    }
}
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
/**
 * Asynchronously scans the classpath for matching files, and if runAsynchronously is true, also calls any
 * MatchProcessors if a match is identified.
 *
 * @param executorService
 *            A custom ExecutorService to use for scheduling worker tasks.
 * @param numParallelTasks
 *            The number of parallel tasks to break the work into during the most CPU-intensive stage of
 *            classpath scanning. Ideally the ExecutorService will have at least this many threads available.
 * @param runMatchProcessorsOnWorkerThread
 *            If true, run MatchProcessors in one of the worker threads after obtaining the ScanResult.
 * @return a Future<ScanResult> object, that when resolved using get() yields a new ScanResult object. You can
 *         call cancel(true) on this Future if you want to interrupt the scan.
 */
private Future<ScanResult> scanAsync(final ExecutorService executorService, final int numParallelTasks,
        final boolean isAsyncScan, final boolean runMatchProcessorsOnWorkerThread) {
    return launchAsyncScan(executorService, numParallelTasks, isAsyncScan,
            runMatchProcessorsOnWorkerThread ? new ScanResultProcessor() {
                @Override
                public void processScanResult(final ScanResult scanResult) {
                    // Call MatchProcessors after scan has completed
                    getScanSpec().callMatchProcessors(scanResult);
                    // Free temporary files if necessary
                    if (scanSpec.removeTemporaryFilesAfterScan) {
                        scanResult.freeTempFiles(log);
                    }
                }
            } : null, /* failureHandler = */ null);
}
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
@Test
public void testSynthetic() {
    final ClassLoader classLoader = Issue175Test.class.getClassLoader();
    final String aJarName = "issue175-has-kotlin-enum.zip";
    final URL aJarURL = classLoader.getResource(aJarName);
    final URLClassLoader overrideClassLoader = new URLClassLoader(new URL[] { aJarURL });

    final ScanResult result = new FastClasspathScanner("net.corda.core.contracts") //
            .overrideClassLoaders(overrideClassLoader).ignoreParentClassLoaders().ignoreMethodVisibility()
            .ignoreFieldVisibility().enableMethodInfo().enableFieldInfo().scan();

    final Map<String, ClassInfo> allInfo = result.getClassNameToClassInfo();

    final List<String> methods = new ArrayList<>();
    for (final String className : result.getNamesOfAllClasses()) {
        final ClassInfo classInfo = allInfo.get(className);
        for (final MethodInfo method : classInfo.getMethodAndConstructorInfo()) {
            methods.add(method.toString());
        }
    }
    assertThat(methods).containsOnly("static void <clinit>()",
            // "protected <init>(synthetic java.lang.String $enum$name, synthetic int $enum$ordinal)",
            "protected <init>()", "public static net.corda.core.contracts.ComponentGroupEnum[] values()",
            "public static net.corda.core.contracts.ComponentGroupEnum valueOf(java.lang.String)");
}
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
@Test
public void testMandated() {
    final ClassLoader classLoader = Issue175Test.class.getClassLoader();
    final String aJarName = "issue175-parameter-arity-mismatch.zip";
    final URL aJarURL = classLoader.getResource(aJarName);
    final URLClassLoader overrideClassLoader = new URLClassLoader(new URL[] { aJarURL });

    final ScanResult result = new FastClasspathScanner("net.corda.core") //
            .overrideClassLoaders(overrideClassLoader).ignoreParentClassLoaders().ignoreMethodVisibility()
            .ignoreFieldVisibility().enableMethodInfo().enableFieldInfo().scan();

    final Map<String, ClassInfo> allInfo = result.getClassNameToClassInfo();

    final List<String> methods = new ArrayList<>();
    for (final String className : result.getNamesOfAllClasses()) {
        final ClassInfo classInfo = allInfo.get(className);
        for (final MethodInfo method : classInfo.getMethodAndConstructorInfo()) {
            methods.add(method.toString());
        }
    }
    assertThat(methods).containsOnly(
            "@org.jetbrains.annotations.NotNull public static final <A> rx.Observable<A> toObservable(@org.jetbrains.annotations.NotNull mandated net.corda.core.concurrent.CordaFuture<? extends A> $receiver)",
            "@org.jetbrains.annotations.NotNull public static final <T> net.corda.core.concurrent.CordaFuture<T> toFuture(@org.jetbrains.annotations.NotNull mandated rx.Observable<T> $receiver)");
}
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
@Test
public void testParameterArityMismatch() {
    final ClassLoader classLoader = Issue175Test.class.getClassLoader();
    final String aJarName = "issue175-missing-bare-types.zip";
    final URL aJarURL = classLoader.getResource(aJarName);
    final URLClassLoader overrideClassLoader = new URLClassLoader(new URL[] { aJarURL });

    final ScanResult result = new FastClasspathScanner("net.corda.core.node.services.vault") //
            .overrideClassLoaders(overrideClassLoader).ignoreParentClassLoaders().ignoreMethodVisibility()
            .ignoreFieldVisibility().enableMethodInfo().enableFieldInfo().scan();

    final Map<String, ClassInfo> allInfo = result.getClassNameToClassInfo();

    final List<String> methods = new ArrayList<>();
    for (final String className : result.getNamesOfAllClasses()) {
        final ClassInfo classInfo = allInfo.get(className);
        for (final MethodInfo method : classInfo.getMethodAndConstructorInfo()) {
            methods.add(method.toString());
        }
    }
    assertThat(methods).containsOnly(
            "@org.jetbrains.annotations.NotNull public static <Q extends net.corda.core.node.services.vault.GenericQueryCriteria<Q, ? super P>, P extends net.corda.core.node.services.vault.BaseQueryCriteriaParser<Q, ? super P, ? super S>, S extends net.corda.core.node.services.vault.BaseSort> java.util.Collection<javax.persistence.criteria.Predicate> visit(@org.jetbrains.annotations.NotNull net.corda.core.node.services.vault.GenericQueryCriteria$ChainableQueryCriteria$AndVisitor<Q, ? super P, ? super S>, P)");
}
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
@Test
public void scanSubAndSuperclass() throws Exception {
    final HashSet<String> subclasses = new HashSet<>();
    final ScanResult scanResult = new FastClasspathScanner(WHITELIST_PACKAGE)
            .matchSubclassesOf(Cls.class, new SubclassMatchProcessor<Cls>() {
                @Override
                public void processMatch(final Class<? extends Cls> matchingClass) {
                    subclasses.add(matchingClass.getName());
                }
            }).scan();
    assertThat(subclasses).doesNotContain(Cls.class.getName());
    assertThat(subclasses).contains(ClsSub.class.getName());
    assertThat(subclasses).contains(ClsSubSub.class.getName());
    assertThat(scanResult.getNamesOfSubclassesOf(Cls.class)).doesNotContain(Cls.class.getName());
    assertThat(scanResult.getNamesOfSubclassesOf(Cls.class)).contains(ClsSub.class.getName());
    assertThat(scanResult.getNamesOfSubclassesOf(Cls.class)).contains(ClsSubSub.class.getName());
    assertThat(scanResult.getNamesOfSuperclassesOf(ClsSubSub.class)).doesNotContain(ClsSubSub.class.getName());
    assertThat(scanResult.getNamesOfSuperclassesOf(ClsSubSub.class)).contains(ClsSub.class.getName());
    assertThat(scanResult.getNamesOfSuperclassesOf(ClsSubSub.class)).contains(Cls.class.getName());
}
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
@Test
public void scanSubAndSuperinterface() throws Exception {
    final HashSet<String> subinterfaces = new HashSet<>();
    final ScanResult scanResult = new FastClasspathScanner(WHITELIST_PACKAGE)
            .matchSubinterfacesOf(Iface.class, new SubinterfaceMatchProcessor<Iface>() {
                @Override
                public void processMatch(final Class<? extends Iface> matchingInterface) {
                    subinterfaces.add(matchingInterface.getName());
                }
            }).scan();
    assertThat(subinterfaces).doesNotContain(Iface.class.getName());
    assertThat(subinterfaces).contains(IfaceSub.class.getName());
    assertThat(subinterfaces).contains(IfaceSubSub.class.getName());
    assertThat(scanResult.getNamesOfSubinterfacesOf(Iface.class)).doesNotContain(Iface.class.getName());
    assertThat(scanResult.getNamesOfSubinterfacesOf(Iface.class)).contains(IfaceSub.class.getName());
    assertThat(scanResult.getNamesOfSubinterfacesOf(Iface.class)).contains(IfaceSubSub.class.getName());
    assertThat(scanResult.getNamesOfSuperinterfacesOf(IfaceSubSub.class))
            .doesNotContain(IfaceSubSub.class.getName());
    assertThat(scanResult.getNamesOfSuperinterfacesOf(IfaceSubSub.class)).contains(IfaceSub.class.getName());
    assertThat(scanResult.getNamesOfSuperinterfacesOf(IfaceSubSub.class)).contains(Iface.class.getName());
}
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
@Test
public void testWhitelistingExternalClassesWithStrictWhitelist() {
    final ScanResult scanResult = new FastClasspathScanner(InternalExternalTest.class.getPackage().getName(),
            ExternalAnnotation.class.getName()).strictWhitelist().scan();
    assertThat(scanResult.getNamesOfAllStandardClasses()).containsOnly(InternalExternalTest.class.getName(),
            InternalExtendsExternal.class.getName(), InternalImplementsExternal.class.getName(),
            InternalAnnotatedByExternal.class.getName());
    assertThat(scanResult.getNamesOfSubclassesOf(ExternalSuperclass.class.getName()))
            .containsExactly(InternalExtendsExternal.class.getName());
    assertThat(scanResult.getNamesOfAllInterfaceClasses()).isEmpty();
    assertThat(scanResult.getNamesOfClassesImplementing(ExternalInterface.class.getName()))
            .containsExactly(InternalImplementsExternal.class.getName());
    assertThat(scanResult.getNamesOfAllAnnotationClasses()).containsExactly(ExternalAnnotation.class.getName());
    assertThat(scanResult.getNamesOfClassesWithAnnotation(ExternalAnnotation.class.getName()))
            .containsExactly(InternalAnnotatedByExternal.class.getName());
}
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
/**
 * Finds all of the messages in the specified packaged and calls register.
 * @param messagePackage A string which contains the full name of the
 *                       package containing the protocol messages.
 */
@Inject
private ProtocolSerializer(
    @Parameter(ProtocolSerializerNamespace.class) final String messagePackage) {

  // Build a list of the message reflection classes.
  final ScanResult scanResult = new FastClasspathScanner(messagePackage).scan();
  final List<String> scanNames = scanResult.getNamesOfSubclassesOf(SpecificRecordBase.class);
  final List<Class<?>> messageClasses = scanResult.classNamesToClassRefs(scanNames);

  // Add the header message from the org.apache.reef.wake.avro.message package.
  messageClasses.add(Header.class);

  // Register all of the messages in the specified package.
  for (final Class<?> cls : messageClasses) {
    this.register(cls);
  }
}
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
public List<String> getGeneratedProtoClasses(String serviceName) {
    FastClasspathScanner cpScanner = new FastClasspathScanner();
    ScanResult scanResult = cpScanner.scan();
    List<String> oldProtobuf = scanResult.getNamesOfSubclassesOf(GeneratedMessage.class);
    List<String> newProtobuf = scanResult.getNamesOfSubclassesOf(GeneratedMessageV3.class);
    List<String> retval = Stream.concat(oldProtobuf.stream(),
            newProtobuf.stream()).collect(Collectors.toList());
    String[] packageTokens = serviceName.split("\\.");
    return retval.stream().filter(s -> protoFilePackageMatches(s, packageTokens)).collect(Collectors.toList());
}
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
private void scanAnnotatedClasses(String scanSpec, SmartPersistanceUnitInfo spui) {

    // ClassAnnotationMatchProcessor processor = spui::addAnnotatedClassName;
    // TODO
    ScanResult scanResult = new FastClasspathScanner(scanSpec).scan(NUMBER_CLASSPATH_SCANNER_THREADS);
    scanResult.getNamesOfClassesWithAnnotation(Entity.class).stream().forEach(spui::addAnnotatedClassName);
  }
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
private static List<SourceType<Type>> fromClassNamePatterns(ScanResult scanResult, List<String> classNamePatterns) {
    final List<String> allClassNames = new ArrayList<>();
    allClassNames.addAll(scanResult.getNamesOfAllStandardClasses());
    allClassNames.addAll(scanResult.getNamesOfAllInterfaceClasses());
    Collections.sort(allClassNames);
    final List<String> classNames = filterClassNames(allClassNames, classNamePatterns);
    System.out.println(String.format("Found %d classes matching pattern.", classNames.size()));
    return fromClassNames(classNames);
}
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
@Test
public void testScanner() {
    final ScanResult scanResult = new FastClasspathScanner().scan();
    final List<String> allClassNames = scanResult.getNamesOfAllClasses();
    final List<String> testClassNames = Input.filterClassNames(allClassNames, Arrays.asList("cz.habarta.typescript.generator.**Test"));
    Assert.assertTrue("Typescript-generator must have at least 20 tests :-)", testClassNames.size() > 20);
}
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
/** Instantiate class ref. Type arguments are ignored. */
@Override
public Class<?> instantiate(final ScanResult scanResult) {
    final StringBuilder buf = new StringBuilder();
    buf.append(className);
    for (int i = 0; i < suffixes.size(); i++) {
        buf.append("$");
        buf.append(suffixes.get(i));
    }
    final String classNameWithSuffixes = buf.toString();
    return scanResult.classNameToClassRef(classNameWithSuffixes);
}
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
/**
 * Asynchronously returns the list of all unique File objects representing directories or zip/jarfiles on the
 * classpath, in classloader resolution order. Classpath elements that do not exist are not included in the
 * list.
 *
 * <p>
 * See the following for info on thread safety:
 *
 * <p>
 * https://github.com/lukehutch/fast-classpath-scanner/wiki/1.-Usage#multithreading-issues
 *
 * <p>
 * Note that if there are nested jarfiles on the classpath, e.g. {@code
 * file:///path/to/jar1.jar!/path/to/jar2.jar}, then both FastClasspathScanner#scanAsync() and
 * FastClasspathScanner#getUniqueClasspathElementsAsync() will cause jar2.jar to be extracted to a temporary
 * file, however FastClasspathScanner#getUniqueClasspathElementsAsync() will not remove this temporary file
 * after the scan (so that the file is still accessible to the caller -- each of the File objects in the
 * returned list of classpath elements should exist). These extracted temporary files are marked for deletion on
 * JVM exit, however.
 *
 * @param executorService
 *            A custom ExecutorService to use for scheduling worker tasks.
 * @param numParallelTasks
 *            The number of parallel tasks to break the work into during the most CPU-intensive stage of
 *            classpath scanning. Ideally the ExecutorService will have at least this many threads available.
 * @return a {@code Future<List<File>>}, that when resolved with get() returns a list of the unique directories
 *         and jarfiles on the classpath, in classpath resolution order. You can call cancel(true) on this
 *         Future if you want to interrupt the process (although the result is typically returned quickly).
 */
public Future<List<File>> getUniqueClasspathElementsAsync(final ExecutorService executorService,
        final int numParallelTasks) {
    // No need to call disallowCallingFromClassInitializer() here, because no MatchProcessors are run, so class
    // initializer deadlock cannot occur.
    final Future<List<File>> classpathElementsFuture;
    try {
        final Future<ScanResult> scanResultFuture = executorService.submit( //
                new Scanner(getScanSpec(), executorService, numParallelTasks,
                        /* enableRecursiveScanning = */ false, /* scanResultProcessor = */ null,
                        /* failureHandler = */ null,
                        log == null ? null : log.log("Getting unique classpath elements")));
        classpathElementsFuture = executorService.submit(new Callable<List<File>>() {
            @Override
            public List<File> call() throws Exception {
                final ScanResult scanResult = scanResultFuture.get();
                final List<File> uniqueClasspathElements = scanResult.getUniqueClasspathElements();
                // N.B. scanResult.freeTempFiles() is *not* called for this method, so that the classpath
                // elements resulting from jars within jars are left in place. However, they are cleaned up on
                // normal JVM exit.
                return uniqueClasspathElements;
            }
        });
    } finally {
        if (log != null) {
            log.flush();
        }
    }
    return classpathElementsFuture;
}
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
/**
 * Asynchronously returns the list of all unique URLs representing directories or zip/jarfiles on the classpath,
 * in classloader resolution order. Classpath elements that do not exist are not included in the list.
 *
 * <p>
 * See the following for info on thread safety:
 *
 * <p>
 * https://github.com/lukehutch/fast-classpath-scanner/wiki/1.-Usage#multithreading-issues
 *
 * <p>
 * Note that if there are nested jarfiles on the classpath, e.g. {@code
 * file:///path/to/jar1.jar!/path/to/jar2.jar}, then both FastClasspathScanner#scanAsync() and
 * FastClasspathScanner#getUniqueClasspathElementsAsync() will cause jar2.jar to be extracted to a temporary
 * file, however FastClasspathScanner#getUniqueClasspathElementURLsAsync() will not remove this temporary file
 * after the scan (so that the file is still accessible to the caller -- each of the File objects in the
 * returned list of classpath elements should exist). These extracted temporary files are marked for deletion on
 * JVM exit, however.
 *
 * @param executorService
 *            A custom ExecutorService to use for scheduling worker tasks.
 * @param numParallelTasks
 *            The number of parallel tasks to break the work into during the most CPU-intensive stage of
 *            classpath scanning. Ideally the ExecutorService will have at least this many threads available.
 * @return a {@code Future<List<URL>>}, that when resolved with get() returns a list of URLs for the unique
 *         directories and jarfiles on the classpath, in classpath resolution order. You can call cancel(true)
 *         on this Future if you want to interrupt the process (although the result is typically returned
 *         quickly).
 */
public Future<List<URL>> getUniqueClasspathElementURLsAsync(final ExecutorService executorService,
        final int numParallelTasks) {
    // No need to call disallowCallingFromClassInitializer() here, because no MatchProcessors are run, so class
    // initializer deadlock cannot occur.
    final Future<List<URL>> classpathElementsFuture;
    try {
        final Future<ScanResult> scanResultFuture = executorService.submit( //
                new Scanner(getScanSpec(), executorService, numParallelTasks,
                        /* enableRecursiveScanning = */ false, /* scanResultProcessor = */ null,
                        /* failureHandler = */ null,
                        log == null ? null : log.log("Getting unique classpath elements")));
        classpathElementsFuture = executorService.submit(new Callable<List<URL>>() {
            @Override
            public List<URL> call() throws Exception {
                final ScanResult scanResult = scanResultFuture.get();
                final List<URL> uniqueClasspathElementURLs = scanResult.getUniqueClasspathElementURLs();
                // N.B. scanResult.freeTempFiles() is *not* called for this method, so that the classpath
                // elements resulting from jars within jars are left in place. However, they are cleaned up on
                // normal JVM exit.
                return uniqueClasspathElementURLs;
            }
        });
    } finally {
        if (log != null) {
            log.flush();
        }
    }
    return classpathElementsFuture;
}
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
/** Test that both CLASS-retained and RUNTIME-retained annotations are visible by default. */
@Test
public void classRetentionIsDefault() {
    final ScanResult scanResult = new FastClasspathScanner(PKG).scan();
    assertThat(scanResult.getNamesOfClassesWithAnnotation(RetentionClass.class))
            .containsOnly(RetentionClassAnnotated.class.getName());
    assertThat(scanResult.getNamesOfClassesWithAnnotation(RetentionRuntime.class))
            .containsOnly(RetentionRuntimeAnnotated.class.getName());
}
 

import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult; //导入依赖的package包/类
/**
 * Test that CLASS-retained annotations are not visible after calling
 * .setAnnotationVisibility(RetentionPolicy.RUNTIME), but RUNTIME-retained annotations are still visible.
 */
@Test
public void classRetentionIsNotVisibleWithRetentionPolicyRUNTIME() {
    final ScanResult scanResult = new FastClasspathScanner(PKG).setAnnotationVisibility(RetentionPolicy.RUNTIME)
            .scan();
    assertThat(scanResult.getNamesOfClassesWithAnnotation(RetentionClass.class)).isEmpty();
    assertThat(scanResult.getNamesOfClassesWithAnnotation(RetentionRuntime.class))
            .containsOnly(RetentionRuntimeAnnotated.class.getName());
}