ClassInfo (neo4j-ogm-core 2.0.0-M03 API)

java.lang.Object
- org.neo4j.ogm.metadata.ClassInfo

```
public class ClassInfo
extends Object
```
Maintains object to graph mapping details at the class (type) level The ClassInfo object is used to maintain mappings from Java Types->Neo4j Labels thereby allowing the correct labels to be applied to new nodes when they are persisted. The ClassInfo object also maintains a map of FieldInfo and MethodInfo objects that maintain the appropriate information for mapping Java class attributes to Neo4j node properties / paths (node)-[:relationship]->(node), via field or method accessors respectively. Given a type hierarchy, the ClassInfo object guarantees that for any type in that hierarchy, the labels associated with that type will include the labels for all its superclass and interface types as well. This is to avoid the need to iterate through the ClassInfo hierarchy to recover label information.

Author:

Vince Bickers, Luanne Misquitta

Constructor Summary

Constructors
Constructor and Description
`ClassInfo(InputStream inputStream)`
`ClassInfo(String name, ClassInfo subclass)` This class was referenced as a superclass of the given subclass.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addSubclass(ClassInfo subclass)` Connect this class to a subclass.
`Collection<AnnotationInfo>`	`annotations()`
`AnnotationsInfo`	`annotationsInfo()`
`Set<FieldInfo>`	`candidateRelationshipFields(String relationshipName, String relationshipDirection, boolean strict)` Finds all relationship fields with a specific name and direction from the ClassInfo's relationship fields
`Set<MethodInfo>`	`candidateRelationshipSetters(String relationshipName, String relationshipDirection, boolean strict)` Finds all relationship setters with a specific name and direction from the specified ClassInfo's relationship setters.
`List<ClassInfo>`	`directImplementingClasses()`
`List<ClassInfo>`	`directInterfaces()`
`List<ClassInfo>`	`directSubclasses()`
`FieldsInfo`	`fieldsInfo()`
`List<FieldInfo>`	`findFields(Class<?> fieldType)` Find all FieldInfos for the specified ClassInfo whose type matches the supplied fieldType
`List<FieldInfo>`	`findFields(String annotation)` Find all FieldInfos for the specified ClassInfo which have the specified annotation
`List<MethodInfo>`	`findGetters(Class<?> returnType)` Find all getter MethodInfos for the specified ClassInfo whose return type matches the supplied class
`List<FieldInfo>`	`findIterableFields()` Retrieves a `List` of `FieldInfo` representing all of the fields that can be iterated over using a "foreach" loop.
`List<FieldInfo>`	`findIterableFields(Class iteratedType)` Finds all fields whose type is equivalent to Array<X> or assignable from Iterable<X> where X is the generic parameter type of the Array or Iterable
`List<FieldInfo>`	`findIterableFields(Class iteratedType, String relationshipType, String relationshipDirection, boolean strict)` Finds all fields whose type is equivalent to Array<X> or assignable from Iterable<X> where X is the generic parameter type of the Array or Iterable and the relationship type backing this iterable is "relationshipType"
`List<MethodInfo>`	`findIterableGetters(Class iteratedType)` Finds all getter methods whose parameterised return type is equivalent to Array<X> or assignable from Iterable<X> where X is the generic parameter type of the Array or Iterable
`List<MethodInfo>`	`findIterableGetters(Class iteratedType, String relationshipType, String relationshipDirection, boolean strict)` Finds all getter methods whose parameterised return type is equivalent to Array<X> or assignable from Iterable<X> where X is the generic parameter type of the Array or Iterable and the relationship type this getter is annotated with is "relationshipType" and the direction of the relationship is "relationshipDirection"
`List<MethodInfo>`	`findIterableSetters(Class iteratedType)` Finds all setter methods whose parameter signature is equivalent to Array<X> or assignable from Iterable<X> where X is the generic parameter type of the Array or Iterable
`List<MethodInfo>`	`findIterableSetters(Class iteratedType, String relationshipType, String relationshipDirection, boolean strict)` Finds all setter methods whose parameter signature is equivalent to Array<X> or assignable from Iterable<X> where X is the generic parameter type of the Array or Iterable and the relationship type this setter is annotated with is "relationshipType" and the relationship direction matches "relationshipDirection"
`List<MethodInfo>`	`findSetters(Class<?> parameterType)` Find all setter MethodInfos for the specified ClassInfo whose parameter type matches the supplied class
`Field`	`getField(FieldInfo fieldInfo)`
`Method`	`getMethod(MethodInfo methodInfo, Class... parameterTypes)`
`Class<?>`	`getType(String typeParameterDescriptor)`
`Class`	`getTypeParameterDescriptorForRelationship(String relationshipType, String relationshipDirection)` Gets the class of the type parameter description of the entity related to this.
`Class`	`getUnderlyingClass()` Get the underlying class represented by this ClassInfo
`void`	`hydrate(ClassInfo classInfoDetails)` A class that was previously only seen as a temp superclass of another class can now be fully hydrated.
`boolean`	`hydrated()`
`FieldInfo`	`identityField()` The identity field is a field annotated with @NodeId, or if none exists, a field of type Long called 'id'
`MethodInfo`	`identityGetter()` The identity getter is any getter annotated with @NodeId returning a Long, or if none exists, a getter returning Long called 'getId'
`MethodInfo`	`identitySetter()` The identity setter is any setter annotated with @NodeId taking a Long parameter, or if none exists, a setter called 'setId' taking a Long parameter
`InterfacesInfo`	`interfacesInfo()`
`boolean`	`isAbstract()`
`boolean`	`isEnum()`
`boolean`	`isInterface()`
`boolean`	`isSubclassOf(ClassInfo classInfo)` Returns true if this classInfo is in the subclass hierarchy of b, or if this classInfo is the same as b, false otherwise
`boolean`	`isTransient()`
`Collection<String>`	`labels()` Retrieves the labels that are applied to nodes in the database that store information about instances of the class.
`MethodsInfo`	`methodsInfo()`
`String`	`name()`
`String`	`neo4jName()`
`FieldInfo`	`propertyField(String propertyName)` Finds the property field with a specific property name from the ClassInfo's property fields
`FieldInfo`	`propertyFieldByName(String propertyName)` Finds the property field with a specific field name from the ClassInfo's property fields
`Collection<FieldInfo>`	`propertyFields()` A property field is any field annotated with @Property, or any field that can be mapped to a node property.
`MethodInfo`	`propertyGetter(String propertyName)` Finds the property getter with a specific name from the specified ClassInfo's property getters
`Collection<MethodInfo>`	`propertyGetters()` A property getter is any getter annotated with @Property, or any getter whose return type can be mapped to a node property.
`MethodInfo`	`propertySetter(String propertyName)` Finds the property setter with a specific name from the specified ClassInfo's property setters
`Collection<MethodInfo>`	`propertySetters()` A property setter is any setter annotated with @Property, or any setter whose parameter type can be mapped to a node property.
`FieldInfo`	`relationshipField(String relationshipName)` Finds the relationship field with a specific name from the ClassInfo's relationship fields
`FieldInfo`	`relationshipField(String relationshipName, String relationshipDirection, boolean strict)` Finds the relationship field with a specific name and direction from the ClassInfo's relationship fields
`FieldInfo`	`relationshipFieldByName(String fieldName)` Finds the relationship field with a specific property name from the ClassInfo's relationship fields
`Collection<FieldInfo>`	`relationshipFields()` A relationship field is any field annotated with @Relationship, or any field that cannot be mapped to a node property.
`MethodInfo`	`relationshipGetter(String relationshipName)` Finds the relationship getter with a specific name from the specified ClassInfo's relationship getters
`MethodInfo`	`relationshipGetter(String relationshipName, String relationshipDirection, boolean strict)` Finds the relationship getter with a specific name and direction from the specified ClassInfo's relationship getters
`Collection<MethodInfo>`	`relationshipGetters()` A relationship getter is any getter annotated with @Relationship, or any getter whose return type cannot be mapped to a node property.
`MethodInfo`	`relationshipSetter(String relationshipName)` Finds the relationship setter with a specific name from the specified ClassInfo's relationship setters
`MethodInfo`	`relationshipSetter(String relationshipName, String relationshipDirection, boolean strict)` Finds the relationship setter with a specific name and direction from the specified ClassInfo's relationship setters.
`Collection<MethodInfo>`	`relationshipSetters()` A relationship setter is any setter annotated with @Relationship, or any setter whose parameter type cannot be mapped to a node property.
`String`	`superclassName()`
`String`	`toString()`

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

- Constructor Detail
  - ClassInfo
```
public ClassInfo(InputStream inputStream)
          throws IOException
```
    Throws:
    
    IOException
  - ClassInfo
```
public ClassInfo(String name,
         ClassInfo subclass)
```
    This class was referenced as a superclass of the given subclass.
    
    Parameters:
    name - the name of the class
    subclass - ClassInfo of the subclass
- Method Detail
  - hydrate
```
public void hydrate(ClassInfo classInfoDetails)
```
    A class that was previously only seen as a temp superclass of another class can now be fully hydrated.
    
    Parameters:
    classInfoDetails - ClassInfo details
  - addSubclass
```
public void addSubclass(ClassInfo subclass)
```
    Connect this class to a subclass.
    
    Parameters:
    subclass - the subclass
  - hydrated
```
public boolean hydrated()
```
  - name
```
public String name()
```
  - labels
```
public Collection<String> labels()
```
    Retrieves the labels that are applied to nodes in the database that store information about instances of the class. If the class' instances are persisted by a relationship instead of a node then this method returns an empty collection.
    
    Returns:
    A Collection of all the labels that apply to the node or an empty list if there aren't any, never null
  - neo4jName
```
public String neo4jName()
```
  - directSubclasses
```
public List<ClassInfo> directSubclasses()
```
  - directImplementingClasses
```
public List<ClassInfo> directImplementingClasses()
```
  - directInterfaces
```
public List<ClassInfo> directInterfaces()
```
  - interfacesInfo
```
public InterfacesInfo interfacesInfo()
```
  - annotations
```
public Collection<AnnotationInfo> annotations()
```
  - isInterface
```
public boolean isInterface()
```
  - isEnum
```
public boolean isEnum()
```
  - annotationsInfo
```
public AnnotationsInfo annotationsInfo()
```
  - superclassName
```
public String superclassName()
```
  - fieldsInfo
```
public FieldsInfo fieldsInfo()
```
  - methodsInfo
```
public MethodsInfo methodsInfo()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - identityField
```
public FieldInfo identityField()
```
    The identity field is a field annotated with @NodeId, or if none exists, a field of type Long called 'id'
    
    Returns:
    A FieldInfo object representing the identity field never null
    
    Throws:
    
    MappingException - if no identity field can be found
  - propertyFields
```
public Collection<FieldInfo> propertyFields()
```
    A property field is any field annotated with @Property, or any field that can be mapped to a node property. The identity field is not a property field.
    
    Returns:
    A Collection of FieldInfo objects describing the classInfo's property fields
  - propertyField
```
public FieldInfo propertyField(String propertyName)
```
    Finds the property field with a specific property name from the ClassInfo's property fields
    
    Parameters:
    propertyName - the propertyName of the field to find
    
    Returns:
    A FieldInfo object describing the required property field, or null if it doesn't exist.
  - propertyFieldByName
```
public FieldInfo propertyFieldByName(String propertyName)
```
    Finds the property field with a specific field name from the ClassInfo's property fields
    
    Parameters:
    propertyName - the propertyName of the field to find
    
    Returns:
    A FieldInfo object describing the required property field, or null if it doesn't exist.
  - relationshipFields
```
public Collection<FieldInfo> relationshipFields()
```
    A relationship field is any field annotated with @Relationship, or any field that cannot be mapped to a node property. The identity field is not a relationship field.
    
    Returns:
    A Collection of FieldInfo objects describing the classInfo's relationship fields
  - relationshipField
```
public FieldInfo relationshipField(String relationshipName)
```
    Finds the relationship field with a specific name from the ClassInfo's relationship fields
    
    Parameters:
    relationshipName - the relationshipName of the field to find
    
    Returns:
    A FieldInfo object describing the required relationship field, or null if it doesn't exist.
  - relationshipField
```
public FieldInfo relationshipField(String relationshipName,
                          String relationshipDirection,
                          boolean strict)
```
    Finds the relationship field with a specific name and direction from the ClassInfo's relationship fields
    
    Parameters:
    relationshipName - the relationshipName of the field to find
    relationshipDirection - the direction of the relationship
    strict - if true, does not infer relationship type but looks for it in the @Relationship annotation. Null if missing. If false, infers relationship type from FieldInfo
    
    Returns:
    A FieldInfo object describing the required relationship field, or null if it doesn't exist.
  - candidateRelationshipFields
```
public Set<FieldInfo> candidateRelationshipFields(String relationshipName,
                                         String relationshipDirection,
                                         boolean strict)
```
    Finds all relationship fields with a specific name and direction from the ClassInfo's relationship fields
    
    Parameters:
    relationshipName - the relationshipName of the field to find
    relationshipDirection - the direction of the relationship
    strict - if true, does not infer relationship type but looks for it in the @Relationship annotation. Null if missing. If false, infers relationship type from FieldInfo
    
    Returns:
    Set of FieldInfo objects describing the required relationship field, or empty set if it doesn't exist.
  - relationshipFieldByName
```
public FieldInfo relationshipFieldByName(String fieldName)
```
    Finds the relationship field with a specific property name from the ClassInfo's relationship fields
    
    Parameters:
    fieldName - the name of the field
    
    Returns:
    A FieldInfo object describing the required relationship field, or null if it doesn't exist.
  - identityGetter
```
public MethodInfo identityGetter()
```
    The identity getter is any getter annotated with @NodeId returning a Long, or if none exists, a getter returning Long called 'getId'
    
    Returns:
    A FieldInfo object representing the identity field or null if it doesn't exist
  - identitySetter
```
public MethodInfo identitySetter()
```
    The identity setter is any setter annotated with @NodeId taking a Long parameter, or if none exists, a setter called 'setId' taking a Long parameter
    
    Returns:
    A FieldInfo object representing the identity field or null if it doesn't exist
  - propertyGetters
```
public Collection<MethodInfo> propertyGetters()
```
    A property getter is any getter annotated with @Property, or any getter whose return type can be mapped to a node property. The identity getter is not a property getter.
    
    Returns:
    A Collection of MethodInfo objects describing the classInfo's property getters
  - propertySetters
```
public Collection<MethodInfo> propertySetters()
```
    A property setter is any setter annotated with @Property, or any setter whose parameter type can be mapped to a node property. The identity setter is not a property setter.
    
    Returns:
    A Collection of MethodInfo objects describing the classInfo's property setters
  - relationshipGetters
```
public Collection<MethodInfo> relationshipGetters()
```
    A relationship getter is any getter annotated with @Relationship, or any getter whose return type cannot be mapped to a node property. The identity getter is not a property getter.
    
    Returns:
    A Collection of MethodInfo objects describing the classInfo's property getters
  - relationshipSetters
```
public Collection<MethodInfo> relationshipSetters()
```
    A relationship setter is any setter annotated with @Relationship, or any setter whose parameter type cannot be mapped to a node property. The identity setter is not a property getter.
    
    Returns:
    A Collection of MethodInfo objects describing the classInfo's property getters
  - relationshipGetter
```
public MethodInfo relationshipGetter(String relationshipName)
```
    Finds the relationship getter with a specific name from the specified ClassInfo's relationship getters
    
    Parameters:
    relationshipName - the relationshipName of the getter to find
    
    Returns:
    A MethodInfo object describing the required relationship getter, or null if it doesn't exist.
  - relationshipGetter
```
public MethodInfo relationshipGetter(String relationshipName,
                            String relationshipDirection,
                            boolean strict)
```
    Finds the relationship getter with a specific name and direction from the specified ClassInfo's relationship getters
    
    Parameters:
    relationshipName - the relationshipName of the getter to find
    relationshipDirection - the relationship direction
    strict - if true, does not infer relationship type but looks for it in the @Relationship annotation. Null if missing. If false, infers relationship type from MethodInfo
    
    Returns:
    A MethodInfo object describing the required relationship getter, or null if it doesn't exist.
  - relationshipSetter
```
public MethodInfo relationshipSetter(String relationshipName)
```
    Finds the relationship setter with a specific name from the specified ClassInfo's relationship setters
    
    Parameters:
    relationshipName - the relationshipName of the setter to find
    
    Returns:
    A MethodInfo object describing the required relationship setter, or null if it doesn't exist.
  - relationshipSetter
```
public MethodInfo relationshipSetter(String relationshipName,
                            String relationshipDirection,
                            boolean strict)
```
    Finds the relationship setter with a specific name and direction from the specified ClassInfo's relationship setters.
    
    Parameters:
    relationshipName - the relationshipName of the setter to find
    relationshipDirection - the relationship direction
    strict - if true, does not infer relationship type but looks for it in the @Relationship annotation. Null if missing. If false, infers relationship type from MethodInfo
    
    Returns:
    A MethodInfo object describing the required relationship setter, or null if it doesn't exist.
  - candidateRelationshipSetters
```
public Set<MethodInfo> candidateRelationshipSetters(String relationshipName,
                                           String relationshipDirection,
                                           boolean strict)
```
    Finds all relationship setters with a specific name and direction from the specified ClassInfo's relationship setters.
    
    Parameters:
    relationshipName - the relationshipName of the setter to find
    relationshipDirection - the relationship direction
    strict - if true, does not infer relationship type but looks for it in the @Relationship annotation. Null if missing. If false, infers relationship type from MethodInfo
    
    Returns:
    A Set of MethodInfo object describing the required relationship setter, or empty set if it doesn't exist.
  - propertySetter
```
public MethodInfo propertySetter(String propertyName)
```
    Finds the property setter with a specific name from the specified ClassInfo's property setters
    
    Parameters:
    propertyName - the propertyName of the setter to find
    
    Returns:
    A MethodInfo object describing the required property setter, or null if it doesn't exist.
  - propertyGetter
```
public MethodInfo propertyGetter(String propertyName)
```
    Finds the property getter with a specific name from the specified ClassInfo's property getters
    
    Parameters:
    propertyName - the propertyName of the getter to find
    
    Returns:
    A MethodInfo object describing the required property getter, or null if it doesn't exist.
  - getField
```
public Field getField(FieldInfo fieldInfo)
```
  - getMethod
```
public Method getMethod(MethodInfo methodInfo,
               Class... parameterTypes)
```
  - findSetters
```
public List<MethodInfo> findSetters(Class<?> parameterType)
```
    Find all setter MethodInfos for the specified ClassInfo whose parameter type matches the supplied class
    
    Parameters:
    parameterType - The setter parameter type to look for.
    
    Returns:
    A List of MethodInfo objects that accept the given parameter type, never null
  - findGetters
```
public List<MethodInfo> findGetters(Class<?> returnType)
```
    Find all getter MethodInfos for the specified ClassInfo whose return type matches the supplied class
    
    Parameters:
    returnType - The getter return type to look for.
    
    Returns:
    A List of MethodInfo objects that return the given type, never null
  - findFields
```
public List<FieldInfo> findFields(Class<?> fieldType)
```
    Find all FieldInfos for the specified ClassInfo whose type matches the supplied fieldType
    
    Parameters:
    fieldType - The field type to look for
    
    Returns:
    A List of FieldInfo objects that are of the given type, never null
  - findFields
```
public List<FieldInfo> findFields(String annotation)
```
    Find all FieldInfos for the specified ClassInfo which have the specified annotation
    
    Parameters:
    annotation - The annotation
    
    Returns:
    A List of FieldInfo objects that are of the given type, never null
  - findIterableFields
```
public List<FieldInfo> findIterableFields()
```
    Retrieves a List of FieldInfo representing all of the fields that can be iterated over using a "foreach" loop.
    
    Returns:
    List of FieldInfo
  - findIterableFields
```
public List<FieldInfo> findIterableFields(Class iteratedType)
```
    Finds all fields whose type is equivalent to Array<X> or assignable from Iterable<X> where X is the generic parameter type of the Array or Iterable
    
    Parameters:
    iteratedType - the type of iterable
    
    Returns:
    List of MethodInfo, never null
  - findIterableFields
```
public List<FieldInfo> findIterableFields(Class iteratedType,
                                 String relationshipType,
                                 String relationshipDirection,
                                 boolean strict)
```
    Finds all fields whose type is equivalent to Array<X> or assignable from Iterable<X> where X is the generic parameter type of the Array or Iterable and the relationship type backing this iterable is "relationshipType"
    
    Parameters:
    iteratedType - the type of iterable
    relationshipType - the relationship type
    relationshipDirection - the relationship direction
    strict - if true, does not infer relationship type but looks for it in the @Relationship annotation. Null if missing. If false, infers relationship type from FieldInfo
    
    Returns:
    List of MethodInfo, never null
  - findIterableSetters
```
public List<MethodInfo> findIterableSetters(Class iteratedType)
```
    Finds all setter methods whose parameter signature is equivalent to Array<X> or assignable from Iterable<X> where X is the generic parameter type of the Array or Iterable
    
    Parameters:
    iteratedType - the type of iterable
    
    Returns:
    List of MethodInfo, never null
  - findIterableSetters
```
public List<MethodInfo> findIterableSetters(Class iteratedType,
                                   String relationshipType,
                                   String relationshipDirection,
                                   boolean strict)
```
    Finds all setter methods whose parameter signature is equivalent to Array<X> or assignable from Iterable<X> where X is the generic parameter type of the Array or Iterable and the relationship type this setter is annotated with is "relationshipType" and the relationship direction matches "relationshipDirection"
    
    Parameters:
    iteratedType - the type of iterable
    relationshipType - the relationship type
    relationshipDirection - the relationship direction
    strict - if true, does not infer relationship type but looks for it in the @Relationship annotation. Null if missing. If false, infers relationship type from MethodInfo
    
    Returns:
    List of MethodInfo, never null
  - findIterableGetters
```
public List<MethodInfo> findIterableGetters(Class iteratedType)
```
    Finds all getter methods whose parameterised return type is equivalent to Array<X> or assignable from Iterable<X> where X is the generic parameter type of the Array or Iterable
    
    Parameters:
    iteratedType - the type of iterable
    
    Returns:
    List of MethodInfo, never null
  - findIterableGetters
```
public List<MethodInfo> findIterableGetters(Class iteratedType,
                                   String relationshipType,
                                   String relationshipDirection,
                                   boolean strict)
```
    Finds all getter methods whose parameterised return type is equivalent to Array<X> or assignable from Iterable<X> where X is the generic parameter type of the Array or Iterable and the relationship type this getter is annotated with is "relationshipType" and the direction of the relationship is "relationshipDirection"
    
    Parameters:
    iteratedType - the type of iterable
    relationshipType - the relationship type
    relationshipDirection - the relationshipDirection
    strict - if true, does not infer relationship type but looks for it in the @Relationship annotation. Null if missing. If false, infers relationship type from MethodInfo
    
    Returns:
    List of MethodInfo, never null
  - isTransient
```
public boolean isTransient()
```
  - isAbstract
```
public boolean isAbstract()
```
  - isSubclassOf
```
public boolean isSubclassOf(ClassInfo classInfo)
```
    Returns true if this classInfo is in the subclass hierarchy of b, or if this classInfo is the same as b, false otherwise
    
    Parameters:
    classInfo - the classInfo at the toplevel of a type hierarchy to search through
    
    Returns:
    true if this classInfo is in the subclass hierarchy of classInfo, false otherwise
  - getType
```
public Class<?> getType(String typeParameterDescriptor)
```
  - getUnderlyingClass
```
public Class getUnderlyingClass()
```
    Get the underlying class represented by this ClassInfo
    
    Returns:
    the underlying class or null if it cannot be determined
  - getTypeParameterDescriptorForRelationship
```
public Class getTypeParameterDescriptorForRelationship(String relationshipType,
                                              String relationshipDirection)
```
    Gets the class of the type parameter description of the entity related to this. The match is done based on the following- 1. Look for a setter explicitly annotated with @Relationship for a type and implied direction 2. Look for a field explicitly annotated with @Relationship for a type and implied direction 3. Look for a setter with name derived from the relationship type for the given direction 4. Look for a field with name derived from the relationship type for the given direction
    
    Parameters:
    relationshipType - the relationship type
    relationshipDirection - the relationship direction
    
    Returns:
    class of the type parameter descriptor or null if it could not be determined

Class ClassInfo

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ClassInfo

ClassInfo

Method Detail

hydrate

addSubclass

hydrated

name

labels

neo4jName

directSubclasses

directImplementingClasses

directInterfaces

interfacesInfo

annotations

isInterface

isEnum

annotationsInfo

superclassName

fieldsInfo

methodsInfo

toString

identityField

propertyFields

propertyField

propertyFieldByName

relationshipFields

relationshipField

relationshipField

candidateRelationshipFields

relationshipFieldByName

identityGetter

identitySetter

propertyGetters

propertySetters

relationshipGetters

relationshipSetters

relationshipGetter

relationshipGetter

relationshipSetter

relationshipSetter

candidateRelationshipSetters

propertySetter

propertyGetter

getField

getMethod

findSetters

findGetters

findFields

findFields

findIterableFields

findIterableFields

findIterableFields

findIterableSetters

findIterableSetters

findIterableGetters

findIterableGetters

isTransient

isAbstract

isSubclassOf

getType

getUnderlyingClass

getTypeParameterDescriptorForRelationship