How to use

getInnerClasses

method

in

org.codehaus.groovy.ast.ClassNode

private static boolean isExtended(ClassNode owner, Iterator<InnerClassNode> classes) {
  while (classes.hasNext()) {
    InnerClassNode next =  classes.next();
    if (next!=owner && next.isDerivedFrom(owner)) return true;
  }
  if (owner.getInnerClasses().hasNext()) {
    return isExtended(owner, owner.getInnerClasses());
  }
  return false;
}

@Override
public void visitClass(final ClassNode node) {
  ClassNode prec = classNode;
  classNode = node;
  super.visitClass(node);
  Iterator<InnerClassNode> innerClasses = classNode.getInnerClasses();
  while (innerClasses.hasNext()) {
    InnerClassNode innerClassNode = innerClasses.next();
    visitClass(innerClassNode);
  }
  classNode = prec;
}

private void addPrivateFieldAndMethodAccessors(ClassNode node) {
  addPrivateBridgeMethods(node);
  addPrivateFieldsAccessors(node);
  Iterator<InnerClassNode> it = node.getInnerClasses();
  while (it.hasNext()) {
    addPrivateFieldAndMethodAccessors(it.next());
  }
}

private boolean helperClassNotCreatedYet(final ClassNode traitReceiver) {
  return !traitReceiver.redirect().getInnerClasses().hasNext()
      && this.unit.getAST().getClasses().contains(traitReceiver.redirect());
}
private boolean isTraitSuperPropertyExpression(Expression exp) {

protected void createInterfaceSyntheticStaticFields() {
  ClassNode icl =  controller.getInterfaceClassLoadingClass();
  if (referencedClasses.isEmpty()) {
    Iterator<InnerClassNode> it = icl.getOuterClass().getInnerClasses();
    while(it.hasNext()) {
      InnerClassNode inner = it.next();
      if (inner==icl) {
        it.remove();
        return;
      }
    }
    return;
  }
  addInnerClass(icl);
  for (Map.Entry<String, ClassNode> entry : referencedClasses.entrySet()) {            // generate a field node
    String staticFieldName = entry.getKey();
    ClassNode cn = entry.getValue();
    icl.addField(staticFieldName, ACC_STATIC + ACC_SYNTHETIC, ClassHelper.CLASS_Type.getPlainNodeReference(), new ClassExpression(cn));
  }
}

private void checkInnerClasses(final ClassNode cNode) {
  Iterator<InnerClassNode> it = cNode.getInnerClasses();
  while (it.hasNext()) {
    InnerClassNode origin = it.next();
    if ((origin.getModifiers() & ACC_STATIC) == 0) {
      unit.addError(new SyntaxException("Cannot have non-static inner class inside a trait ("+origin.getName()+")", origin.getLineNumber(), origin.getColumnNumber()));
    }
  }
}

public void visitClass(ClassNode node) {
  // AIC are already done, doing them here again will lead to wrong scopes
  if (node instanceof InnerClassNode) {
    InnerClassNode in = (InnerClassNode) node;
    if (in.isAnonymous() && !in.isEnum()) return;
  }
  pushState();
  prepareVisit(node);
  super.visitClass(node);
  if (recurseInnerClasses) {
    Iterator<InnerClassNode> innerClasses = node.getInnerClasses();
    while (innerClasses.hasNext()) {
      visitClass(innerClasses.next());
    }
  }
  popState();
}

ClassNode fieldHelperClassNode = null;
ClassNode staticFieldHelperClassNode = null;
Iterator<InnerClassNode> innerClasses = trait.redirect().getInnerClasses();
if (innerClasses != null && innerClasses.hasNext()) {

printMethods(out, classNode, isEnum);
for (Iterator<InnerClassNode> inner = classNode.getInnerClasses(); inner.hasNext(); ) {

@Override
public void visitClass(ClassNode node) {
  this.classNode = node;
  thisField = null;
  InnerClassNode innerClass = null;
  if (!node.isEnum() && !node.isInterface() && node instanceof InnerClassNode) {
    innerClass = (InnerClassNode) node;
    thisField = innerClass.getField("this$0");
    if (innerClass.getVariableScope() == null && innerClass.getDeclaredConstructors().isEmpty()) {
      // add dummy constructor
      innerClass.addConstructor(ACC_PUBLIC, Parameter.EMPTY_ARRAY, null, null);
    }
  }
  if (node.isEnum() || node.isInterface()) return;
  // use Iterator.hasNext() to check for available inner classes
  if (node.getInnerClasses().hasNext()) addDispatcherMethods(node);
  if (innerClass == null) return;
  super.visitClass(node);
  addDefaultMethods(innerClass);
}

private void processClass(ClassNode cNode, final ClassCodeVisitorSupport visitor) {
  if (!isEnabled(cNode)) return;
  if (cNode.isInterface()) {
    addError("Error processing interface '" + cNode.getName() +
        "'. " + MY_TYPE_NAME + " only allowed for classes.", cNode);
    return;
  }
  for (ConstructorNode cn : cNode.getDeclaredConstructors()) {
    if (hasNoExplicitAutoFinal(cn)) {
      processConstructorOrMethod(cn, visitor);
    }
  }
  for (MethodNode mn : cNode.getAllDeclaredMethods()) {
    if (hasNoExplicitAutoFinal(mn)) {
      processConstructorOrMethod(mn, visitor);
    }
  }
  Iterator<InnerClassNode> it = cNode.getInnerClasses();
  while (it.hasNext()) {
    InnerClassNode in = it.next();
    if (in.getAnnotations(MY_TYPE).isEmpty()) {
      processClass(in, visitor);
    }
  }
  visitor.visitClass(cNode);
}

typeCheckingContext.alreadyVisitedMethods = new LinkedHashSet<MethodNode>();
super.visitClass(node);
Iterator<InnerClassNode> innerClasses = node.getInnerClasses();
while (innerClasses.hasNext()) {
  InnerClassNode innerClassNode = innerClasses.next();

@Override
public void visitClass(final ClassNode node) {
  boolean skip = shouldSkipClassNode(node);
  if (!skip && !anyMethodSkip(node)) {
    node.putNodeMetaData(MopWriter.Factory.class, StaticCompilationMopWriter.FACTORY);
  }
  ClassNode oldCN = classNode;
  classNode = node;
  Iterator<InnerClassNode> innerClasses = classNode.getInnerClasses();
  while (innerClasses.hasNext()) {
    InnerClassNode innerClassNode = innerClasses.next();
    boolean innerStaticCompile = !(skip || isSkippedInnerClass(innerClassNode));
    innerClassNode.putNodeMetaData(STATIC_COMPILE_NODE, innerStaticCompile);
    innerClassNode.putNodeMetaData(WriterControllerFactory.class, node.getNodeMetaData(WriterControllerFactory.class));
    if (innerStaticCompile && !anyMethodSkip(innerClassNode)) {
      innerClassNode.putNodeMetaData(MopWriter.Factory.class, StaticCompilationMopWriter.FACTORY);
    }
  }
  super.visitClass(node);
  addPrivateFieldAndMethodAccessors(node);
  if (isStaticallyCompiled(node)) addDynamicOuterClassAccessorsCallback(node.getOuterClass());
  classNode = oldCN;
}

if (context == null || context.phase < phase || (context.phase == phase && !context.phaseComplete)) {
  int offset = 1;
  for (Iterator<InnerClassNode> iterator = classNode.getInnerClasses(); iterator.hasNext(); ) {
    iterator.next();
    offset++;

Iterator<InnerClassNode> innerClasses = node.getInnerClasses();
if (innerClasses.hasNext()) {
  thatType = innerClasses.next();

for (Iterator<InnerClassNode> iter = classNode.getInnerClasses(); iter.hasNext();) {
  InnerClassNode innerClass = iter.next();
  makeInnerClassEntry(innerClass);

  || (top instanceof InnerClassNode
  && Modifier.isPrivate(top.getModifiers())
  && !isExtended(top, top.getOuterClass().getInnerClasses()))
  ) {
CompareToNullExpression expr = new CompareToNullExpression(

@Override
public void visitClass(final ClassNode node) {
  super.visitClass(node);
  Iterator<InnerClassNode> it = node.getInnerClasses();
  while (it.hasNext()) {
    InnerClassNode next = it.next();
    visitClass(next);
  }
}

protected void createInterfaceSyntheticStaticFields() {
  ClassNode icl =  controller.getInterfaceClassLoadingClass();
  if (referencedClasses.isEmpty()) {
    Iterator<InnerClassNode> it = controller.getClassNode().getInnerClasses();
    while(it.hasNext()) {
      InnerClassNode inner = it.next();
      if (inner==icl) {
        it.remove();
        return;
      }
    }
    return;
  }
  addInnerClass(icl);
  for (String staticFieldName : referencedClasses.keySet()) {            // generate a field node
    icl.addField(staticFieldName, ACC_STATIC + ACC_SYNTHETIC, ClassHelper.CLASS_Type.getPlainNodeReference(), new ClassExpression(referencedClasses.get(staticFieldName)));
  }
}

if (context == null || context.phase < phase || (context.phase == phase && !context.phaseComplete)) {
  int offset = 1;
  Iterator<InnerClassNode> iterator = classNode.getInnerClasses();
  while (iterator.hasNext()) {
    iterator.next();