FastClasspathScanner (Fast Classpath Scanner 2.0.2 API)

java.lang.Object
- io.github.lukehutch.fastclasspathscanner.FastClasspathScanner

```
public class FastClasspathScanner
extends Object
```
Uber-fast, ultra-lightweight Java classpath scanner. Scans the classpath by parsing the classfile binary format directly rather than by using reflection. (Reflection causes the classloader to load each class, which can take an order of magnitude more time than parsing the classfile directly.) Documentation: https://github.com/lukehutch/fast-classpath-scanner/wiki

Constructor Summary

Constructors
Constructor and Description

FastClasspathScanner(String... scanSpec)
Construct a FastClasspathScanner instance.

Constructors
Constructor and Description
`FastClasspathScanner(String... scanSpec)` Construct a FastClasspathScanner instance.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`FastClasspathScanner`	`enableFieldTypeIndexing()` Enables field type indexing, which allows you to call ScanResult#getClassesWithFieldsOfType(type).
`FastClasspathScanner`	`enableFieldTypeIndexing(boolean enableFieldTypeIndexing)` If enableFieldTypeIndexing is true, enables field type indexing, which allows you to call ScanResult#getClassesWithFieldsOfType(type).
`FastClasspathScanner`	`enableMethodAnnotationIndexing()` Enables method annotation indexing, which allows you to call ScanResult#getClassesWithMethodAnnotations(annotationType).
`FastClasspathScanner`	`enableMethodAnnotationIndexing(boolean enableMethodAnnotationIndexing)` If enableMethodAnnotationIndexing is true, enables method annotation indexing, which allows you to call ScanResult#getClassesWithMethodAnnotations(annotationType).
`List<File>`	`getUniqueClasspathElements()` Returns the list of all unique File objects representing directories or zip/jarfiles on the classpath, in classloader resolution order.
`List<File>`	`getUniqueClasspathElements(ExecutorService executorService, int numParallelTasks)` Returns the list of all unique File objects representing directories or zip/jarfiles on the classpath, in classloader resolution order.
`Future<List<File>>`	`getUniqueClasspathElementsAsync(ExecutorService executorService, int numParallelTasks)` Asynchronously returns the list of all unique File objects representing directories or zip/jarfiles on the classpath, in classloader resolution order.
`static String`	`getVersion()` Get the version number of FastClasspathScanner.
`FastClasspathScanner`	`ignoreFieldVisibility()` This method causes FastClasspathScanner to ignore field visibility, enabling it to see private, package-private and protected fields.
`FastClasspathScanner`	`ignoreFieldVisibility(boolean ignoreFieldVisibility)` If ignoreFieldVisibility is true, causes FastClasspathScanner to ignore field visibility, enabling it to see private, package-private and protected fields.
`FastClasspathScanner`	`ignoreMethodVisibility()` This method causes FastClasspathScanner to ignore method visibility, enabling it to see private, package-private and protected methods.
`FastClasspathScanner`	`ignoreMethodVisibility(boolean ignoreMethodVisibility)` If ignoreMethodVisibility is true, causes FastClasspathScanner to ignore method visibility, enabling it to see private, package-private and protected methods.
`FastClasspathScanner`	`matchAllAnnotationClasses(ClassMatchProcessor ClassMatchProcessor)` Calls the provided ClassMatchProcessor for all annotation classes (annotation definitions) found in whitelisted packages on the classpath.
`FastClasspathScanner`	`matchAllClasses(ClassMatchProcessor classMatchProcessor)` Calls the provided ClassMatchProcessor for all standard classes, interfaces and annotations found in whitelisted packages on the classpath.
`FastClasspathScanner`	`matchAllInterfaceClasses(ClassMatchProcessor ClassMatchProcessor)` Calls the provided ClassMatchProcessor for all interface classes (interface definitions) found in whitelisted packages on the classpath.
`FastClasspathScanner`	`matchAllStandardClasses(ClassMatchProcessor classMatchProcessor)` Calls the provided ClassMatchProcessor for all standard classes (i.e.
`<T> FastClasspathScanner`	`matchClassesImplementing(Class<T> implementedInterface, ImplementingClassMatchProcessor<T> interfaceMatchProcessor)` Calls the provided InterfaceMatchProcessor for classes on the classpath that implement the specified interface or a subinterface, or whose superclasses implement the specified interface or a sub-interface.
`FastClasspathScanner`	`matchClassesWithAnnotation(Class<?> annotation, ClassAnnotationMatchProcessor classAnnotationMatchProcessor)` Calls the provided ClassAnnotationMatchProcessor if classes are found on the classpath that have the specified annotation.
`<T> FastClasspathScanner`	`matchClassesWithFieldOfType(Class<T> fieldType, ClassMatchProcessor classMatchProcessor)` Calls the provided ClassMatchProcessor for classes on the classpath that have a field of the given type.
`FastClasspathScanner`	`matchClassesWithMethodAnnotation(Class<? extends Annotation> annotation, MethodAnnotationMatchProcessor methodAnnotationMatchProcessor)` Calls the provided MethodAnnotationMatchProcessor if classes are found on the classpath that have one or more methods with the specified annotation.
`FastClasspathScanner`	`matchFilenameExtension(String extensionToMatch, FileMatchContentsProcessor fileMatchContentsProcessor)` Calls the given FileMatchProcessor if files are found on the classpath that have the given file extension.
`FastClasspathScanner`	`matchFilenameExtension(String extensionToMatch, FileMatchContentsProcessorWithContext fileMatchContentsProcessorWithContext)` Calls the given FileMatchProcessorWithContext if files are found on the classpath that have the given file extension.
`FastClasspathScanner`	`matchFilenameExtension(String extensionToMatch, FileMatchProcessor fileMatchProcessor)` Calls the given FileMatchProcessor if files are found on the classpath that have the given file extension.
`FastClasspathScanner`	`matchFilenameExtension(String extensionToMatch, FileMatchProcessorWithContext fileMatchProcessorWithContext)` Calls the given FileMatchProcessorWithContext if files are found on the classpath that have the given file extension.
`FastClasspathScanner`	`matchFilenamePath(String relativePathToMatch, FileMatchContentsProcessor fileMatchContentsProcessor)` Calls the given FileMatchContentsProcessor if files are found on the classpath that exactly match the given relative path.
`FastClasspathScanner`	`matchFilenamePath(String relativePathToMatch, FileMatchContentsProcessorWithContext fileMatchContentsProcessorWithContext)` Calls the given FileMatchContentsProcessorWithContext if files are found on the classpath that exactly match the given relative path.
`FastClasspathScanner`	`matchFilenamePath(String relativePathToMatch, FileMatchProcessor fileMatchProcessor)` Calls the given FileMatchProcessor if files are found on the classpath that exactly match the given relative path.
`FastClasspathScanner`	`matchFilenamePath(String relativePathToMatch, FileMatchProcessorWithContext fileMatchProcessorWithContext)` Calls the given FileMatchProcessorWithContext if files are found on the classpath that exactly match the given relative path.
`FastClasspathScanner`	`matchFilenamePathLeaf(String pathLeafToMatch, FileMatchContentsProcessor fileMatchContentsProcessor)` Calls the given FileMatchContentsProcessor if files are found on the classpath that exactly match the given path leafname.
`FastClasspathScanner`	`matchFilenamePathLeaf(String pathLeafToMatch, FileMatchContentsProcessorWithContext fileMatchContentsProcessorWithContext)` Calls the given FileMatchContentsProcessorWithContext if files are found on the classpath that exactly match the given path leafname.
`FastClasspathScanner`	`matchFilenamePathLeaf(String pathLeafToMatch, FileMatchProcessor fileMatchProcessor)` Calls the given FileMatchProcessor if files are found on the classpath that exactly match the given path leafname.
`FastClasspathScanner`	`matchFilenamePathLeaf(String pathLeafToMatch, FileMatchProcessorWithContext fileMatchProcessorWithContext)` Calls the given FileMatchProcessorWithContext if files are found on the classpath that exactly match the given path leafname.
`FastClasspathScanner`	`matchFilenamePattern(String pathRegexp, FileMatchContentsProcessor fileMatchContentsProcessor)` Calls the given FileMatchContentsProcessor if files are found on the classpath with the given regexp pattern in their path.
`FastClasspathScanner`	`matchFilenamePattern(String pathRegexp, FileMatchContentsProcessorWithContext fileMatchContentsProcessorWithContext)` Calls the given FileMatchContentsProcessorWithContext if files are found on the classpath with the given regexp pattern in their path.
`FastClasspathScanner`	`matchFilenamePattern(String pathRegexp, FileMatchProcessor fileMatchProcessor)` Calls the given FileMatchProcessor if files are found on the classpath with the given regexp pattern in their path.
`FastClasspathScanner`	`matchFilenamePattern(String pathRegexp, FileMatchProcessorWithContext fileMatchProcessorWithContext)` Calls the given FileMatchProcessorWithContext if files are found on the classpath with the given regexp pattern in their path.
`FastClasspathScanner`	`matchStaticFinalFieldNames(Set<String> fullyQualifiedStaticFinalFieldNames, StaticFinalFieldMatchProcessor staticFinalFieldMatchProcessor)` Calls the given StaticFinalFieldMatchProcessor if classes are found on the classpath that contain static final fields that match one of a set of fully-qualified field names, e.g.
`FastClasspathScanner`	`matchStaticFinalFieldNames(String[] fullyQualifiedStaticFinalFieldNames, StaticFinalFieldMatchProcessor staticFinalFieldMatchProcessor)` Calls the given StaticFinalFieldMatchProcessor if classes are found on the classpath that contain static final fields that match one of a list of fully-qualified field names, e.g.
`FastClasspathScanner`	`matchStaticFinalFieldNames(String fullyQualifiedStaticFinalFieldName, StaticFinalFieldMatchProcessor staticFinalFieldMatchProcessor)` Calls the given StaticFinalFieldMatchProcessor if classes are found on the classpath that contain static final fields that match a fully-qualified field name, e.g.
`<T> FastClasspathScanner`	`matchSubclassesOf(Class<T> superclass, SubclassMatchProcessor<T> subclassMatchProcessor)` Calls the provided SubclassMatchProcessor if classes are found on the classpath that extend the specified superclass.
`<T> FastClasspathScanner`	`matchSubinterfacesOf(Class<T> superinterface, SubinterfaceMatchProcessor<T> subinterfaceMatchProcessor)` Calls the provided SubinterfaceMatchProcessor if an interface that extends a given superinterface is found on the classpath.
`FastClasspathScanner`	`overrideClasspath(String classpath)` Override the automatically-detected classpath with a custom search path.
`FastClasspathScanner`	`registerClassLoaderHandler(Class<? extends ClassLoaderHandler> classLoaderHandlerClass)` Add an extra ClassLoaderHandler.
`ScanResult`	`scan()` Scans the classpath for matching files, and calls any MatchProcessors if a match is identified.
`ScanResult`	`scan(ExecutorService executorService, int numParallelTasks)` Scans the classpath for matching files, and calls any MatchProcessors if a match is identified.
`ScanResult`	`scan(int numThreads)` Scans the classpath for matching files, and calls any MatchProcessors if a match is identified.
`Future<ScanResult>`	`scanAsync(ExecutorService executorService, int numParallelTasks)` Asynchronously scans the classpath for matching files, and calls any MatchProcessors if a match is identified.
`FastClasspathScanner`	`strictWhitelist()` Switches FastClasspathScanner to strict mode, which disallows searching/matching based on blacklisted classes, and removes "external" classes from result lists returned by ScanSpec#get...() methods.
`FastClasspathScanner`	`strictWhitelist(boolean strictWhitelist)` If strictWhitelist is true, switches FastClasspathScanner to strict mode, which disallows searching/matching based on blacklisted classes, and removes "external" classes from result lists returned by ScanSpec#get...() methods.
`FastClasspathScanner`	`verbose()` Switches on verbose mode for debugging purposes.
`FastClasspathScanner`	`verbose(boolean verbose)` Switches on verbose mode for debugging purposes if verbose == true.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - FastClasspathScanner
```
public FastClasspathScanner(String... scanSpec)
```
    Construct a FastClasspathScanner instance. You can pass a scanning specification to the constructor to describe what should be scanned -- see the docs for info: https://github.com/lukehutch/fast-classpath-scanner/wiki/2.-Constructor The scanSpec, if non-empty, prevents irrelevant classpath entries from being unecessarily scanned, which can be time-consuming. Note that calling the constructor does not start the scan, you must separately call .scan() to perform the actual scan.
    
    Parameters:
    
    scanSpec - The constructor accepts a list of whitelisted package prefixes / jar names to scan, as well as blacklisted packages/jars not to scan, where blacklisted entries are prefixed with the '-' character. See https://github.com/lukehutch/fast-classpath-scanner/wiki/2.-Constructor for info.
- Method Detail
  - getVersion
```
public static final String getVersion()
```
    Get the version number of FastClasspathScanner.
    
    Returns:
    
    the FastClasspathScanner version, or "unknown" if it could not be determined.
  - verbose
```
public FastClasspathScanner verbose(boolean verbose)
```
    Switches on verbose mode for debugging purposes if verbose == true. Call immediately after calling the constructor if you want full log output. Prints debug info to System.err.
    
    Parameters:
    
    verbose - Whether or not to give verbose output.
    
    Returns:
    
    this (for method chaining).
  - verbose
```
public FastClasspathScanner verbose()
```
    Switches on verbose mode for debugging purposes. Call immediately after calling the constructor if you want full log output. Prints debug info to System.err.
    
    Returns:
    
    this (for method chaining).
  - ignoreFieldVisibility
```
public FastClasspathScanner ignoreFieldVisibility(boolean ignoreFieldVisibility)
```
    If ignoreFieldVisibility is true, causes FastClasspathScanner to ignore field visibility, enabling it to see private, package-private and protected fields. This affects finding classes with fields of a given type, as well as matching static final fields with constant initializers. If false, fields must be public to be indexed/matched.
    
    Parameters:
    
    ignoreFieldVisibility - Whether or not to ignore the field visibility modifier.
    
    Returns:
    
    this (for method chaining).
  - ignoreFieldVisibility
```
public FastClasspathScanner ignoreFieldVisibility()
```
    This method causes FastClasspathScanner to ignore field visibility, enabling it to see private, package-private and protected fields. This affects finding classes with fields of a given type, as well as matching static final fields with constant initializers. If false, fields must be public to be indexed/matched.
    
    Returns:
    
    this (for method chaining).
  - ignoreMethodVisibility
```
public FastClasspathScanner ignoreMethodVisibility(boolean ignoreMethodVisibility)
```
    If ignoreMethodVisibility is true, causes FastClasspathScanner to ignore method visibility, enabling it to see private, package-private and protected methods. This affects finding classes that have methods with a given annotation. If false, methods must be public for the containing classes to be indexed/matched.
    
    Parameters:
    
    ignoreMethodVisibility - Whether or not to ignore the method visibility modifier.
    
    Returns:
    
    this (for method chaining).
  - ignoreMethodVisibility
```
public FastClasspathScanner ignoreMethodVisibility()
```
    This method causes FastClasspathScanner to ignore method visibility, enabling it to see private, package-private and protected methods. This affects finding classes that have methods with a given annotation. If false, methods must be public for the containing classes to be indexed/matched.
    
    Returns:
    
    this (for method chaining).
  - enableFieldTypeIndexing
```
public FastClasspathScanner enableFieldTypeIndexing(boolean enableFieldTypeIndexing)
```
    If enableFieldTypeIndexing is true, enables field type indexing, which allows you to call ScanResult#getClassesWithFieldsOfType(type). (If you add a field type match processor, this method is called for you.) Field type indexing is disabled by default, because it is expensive in terms of time (adding ~10% to the scan time) and memory, and it is not needed for most uses of FastClasspathScanner.
    
    Parameters:
    
    enableFieldTypeIndexing - Whether or not to enable field type indexing.
    
    Returns:
    
    this (for method chaining).
  - enableFieldTypeIndexing
```
public FastClasspathScanner enableFieldTypeIndexing()
```
    Enables field type indexing, which allows you to call ScanResult#getClassesWithFieldsOfType(type). (If you add a field type match processor, this method is called for you.) Field type indexing is disabled by default, because it is expensive in terms of time (adding ~10% to the scan time) and memory, and it is not needed for most uses of FastClasspathScanner.
    
    Returns:
    
    this (for method chaining).
  - enableMethodAnnotationIndexing
```
public FastClasspathScanner enableMethodAnnotationIndexing(boolean enableMethodAnnotationIndexing)
```
    If enableMethodAnnotationIndexing is true, enables method annotation indexing, which allows you to call ScanResult#getClassesWithMethodAnnotations(annotationType). (If you add a method annotation match processor, this method is called for you.) Method annotation indexing is disabled by default, because it is expensive in terms of time, and it is not needed for most uses of FastClasspathScanner.
    
    Parameters:
    
    enableMethodAnnotationIndexing - Whether or not to enable method annotation indexing.
    
    Returns:
    
    this (for method chaining).
  - enableMethodAnnotationIndexing
```
public FastClasspathScanner enableMethodAnnotationIndexing()
```
    Enables method annotation indexing, which allows you to call ScanResult#getClassesWithMethodAnnotations(annotationType). (If you add a method annotation match processor, this method is called for you.) Method annotation indexing is disabled by default, because it is expensive in terms of time, and it is not needed for most uses of FastClasspathScanner.
    
    Returns:
    
    this (for method chaining).
  - strictWhitelist
```
public FastClasspathScanner strictWhitelist(boolean strictWhitelist)
```
    If strictWhitelist is true, switches FastClasspathScanner to strict mode, which disallows searching/matching based on blacklisted classes, and removes "external" classes from result lists returned by ScanSpec#get...() methods. (External classes are classes outside of whitelisted packages that are directly referred to by classes within whitelisted packages as a superclass, implemented interface or annotation.) See the following for info on external classes, and strict mode vs. non-strict mode: https://github.com/lukehutch/fast-classpath-scanner/wiki/2.-Constructor#external-classes
    
    Parameters:
    
    strictWhitelist - Whether or not to switch to strict mode.
    
    Returns:
    
    this (for method chaining).
  - strictWhitelist
```
public FastClasspathScanner strictWhitelist()
```
    Switches FastClasspathScanner to strict mode, which disallows searching/matching based on blacklisted classes, and removes "external" classes from result lists returned by ScanSpec#get...() methods. (External classes are classes outside of whitelisted packages that are directly referred to by classes within whitelisted packages as a superclass, implemented interface or annotation.) See the following for info on external classes, and strict mode vs. non-strict mode: https://github.com/lukehutch/fast-classpath-scanner/wiki/2.-Constructor#external-classes
    
    Returns:
    
    this (for method chaining).
  - registerClassLoaderHandler
```
public FastClasspathScanner registerClassLoaderHandler(Class<? extends ClassLoaderHandler> classLoaderHandlerClass)
```
    Add an extra ClassLoaderHandler. Needed if FastClasspathScanner doesn't know how to extract classpath entries from your runtime environment's ClassLoader. See: https://github.com/lukehutch/fast-classpath-scanner/wiki/4.-Working-with-nonstandard-ClassLoaders
    
    Parameters:
    
    extraClassLoaderHandler - The ClassLoaderHandler class to register.
    
    Returns:
    
    this (for method chaining).
  - overrideClasspath
```
public FastClasspathScanner overrideClasspath(String classpath)
```
    Override the automatically-detected classpath with a custom search path. You can specify multiple elements, separated by File.pathSeparatorChar. If this method is called, nothing but the provided classpath will be scanned.
    
    Parameters:
    
    classpath - The custom classpath to use for scanning, with path elements separated by File.pathSeparatorChar.
    
    Returns:
    
    this (for method chaining).
  - matchAllClasses
```
public FastClasspathScanner matchAllClasses(ClassMatchProcessor classMatchProcessor)
```
    Calls the provided ClassMatchProcessor for all standard classes, interfaces and annotations found in whitelisted packages on the classpath.
    
    Parameters:
    
    classMatchProcessor - the ClassMatchProcessor to call when a match is found.
    
    Returns:
    
    this (for method chaining).
  - matchAllStandardClasses
```
public FastClasspathScanner matchAllStandardClasses(ClassMatchProcessor classMatchProcessor)
```
    Calls the provided ClassMatchProcessor for all standard classes (i.e. non-interface, non-annotation classes) found in whitelisted packages on the classpath.
    
    Parameters:
    
    classMatchProcessor - the ClassMatchProcessor to call when a match is found.
    
    Returns:
    
    this (for method chaining).
  - matchAllInterfaceClasses
```
public FastClasspathScanner matchAllInterfaceClasses(ClassMatchProcessor ClassMatchProcessor)
```
    Calls the provided ClassMatchProcessor for all interface classes (interface definitions) found in whitelisted packages on the classpath.
    
    Parameters:
    
    ClassMatchProcessor - the ClassMatchProcessor to call when a match is found.
    
    Returns:
    
    this (for method chaining).
  - matchAllAnnotationClasses
```
public FastClasspathScanner matchAllAnnotationClasses(ClassMatchProcessor ClassMatchProcessor)
```
    Calls the provided ClassMatchProcessor for all annotation classes (annotation definitions) found in whitelisted packages on the classpath.
    
    Parameters:
    
    ClassMatchProcessor - the ClassMatchProcessor to call when a match is found.
    
    Returns:
    
    this (for method chaining).
  - matchSubclassesOf
```
public <T> FastClasspathScanner matchSubclassesOf(Class<T> superclass,
                                                  SubclassMatchProcessor<T> subclassMatchProcessor)
```
    Calls the provided SubclassMatchProcessor if classes are found on the classpath that extend the specified superclass.
    
    Parameters:
    
    superclass - The superclass to match (i.e. the class that subclasses need to extend to match).
    
    subclassMatchProcessor - the SubclassMatchProcessor to call when a match is found.
    
    Returns:
    
    this (for method chaining).
  - matchSubinterfacesOf
```
public <T> FastClasspathScanner matchSubinterfacesOf(Class<T> superinterface,
                                                     SubinterfaceMatchProcessor<T> subinterfaceMatchProcessor)
```
    Calls the provided SubinterfaceMatchProcessor if an interface that extends a given superinterface is found on the classpath.
    
    Parameters:
    
    superinterface - The superinterface to match (i.e. the interface that subinterfaces need to extend to match).
    
    subinterfaceMatchProcessor - the SubinterfaceMatchProcessor to call when a match is found.
    
    Returns:
    
    this (for method chaining).
  - matchClassesImplementing
```
public <T> FastClasspathScanner matchClassesImplementing(Class<T> implementedInterface,
                                                         ImplementingClassMatchProcessor<T> interfaceMatchProcessor)
```
    Calls the provided InterfaceMatchProcessor for classes on the classpath that implement the specified interface or a subinterface, or whose superclasses implement the specified interface or a sub-interface.
    
    Parameters:
    
    implementedInterface - The interface that classes need to implement.
    
    interfaceMatchProcessor - the ClassMatchProcessor to call when a match is found.
    
    Returns:
    
    this (for method chaining).
  - matchClassesWithFieldOfType
```
public <T> FastClasspathScanner matchClassesWithFieldOfType(Class<T> fieldType,
                                                            ClassMatchProcessor classMatchProcessor)
```
    Calls the provided ClassMatchProcessor for classes on the classpath that have a field of the given type. Matches classes that have fields of the given type, array fields with an element type of the given type, and fields of parameterized type that have a type parameter of the given type. Calls enableFieldTypeIndexing() for you.
    
    Parameters:
    
    fieldType - The type of the field to match..
    
    classMatchProcessor - the ClassMatchProcessor to call when a match is found.
    
    Returns:
    
    this (for method chaining).
  - matchClassesWithAnnotation
```
public FastClasspathScanner matchClassesWithAnnotation(Class<?> annotation,
                                                       ClassAnnotationMatchProcessor classAnnotationMatchProcessor)
```
    Calls the provided ClassAnnotationMatchProcessor if classes are found on the classpath that have the specified annotation.
    
    Parameters:
    
    annotation - The class annotation to match.
    
    classAnnotationMatchProcessor - the ClassAnnotationMatchProcessor to call when a match is found.
    
    Returns:
    
    this (for method chaining).
  - matchClassesWithMethodAnnotation
```
public FastClasspathScanner matchClassesWithMethodAnnotation(Class<? extends Annotation> annotation,
                                                             MethodAnnotationMatchProcessor methodAnnotationMatchProcessor)
```
    Calls the provided MethodAnnotationMatchProcessor if classes are found on the classpath that have one or more methods with the specified annotation. Calls enableMethodAnnotationIndexing() for you.
    
    Parameters:
    
    annotation - The method annotation to match.
    
    methodAnnotationMatchProcessor - the MethodAnnotationMatchProcessor to call when a match is found.
    
    Returns:
    
    this (for method chaining).
  - matchStaticFinalFieldNames
```
public FastClasspathScanner matchStaticFinalFieldNames(Set<String> fullyQualifiedStaticFinalFieldNames,
                                                       StaticFinalFieldMatchProcessor staticFinalFieldMatchProcessor)
```
    Calls the given StaticFinalFieldMatchProcessor if classes are found on the classpath that contain static final fields that match one of a set of fully-qualified field names, e.g. "com.package.ClassName.STATIC_FIELD_NAME". Field values are obtained from the constant pool in classfiles, not from a loaded class using reflection. This allows you to detect changes to the classpath and then run another scan that picks up the new values of selected static constants without reloading the class. (Class reloading is fraught with issues, see: http://tutorials.jenkov.com/java-reflection/dynamic-class-loading-reloading.html ) Note: Only static final fields with constant-valued literals are matched, not fields with initializer values that are the result of an expression or reference, except for cases where the compiler is able to simplify an expression into a single constant at compiletime, such as in the case of string concatenation. Note that the visibility of the fields is not checked if ignoreFieldVisibility() was called before scan().
    
    Parameters:
    
    fullyQualifiedStaticFinalFieldNames - The set of fully-qualified static field names to match.
    
    staticFinalFieldMatchProcessor - the StaticFinalFieldMatchProcessor to call when a match is found.
    
    Returns:
    
    this (for method chaining).
  - matchStaticFinalFieldNames
```
public FastClasspathScanner matchStaticFinalFieldNames(String fullyQualifiedStaticFinalFieldName,
                                                       StaticFinalFieldMatchProcessor staticFinalFieldMatchProcessor)
```
    Calls the given StaticFinalFieldMatchProcessor if classes are found on the classpath that contain static final fields that match a fully-qualified field name, e.g. "com.package.ClassName.STATIC_FIELD_NAME". Field values are obtained from the constant pool in classfiles, *not* from a loaded class using reflection. This allows you to detect changes to the classpath and then run another scan that picks up the new values of selected static constants without reloading the class. (Class reloading is fraught with issues, see: http://tutorials.jenkov.com/java-reflection/dynamic-class-loading-reloading.html ) Note: Only static final fields with constant-valued literals are matched, not fields with initializer values that are the result of an expression or reference, except for cases where the compiler is able to simplify an expression into a single constant at compiletime, such as in the case of string concatenation. Note that the visibility of the fields is not checked if ignoreFieldVisibility() was called before scan().
    
    Parameters:
    
    fullyQualifiedStaticFinalFieldName - The fully-qualified static field name to match
    
    staticFinalFieldMatchProcessor - the StaticFinalFieldMatchProcessor to call when a match is found.
    
    Returns:
    
    this (for method chaining).
  - matchStaticFinalFieldNames
```
public FastClasspathScanner matchStaticFinalFieldNames(String[] fullyQualifiedStaticFinalFieldNames,
                                                       StaticFinalFieldMatchProcessor staticFinalFieldMatchProcessor)
```
    Calls the given StaticFinalFieldMatchProcessor if classes are found on the classpath that contain static final fields that match one of a list of fully-qualified field names, e.g. "com.package.ClassName.STATIC_FIELD_NAME". Field values are obtained from the constant pool in classfiles, *not* from a loaded class using reflection. This allows you to detect changes to the classpath and then run another scan that picks up the new values of selected static constants without reloading the class. (Class reloading is fraught with issues, see: http://tutorials.jenkov.com/java-reflection/dynamic-class-loading-reloading.html ) Note: Only static final fields with constant-valued literals are matched, not fields with initializer values that are the result of an expression or reference, except for cases where the compiler is able to simplify an expression into a single constant at compiletime, such as in the case of string concatenation. Note that the visibility of the fields is not checked if ignoreFieldVisibility() was called before scan().
    
    Parameters:
    
    fullyQualifiedStaticFinalFieldNames - The list of fully-qualified static field names to match.
    
    staticFinalFieldMatchProcessor - the StaticFinalFieldMatchProcessor to call when a match is found.
    
    Returns:
    
    this (for method chaining).
  - matchFilenamePattern
```
public FastClasspathScanner matchFilenamePattern(String pathRegexp,
                                                 FileMatchProcessor fileMatchProcessor)
```
    Calls the given FileMatchProcessor if files are found on the classpath with the given regexp pattern in their path.
    
    Parameters:
    
    pathRegexp - The regexp to match, e.g. "app/templates/.\*\.html"
    
    fileMatchProcessor - The FileMatchProcessor to call when each match is found.
    
    Returns:
    
    this (for method chaining).
  - matchFilenamePattern
```
public FastClasspathScanner matchFilenamePattern(String pathRegexp,
                                                 FileMatchContentsProcessor fileMatchContentsProcessor)
```
    Calls the given FileMatchContentsProcessor if files are found on the classpath with the given regexp pattern in their path.
    
    Parameters:
    
    pathRegexp - The regexp to match, e.g. "app/templates/.\*\.html"
    
    fileMatchContentsProcessor - The FileMatchContentsProcessor to call when each match is found.
    
    Returns:
    
    this (for method chaining).
  - matchFilenamePattern
```
public FastClasspathScanner matchFilenamePattern(String pathRegexp,
                                                 FileMatchProcessorWithContext fileMatchProcessorWithContext)
```
    Calls the given FileMatchProcessorWithContext if files are found on the classpath with the given regexp pattern in their path.
    
    Parameters:
    
    pathRegexp - The regexp to match, e.g. "app/templates/.\*\.html"
    
    fileMatchProcessorWithContext - The FileMatchProcessorWithContext to call when each match is found.
    
    Returns:
    
    this (for method chaining).
  - matchFilenamePattern
```
public FastClasspathScanner matchFilenamePattern(String pathRegexp,
                                                 FileMatchContentsProcessorWithContext fileMatchContentsProcessorWithContext)
```
    Calls the given FileMatchContentsProcessorWithContext if files are found on the classpath with the given regexp pattern in their path.
    
    Parameters:
    
    pathRegexp - The regexp to match, e.g. "app/templates/.\*\.html"
    
    fileMatchContentsProcessorWithContext - The FileMatchContentsProcessorWithContext to call when each match is found.
    
    Returns:
    
    this (for method chaining).
  - matchFilenamePath
```
public FastClasspathScanner matchFilenamePath(String relativePathToMatch,
                                              FileMatchProcessor fileMatchProcessor)
```
    Calls the given FileMatchProcessor if files are found on the classpath that exactly match the given relative path.
    
    Parameters:
    
    relativePathToMatch - The complete path to match relative to the classpath entry, e.g. "app/templates/WidgetTemplate.html"
    
    fileMatchProcessor - The FileMatchProcessor to call when each match is found.
    
    Returns:
    
    this (for method chaining).
  - matchFilenamePath
```
public FastClasspathScanner matchFilenamePath(String relativePathToMatch,
                                              FileMatchContentsProcessor fileMatchContentsProcessor)
```
    Calls the given FileMatchContentsProcessor if files are found on the classpath that exactly match the given relative path.
    
    Parameters:
    
    relativePathToMatch - The complete path to match relative to the classpath entry, e.g. "app/templates/WidgetTemplate.html"
    
    fileMatchContentsProcessor - The FileMatchContentsProcessor to call when each match is found.
    
    Returns:
    
    this (for method chaining).
  - matchFilenamePath
```
public FastClasspathScanner matchFilenamePath(String relativePathToMatch,
                                              FileMatchProcessorWithContext fileMatchProcessorWithContext)
```
    Calls the given FileMatchProcessorWithContext if files are found on the classpath that exactly match the given relative path.
    
    Parameters:
    
    relativePathToMatch - The complete path to match relative to the classpath entry, e.g. "app/templates/WidgetTemplate.html"
    
    fileMatchProcessorWithContext - The FileMatchProcessorWithContext to call when each match is found.
    
    Returns:
    
    this (for method chaining).
  - matchFilenamePath
```
public FastClasspathScanner matchFilenamePath(String relativePathToMatch,
                                              FileMatchContentsProcessorWithContext fileMatchContentsProcessorWithContext)
```
    Calls the given FileMatchContentsProcessorWithContext if files are found on the classpath that exactly match the given relative path.
    
    Parameters:
    
    relativePathToMatch - The complete path to match relative to the classpath entry, e.g. "app/templates/WidgetTemplate.html"
    
    fileMatchContentsProcessorWithContext - The FileMatchContentsProcessorWithContext to call when each match is found.
    
    Returns:
    
    this (for method chaining).
  - matchFilenamePathLeaf
```
public FastClasspathScanner matchFilenamePathLeaf(String pathLeafToMatch,
                                                  FileMatchProcessor fileMatchProcessor)
```
    Calls the given FileMatchProcessor if files are found on the classpath that exactly match the given path leafname.
    
    Parameters:
    
    pathLeafToMatch - The complete path leaf to match, e.g. "WidgetTemplate.html"
    
    fileMatchProcessor - The FileMatchProcessor to call when each match is found.
    
    Returns:
    
    this (for method chaining).
  - matchFilenamePathLeaf
```
public FastClasspathScanner matchFilenamePathLeaf(String pathLeafToMatch,
                                                  FileMatchContentsProcessor fileMatchContentsProcessor)
```
    Calls the given FileMatchContentsProcessor if files are found on the classpath that exactly match the given path leafname.
    
    Parameters:
    
    pathLeafToMatch - The complete path leaf to match, e.g. "WidgetTemplate.html"
    
    fileMatchContentsProcessor - The FileMatchContentsProcessor to call when each match is found.
    
    Returns:
    
    this (for method chaining).
  - matchFilenamePathLeaf
```
public FastClasspathScanner matchFilenamePathLeaf(String pathLeafToMatch,
                                                  FileMatchProcessorWithContext fileMatchProcessorWithContext)
```
    Calls the given FileMatchProcessorWithContext if files are found on the classpath that exactly match the given path leafname.
    
    Parameters:
    
    pathLeafToMatch - The complete path leaf to match, e.g. "WidgetTemplate.html"
    
    fileMatchProcessorWithContext - The FileMatchProcessorWithContext to call when each match is found.
    
    Returns:
    
    this (for method chaining).
  - matchFilenamePathLeaf
```
public FastClasspathScanner matchFilenamePathLeaf(String pathLeafToMatch,
                                                  FileMatchContentsProcessorWithContext fileMatchContentsProcessorWithContext)
```
    Calls the given FileMatchContentsProcessorWithContext if files are found on the classpath that exactly match the given path leafname.
    
    Parameters:
    
    pathLeafToMatch - The complete path leaf to match, e.g. "WidgetTemplate.html"
    
    fileMatchContentsProcessorWithContext - The FileMatchContentsProcessorWithContext to call when each match is found.
    
    Returns:
    
    this (for method chaining).
  - matchFilenameExtension
```
public FastClasspathScanner matchFilenameExtension(String extensionToMatch,
                                                   FileMatchProcessor fileMatchProcessor)
```
    Calls the given FileMatchProcessor if files are found on the classpath that have the given file extension.
    
    Parameters:
    
    extensionToMatch - The extension to match, e.g. "html" matches "WidgetTemplate.html" and "WIDGET.HTML".
    
    fileMatchProcessor - The FileMatchProcessor to call when each match is found.
    
    Returns:
    
    this (for method chaining).
  - matchFilenameExtension
```
public FastClasspathScanner matchFilenameExtension(String extensionToMatch,
                                                   FileMatchContentsProcessor fileMatchContentsProcessor)
```
    Calls the given FileMatchProcessor if files are found on the classpath that have the given file extension.
    
    Parameters:
    
    extensionToMatch - The extension to match, e.g. "html" matches "WidgetTemplate.html".
    
    fileMatchContentsProcessor - The FileMatchContentsProcessor to call when each match is found.
    
    Returns:
    
    this (for method chaining).
  - matchFilenameExtension
```
public FastClasspathScanner matchFilenameExtension(String extensionToMatch,
                                                   FileMatchProcessorWithContext fileMatchProcessorWithContext)
```
    Calls the given FileMatchProcessorWithContext if files are found on the classpath that have the given file extension.
    
    Parameters:
    
    extensionToMatch - The extension to match, e.g. "html" matches "WidgetTemplate.html" and "WIDGET.HTML".
    
    fileMatchProcessorWithContext - The FileMatchProcessorWithContext to call when each match is found.
    
    Returns:
    
    this (for method chaining).
  - matchFilenameExtension
```
public FastClasspathScanner matchFilenameExtension(String extensionToMatch,
                                                   FileMatchContentsProcessorWithContext fileMatchContentsProcessorWithContext)
```
    Calls the given FileMatchProcessorWithContext if files are found on the classpath that have the given file extension.
    
    Parameters:
    
    extensionToMatch - The extension to match, e.g. "html" matches "WidgetTemplate.html".
    
    fileMatchContentsProcessorWithContext - The FileMatchContentsProcessorWithContext to call when each match is found.
    
    Returns:
    
    this (for method chaining).
  - scanAsync
```
public Future<ScanResult> scanAsync(ExecutorService executorService,
                                    int numParallelTasks)
```
    Asynchronously scans the classpath for matching files, and calls any MatchProcessors if a match is identified. Returns a Future object immediately after starting the scan. To block on scan completion, get the result of the returned Future. Uses the provided ExecutorService, and divides the work according to the requested degree of parallelism. This method should be called after all required MatchProcessors have been added. Note on thread safety: MatchProcessors are all run on a separate thread from the thread that calls this method (although the MatchProcessors are all run on one thread). You will need to add your own synchronization logic if MatchProcessors interact with the main thread. See the following for more info: https://github.com/lukehutch/fast-classpath-scanner/wiki/1.-Usage#multithreading-issues
    
    Parameters:
    
    executorService - A custom ExecutorService to use for scheduling worker tasks.
    
    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.
    
    Returns:
    
    a Future object, that when resolved using get() yields a new ScanResult object. This ScanResult object contains info about the class graph within whitelisted packages encountered during the scan.
  - scan
```
public ScanResult scan(ExecutorService executorService,
                       int numParallelTasks)
```
    Scans the classpath for matching files, and calls any MatchProcessors if a match is identified. Uses the provided ExecutorService, and divides the work according to the requested degree of parallelism. Blocks and waits for the scan to complete before returning a ScanResult. This method should be called after all required MatchProcessors have been added.
    
    Parameters:
    
    executorService - A custom ExecutorService to use for scheduling worker tasks. This ExecutorService should start tasks in FIFO order to avoid a deadlock during scan, i.e. be sure to construct the ExecutorService with a LinkedBlockingQueue as its task queue. (This is the default for Executors.newFixedThreadPool().)
    
    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.
    
    Returns:
    
    a new ScanResult object, containing info about the class graph within whitelisted packages encountered during the scan.
    
    Throws:
    
    ScanInterruptedException - if the scan was interrupted by the interrupt status being set on worker threads. If you care about thread interruption, you should catch this exception. If you don't plan to interrupt the scan, you probably don't need to catch this.
    
    RuntimeException - if any of the worker threads throws an uncaught exception.
  - scan
```
public ScanResult scan(int numThreads)
```
    Scans the classpath for matching files, and calls any MatchProcessors if a match is identified. Temporarily starts up a new fixed thread pool for scanning, with the requested number of threads. Blocks and waits for the scan to complete before returning a ScanResult. This method should be called after all required MatchProcessors have been added.
    
    Parameters:
    
    numThreads - The number of worker threads to start up.
    
    Returns:
    
    a new ScanResult object, containing info about the class graph within whitelisted packages encountered during the scan.
    
    Throws:
    
    ScanInterruptedException - if the scan was interrupted by the interrupt status being set on worker threads. If you care about thread interruption, you should catch this exception. If you don't plan to interrupt the scan, you probably don't need to catch this.
    
    RuntimeException - if any of the worker threads throws an uncaught exception.
  - scan
```
public ScanResult scan()
```
    Scans the classpath for matching files, and calls any MatchProcessors if a match is identified. Temporarily starts up a new fixed thread pool for scanning, with the default number of threads. Blocks and waits for the scan to complete before returning a ScanResult. This method should be called after all required MatchProcessors have been added.
    
    Returns:
    
    a new ScanResult object, containing info about the class graph within whitelisted packages encountered during the scan.
    
    Throws:
    
    ScanInterruptedException - if the scan was interrupted by the interrupt status being set on worker threads. If you care about thread interruption, you should catch this exception.
    
    RuntimeException - if any of the worker threads throws an uncaught exception.
  - getUniqueClasspathElementsAsync
```
public Future<List<File>> getUniqueClasspathElementsAsync(ExecutorService executorService,
                                                          int numParallelTasks)
```
    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. See the following for info on thread safety: https://github.com/lukehutch/fast-classpath-scanner/wiki/1.-Usage#multithreading-issues
    
    Parameters:
    
    executorService - A custom ExecutorService to use for scheduling worker tasks.
    
    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.
    
    Returns:
    
    a Future>, that when resolved with get() returns a list of the unique directories and jarfiles on the classpath, in classpath resolution order.
  - getUniqueClasspathElements
```
public List<File> getUniqueClasspathElements(ExecutorService executorService,
                                             int numParallelTasks)
```
    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. Blocks until the result can be returned, when all classpath elements have been found and tested to see if they exist in the filesystem.
    
    Parameters:
    
    executorService - A custom ExecutorService to use for scheduling worker tasks.
    
    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.
    
    Returns:
    
    a List consisting of the unique directories and jarfiles on the classpath, in classpath resolution order.
  - getUniqueClasspathElements
```
public List<File> getUniqueClasspathElements()
```
    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. Blocks until the result can be returned, when all classpath elements have been found and tested to see if they exist in the filesystem.
    
    Returns:
    
    a List consisting of the unique directories and jarfiles on the classpath, in classpath resolution order.

Class FastClasspathScanner

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

FastClasspathScanner

Method Detail

getVersion

verbose

verbose

ignoreFieldVisibility

ignoreFieldVisibility

ignoreMethodVisibility

ignoreMethodVisibility

enableFieldTypeIndexing

enableFieldTypeIndexing

enableMethodAnnotationIndexing

enableMethodAnnotationIndexing

strictWhitelist

strictWhitelist

registerClassLoaderHandler

overrideClasspath

matchAllClasses

matchAllStandardClasses

matchAllInterfaceClasses

matchAllAnnotationClasses

matchSubclassesOf

matchSubinterfacesOf

matchClassesImplementing

matchClassesWithFieldOfType

matchClassesWithAnnotation

matchClassesWithMethodAnnotation

matchStaticFinalFieldNames

matchStaticFinalFieldNames

matchStaticFinalFieldNames

matchFilenamePattern

matchFilenamePattern

matchFilenamePattern

matchFilenamePattern

matchFilenamePath

matchFilenamePath

matchFilenamePath

matchFilenamePath

matchFilenamePathLeaf

matchFilenamePathLeaf

matchFilenamePathLeaf

matchFilenamePathLeaf

matchFilenameExtension

matchFilenameExtension

matchFilenameExtension

matchFilenameExtension

scanAsync

scan

scan

scan

getUniqueClasspathElementsAsync

getUniqueClasspathElements

getUniqueClasspathElements