Package com.github.javaparser.resolution.declarations

Interface ResolvedReferenceTypeDeclaration

All Superinterfaces:
ResolvedDeclaration, ResolvedTypeDeclaration, ResolvedTypeParametrizable
All Known Subinterfaces:
ResolvedAnnotationDeclaration, ResolvedClassDeclaration, ResolvedEnumDeclaration, ResolvedInterfaceDeclaration
public interface ResolvedReferenceTypeDeclaration extends ResolvedTypeDeclaration, ResolvedTypeParametrizable
Author:
Federico Tomassetti

  • Field Details

  • Method Details

    • asReferenceType

      default ResolvedReferenceTypeDeclaration asReferenceType()
      Specified by:
      asReferenceType in interface ResolvedTypeDeclaration

    • getAncestors

      default List<ResolvedReferenceType> getAncestors()
      Resolves the types of all direct ancestors (i.e., the directly extended class and the directly implemented interfaces) and returns the list of ancestors as a list of resolved reference types.

      In case any ancestor cannot be resolved, an UnsolvedSymbolException is thrown. In order to obtain a list of only the resolvable direct ancestors, use getAncestors(boolean) and pass the value true.

      Note that an ancestor can be parametrized types with values specified. For example:

      class A implements Comparable<String> {}

      In this case the ancestor is Comparable<String>

      Returns:
      The list of resolved ancestors.
      Throws:
      UnsolvedSymbolException - if some ancestor could not be resolved.

    • getAncestors

      List<ResolvedReferenceType> getAncestors​(boolean acceptIncompleteList)
      Resolves the types of all direct ancestors (i.e., the directly extended class and the directly implemented interfaces) and returns the list of ancestors as a list of resolved reference types.

      If acceptIncompleteList is false, then an UnsolvedSymbolException is thrown if any ancestor cannot be resolved. Otherwise, a list of only the resolvable direct ancestors is returned.

      Parameters:
      acceptIncompleteList - When set to false, this method throws an UnsolvedSymbolException if one or more ancestor could not be resolved. When set to true, this method does not throw an UnsolvedSymbolException, but the list of returned ancestors may be incomplete in case one or more ancestor could not be resolved.
      Returns:
      The list of resolved ancestors.
      Throws:
      UnsolvedSymbolException - if some ancestor could not be resolved and acceptIncompleteList is set to false.

    • getAllAncestors

      default List<ResolvedReferenceType> getAllAncestors()
      The list of all the ancestors of the current declaration, direct and indirect. This list does not contains duplicates with the exact same type parameters. For example if A inherits from B, and B inherits from C and implements D, and C inherits from E By default the traversal is depth first

    • getAllAncestors

      default List<ResolvedReferenceType> getAllAncestors​(Function<ResolvedReferenceTypeDeclaration,​List<ResolvedReferenceType>> traverser)
      The list of all the ancestors of the current declaration, direct and indirect. This list does not contains duplicates with the exact same type parameters. For example if A inherits from B, and B inherits from C and implements D, and C inherits from E Apply the specified traversal

    • getField

      default ResolvedFieldDeclaration getField​(String name)
      Note that the type of the field should be expressed using the type variables of this particular type. Consider for example:

      class Foo { E field; }

      class Bar extends Foo { }

      When calling getField("field") on Foo I should get a FieldDeclaration with type E, while calling it on Bar I should get a FieldDeclaration with type String.

    • getVisibleField

      default ResolvedFieldDeclaration getVisibleField​(String name)
      Consider only field or inherited field which is not private.

    • hasField

      default boolean hasField​(String name)
      Has this type a field with the given name?

    • hasVisibleField

      default boolean hasVisibleField​(String name)
      Either a declared field or inherited field which is not private.

    • getAllFields

      List<ResolvedFieldDeclaration> getAllFields()
      Return a list of all fields, either declared in this declaration or inherited.

    • getVisibleFields

      default List<ResolvedFieldDeclaration> getVisibleFields()
      Return a list of all fields declared and the inherited ones which are not private.

    • getAllNonStaticFields

      default List<ResolvedFieldDeclaration> getAllNonStaticFields()
      Return a list of all the non static fields, either declared or inherited.

    • getAllStaticFields

      default List<ResolvedFieldDeclaration> getAllStaticFields()
      Return a list of all the static fields, either declared or inherited.

    • getDeclaredFields

      default List<ResolvedFieldDeclaration> getDeclaredFields()
      Return a list of all the fields declared in this type.

    • getDeclaredMethods

      Set<ResolvedMethodDeclaration> getDeclaredMethods()
      Return a list of all the methods declared in this type declaration.

    • getAllMethods

      Set<MethodUsage> getAllMethods()
      Return a list of all the methods declared of this type declaration, either declared or inherited. Note that it should not include overridden methods.

    • isAssignableBy

      boolean isAssignableBy​(ResolvedType type)
      Can we assign instances of the given type to variables having the type defined by this declaration?

    • canBeAssignedTo

      default boolean canBeAssignedTo​(ResolvedReferenceTypeDeclaration other)
      Can we assign instances of the type defined by this declaration to variables having the type defined by the given type?

    • isAssignableBy

      boolean isAssignableBy​(ResolvedReferenceTypeDeclaration other)
      Can we assign instances of the given type to variables having the type defined by this declaration?

    • hasDirectlyAnnotation

      boolean hasDirectlyAnnotation​(String qualifiedName)
      Has the type at least one annotation declared having the specified qualified name?

    • hasAnnotation

      default boolean hasAnnotation​(String qualifiedName)
      Has the type at least one annotation declared or inherited having the specified qualified name?

    • isFunctionalInterface

      boolean isFunctionalInterface()
      This means that the type has a functional method. Conceptually, a functional interface has exactly one abstract method. Typically these classes has the FunctionInterface annotation but this is not mandatory.

    • findTypeParameter

      default Optional<ResolvedTypeParameterDeclaration> findTypeParameter​(String name)
      Description copied from interface: ResolvedTypeParametrizable
      Find the closest TypeParameterDeclaration with the given name. It first look on this element itself and then on the containers.
      Specified by:
      findTypeParameter in interface ResolvedTypeParametrizable

    • getConstructors

      List<ResolvedConstructorDeclaration> getConstructors()

    • isJavaLangObject

      default boolean isJavaLangObject()
      We don't make this _ex_plicit in the data representation because that would affect codegen and make everything generate like <T extends Object> instead of <T>
      Returns:
      true, if this represents java.lang.Object
      See Also:
      ResolvedReferenceType.isJavaLangObject(), https://github.com/javaparser/javaparser/issues/2044

    • isJavaLangEnum

      default boolean isJavaLangEnum()
      Returns:
      true, if this represents java.lang.Enum
      See Also:
      ResolvedReferenceType.isJavaLangEnum()