ru.vyarus.java.generics.resolver.util.walk

Class ComparatorTypesVisitor

java.lang.Object

ru.vyarus.java.generics.resolver.util.walk.ComparatorTypesVisitor

All Implemented Interfaces:

TypesVisitor

public class ComparatorTypesVisitor
extends java.lang.Object
implements TypesVisitor

Check if one type is more specific. Stops when first type is not more specific. Implicitly tracks compatibility: check isCompatible() before calling isMoreSpecific() as the later always assume compatible hierarchies. For example, ArrayList<String> is more specific then List<Integer>, but not compatible.

Note that specificity is not the same as assignability. For example List is assignable to List<? extends String>, but later is more specific (actually). Other example is unknown types: T<String, Object> is assignable to T<String, String>, but later is more specific (contains more type information).

Since:

11.05.2018

See Also:

TypesWalker

Constructor Summary

Constructors

Constructor and Description
ComparatorTypesVisitor()

Method Summary

Modifier and Type	Method and Description
void	incompatibleHierarchy(java.lang.reflect.Type one, java.lang.reflect.Type two) Called when synchronous walk is impossible.
boolean	isCompatible()
boolean	isMoreSpecific()
boolean	next(java.lang.reflect.Type one, java.lang.reflect.Type two) Method is called for each matching types pair in types hierarchy.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ComparatorTypesVisitor

public ComparatorTypesVisitor()

Method Detail

next

public boolean next(java.lang.reflect.Type one,
                    java.lang.reflect.Type two)

Description copied from interface: TypesVisitor

Method is called for each matching types pair in types hierarchy. For example, walking on List<String> and ArrayList<String> will lead to two calls with List<String>, ArrayList<String> and then String, String. Method may return false to stop types traversing.

When types are not compatible then TypesVisitor.incompatibleHierarchy(Type, Type) is called instead.

Passed types are always compatible on current level. For example List<String> and List<Integer> are compatible on class level (assumed as List and List, but on the next level incompatible type will be notified. Overall two visitor calls will be done: TypesVisitor.next(Type, Type) for lists and TypesVisitor.incompatibleHierarchy(Type, Type) for list generics.

If one of the types is Object then it will be the last step (no hierarchy incompatibility will be called as object is compatible with everything - we just can't go further because of not enough information).

Specified by:

next in interface TypesVisitor

Parameters:

one - current class in first hierarchy

two - class from second hierarchy, but from the same place (in type tree)

Returns:

true to continue walking, false to stop

incompatibleHierarchy

public void incompatibleHierarchy(java.lang.reflect.Type one,
                                  java.lang.reflect.Type two)

Description copied from interface: TypesVisitor

Called when synchronous walk is impossible.

• One type is array and other is not
• Types are not compatible (this means hierarchies doesn't match, even if classes doesn't use generics and so will not be analyzed further)

Specified by:

incompatibleHierarchy in interface TypesVisitor

Parameters:

one - current type from hierarchy one (not root type)

two - current type from hierarchy two

isMoreSpecific

public boolean isMoreSpecific()

Returns:

true if first type is more specific, false otherwise

isCompatible

public boolean isCompatible()

Returns:

true when types are incompatible, false when compatible