ScanSpec (FastClasspathScanner 2.4.7 API)

java.lang.Object
- io.github.lukehutch.fastclasspathscanner.scanner.ScanSpec

```
public class ScanSpec
extends Object
```
Parses the scanning specification that was passed to the FastClasspathScanner constructor, and finds all ClassLoaders. Also defines core MatchProcessor matching logic.

Field Summary

Fields
Modifier and Type	Field and Description
`RetentionPolicy`	`annotationVisibility` Annotation retention visibility: RetentionPolicy.CLASS matches all annotations (both RuntimeVisible and RuntimeInvisible); RetentionPolicy.RUNTIME matches only RuntimeVisible annotations.
`boolean`	`disableRecursiveScanning` Whether to disable recursive scanning (enabled by default).
`boolean`	`enableFieldAnnotationIndexing` If true, index field annotations.
`boolean`	`enableFieldInfo` If true, enables the saving of field info during the scan.
`boolean`	`enableFieldTypeIndexing` If true, index types of fields.
`boolean`	`enableMethodAnnotationIndexing` If true, index method annotations.
`boolean`	`enableMethodInfo` If true, enables the saving of method info during the scan.
`boolean`	`ignoreFieldVisibility` If true, ignore field visibility (affects finding classes with fields of a given type, and matching of static final fields with constant initializers).
`boolean`	`ignoreMethodVisibility` If true, ignore method visibility (affects finding methods with annotations of a given type).
`boolean`	`initializeLoadedClasses` If true, classes loaded with Class.forName() are initialized before passing class references to MatchProcessors.
`boolean`	`removeTemporaryFilesAfterScan` If true, nested jarfiles (jarfiles within jarfiles) that are extracted during scanning are removed from their temporary directory (e.g.
`boolean`	`strictWhitelist` If true, remove "external" classes from consideration (i.e.

Constructor Summary

Constructors
Constructor and Description
`ScanSpec(String[] scanSpec, LogNode log)` Parses the scanning specification that was passed to the FastClasspathScanner constructor, and finds all ClassLoaders.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addClassLoader(ClassLoader classLoader)` Add a ClassLoader to the list of ClassLoaders to scan.
`void`	`callMatchProcessors(ScanResult scanResult)` Run the MatchProcessors after a scan has completed.
`MultiMapKeyToSet<String,String>`	`getClassNameToStaticFinalFieldsToMatch()`
`boolean`	`hasMatchProcessors()` Return true if any MatchProcessors have been added.
`void`	`ignoreParentClassLoaders(boolean ignoreParentClassloaders)`
`void`	`matchAllAnnotationClasses(ClassMatchProcessor classMatchProcessor)` Calls the provided ClassMatchProcessor for all annotation classes (annotation definitions) found in whitelisted packages on the classpath.
`void`	`matchAllClasses(ClassMatchProcessor classMatchProcessor)` Calls the provided ClassMatchProcessor for all standard classes, interfaces and annotations found in whitelisted packages on the classpath.
`void`	`matchAllInterfaceClasses(ClassMatchProcessor classMatchProcessor)` Calls the provided ClassMatchProcessor for all interface classes (interface definitions) found in whitelisted packages on the classpath.
`void`	`matchAllStandardClasses(ClassMatchProcessor classMatchProcessor)` Calls the provided ClassMatchProcessor for all standard classes (i.e.
`<T> void`	`matchClassesImplementing(Class<T> implementedInterface, ImplementingClassMatchProcessor<T> implementingClassMatchProcessor)` 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.
`void`	`matchClassesWithAnnotation(Class<?> annotation, ClassAnnotationMatchProcessor classAnnotationMatchProcessor)` Calls the provided ClassAnnotationMatchProcessor if classes are found on the classpath that have the specified annotation.
`void`	`matchClassesWithFieldAnnotation(Class<? extends Annotation> annotation, FieldAnnotationMatchProcessor fieldAnnotationMatchProcessor)` Calls the provided FieldAnnotationMatchProcessor if classes are found on the classpath that have one or more fields with the specified annotation.
`<T> void`	`matchClassesWithFieldOfType(Class<T> fieldType, ClassMatchProcessor classMatchProcessor)` Calls the provided ClassMatchProcessor for classes on the classpath that have a field of the given type.
`void`	`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.
`void`	`matchFilenameExtension(String extensionToMatch, FileMatchContentsProcessor fileMatchContentsProcessor)` Calls the given FileMatchProcessor if files are found on the classpath that have the given file extension.
`void`	`matchFilenameExtension(String extensionToMatch, FileMatchContentsProcessorWithContext fileMatchContentsProcessorWithContext)` Calls the given FileMatchProcessorWithContext if files are found on the classpath that have the given file extension.
`void`	`matchFilenameExtension(String extensionToMatch, FileMatchProcessor fileMatchProcessor)` Calls the given FileMatchProcessor if files are found on the classpath that have the given file extension.
`void`	`matchFilenameExtension(String extensionToMatch, FileMatchProcessorWithContext fileMatchProcessorWithContext)` Calls the given FileMatchProcessorWithContext if files are found on the classpath that have the given file extension.
`void`	`matchFilenamePath(String relativePathToMatch, FileMatchContentsProcessor fileMatchContentsProcessor)` Calls the given FileMatchContentsProcessor if files are found on the classpath that exactly match the given relative path.
`void`	`matchFilenamePath(String relativePathToMatch, FileMatchContentsProcessorWithContext fileMatchContentsProcessorWithContext)` Calls the given FileMatchContentsProcessorWithContext if files are found on the classpath that exactly match the given relative path.
`void`	`matchFilenamePath(String relativePathToMatch, FileMatchProcessor fileMatchProcessor)` Calls the given FileMatchProcessor if files are found on the classpath that exactly match the given relative path.
`void`	`matchFilenamePath(String relativePathToMatch, FileMatchProcessorWithContext fileMatchProcessorWithContext)` Calls the given FileMatchProcessorWithContext if files are found on the classpath that exactly match the given relative path.
`void`	`matchFilenamePathLeaf(String pathLeafToMatch, FileMatchContentsProcessor fileMatchContentsProcessor)` Calls the given FileMatchContentsProcessor if files are found on the classpath that exactly match the given path leafname.
`void`	`matchFilenamePathLeaf(String pathLeafToMatch, FileMatchContentsProcessorWithContext fileMatchContentsProcessorWithContext)` Calls the given FileMatchContentsProcessorWithContext if files are found on the classpath that exactly match the given path leafname.
`void`	`matchFilenamePathLeaf(String pathLeafToMatch, FileMatchProcessor fileMatchProcessor)` Calls the given FileMatchProcessor if files are found on the classpath that exactly match the given path leafname.
`void`	`matchFilenamePathLeaf(String pathLeafToMatch, FileMatchProcessorWithContext fileMatchProcessorWithContext)` Calls the given FileMatchProcessorWithContext if files are found on the classpath that exactly match the given path leafname.
`void`	`matchFilenamePattern(String pathRegexp, FileMatchContentsProcessor fileMatchContentsProcessor)` Calls the given FileMatchContentsProcessor if files are found on the classpath with the given regexp pattern in their path.
`void`	`matchFilenamePattern(String pathRegexp, FileMatchContentsProcessorWithContext fileMatchContentsProcessorWithContext)` Calls the given FileMatchContentsProcessorWithContext if files are found on the classpath with the given regexp pattern in their path.
`void`	`matchFilenamePattern(String pathRegexp, FileMatchProcessor fileMatchProcessor)` Calls the given FileMatchProcessor if files are found on the classpath with the given regexp pattern in their path.
`void`	`matchFilenamePattern(String pathRegexp, FileMatchProcessorWithContext fileMatchProcessorWithContext)` Calls the given FileMatchProcessorWithContext if files are found on the classpath with the given regexp pattern in their path.
`void`	`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.
`void`	`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.
`void`	`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> void`	`matchSubclassesOf(Class<T> superclass, SubclassMatchProcessor<T> subclassMatchProcessor)` Calls the provided SubclassMatchProcessor if classes are found on the classpath that extend the specified superclass.
`<T> void`	`matchSubinterfacesOf(Class<T> superinterface, SubinterfaceMatchProcessor<T> subinterfaceMatchProcessor)` Calls the provided SubinterfaceMatchProcessor if an interface that extends a given superinterface is found on the classpath.
`void`	`overrideClassLoaders(ClassLoader... overrideClassLoaders)` Completely override the list of ClassLoaders to scan.
`void`	`overrideClasspath(String overrideClasspath)` Override the automatically-detected classpath with a custom search path.
`void`	`registerClassLoaderHandler(Class<? extends ClassLoaderHandler> classLoaderHandler)` Register an extra ClassLoaderHandler.

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

- Field Detail
  - enableFieldTypeIndexing
```
public boolean enableFieldTypeIndexing
```
    If true, index types of fields.
  - enableMethodAnnotationIndexing
```
public boolean enableMethodAnnotationIndexing
```
    If true, index method annotations.
  - enableFieldAnnotationIndexing
```
public boolean enableFieldAnnotationIndexing
```
    If true, index field annotations.
  - enableFieldInfo
```
public boolean enableFieldInfo
```
    If true, enables the saving of field info during the scan. This information can be obtained using ClassInfo#getFieldInfo(). By default, field info is not saved for efficiency.
  - enableMethodInfo
```
public boolean enableMethodInfo
```
    If true, enables the saving of method info during the scan. This information can be obtained using ClassInfo#getMethodInfo(). By default, method info is not saved for efficiency.
  - strictWhitelist
```
public boolean strictWhitelist
```
    If 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.
  - ignoreFieldVisibility
```
public boolean ignoreFieldVisibility
```
    If true, ignore field visibility (affects finding classes with fields of a given type, and matching of static final fields with constant initializers). If false, fields must be public to be indexed/matched.
  - ignoreMethodVisibility
```
public boolean ignoreMethodVisibility
```
    If true, ignore method visibility (affects finding methods with annotations of a given type). If false, methods must be public to be indexed/matched.
  - annotationVisibility
```
public RetentionPolicy annotationVisibility
```
    Annotation retention visibility: RetentionPolicy.CLASS matches all annotations (both RuntimeVisible and RuntimeInvisible); RetentionPolicy.RUNTIME matches only RuntimeVisible annotations.
  - disableRecursiveScanning
```
public boolean disableRecursiveScanning
```
    Whether to disable recursive scanning (enabled by default). If set to false, only toplevel entries within each whitelisted package will be scanned, i.e. sub-packages of whitelisted packages will not be scanned. If no whitelisted packages were provided to the FastClasspathScanner constructor, then only the toplevel directory within each classpath element will be scanned.
  - initializeLoadedClasses
```
public boolean initializeLoadedClasses
```
    If true, classes loaded with Class.forName() are initialized before passing class references to MatchProcessors. If false (the default), matched classes are loaded but not initialized before passing class references to MatchProcessors (meaning classes are instead initialized lazily on first usage of the class).
  - removeTemporaryFilesAfterScan
```
public boolean removeTemporaryFilesAfterScan
```
    If true, nested jarfiles (jarfiles within jarfiles) that are extracted during scanning are removed from their temporary directory (e.g. /tmp-FastClasspathScanner-8JX2u4w) after the scan has completed. If false, temporary files are removed on JVM exit.
- Constructor Detail
  - ScanSpec
```
public ScanSpec(String[] scanSpec,
                LogNode log)
```
    Parses the scanning specification that was passed to the FastClasspathScanner constructor, and finds all ClassLoaders.
- Method Detail
  - getClassNameToStaticFinalFieldsToMatch
```
public MultiMapKeyToSet<String,String> getClassNameToStaticFinalFieldsToMatch()
```
  - registerClassLoaderHandler
```
public void registerClassLoaderHandler(Class<? extends ClassLoaderHandler> classLoaderHandler)
```
    Register an extra ClassLoaderHandler.
  - overrideClasspath
```
public void overrideClasspath(String overrideClasspath)
```
    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, i.e. causes ClassLoaders to be ignored, as well as the java.class.path system property.
  - addClassLoader
```
public void addClassLoader(ClassLoader classLoader)
```
    Add a ClassLoader to the list of ClassLoaders to scan. (This only works if overrideClasspath() is not called.)
  - overrideClassLoaders
```
public void overrideClassLoaders(ClassLoader... overrideClassLoaders)
```
    Completely override the list of ClassLoaders to scan. (This only works if overrideClasspath() is not called.) Causes the java.class.path system property to be ignored.
  - ignoreParentClassLoaders
```
public void ignoreParentClassLoaders(boolean ignoreParentClassloaders)
```
  - hasMatchProcessors
```
public boolean hasMatchProcessors()
```
    Return true if any MatchProcessors have been added.
  - callMatchProcessors
```
public void callMatchProcessors(ScanResult scanResult)
```
    Run the MatchProcessors after a scan has completed.
  - matchAllClasses
```
public void 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.
  - matchAllStandardClasses
```
public void 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.
  - matchAllInterfaceClasses
```
public void 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.
  - matchAllAnnotationClasses
```
public void 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.
  - matchSubclassesOf
```
public <T> void 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.
  - matchSubinterfacesOf
```
public <T> void 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.
  - matchClassesImplementing
```
public <T> void matchClassesImplementing(Class<T> implementedInterface,
                                         ImplementingClassMatchProcessor<T> implementingClassMatchProcessor)
```
    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.
    
    implementingClassMatchProcessor - the ClassMatchProcessor to call when a match is found.
  - matchClassesWithFieldOfType
```
public <T> void 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.
    
    Parameters:
    
    fieldType - The type of the field to match..
    
    classMatchProcessor - the ClassMatchProcessor to call when a match is found.
  - matchClassesWithAnnotation
```
public void 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.
  - matchClassesWithMethodAnnotation
```
public void 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.
    
    Parameters:
    
    annotation - The method annotation to match.
    
    methodAnnotationMatchProcessor - the MethodAnnotationMatchProcessor to call when a match is found.
  - matchClassesWithFieldAnnotation
```
public void matchClassesWithFieldAnnotation(Class<? extends Annotation> annotation,
                                            FieldAnnotationMatchProcessor fieldAnnotationMatchProcessor)
```
    Calls the provided FieldAnnotationMatchProcessor if classes are found on the classpath that have one or more fields with the specified annotation.
    
    Parameters:
    
    annotation - The method annotation to match.
    
    fieldAnnotationMatchProcessor - the FieldAnnotationMatchProcessor to call when a match is found.
  - matchStaticFinalFieldNames
```
public void 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.
  - matchStaticFinalFieldNames
```
public void 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.
  - matchStaticFinalFieldNames
```
public void 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.
  - matchFilenamePattern
```
public void 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 void 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.
  - matchFilenamePattern
```
public void 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 void 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.
  - matchFilenamePath
```
public void 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 void 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.
  - matchFilenamePath
```
public void 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 void 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.
  - matchFilenamePathLeaf
```
public void 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 void 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.
  - matchFilenamePathLeaf
```
public void 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 void 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.
  - matchFilenameExtension
```
public void 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 void 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.
  - matchFilenameExtension
```
public void 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 void 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.

Class ScanSpec

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

enableFieldTypeIndexing

enableMethodAnnotationIndexing

enableFieldAnnotationIndexing

enableFieldInfo

enableMethodInfo

strictWhitelist

ignoreFieldVisibility

ignoreMethodVisibility

annotationVisibility

disableRecursiveScanning

initializeLoadedClasses

removeTemporaryFilesAfterScan

Constructor Detail

ScanSpec

Method Detail

getClassNameToStaticFinalFieldsToMatch

registerClassLoaderHandler

overrideClasspath

addClassLoader

overrideClassLoaders

ignoreParentClassLoaders

hasMatchProcessors

callMatchProcessors

matchAllClasses

matchAllStandardClasses

matchAllInterfaceClasses

matchAllAnnotationClasses

matchSubclassesOf

matchSubinterfacesOf

matchClassesImplementing

matchClassesWithFieldOfType

matchClassesWithAnnotation

matchClassesWithMethodAnnotation

matchClassesWithFieldAnnotation

matchStaticFinalFieldNames

matchStaticFinalFieldNames

matchStaticFinalFieldNames

matchFilenamePattern

matchFilenamePattern

matchFilenamePattern

matchFilenamePattern

matchFilenamePath

matchFilenamePath

matchFilenamePath

matchFilenamePath

matchFilenamePathLeaf

matchFilenamePathLeaf

matchFilenamePathLeaf

matchFilenamePathLeaf

matchFilenameExtension

matchFilenameExtension

matchFilenameExtension

matchFilenameExtension