@Override public ClassNode[] getInterfaces() { Set<ClassNode> nodes = new LinkedHashSet<ClassNode>(); for (ClassNode delegate : delegates) { ClassNode[] interfaces = delegate.getInterfaces(); if (interfaces != null) Collections.addAll(nodes, interfaces); } return nodes.toArray(ClassNode.EMPTY_ARRAY); }
private int getSuperInterfaceCount(ClassNode element) { int count = 1; ClassNode[] interfaces = element.getInterfaces(); for (ClassNode anInterface : interfaces) { count = Math.max(count, getSuperInterfaceCount(anInterface) + 1); } return count; }
@Override public ClassNode[] getInterfaces() { lazyInitSupers(); return super.getInterfaces(); }
/** * Get methods from all interfaces. * Methods from interfaces visited early will be overwritten by later ones. * * @param cNode The ClassNode * @return A map of methods */ public static Map<String, MethodNode> getDeclaredMethodsFromInterfaces(ClassNode cNode) { Map<String, MethodNode> result = new HashMap<String, MethodNode>(); ClassNode[] interfaces = cNode.getInterfaces(); for (ClassNode iface : interfaces) { result.putAll(iface.getDeclaredMethodsMap()); } return result; }
private static FieldNode getDeclaredOrInheritedField(ClassNode cn, String fieldName) { ClassNode node = cn; while (node != null) { FieldNode fn = node.getDeclaredField(fieldName); if (fn != null) return fn; List<ClassNode> interfacesToCheck = new ArrayList<ClassNode>(Arrays.asList(node.getInterfaces())); while (!interfacesToCheck.isEmpty()) { ClassNode nextInterface = interfacesToCheck.remove(0); fn = nextInterface.getDeclaredField(fieldName); if (fn != null) return fn; interfacesToCheck.addAll(Arrays.asList(nextInterface.getInterfaces())); } node = node.getSuperClass(); } return null; }
private void getAllInterfaces(Set<ClassNode> res) { if (isInterface()) res.add(this); for (ClassNode anInterface : getInterfaces()) { res.add(anInterface); anInterface.getAllInterfaces(res); } }
public int compare(final ClassNode o1, final ClassNode o2) { int interfaceCountForO1 = o1.getInterfaces().length; int interfaceCountForO2 = o2.getInterfaces().length; if (interfaceCountForO1 > interfaceCountForO2) return -1; if (interfaceCountForO1 < interfaceCountForO2) return 1; int methodCountForO1 = o1.getMethods().size(); int methodCountForO2 = o2.getMethods().size(); if (methodCountForO1 > methodCountForO2) return -1; if (methodCountForO1 < methodCountForO2) return 1; return o1.getName().compareTo(o2.getName()); } };
private static void extractInterfaces(ClassNode node, Set<ClassNode> interfaces) { if (node==null) return; Collections.addAll(interfaces, node.getInterfaces()); extractInterfaces(node.getSuperClass(), interfaces); }
/** * @return the array of interfaces which this ClassNode implements */ public ClassNode[] getInterfaces() { if (redirect!=null) return redirect().getInterfaces(); lazyClassInit(); return interfaces; }
private static void extractMostSpecificImplementedInterfaces(final ClassNode type, final ClassNode inode, final List<ClassNode> result) { if (type.implementsInterface(inode)) result.add(inode); else { ClassNode[] interfaces = inode.getInterfaces(); for (ClassNode interfaceNode : interfaces) { if (type.implementsInterface(interfaceNode)) result.add(interfaceNode); } if (result.isEmpty() && interfaces.length>0) { // none if the direct interfaces match, but we must check "upper" in the hierarchy for (ClassNode interfaceNode : interfaces) { extractMostSpecificImplementedInterfaces(type, interfaceNode, result); } } } }
/** * Adds methods from interfaces and parent interfaces. Existing entries in the methods map take precedence. * Methods from interfaces visited early take precedence over later ones. * * @param cNode The ClassNode * @param methodsMap A map of existing methods to alter */ public static void addDeclaredMethodsFromAllInterfaces(ClassNode cNode, Map<String, MethodNode> methodsMap) { List cnInterfaces = Arrays.asList(cNode.getInterfaces()); ClassNode parent = cNode.getSuperClass(); while (parent != null && !parent.equals(ClassHelper.OBJECT_TYPE)) { ClassNode[] interfaces = parent.getInterfaces(); for (ClassNode iface : interfaces) { if (!cnInterfaces.contains(iface)) { methodsMap.putAll(iface.getDeclaredMethodsMap()); } } parent = parent.getSuperClass(); } }
protected void collectAllInterfaceMethodsByName(final ClassNode receiver, final String name, final List<MethodNode> methods) { ClassNode cNode = receiver; while (cNode != null) { ClassNode[] interfaces = cNode.getInterfaces(); if (interfaces != null && interfaces.length > 0) { for (ClassNode node : interfaces) { List<MethodNode> intfMethods = node.getMethods(name); methods.addAll(intfMethods); collectAllInterfaceMethodsByName(node, name, methods); } } cNode = cNode.getSuperClass(); } }
/** * Collects all interfaces of a class node, but reverses the order of the declaration of direct interfaces * of this class node. This is used to make sure a trait implementing A,B where both A and B have the same * method will take the method from B (latest), aligning the behavior with categories. * @param cNode a class node * @param interfaces ordered set of interfaces */ public static LinkedHashSet<ClassNode> collectAllInterfacesReverseOrder(ClassNode cNode, LinkedHashSet<ClassNode> interfaces) { if (cNode.isInterface()) interfaces.add(cNode); ClassNode[] directInterfaces = cNode.getInterfaces(); for (int i = directInterfaces.length-1; i >=0 ; i--) { final ClassNode anInterface = directInterfaces[i]; interfaces.add(GenericsUtils.parameterizeType(cNode,anInterface)); collectAllInterfacesReverseOrder(anInterface, interfaces); } return interfaces; }
private void addToCache(ClassNode node){ if (node == null) return; String name = node.getName(); if (!precompiledDependencies.containsKey(name) && !node.isPrimaryClassNode()) { return; } current.add(node.getName()); addToCache(node.getSuperClass()); addToCache(node.getInterfaces()); }
public static String getGenericsSignature(ClassNode node) { if (!usesGenericsInClassSignature(node)) return null; GenericsType[] genericsTypes = node.getGenericsTypes(); StringBuilder ret = new StringBuilder(100); getGenericsTypeSpec(ret, genericsTypes); GenericsType extendsPart = new GenericsType(node.getUnresolvedSuperClass(false)); writeGenericsBounds(ret, extendsPart, true); ClassNode[] interfaces = node.getInterfaces(); for (int i = 0; i < interfaces.length; i++) { GenericsType interfacePart = new GenericsType(interfaces[i]); writeGenericsBounds(ret, interfacePart, false); } return ret.toString(); }
private static boolean usesGenericsInClassSignature(ClassNode node) { if (!node.isUsingGenerics()) return false; if (hasGenerics(node)) return true; ClassNode sclass = node.getUnresolvedSuperClass(false); if (sclass.isUsingGenerics()) return true; ClassNode[] interfaces = node.getInterfaces(); if (interfaces != null) { for (int i = 0; i < interfaces.length; i++) { if (interfaces[i].isUsingGenerics()) return true; } } return false; }
private boolean directlyImplementsTrait(ClassNode trait) { ClassNode[] interfaces = currentClass.getInterfaces(); if (interfaces==null) { return currentClass.getSuperClass().equals(trait); } for (ClassNode node : interfaces) { if (node.equals(trait)) { return true; } } return currentClass.getSuperClass().equals(trait); }
@Override public void visitClass(ClassNode node) { boolean error = checkWildcard(node); if (error) return; boolean isAnon = node instanceof InnerClassNode && ((InnerClassNode) node).isAnonymous(); checkGenericsUsage(node.getUnresolvedSuperClass(false), node.getSuperClass(), isAnon ? true : null); ClassNode[] interfaces = node.getInterfaces(); for (ClassNode anInterface : interfaces) { checkGenericsUsage(anInterface, anInterface.redirect()); } node.visitContents(this); }
private void checkImplementsAndExtends(ClassNode node) { ClassNode cn = node.getSuperClass(); if (cn.isInterface() && !node.isInterface()) { addError("You are not allowed to extend the " + getDescription(cn) + ", use implements instead.", node); } for (ClassNode anInterface : node.getInterfaces()) { cn = anInterface; if (!cn.isInterface()) { addError("You are not allowed to implement the " + getDescription(cn) + ", use extends instead.", node); } } }
public void visitClass(ClassNode node) { visitType(node); visitType(node.getUnresolvedSuperClass()); visitTypes(node.getInterfaces()); super.visitClass(node); }