ClassInfo (Fast Classpath Scanner 1.10.0 API)

java.lang.Object
- io.github.lukehutch.fastclasspathscanner.classfileparser.ClassInfo

All Implemented Interfaces:: Comparable<ClassInfo>

public class ClassInfo
extends Object
implements Comparable<ClassInfo>

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class ClassInfo.ClassType
The class type to return.

static class ClassInfo.RelType

Nested Classes
Modifier and Type	Class and Description
`static class`	`ClassInfo.ClassType` The class type to return.
`static class`	`ClassInfo.RelType`

Field Summary

Fields
Modifier and Type	Field and Description
`boolean`	`classfileScanned` True when a class has been scanned (i.e.
`String`	`className` Name of the class/interface/annotation.
`Map<String,Object>`	`fieldValues` The static constant initializer values of static final fields, if a StaticFinalFieldMatchProcessor matched a field in this class.
`Map<ClassInfo.RelType,Set<ClassInfo>>`	`relatedTypeToClassInfoSet` The set of classes related to this one.

Constructor Summary

Constructors
Constructor and Description

ClassInfo(String className)

Constructors
Constructor and Description
`ClassInfo(String className)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addAnnotation(String annotationName, Map<String,ClassInfo> classNameToClassInfo)`
`void`	`addFieldConstantValue(String fieldName, Object constValue)`
`void`	`addFieldType(String fieldTypeName, Map<String,ClassInfo> classNameToClassInfo)`
`void`	`addImplementedInterface(String interfaceName, Map<String,ClassInfo> classNameToClassInfo)`
`boolean`	`addRelatedClass(ClassInfo.RelType relType, ClassInfo classInfo)` Add a ClassInfo objects for the given relationship type.
`boolean`	`addRelatedClasses(ClassInfo.RelType relType, Collection<ClassInfo> classInfoSetToAdd)` Add a ClassInfo objects for the given relationship type.
`static ClassInfo`	`addScannedClass(String className, boolean isInterface, boolean isAnnotation, Map<String,ClassInfo> classNameToClassInfo)` Add a class that has just been scanned (as opposed to just referenced by a scanned class).
`void`	`addSuperclass(String superclassName, Map<String,ClassInfo> classNameToClassInfo)`
`int`	`compareTo(ClassInfo o)`
`boolean`	`equals(Object obj)`
`static Set<ClassInfo>`	`filterClassInfo(Set<ClassInfo> classInfoSet, boolean removeExternalClasses, ClassInfo.ClassType... classTypes)` Get the ClassInfo objects for the classes related to this one in the specified way.
`static List<String>`	`getClassNames(Collection<ClassInfo> classInfoColl)` Get the sorted list of the names of classes given a set of ClassInfo objects.
`Set<ClassInfo>`	`getReachableClasses(ClassInfo.RelType relType)` Find all ClassInfo nodes reachable from this ClassInfo node over the given relationship type links (not including this class itself).
`Set<ClassInfo>`	`getRelatedClasses(ClassInfo.RelType relType)` Get the ClassInfo objects for the classes related to this one in the specified way.
`static Set<ClassInfo>`	`getRelatedClasses(String className, Map<String,ClassInfo> classNameToClassInfo, ClassInfo.RelType relType)` Get the ClassInfo objects for the classes related to the named class in the specified way.
`int`	`hashCode()`
`boolean`	`isAnnotation()` Returns true if this ClassInfo corresponds to an annotation.
`boolean`	`isImplementedInterface()` Returns true if this ClassInfo corresponds to an "implemented interface" (meaning a non-annotation interface, or an annotation that has also been implemented as an interface by some class).
`boolean`	`isStandardClass()` Regular classes are not annotations, and should not be interfaces, but to be robust, even if it's an interface, check if there are super- or sub-classes (if the classpath can contain two versions of a class, once with it defined as a class, and once with it defined as an interface -- classpath masking should fix this, but this is to fix problems like issue #38 in future).
`String`	`toString()`

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

- Field Detail
  - className
```
public String className
```
    Name of the class/interface/annotation.
  - classfileScanned
```
public boolean classfileScanned
```
    True when a class has been scanned (i.e. its classfile contents read), as opposed to only being referenced by another class' classfile as a superclass/superinterface/annotation. If classfileScanned is true, then this also must be a whitelisted (and non-blacklisted) class in a whitelisted (and non-blacklisted) package.
  - relatedTypeToClassInfoSet
```
public Map<ClassInfo.RelType,Set<ClassInfo>> relatedTypeToClassInfoSet
```
    The set of classes related to this one.
  - fieldValues
```
public Map<String,Object> fieldValues
```
    The static constant initializer values of static final fields, if a StaticFinalFieldMatchProcessor matched a field in this class.
- Constructor Detail
  - ClassInfo
```
public ClassInfo(String className)
```
- Method Detail
  - filterClassInfo
```
public static Set<ClassInfo> filterClassInfo(Set<ClassInfo> classInfoSet,
                                             boolean removeExternalClasses,
                                             ClassInfo.ClassType... classTypes)
```
    Get the ClassInfo objects for the classes related to this one in the specified way.
  - getClassNames
```
public static List<String> getClassNames(Collection<ClassInfo> classInfoColl)
```
    Get the sorted list of the names of classes given a set of ClassInfo objects.
  - getRelatedClasses
```
public Set<ClassInfo> getRelatedClasses(ClassInfo.RelType relType)
```
    Get the ClassInfo objects for the classes related to this one in the specified way.
  - getReachableClasses
```
public Set<ClassInfo> getReachableClasses(ClassInfo.RelType relType)
```
    Find all ClassInfo nodes reachable from this ClassInfo node over the given relationship type links (not including this class itself).
  - getRelatedClasses
```
public static Set<ClassInfo> getRelatedClasses(String className,
                                               Map<String,ClassInfo> classNameToClassInfo,
                                               ClassInfo.RelType relType)
```
    Get the ClassInfo objects for the classes related to the named class in the specified way. Equivalent to getRelatedClasses(relType, false, ClassType.ALL)
  - addRelatedClass
```
public boolean addRelatedClass(ClassInfo.RelType relType,
                               ClassInfo classInfo)
```
    Add a ClassInfo objects for the given relationship type. Returns true if the collection changed as a result of the call.
  - addRelatedClasses
```
public boolean addRelatedClasses(ClassInfo.RelType relType,
                                 Collection<ClassInfo> classInfoSetToAdd)
```
    Add a ClassInfo objects for the given relationship type. Returns true if the collection changed as a result of the call.
  - isAnnotation
```
public boolean isAnnotation()
```
    Returns true if this ClassInfo corresponds to an annotation.
  - isImplementedInterface
```
public boolean isImplementedInterface()
```
    Returns true if this ClassInfo corresponds to an "implemented interface" (meaning a non-annotation interface, or an annotation that has also been implemented as an interface by some class). Annotations are interfaces, but you can also implement an annotation, so to we need to check if an interface (even an annotation) is implemented by a class / extended by a subinterface (when classesImplementing contains at least one element), or (failing that) if it is not an interface but not an annotation. (This is named "implemented interface" rather than just "interface" to distinguish it from an annotation.)
  - isStandardClass
```
public boolean isStandardClass()
```
    Regular classes are not annotations, and should not be interfaces, but to be robust, even if it's an interface, check if there are super- or sub-classes (if the classpath can contain two versions of a class, once with it defined as a class, and once with it defined as an interface -- classpath masking should fix this, but this is to fix problems like issue #38 in future).
  - addSuperclass
```
public void addSuperclass(String superclassName,
                          Map<String,ClassInfo> classNameToClassInfo)
```
  - addAnnotation
```
public void addAnnotation(String annotationName,
                          Map<String,ClassInfo> classNameToClassInfo)
```
  - addImplementedInterface
```
public void addImplementedInterface(String interfaceName,
                                    Map<String,ClassInfo> classNameToClassInfo)
```
  - addFieldType
```
public void addFieldType(String fieldTypeName,
                         Map<String,ClassInfo> classNameToClassInfo)
```
  - addFieldConstantValue
```
public void addFieldConstantValue(String fieldName,
                                  Object constValue)
```
  - addScannedClass
```
public static ClassInfo addScannedClass(String className,
                                        boolean isInterface,
                                        boolean isAnnotation,
                                        Map<String,ClassInfo> classNameToClassInfo)
```
    Add a class that has just been scanned (as opposed to just referenced by a scanned class).
  - compareTo
```
public int compareTo(ClassInfo o)
```
    Specified by:
    
    compareTo in interface Comparable<ClassInfo>
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class ClassInfo

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

className

classfileScanned

relatedTypeToClassInfoSet

fieldValues

Constructor Detail

ClassInfo

Method Detail

filterClassInfo

getClassNames

getRelatedClasses

getReachableClasses

getRelatedClasses

addRelatedClass

addRelatedClasses

isAnnotation

isImplementedInterface

isStandardClass

addSuperclass

addAnnotation

addImplementedInterface

addFieldType

addFieldConstantValue

addScannedClass

compareTo

equals

hashCode

toString