FastClasspathScanner (Fast Classpath Scanner 1.93.1 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.) See the accompanying README.md file for documentation.

Constructor Summary

Constructors
Constructor and Description

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

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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`FastClasspathScanner`	`enableFieldTypeIndexing()` This method causes FastClasspathScanner enables field indexing in FastClasspathScanner, which allows you to call ScanResult#matchClassesWithFieldsOfType(type).
`FastClasspathScanner`	`enableFieldTypeIndexing(boolean enableFieldTypeIndexing)` If enableFieldIndexing is true, causes FastClasspathScanner enables field type indexing in FastClasspathScanner, which allows you to call ScanResult#getClassesWithFieldsOfType(type).
`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`	`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, InterfaceMatchProcessor<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 ClassMatchProcessor 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`	`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(ClassLoaderHandler extraClassLoaderHandler)` 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()` Remove "external" classes from consideration (i.e.
`FastClasspathScanner`	`strictWhitelist(boolean strictWhitelist)` If strictWhitelist is true, remove "external" classes from consideration (i.e.
`FastClasspathScanner`	`verbose()` Switch on verbose mode (prints debug info to System.out).
`FastClasspathScanner`	`verbose(boolean verbose)` Switch on verbose mode 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)
```
    Constructs a FastClasspathScanner instance. You can pass a scanning specification to the constructor to describe what should be scanned. This 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#constructor for info.
- Method Detail
  - verbose
```
public FastClasspathScanner verbose()
```
    Switch on verbose mode (prints debug info to System.out). Call immediately after the constructor if you want full log output.
  - verbose
```
public FastClasspathScanner verbose(boolean verbose)
```
    Switch on verbose mode if verbose == true. (Prints debug info to System.out.) Call immediately after the constructor if you want full log output.
  - registerClassLoaderHandler
```
public FastClasspathScanner registerClassLoaderHandler(ClassLoaderHandler extraClassLoaderHandler)
```
    Add an extra ClassLoaderHandler. Needed if the ServiceLoader framework is not able to find the ClassLoaderHandler for your specific ClassLoader, or if you want to manually register your own ClassLoaderHandler rather than using the ServiceLoader framework.
  - overrideClasspath
```
public FastClasspathScanner overrideClasspath(String classpath)
```
    Override the automatically-detected classpath with a custom search path.
  - 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.
  - 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.
  - 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.
  - getVersion
```
public static final String getVersion()
```
    Get the version number of FastClasspathScanner
  - 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.
  - 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.
  - enableFieldTypeIndexing
```
public FastClasspathScanner enableFieldTypeIndexing(boolean enableFieldTypeIndexing)
```
    If enableFieldIndexing is true, causes FastClasspathScanner enables field type indexing in FastClasspathScanner, which allows you to call ScanResult#getClassesWithFieldsOfType(type). Field type indexing is disabled by default, because it is expensive in terms of time and memory, and it is not needed for most uses of FastClasspathScanner.
  - enableFieldTypeIndexing
```
public FastClasspathScanner enableFieldTypeIndexing()
```
    This method causes FastClasspathScanner enables field indexing in FastClasspathScanner, which allows you to call ScanResult#matchClassesWithFieldsOfType(type). Field type indexing is disabled by default, because it is expensive in terms of time and memory, and it is not needed for most uses of FastClasspathScanner.
  - strictWhitelist
```
public FastClasspathScanner strictWhitelist(boolean strictWhitelist)
```
    If strictWhitelist is true, remove "external" classes from consideration (i.e. classes outside of whitelisted packages that are referred to by classes within whitelisted packages, e.g. as a superclass). This affects both the ability to use an external classname as a matching criterion, and whether external classes are returned to the user by ScanResult methods.
  - strictWhitelist
```
public FastClasspathScanner strictWhitelist()
```
    Remove "external" classes from consideration (i.e. classes outside of whitelisted packages that are referred to by classes within whitelisted packages, e.g. as a superclass). This affects both the ability to use an external classname as a matching criterion, and whether external classes are returned to the user by ScanResult methods.
  - matchAllClasses
```
public FastClasspathScanner matchAllClasses(ClassMatchProcessor classMatchProcessor)
```
    Calls the provided ClassMatchProcessor for all standard classes, interfaces and annotations found in whitelisted packages on the classpath. Calls the class loader on each matching class (using Class.forName()) before calling the ClassMatchProcessor.
    
    Parameters:
    
    classMatchProcessor - the ClassMatchProcessor to call when a match is found.
  - 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. Calls the class loader on each matching class (using Class.forName()) before calling the ClassMatchProcessor.
    
    Parameters:
    
    classMatchProcessor - the ClassMatchProcessor to call when a match is found.
  - matchAllInterfaceClasses
```
public FastClasspathScanner matchAllInterfaceClasses(ClassMatchProcessor ClassMatchProcessor)
```
    Calls the provided ClassMatchProcessor for all interface classes (interface definitions) found in whitelisted packages on the classpath. Calls the class loader on each matching interface class (using Class.forName()) before calling the ClassMatchProcessor.
    
    Parameters:
    
    ClassMatchProcessor - the ClassMatchProcessor to call when a match is found.
  - matchAllAnnotationClasses
```
public FastClasspathScanner matchAllAnnotationClasses(ClassMatchProcessor ClassMatchProcessor)
```
    Calls the provided ClassMatchProcessor for all annotation classes (annotation definitions) found in whitelisted packages on the classpath. Calls the class loader on each matching annotation class (using Class.forName()) before calling the ClassMatchProcessor.
    
    Parameters:
    
    ClassMatchProcessor - the ClassMatchProcessor to call when a match is found.
  - 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. Calls the class loader on each matching class (using Class.forName()) before calling the SubclassMatchProcessor. Does not call the classloader on non-matching classes or interfaces.
    
    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.
  - 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. Will call the class loader on each matching interface (using Class.forName()) before calling the SubinterfaceMatchProcessor. Does not call the classloader on non-matching classes or interfaces.
    
    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.
  - matchClassesImplementing
```
public <T> FastClasspathScanner matchClassesImplementing(Class<T> implementedInterface,
                                                         InterfaceMatchProcessor<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. Will call the class loader on each matching interface (using Class.forName()) before calling the InterfaceMatchProcessor. Does not call the classloader on non-matching classes or interfaces.
    
    Parameters:
    
    implementedInterface - The interface that classes need to implement.
    
    interfaceMatchProcessor - the ClassMatchProcessor to call when a match is found.
  - 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. (Does not call the classloader on non-matching classes.) The field type must be declared in a package that is whitelisted (and not blacklisted).
    
    Parameters:
    
    fieldType - The type of the field to match..
    
    classMatchProcessor - the ClassMatchProcessor to call when a match is found.
  - matchClassesWithAnnotation
```
public FastClasspathScanner matchClassesWithAnnotation(Class<?> annotation,
                                                       ClassAnnotationMatchProcessor classAnnotationMatchProcessor)
```
    Calls the provided ClassMatchProcessor 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.
  - 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; the value of the field in the classfile is returned whether or not it should be visible to the caller.
    
    Parameters:
    
    fullyQualifiedStaticFinalFieldNames - The set of fully-qualified static field names to match.
    
    staticFinalFieldMatchProcessor - the StaticFinalFieldMatchProcessor to call when a match is found.
  - 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; the value of the field in the classfile is returned whether or not it should be visible to the caller.
    
    Parameters:
    
    fullyQualifiedStaticFinalFieldName - The fully-qualified static field name to match
    
    staticFinalFieldMatchProcessor - the StaticFinalFieldMatchProcessor to call when a match is found.
  - 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; the value of the field in the classfile is returned whether or not it should be visible to the caller.
    
    Parameters:
    
    fullyQualifiedStaticFinalFieldNames - The list of fully-qualified static field names to match.
    
    staticFinalFieldMatchProcessor - the StaticFinalFieldMatchProcessor to call when a match is found.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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 that MatchProcessors are all run on a separate thread from the main thread (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.
    
    Parameters:
    
    executorService - A custom ExecutorService to use for scheduling worker threads.
    
    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.
  - 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. This method should be called after all required MatchProcessors have been added.
    
    Parameters:
    
    executorService - A custom ExecutorService to use for scheduling worker threads. 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.
    
    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.
  - 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. This method should be called after all required MatchProcessors have been added.
    
    Parameters:
    
    numThreads - The number of worker threads to start up.
    
    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.
  - 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. This method should be called after all required MatchProcessors have been added.
    
    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.

Class FastClasspathScanner

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

FastClasspathScanner

Method Detail

verbose

verbose

registerClassLoaderHandler

overrideClasspath

getUniqueClasspathElementsAsync

getUniqueClasspathElements

getUniqueClasspathElements

getVersion

ignoreFieldVisibility

ignoreFieldVisibility

enableFieldTypeIndexing

enableFieldTypeIndexing

strictWhitelist

strictWhitelist

matchAllClasses

matchAllStandardClasses

matchAllInterfaceClasses

matchAllAnnotationClasses

matchSubclassesOf

matchSubinterfacesOf

matchClassesImplementing

matchClassesWithFieldOfType

matchClassesWithAnnotation

matchStaticFinalFieldNames

matchStaticFinalFieldNames

matchStaticFinalFieldNames

matchFilenamePattern

matchFilenamePattern

matchFilenamePattern

matchFilenamePattern

matchFilenamePath

matchFilenamePath

matchFilenamePath

matchFilenamePath

matchFilenamePathLeaf

matchFilenamePathLeaf

matchFilenamePathLeaf

matchFilenamePathLeaf

matchFilenameExtension

matchFilenameExtension

matchFilenameExtension

matchFilenameExtension

scanAsync

scan

scan

scan