public static Set<JavaType> extractInterfaces(JavaType type) { Set<JavaType> result = new LinkedHashSet<JavaType>(); if (type.getInterfaces().isEmpty()) { result.add(type); } else { for (JavaType interfaceType : type.getInterfaces()) { result.addAll(extractInterfaces(interfaceType)); } } return result; }
public static boolean isSet(JavaType type) { return type.equals(SET) || type.getInterfaces().contains(SET); } }
public static boolean isList(JavaType type) { return type.equals(LIST) || type.getInterfaces().contains(LIST); }
public static boolean isMap(JavaType type) { return type.equals(MAP) || type.getInterfaces().contains(MAP); }
public static Node<JavaClazz> createGraph(JavaClazz root, Set<JavaClazz> all, Set<JavaType> path, Set<JavaType> visited) { Set<JavaClazz> next = new LinkedHashSet<JavaClazz>(); Set<JavaType> currentPath = new LinkedHashSet<JavaType>(path); if (!JavaTypeUtils.isTerminal(root)) { currentPath.add(root.getType()); for (JavaClazz candidate : exclusion(all, visited)) { if (!JavaTypeUtils.isEntryPoint(candidate) && isSatisfied(candidate, currentPath)) { next.add(candidate); } } next.remove(root); } Set<Node<JavaClazz>> nextVertices = new LinkedHashSet<Node<JavaClazz>>(); Set<JavaType> levelInterfaces = new LinkedHashSet<JavaType>(); levelInterfaces.addAll(visited); for (JavaClazz c : next) { Node<JavaClazz> subGraph = createGraph(c, all, currentPath, levelInterfaces); levelInterfaces.add(subGraph.getItem().getType()); levelInterfaces.addAll(subGraph.getItem().getType().getInterfaces()); if (subGraph.getTransitions().size() > 0 || JavaTypeUtils.isTerminal(subGraph.getItem())) { nextVertices.add(subGraph); } } return new Node<JavaClazz>(root, nextVertices); }
public JavaType apply(JavaType type) { Set<JavaType> interfaces = new LinkedHashSet<JavaType>(); Set<JavaType> generics = new LinkedHashSet<JavaType>(); if (GENERIC_MAPPINGS.containsValue(type)) { JavaType unmapped = UNMAP.apply(type); if (!unmapped.equals(type)) { return UNWRAP.apply(unmapped); } return unmapped; } else { for (JavaType iface : type.getInterfaces()) { interfaces.add(UNWRAP.apply(iface)); } for (JavaType generic : type.getGenericTypes()) { generics.add(UNWRAP.apply(generic)); } return new JavaTypeBuilder(type) .withGenericTypes(generics.toArray(new JavaType[generics.size()])) .withInterfaces(interfaces) .build(); } } };
@Override public JavaType apply(JavaType... items) { if (items == null || items.length == 0) { throw new IllegalArgumentException("Items cannot be empty."); } else if (items.length == 1) { return items[0]; } else if (items.length == 2) { JavaTypeBuilder builder = new JavaTypeBuilder(items[0]); for (JavaType type : items[1].getInterfaces()) { builder = builder.addToInterfaces(type); } for (JavaType type : items[1].getGenericTypes()) { if (!Arrays.asList(items[0].getGenericTypes()).contains(type)) { builder = builder.addToGenericTypes(type); } } return builder.build(); } else { JavaType[] rest = new JavaType[items.length - 1]; System.arraycopy(items, 1, rest, 0, rest.length); return TYPES.apply(new JavaType[]{items[0], TYPES.apply(rest)}); } } };
/** * Checks if a type is an descendant of an other type * @param item The base type. * @param candidate The candidate type. * @return true if candidate is a descendant of base type. */ public static boolean isDescendant(JavaType item, JavaType candidate) { if (item == null || candidate == null) { return false; } else if (item.equals(candidate)) { return true; } else if (isDescendant(item.getSuperClass(), candidate)) { return true; } else { for (JavaType interfaceType : item.getInterfaces()) { if (isDescendant(interfaceType, candidate)) { return true; } } return false; } }