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

Class CompatibilityTypesVisitor

java.lang.Object

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

All Implemented Interfaces:

TypesVisitor

public class CompatibilityTypesVisitor
extends java.lang.Object
implements TypesVisitor

Checks if types hierarchies are compatible (one could be casted to another). Completely rely on TypesWalker logic.

Since:

11.05.2018

Constructor Summary

Constructors

Constructor and Description
CompatibilityTypesVisitor()

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	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

CompatibilityTypesVisitor

public CompatibilityTypesVisitor()

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

isCompatible

public boolean isCompatible()

Returns:

true when types are incompatible, false when compatible