Package org.mapstruct.ap.internal.model.common

Class Type

java.lang.Object
org.mapstruct.ap.internal.writer.FreeMarkerWritable
org.mapstruct.ap.internal.model.common.ModelElement
org.mapstruct.ap.internal.model.common.Type
All Implemented Interfaces:
Comparable<Type>, Writable
public class Type extends ModelElement implements Comparable<Type>
Represents (a reference to) the type of a bean property, parameter etc. Types are managed per generated source file. Each type corresponds to a TypeMirror, i.e. there are different instances for e.g. Set<String> and Set<Integer>.

Allows for a unified handling of declared and primitive types and usage within templates. Instances are obtained through TypeFactory.

Author:
Gunnar Morling, Filip Hrisafov

  • Constructor Details

  • Method Details

    • getTypeMirror

      public TypeMirror getTypeMirror()

    • getTypeElement

      public TypeElement getTypeElement()

    • getPackageName

      public String getPackageName()

    • getName

      public String getName()

    • createReferenceName

      public String createReferenceName()
      Returns a String that could be used in generated code to reference to this Type.

      The first time a name is referred-to it will be marked as to be imported. For instance LocalDateTime can be one of java.time.LocalDateTime and org.joda.LocalDateTime)

      If the java.time variant is referred to first, the java.time.LocalDateTime will be imported and the org.joda variant will be referred to with its FQN.

      If the type is nested and its top level type is to be imported then the name including its top level type will be returned.

      Returns:
      Just the name if this Type will be imported, the name up to the top level Type (if the top level type is important, otherwise the fully-qualified name.

    • getTypeParameters

      public List<Type> getTypeParameters()

    • getComponentType

      public Type getComponentType()

    • isPrimitive

      public boolean isPrimitive()

    • isInterface

      public boolean isInterface()

    • isEnumType

      public boolean isEnumType()

    • isVoid

      public boolean isVoid()

    • isAbstract

      public boolean isAbstract()

    • isString

      public boolean isString()

    • getEnumConstants

      public List<String> getEnumConstants()
      Returns:
      this type's enum constants in case it is an enum, an empty list otherwise.

    • getImplementationType

      public Type getImplementationType()
      Returns the implementation type to be instantiated in case this type is an interface iterable, collection or map type. The type will have the correct type arguments, so if this type e.g. represents Set<String>, the implementation type is HashSet<String>.
      Returns:
      The implementation type to be instantiated in case this type is an interface iterable, collection or map type, null otherwise.

    • getImplementation

      public ImplementationType getImplementation()

    • isIterableType

      public boolean isIterableType()
      Whether this type is a sub-type of Iterable or an array type.
      Returns:
      true if this type is a sub-type of Iterable or an array type, false otherwise.

    • isIterableOrStreamType

      public boolean isIterableOrStreamType()
      Whether this type is a sub-type ofIterable, Stream or an array type
      Returns:
      true if this type is a sub-type ofIterable, Stream or an array type, false otherwise

    • isCollectionType

      public boolean isCollectionType()

    • isMapType

      public boolean isMapType()

    • isCollectionOrMapType

      public boolean isCollectionOrMapType()

    • isArrayType

      public boolean isArrayType()

    • isOptionalType

      public boolean isOptionalType()

    • getOptionalBaseType

      public Type getOptionalBaseType()

    • isTypeVar

      public boolean isTypeVar()

    • isIntersection

      public boolean isIntersection()

    • isJavaLangType

      public boolean isJavaLangType()

    • isRecord

      public boolean isRecord()

    • isStreamType

      public boolean isStreamType()
      Whether this type is a sub-type of Stream.
      Returns:
      true it this type is a sub-type of Stream, false otherwise

    • hasSuperBound

      public boolean hasSuperBound()
      A wild card type can have two types of bounds (mutual exclusive): extends and super.
      Returns:
      true if the bound has a wild card super bound (e.g. ? super Number)

    • hasExtendsBound

      public boolean hasExtendsBound()
      A wild card type can have two types of bounds (mutual exclusive): extends and super.
      Returns:
      true if the bound has a wild card super bound (e.g. ? extends Number)

    • hasLowerBound

      public boolean hasLowerBound()
      A type variable type can have two types of bounds (mutual exclusive): lower and upper. Note that its use is only permitted on a definition (not on the place where its used). For instance: <T super Number> T map( T in)
      Returns:
      true if the bound has a type variable lower bound (e.g. T super Number)

    • hasUpperBound

      public boolean hasUpperBound()
      A type variable type can have two types of bounds (mutual exclusive): lower and upper. Note that its use is only permitted on a definition (not on the place where its used). For instance: ><T extends Number> T map( T in)
      Returns:
      true if the bound has a type variable upper bound (e.g. T extends Number)

    • getFullyQualifiedName

      public String getFullyQualifiedName()

    • getImportName

      public String getImportName()
      Returns:
      The name of this type as to be used within import statements.

    • getImportTypes

      public Set<Type> getImportTypes()
      Description copied from class: ModelElement
      Returns a set containing those Types referenced by this model element for which an import statement needs to be declared.
      Specified by:
      getImportTypes in class ModelElement
      Returns:
      A set with type referenced by this model element. Must not be null.

    • isTopLevelTypeToBeImported

      protected boolean isTopLevelTypeToBeImported()

    • isToBeImported

      public boolean isToBeImported()
      Whether this type is to be imported by means of an import statement in the currently generated source file (it can be referenced in the generated source using its simple name) or not (referenced using the FQN).
      Returns:
      true if the type is imported, false otherwise.

    • erasure

      public Type erasure()

    • withoutBounds

      public Type withoutBounds()

    • isAssignableTo

      public boolean isAssignableTo(Type other)
      Whether this type is assignable to the given other type, considering the "extends / upper bounds" as well.
      Parameters:
      other - The other type.
      Returns:
      true if and only if this type is assignable to the given other type.

    • isRawAssignableTo

      public boolean isRawAssignableTo(Type other)
      Whether this type is raw assignable to the given other type. We can't make a verdict on typevars, they need to be resolved first.
      Parameters:
      other - The other type.
      Returns:
      true if and only if this type is assignable to the given other type.

    • asRawType

      public Type asRawType()
      removes any bounds from this type.
      Returns:
      the raw type

    • getReadAccessor

      public ReadAccessor getReadAccessor(String propertyName, boolean allowedMapToBean)

    • getPresenceChecker

      public PresenceCheckAccessor getPresenceChecker(String propertyName)

    • getPropertyReadAccessors

      public Map<String,ReadAccessor> getPropertyReadAccessors()
      getPropertyReadAccessors
      Returns:
      an unmodifiable map of all read accessors (including 'is' for booleans), indexed by property name

    • getPropertyPresenceCheckers

      public Map<String,PresenceCheckAccessor> getPropertyPresenceCheckers()
      getPropertyPresenceCheckers
      Returns:
      an unmodifiable map of all presence checkers, indexed by property name

    • getPropertyWriteAccessors

      public Map<String,Accessor> getPropertyWriteAccessors(org.mapstruct.ap.internal.gem.CollectionMappingStrategyGem cmStrategy)
      getPropertyWriteAccessors returns a map of the write accessors according to the CollectionMappingStrategy. These accessors include:
      • setters, the obvious candidate :-), getSetters()
      • readAccessors, for collections that do not have a setter, e.g. for JAXB generated collection attributes getPropertyReadAccessors()
      • adders, typically for from table generated entities, getAdders()
      Parameters:
      cmStrategy - collection mapping strategy
      Returns:
      an unmodifiable map of all write accessors indexed by property name

    • getRecordComponents

      public List<Element> getRecordComponents()

    • distanceTo

      public int distanceTo(Type assignableOther)
      Returns the length of the shortest path in the type hierarchy between this type and the specified other type. Returns -1 if this type is not assignable to the other type. Returns 0 if this type is equal to the other type. Returns 1, if the other type is a direct super type of this type, and so on.
      Parameters:
      assignableOther - the other type
      Returns:
      the length of the shortest path in the type hierarchy between this type and the specified other type

    • canAccess

      public boolean canAccess(Type type, ExecutableElement method)
      Parameters:
      type - the type declaring the method
      method - the method to check
      Returns:
      Whether this type can access the given method declared on the given type.

    • getNull

      public String getNull()
      Returns:
      A valid Java expression most suitable for representing null - useful for dealing with primitives from FTL.

    • getSensibleDefault

      public String getSensibleDefault()

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • equals

      public boolean equals(Object obj)
      Overrides:
      equals in class Object

    • compareTo

      public int compareTo(Type o)
      Specified by:
      compareTo in interface Comparable<Type>

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • describe

      public String describe()
      Returns:
      a string representation of the type for use in messages

    • getIdentification

      public String getIdentification()
      Returns:
      an identification that can be used as part in a forged method name.

    • getTypeBound

      public Type getTypeBound()
      Establishes the type bound:
      1. <? extends Number>, returns Number
      2. <? super Number>, returns Number
      3. <?>, returns Object
      4. <T extends Number>, returns Number
      Returns:
      the bound for this parameter

    • getTypeBounds

      public List<Type> getTypeBounds()

    • hasAccessibleConstructor

      public boolean hasAccessibleConstructor()

    • getKotlinMetadata

      public KotlinMetadata getKotlinMetadata()

    • getDirectSuperTypes

      public List<Type> getDirectSuperTypes()
      Returns the direct supertypes of a type. The interface types, if any, will appear last in the list.
      Returns:
      the direct supertypes, or an empty list if none

    • determineTypeArguments

      public List<Type> determineTypeArguments(Class<?> superclass)
      Searches for the given superclass and collects all type arguments for the given class
      Parameters:
      superclass - the superclass or interface the generic type arguments are searched for
      Returns:
      a list of type arguments or null, if superclass was not found

    • isNative

      public boolean isNative()
      All primitive types and their corresponding boxed types are considered native.
      Returns:
      true when native.

    • isLiteral

      public boolean isLiteral()

    • resolveParameterToType

      public Type.ResolvedPair resolveParameterToType(Type declared, Type parameterized)
      Steps through the declaredType in order to find a match for this typeVar Type. It aligns with the provided parameterized type where this typeVar type is used.

      For example:
       
 this: T
 declaredType: JAXBElement<String>
 parameterizedType: JAXBElement<T>
 result: String


 this: T, T[] or ? extends T,
 declaredType: E.g. Callable<? extends T>
 parameterizedType: Callable<BigDecimal>
 return: BigDecimal
      Parameters:
      declared - the type
      parameterized - the parameterized type
      Returns:
      - the same type when this is not a type var in the broadest sense (T, T[], or ? extends T)
      - the matching parameter in the parameterized type when this is a type var when found
      - null in all other cases

    • resolveGenericTypeParameters

      public Type resolveGenericTypeParameters(Type declared, Type parameterized)
      Resolves generic types using the declared and parameterized types as input.

      For example: 
       
 this: T
 declaredType: JAXBElement<T>
 parameterizedType: JAXBElement<Integer>
 result: Integer

 this: List<T>
 declaredType: JAXBElement<T>
 parameterizedType: JAXBElement<Integer>
 result: List<Integer>

 this: List<? extends T>
 declaredType: JAXBElement<? extends T>
 parameterizedType: JAXBElement<BigDecimal>
 result: List<BigDecimal>

 this: List<Optional<T>>
 declaredType: JAXBElement<T>
 parameterizedType: JAXBElement<BigDecimal>
 result: List<Optional<BigDecimal>>
      It also works for partial matching.

      For example: 
       
 this: Map<K, V>
 declaredType: JAXBElement<K>
 parameterizedType: JAXBElement<BigDecimal>
 result: Map<BigDecimal, V>
      It also works with multiple parameters at both sides.

      For example when reversing Key/Value for a Map: 
       
 this: Map<KEY, VALUE>
 declaredType: HashMap<VALUE, KEY>
 parameterizedType: HashMap<BigDecimal, String>
 result: Map<String, BigDecimal>
      Mismatch result examples: 
       
 this: T
 declaredType: JAXBElement<Y>
 parameterizedType: JAXBElement<Integer>
 result: null

 this: List<T>
 declaredType: JAXBElement<Y>
 parameterizedType: JAXBElement<Integer>
 result: List<T>
      Parameters:
      declared - the type
      parameterized - the parameterized type
      Returns:
      - the result of resolveParameterToType(Type, Type) when this type itself is a type var.
      - the type but then with the matching type parameters replaced.
      - the same type when this type does not contain matching type parameters.

    • isWildCardBoundByTypeVar

      public boolean isWildCardBoundByTypeVar()

    • isArrayTypeVar

      public boolean isArrayTypeVar()

    • getBoxedEquivalent

      public Type getBoxedEquivalent()
      Gets the boxed equivalent type if the type is primitive, int will return Integer
      Returns:
      boxed equivalent

    • isEnumSet

      public boolean isEnumSet()

    • isSealed

      public boolean isSealed()
      return true if this type is a java 17+ sealed class

    • getPermittedSubclasses

      public List<? extends TypeMirror> getPermittedSubclasses()
      return the list of permitted TypeMirrors for the java 17+ sealed class