Package nonapi.io.github.classgraph.scanspec

Class ScanSpec

java.lang.Object
nonapi.io.github.classgraph.scanspec.ScanSpec
public class ScanSpec extends Object
The scanning specification.

  • Field Details

    • packageAcceptReject

      public AcceptReject.AcceptRejectWholeString packageAcceptReject
      Package accept/reject criteria (with separator '.').

    • packagePrefixAcceptReject

      public AcceptReject.AcceptRejectPrefix packagePrefixAcceptReject
      Package prefix accept/reject criteria, for recursive scanning (with separator '.', ending in '.').

    • pathAcceptReject

      public AcceptReject.AcceptRejectWholeString pathAcceptReject
      Path accept/reject criteria (with separator '/').

    • pathPrefixAcceptReject

      public AcceptReject.AcceptRejectPrefix pathPrefixAcceptReject
      Path prefix accept/reject criteria, for recursive scanning (with separator '/', ending in '/').

    • classAcceptReject

      public AcceptReject.AcceptRejectWholeString classAcceptReject
      Class accept/reject criteria (fully-qualified class names, with separator '.').

    • classfilePathAcceptReject

      public AcceptReject.AcceptRejectWholeString classfilePathAcceptReject
      Classfile accept/reject criteria (path to classfiles, with separator '/', ending in ".class").

    • classPackageAcceptReject

      public AcceptReject.AcceptRejectWholeString classPackageAcceptReject
      Package containing accept/reject criteriaed classes (with separator '.').

    • classPackagePathAcceptReject

      public AcceptReject.AcceptRejectWholeString classPackagePathAcceptReject
      Path to accept/reject criteriaed classes (with separator '/').

    • moduleAcceptReject

      public AcceptReject.AcceptRejectWholeString moduleAcceptReject
      Module accept/reject criteria (with separator '.').

    • jarAcceptReject

      public AcceptReject.AcceptRejectLeafname jarAcceptReject
      Jar accept/reject criteria (leafname only, ending in ".jar").

    • classpathElementResourcePathAcceptReject

      public AcceptReject.AcceptRejectWholeString classpathElementResourcePathAcceptReject
      Classpath element resource path accept/reject criteria.

    • libOrExtJarAcceptReject

      public AcceptReject.AcceptRejectLeafname libOrExtJarAcceptReject
      lib/ext jar accept/reject criteria (leafname only, ending in ".jar").

    • scanJars

      public boolean scanJars
      If true, scan jarfiles.

    • scanNestedJars

      public boolean scanNestedJars
      If true, scan nested jarfiles (jarfiles within jarfiles).

    • scanDirs

      public boolean scanDirs
      If true, scan directories.

    • scanModules

      public boolean scanModules
      If true, scan modules.

    • enableClassInfo

      public boolean enableClassInfo
      If true, scan classfile bytecodes, producing ClassInfo objects.

    • 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 scanned, 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 scanned, for efficiency.

    • enableAnnotationInfo

      public boolean enableAnnotationInfo
      If true, enables the saving of annotation info (for class, field, method or method parameter annotations) during the scan. This information can be obtained using ClassInfo.getAnnotationInfo() etc. By default, annotation info is not scanned, for efficiency.

    • enableStaticFinalFieldConstantInitializerValues

      public boolean enableStaticFinalFieldConstantInitializerValues
      Enable the storing of constant initializer values for static final fields in ClassInfo objects.

    • enableInterClassDependencies

      public boolean enableInterClassDependencies
      If true, enables the determination of inter-class dependencies.

    • enableExternalClasses

      public boolean enableExternalClasses
      If true, allow external classes (classes outside of accepted packages) to be returned in the ScanResult, if they are directly referred to by an accepted class, as a superclass, implemented interface or annotation. Disabled by default.

    • enableSystemJarsAndModules

      public boolean enableSystemJarsAndModules
      If true, system jarfiles (rt.jar) and system packages and modules (java.*, jre.*, etc.) should be scanned .

    • ignoreClassVisibility

      public boolean ignoreClassVisibility
      If true, ignore class visibility. If false, classes must be public to be scanned.

    • ignoreFieldVisibility

      public boolean ignoreFieldVisibility
      If true, ignore field visibility. If false, fields must be public to be scanned.

    • ignoreMethodVisibility

      public boolean ignoreMethodVisibility
      If true, ignore method visibility. If false, methods must be public to be scanned.

    • disableRuntimeInvisibleAnnotations

      public boolean disableRuntimeInvisibleAnnotations
      If true, don't scan runtime-invisible annotations (only scan annotations with RetentionPolicy.RUNTIME).

    • extendScanningUpwardsToExternalClasses

      public boolean extendScanningUpwardsToExternalClasses
      If true, when classes have superclasses, implemented interfaces or annotations that are external classes, those classes are also scanned. (Even though this slows down scanning a bit, there is no API for disabling this currently, since disabling it can lead to problems -- see #261.)

    • allowedURLSchemes

      public Set<String> allowedURLSchemes
      URL schemes that are allowed in classpath elements (not counting the optional "jar:" prefix and/or "file:", which are automatically allowed).

    • addedClassLoaders

      public transient List<ClassLoader> addedClassLoaders
      If non-null, specifies manually-added classloaders that should be searched after the context classloader(s).

    • overrideClassLoaders

      public transient List<ClassLoader> overrideClassLoaders
      If non-null, this list of ClassLoaders will be searched instead of the visible/context ClassLoader(s). In particular, this causes ClassGraph to ignore the java.class.path system property.

    • addedModuleLayers

      public transient List<Object> addedModuleLayers
      If non-null, specifies manually-added ModuleLayers that should be searched after the visible ModuleLayers.

    • overrideModuleLayers

      public transient List<Object> overrideModuleLayers
      If non-null, this list of ModuleLayers will be searched instead of the visible ModuleLayers.

    • overrideClasspath

      public List<Object> overrideClasspath
      If non-null, specifies a list of classpath elements (String, URL or URI to use to override the default classpath.

    • classpathElementFilters

      public transient List<Object> classpathElementFilters
      If non-null, a list of filter operations to apply to classpath elements.

    • initializeLoadedClasses

      public boolean initializeLoadedClasses
      Whether to initialize classes when loading them.

    • 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/ClassGraph-8JX2u4w) after the scan has completed. If false, temporary files are removed by the ScanResult finalizer, or on JVM exit.

    • ignoreParentClassLoaders

      public boolean ignoreParentClassLoaders
      If true, do not fetch paths from parent classloaders.

    • ignoreParentModuleLayers

      public boolean ignoreParentModuleLayers
      If true, do not scan module layers that are the parent of other module layers.

    • modulePathInfo

      public ModulePathInfo modulePathInfo
      Commandline module path parameters.

    • maxBufferedJarRAMSize

      public int maxBufferedJarRAMSize
      The maximum size of an inner (nested) jar that has been deflated (i.e. compressed, not stored) within an outer jar, before it has to be spilled to disk rather than stored in a RAM-backed ByteBuffer when it is deflated, in order for the inner jar's entries to be read. (Note that this situation of having to deflate a nested jar to RAM or disk in order to read it is rare, because normally adding a jarfile to another jarfile will store the inner jar, rather than deflate it, because deflating a jarfile does not usually produce any further compression gains. If an inner jar is stored, not deflated, then its zip entries can be read directly using ClassGraph's own zipfile central directory parser, which can use file slicing to extract entries directly from stored nested jars.)

      This is also the maximum size of a jar downloaded from an http:// or https:// classpath URL to RAM. Once this many bytes have been read from the URL's InputStream, then the RAM contents are spilled over to a temporary file on disk, and the rest of the content is downloaded to the temporary file. (This is also rare, because normally there are no http:// or https:// classpath entries.)

      Default: 64MB (i.e. writing to disk is avoided wherever possible). Setting a lower max RAM size value will decrease ClassGraph's memory usage if either of the above rare situations occurs.

    • enableMemoryMapping

      public boolean enableMemoryMapping
      If true, use a MappedByteBuffer rather than the FileChannel API to access file content.

    • enableMultiReleaseVersions

      public boolean enableMultiReleaseVersions
      If true, all multi-release versions of a resource are found.

  • Constructor Details

    • ScanSpec

      public ScanSpec()
      Constructor for deserialization.

  • Method Details

    • sortPrefixes

      public void sortPrefixes()
      Sort prefixes to ensure correct accept/reject evaluation (see Issue #167).

    • addClasspathOverride

      public void addClasspathOverride(Object overrideClasspathElement)
      Override the automatically-detected classpath with a custom path. You can specify multiple elements in separate calls, and if this method is called even once, the default classpath will be overridden, such that nothing but the provided classpath will be scanned, i.e. causes ClassLoaders to be ignored, as well as the java.class.path system property.
      Parameters:
      overrideClasspathElement - The classpath element to add as an override to the default classpath.

    • filterClasspathElements

      public void filterClasspathElements(Object filterLambda)
      Add a classpath element filter. The provided ClassGraph.ClasspathElementFilter or ClassGraph.ClasspathElementURLFilter should return true if the path string or URL passed to it is a path that should be scanned.
      Parameters:
      filterLambda - The classpath element filter to apply to all discovered classpath elements, to decide which should be scanned.

    • addClassLoader

      public void addClassLoader(ClassLoader classLoader)
      Add a ClassLoader to the list of ClassLoaders to scan. (This only works if overrideClasspath() is not called.)
      Parameters:
      classLoader - The classloader to add.

    • enableURLScheme

      public void enableURLScheme(String scheme)
      Allow a specified URL scheme in classpath elements.
      Parameters:
      scheme - the scheme, e.g. "http".

    • 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.
      Parameters:
      overrideClassLoaders - The classloaders to override the default context classloaders with.

    • isModuleLayer

      private static boolean isModuleLayer(Object moduleLayer)
      Return true if the argument is a ModuleLayer or a subclass of ModuleLayer.
      Parameters:
      moduleLayer - the module layer
      Returns:
      true if the argument is a ModuleLayer or a subclass of ModuleLayer.

    • addModuleLayer

      public void addModuleLayer(Object moduleLayer)
      Add a ModuleLayer to the list of ModuleLayers to scan. Use this method if you define your own ModuleLayer, but the scanning code is not running within that custom ModuleLayer.

      This call is ignored if it is called before overrideModuleLayers(Object...).

      Parameters:
      moduleLayer - The additional ModuleLayer to scan. (The parameter is of type Object for backwards compatibility with JDK 7 and JDK 8, but the argument should be of type ModuleLayer.)

    • overrideModuleLayers

      public void overrideModuleLayers(Object... overrideModuleLayers)
      Completely override (and ignore) the visible ModuleLayers, and instead scan the requested ModuleLayers.

      This call is ignored if overrideClasspath() is called.

      Parameters:
      overrideModuleLayers - The ModuleLayers to scan instead of the automatically-detected ModuleLayers. (The parameter is of type Object[] for backwards compatibility with JDK 7 and JDK 8, but the argument should be of type ModuleLayer[].)

    • dirAcceptMatchStatus

      public ScanSpec.ScanSpecPathMatch dirAcceptMatchStatus(String relativePath)
      Returns true if the given directory path is a descendant of a rejected path, or an ancestor or descendant of an accepted path. The path should end in "/".
      Parameters:
      relativePath - the relative path
      Returns:
      the ScanSpec.ScanSpecPathMatch

    • classfileIsSpecificallyAccepted

      public boolean classfileIsSpecificallyAccepted(String relativePath)
      Returns true if the given relative path (for a classfile name, including ".class") matches a specifically-accepted (and non-rejected) classfile's relative path.
      Parameters:
      relativePath - the relative path
      Returns:
      true if the given relative path (for a classfile name, including ".class") matches a specifically-accepted (and non-rejected) classfile's relative path.

    • classOrPackageIsRejected

      public boolean classOrPackageIsRejected(String className)
      Returns true if the class is specifically rejected, or is within a rejected package.
      Parameters:
      className - the class name
      Returns:
      true if the class is specifically rejected, or is within a rejected package.

    • log

      public void log(LogNode log)
      Write to log.
      Parameters:
      log - The LogNode to log to.