ScanSpec (FastClasspathScanner 2.12.4 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
`List<ClassLoader>`	`addedClassLoaders` If non-null, specified manually-added classloaders that should be searched after the context classloader(s).
`RetentionPolicy`	`annotationVisibility` Annotation retention visibility: RetentionPolicy.CLASS matches all annotations (both RuntimeVisible and RuntimeInvisible); RetentionPolicy.RUNTIME matches only RuntimeVisible annotations.
`List<Pattern>`	`blacklistedJarPatterns` Blacklisted jarfile names containing a glob('*') character, converted to a regexp.
`Set<String>`	`blacklistedJars` Blacklisted jarfile names.
`List<String>`	`blacklistedPackagePrefixes` Blacklisted package names with "." appended.
`List<String>`	`blacklistedPathPrefixes` Blacklisted package paths with "/" appended.
`boolean`	`blacklistSystemJars` True if JRE system jarfiles (rt.jar etc.) should not be scanned.
`boolean`	`blacklistSystemPackages` By default, blacklist all java.* and sun.* packages.
`ClassLoaderFinder`	`classLoaderFinder` The ClassLoader finder.
`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.
`ArrayList<ClassLoaderHandlerRegistry.ClassLoaderHandlerRegistryEntry>`	`extraClassLoaderHandlers` Manually-registered ClassLoaderHandlers.
`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`	`ignoreParentClassLoaders` If true, do not fetch paths from parent classloaders.
`boolean`	`initializeLoadedClasses` If true, classes loaded with Class.forName() are initialized before passing class references to MatchProcessors.
`List<ClassLoader>`	`overrideClassLoaders` If non-null, all ClassLoaders have been overriden.
`String`	`overrideClasspath` If non-null, specifies a classpath to override the default one.
`boolean`	`removeTemporaryFilesAfterScan` If true, nested jarfiles (jarfiles within jarfiles) that are extracted during scanning are removed from their temporary directory (e.g.
`boolean`	`scanDirs` True if directories on the classpath should be scanned.
`boolean`	`scanJars` True if jarfiles on the classpath should be scanned.
`Set<String>`	`specificallyBlacklistedClassNames` Blacklisted class names.
`Set<String>`	`specificallyBlacklistedClassRelativePaths` Blacklisted class relative paths.
`Set<String>`	`specificallyWhitelistedClassParentRelativePaths` Path prefixes of whitelisted classes, or the empty list if none.
`Set<String>`	`specificallyWhitelistedClassRelativePaths` Whitelisted class names, or the empty list if none.
`boolean`	`strictWhitelist` If true, remove "external" classes from consideration (i.e.
`List<Pattern>`	`whitelistedJarPatterns` Whitelisted jarfile names containing a glob('*') character, converted to a regexp.
`Set<String>`	`whitelistedJars` Whitelisted jarfile names.
`List<String>`	`whitelistedPathPrefixes` Whitelisted package paths with "/" appended, or the empty list if all packages are whitelisted.
`List<String>`	`whitelistedPathsNonRecursive` Whitelisted package paths with "/" appended, or the empty list if all packages are whitelisted.

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, FileMatchProcessorAny fileMatchProcessor)` Calls the given FileMatchProcessor if files are found on the classpath that have the given file extension.
`void`	`matchFilenamePath(String relativePathToMatch, FileMatchProcessorAny fileMatchProcessor)` Calls the given FileMatchProcessor if files are found on the classpath that exactly match the given relative path.
`void`	`matchFilenamePathLeaf(String pathLeafToMatch, FileMatchProcessorAny fileMatchProcessor)` Calls the given FileMatchProcessor if files are found on the classpath that exactly match the given path leafname.
`void`	`matchFilenamePattern(String pathRegexp, FileMatchProcessorAny fileMatchProcessor)` Calls the given FileMatchProcessor 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
  - whitelistedPathPrefixes
```
public final List<String> whitelistedPathPrefixes
```
    Whitelisted package paths with "/" appended, or the empty list if all packages are whitelisted. These packages and any subpackages will be scanned.
  - whitelistedPathsNonRecursive
```
public final List<String> whitelistedPathsNonRecursive
```
    Whitelisted package paths with "/" appended, or the empty list if all packages are whitelisted. These packages will be scanned, but subpackages will not be scanned unless they are whitelisted.
  - blacklistedPathPrefixes
```
public final List<String> blacklistedPathPrefixes
```
    Blacklisted package paths with "/" appended. Neither these packages nor any subpackages will be scanned.
  - blacklistedPackagePrefixes
```
public final List<String> blacklistedPackagePrefixes
```
    Blacklisted package names with "." appended. Neither these packages nor any subpackages will be scanned.
  - specificallyWhitelistedClassRelativePaths
```
public final Set<String> specificallyWhitelistedClassRelativePaths
```
    Whitelisted class names, or the empty list if none.
  - specificallyWhitelistedClassParentRelativePaths
```
public final Set<String> specificallyWhitelistedClassParentRelativePaths
```
    Path prefixes of whitelisted classes, or the empty list if none.
  - specificallyBlacklistedClassRelativePaths
```
public final Set<String> specificallyBlacklistedClassRelativePaths
```
    Blacklisted class relative paths.
  - specificallyBlacklistedClassNames
```
public final Set<String> specificallyBlacklistedClassNames
```
    Blacklisted class names.
  - whitelistedJars
```
public final Set<String> whitelistedJars
```
    Whitelisted jarfile names. (Leaf filename only.)
  - blacklistedJars
```
public final Set<String> blacklistedJars
```
    Blacklisted jarfile names. (Leaf filename only.)
  - whitelistedJarPatterns
```
public final List<Pattern> whitelistedJarPatterns
```
    Whitelisted jarfile names containing a glob('*') character, converted to a regexp. (Leaf filename only.)
  - blacklistedJarPatterns
```
public final List<Pattern> blacklistedJarPatterns
```
    Blacklisted jarfile names containing a glob('*') character, converted to a regexp. (Leaf filename only.)
  - scanJars
```
public boolean scanJars
```
    True if jarfiles on the classpath should be scanned.
  - scanDirs
```
public boolean scanDirs
```
    True if directories on the classpath should be scanned.
  - 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.
  - blacklistSystemJars
```
public boolean blacklistSystemJars
```
    True if JRE system jarfiles (rt.jar etc.) should not be scanned. By default, these are not scanned. This can be overridden by including "!!" in the scan spec. Disabling this blacklisting will increase the time or memory required to scan the classpath.
  - blacklistSystemPackages
```
public boolean blacklistSystemPackages
```
    By default, blacklist all java.* and sun.* packages. This means for example that you can't use java.lang.Comparable as a match criterion. This can be overridden by including "!!" in the scan spec. Disabling this blacklisting may increase the time or memory required to scan the classpath.
  - 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.
  - addedClassLoaders
```
public List<ClassLoader> addedClassLoaders
```
    If non-null, specified manually-added classloaders that should be searched after the context classloader(s).
  - overrideClassLoaders
```
public List<ClassLoader> overrideClassLoaders
```
    If non-null, all ClassLoaders have been overriden. In particular, this causes FastClasspathScanner to ignore the java.class.path system property.
  - classLoaderFinder
```
public ClassLoaderFinder classLoaderFinder
```
    The ClassLoader finder.
  - overrideClasspath
```
public String overrideClasspath
```
    If non-null, specifies a classpath to override the default one.
  - extraClassLoaderHandlers
```
public final ArrayList<ClassLoaderHandlerRegistry.ClassLoaderHandlerRegistryEntry> extraClassLoaderHandlers
```
    Manually-registered ClassLoaderHandlers.
  - 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.
  - ignoreParentClassLoaders
```
public boolean ignoreParentClassLoaders
```
    If true, do not fetch paths from parent classloaders.
- 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.
    
    Parameters:
    
    classLoaderHandler - The class of the ClassLoaderHandler that can handle those ClassLoaders.
  - 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,
                                 FileMatchProcessorAny 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.
  - matchFilenamePath
```
public void matchFilenamePath(String relativePathToMatch,
                              FileMatchProcessorAny 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.
  - matchFilenamePathLeaf
```
public void matchFilenamePathLeaf(String pathLeafToMatch,
                                  FileMatchProcessorAny 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.
  - matchFilenameExtension
```
public void matchFilenameExtension(String extensionToMatch,
                                   FileMatchProcessorAny 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.

Class ScanSpec

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

whitelistedPathPrefixes

whitelistedPathsNonRecursive

blacklistedPathPrefixes

blacklistedPackagePrefixes

specificallyWhitelistedClassRelativePaths

specificallyWhitelistedClassParentRelativePaths

specificallyBlacklistedClassRelativePaths

specificallyBlacklistedClassNames

whitelistedJars

blacklistedJars

whitelistedJarPatterns

blacklistedJarPatterns

scanJars

scanDirs

enableFieldTypeIndexing

enableMethodAnnotationIndexing

enableFieldAnnotationIndexing

enableFieldInfo

enableMethodInfo

strictWhitelist

blacklistSystemJars

blacklistSystemPackages

ignoreFieldVisibility

ignoreMethodVisibility

annotationVisibility

disableRecursiveScanning

addedClassLoaders

overrideClassLoaders

classLoaderFinder

overrideClasspath

extraClassLoaderHandlers

initializeLoadedClasses

removeTemporaryFilesAfterScan

ignoreParentClassLoaders

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

matchFilenamePath

matchFilenamePathLeaf

matchFilenameExtension