public Set<ClassNode> getAllInterfaces () { Set<ClassNode> res = new LinkedHashSet<ClassNode>(); getAllInterfaces(res); return res; }
@Override public Set<ClassNode> getAllInterfaces() { Set<ClassNode> allMethods = new HashSet<ClassNode>(); for (ClassNode delegate : delegates) { allMethods.addAll(delegate.getAllInterfaces()); } return allMethods; }
private static List<ClassNode> getAllSuperClassesAndInterfaces(ClassNode actualReceiver) { List<ClassNode> superClassAndInterfaceList = new LinkedList<>(); List<ClassNode> allSuperClassNodeList = getAllUnresolvedSuperClasses(actualReceiver); superClassAndInterfaceList.addAll(allSuperClassNodeList); superClassAndInterfaceList.addAll(actualReceiver.getAllInterfaces()); for (ClassNode superClassNode : allSuperClassNodeList) { superClassAndInterfaceList.addAll(superClassNode.getAllInterfaces()); } return superClassAndInterfaceList; }
private void getAllInterfaces(Set<ClassNode> res) { if (isInterface()) res.add(this); for (ClassNode anInterface : getInterfaces()) { res.add(anInterface); anInterface.getAllInterfaces(res); } }
public static Set<ClassNode> getInterfacesAndSuperInterfaces(ClassNode type) { Set<ClassNode> res = new LinkedHashSet<ClassNode>(); if (type.isInterface()) { res.add(type); return res; } ClassNode next = type; while (next != null) { res.addAll(next.getAllInterfaces()); next = next.getSuperClass(); } return res; }
/** * Collects all interfaces of a class node, including those defined by the * super class. * * @param node a class for which we want to retrieve all interfaces * @param out the set where to collect interfaces */ private static void collectAllInterfaces(final ClassNode node, final Set<ClassNode> out) { if (node == null) return; Set<ClassNode> allInterfaces = node.getAllInterfaces(); out.addAll(allInterfaces); collectAllInterfaces(node.getSuperClass(), out); }
@Override public void visitClass(final ClassNode node) { List<Statement> savedStatements = new ArrayList<Statement>(node.getObjectInitializerStatements()); super.visitClass(node); node.getObjectInitializerStatements().addAll(savedStatements); for (ClassNode inode : node.getAllInterfaces()) { if (Traits.isTrait(inode)) { List<PropertyNode> traitProps = inode.getProperties(); for (PropertyNode pn : traitProps) { super.visitProperty(pn); } } } }
queue.add(testClass); if (testClass.isInterface()) { queue.addAll(testClass.getAllInterfaces());
private boolean setRedirect(ClassNode type, ClassNode classToCheck) { ClassNode val = new ConstructedNestedClass(classToCheck, type.getName()); if (resolveFromCompileUnit(val)) { type.setRedirect(val); return true; } // also check interfaces in case we have interfaces with nested classes for (ClassNode next : classToCheck.getAllInterfaces()) { if (type.getName().contains(next.getName())) continue; val = new ConstructedNestedClass(next, type.getName()); if (resolve(val, false, false, false)) { type.setRedirect(val); return true; } } return false; }
for (ClassNode node : classNode.getAllInterfaces()) { if (Traits.isTrait(node)) { List<MethodNode> traitMethods = node.getMethods();
if (source.equals(type)) return source; if (type.isInterface()) { for (ClassNode interfaceNode : source.getAllInterfaces()) { if (interfaceNode.equals(type)) { ClassNode parameterizedInterface = GenericsUtils.parameterizeType(source, interfaceNode);
if (handledNodes.contains(current)) continue; handledNodes.add(current); Set<ClassNode> allInterfaces = current.getAllInterfaces(); for (ClassNode intf : allInterfaces) {
Set<ClassNode> interfaces = classNode.getAllInterfaces();
for (ClassNode next : delegate.type.getAllInterfaces()) { delegateMethods.addAll(getAllMethods(next)); final Set<ClassNode> ownerIfaces = delegate.owner.getAllInterfaces(); Map<String,ClassNode> genericsSpec = createGenericsSpec(delegate.owner); genericsSpec = createGenericsSpec(delegate.type, genericsSpec);
String altGetterName = "is" + MetaClassHelper.capitalize(methodName); if (receiverType.isInterface()) { Set<ClassNode> allInterfaces = receiverType.getAllInterfaces(); MethodNode getterMethod = null; for (ClassNode anInterface : allInterfaces) {
public Set<ClassNode> getAllInterfaces () { Set<ClassNode> res = new HashSet<ClassNode>(); getAllInterfaces(res); return res; }
public Set getAllInterfaces () { Set res = new HashSet (); getAllInterfaces(res); return res; }
private void getAllInterfaces(Set res) { if (isInterface()) res.add(this); ClassNode[] interfaces = getInterfaces(); for (int i = 0; i < interfaces.length; i++) { res.add(interfaces[i]); interfaces[i].getAllInterfaces(res); } }
private void getAllInterfaces(Set<ClassNode> res) { if (isInterface()) res.add(this); for (ClassNode anInterface : getInterfaces()) { res.add(anInterface); anInterface.getAllInterfaces(res); } }
@Override public void visitClass(ClassNode node) { if (node == null) return; classNode = node; methodNodes = classNode.getMethods(); // walk up the class hierarchy super.visitClass(node.getSuperClass()); // walk through all interfaces for (ClassNode i : node.getAllInterfaces()) { } }