How to use

getModifiers

method

in

org.codehaus.groovy.ast.ClassNode

private boolean isAnInterface() {
  return classNode != null && (classNode.getModifiers() & Opcodes.ACC_INTERFACE) > 0;
}

private boolean checkInnerTypeVisibility(ClassNode enclosingType, ClassNode innerClassNode) {
  if (currentClass == enclosingType) {
    return true;
  }
  int modifiers = innerClassNode.getModifiers();
  return Modifier.isPublic(modifiers) || Modifier.isProtected(modifiers);
}

private void checkClassForOtherModifiers(ClassNode node) {
  checkClassForModifier(node, isTransient(node.getModifiers()), "transient");
  checkClassForModifier(node, isVolatile(node.getModifiers()), "volatile");
  checkClassForModifier(node, isNative(node.getModifiers()), "native");
  if (!(node instanceof InnerClassNode)) {
    checkClassForModifier(node, isStatic(node.getModifiers()), "static");
    checkClassForModifier(node, isPrivate(node.getModifiers()), "private");
  }
  // don't check synchronized here as it overlaps with ACC_SUPER
}

private static boolean validTypeForCall(ClassNode type) {
  // do call only for final classes and primitive types
  if (isPrimitiveType(type)) return true;
  return (type.getModifiers() & ACC_FINAL) > 0;
}

  @Override
  public void call(final SourceUnit source, final GeneratorContext context, final ClassNode classNode) throws CompilationFailedException {
    if ((classNode.getModifiers() & Opcodes.ACC_INTERFACE) > 0) {
      // does not apply on interfaces
      return;
    }
    if (!(classNode instanceof InnerClassNode)) {
      addTimeStamp(classNode);
    }
  }
}

public boolean isAnnotationDefinition() {
  return /* redirect().isPrimaryNode && */
      isInterface() && (getModifiers() & Opcodes.ACC_ANNOTATION) != 0;
}

private boolean isVisibleNestedClass(ClassNode type, ClassNode ceType) {
  if (!type.isRedirectNode()) return false;
  ClassNode redirect = type.redirect();
  if (Modifier.isPublic(redirect.getModifiers()) || Modifier.isProtected(redirect.getModifiers())) return true;
  // package local
  return isDefaultVisibility(redirect.getModifiers()) && inSamePackage(ceType, redirect);
}

/**
 * Detect whether a given ClassNode is a inner class (non-static).
 *
 * @param cNode the ClassNode of interest
 * @return true if the given node is a (non-static) inner class, else false
 */
public static boolean isInnerClass(ClassNode cNode) {
  return cNode.redirect().getOuterClass() != null
      && !Modifier.isStatic(cNode.getModifiers());
}

private void checkAbstractMethodVisibility(ClassNode node) {
  // we only do check abstract classes (including enums), no interfaces or non-abstract classes
  if (!isAbstract(node.getModifiers()) || isInterface(node.getModifiers())) return;
  List<MethodNode> abstractMethods = node.getAbstractMethods();
  if (abstractMethods == null || abstractMethods.isEmpty()) return;
  for (MethodNode method : abstractMethods) {
    if (method.isPrivate()) {
      addError("Method '" + method.getName() + "' from " + getDescription(node) +
          " must not be private as it is declared as an abstract method.", method);
    }
  }
}

private void checkClassForAbstractAndFinal(ClassNode node) {
  if (!isAbstract(node.getModifiers())) return;
  if (!isFinal(node.getModifiers())) return;
  if (node.isInterface()) {
    addError("The " + getDescription(node) + " must not be final. It is by definition abstract.", node);
  } else {
    addError("The " + getDescription(node) + " must not be both final and abstract.", node);
  }
}

private static int adjustedClassModifiersForInnerClassTable(ClassNode classNode) {
  int modifiers = classNode.getModifiers();
  modifiers = modifiers & ~ACC_SUPER;
  modifiers = fixInterfaceModifiers(classNode, modifiers);
  modifiers = fixInnerClassModifiers(classNode, modifiers);
  return modifiers;
}

private static boolean possiblyCloneable(ClassNode type) {
  return !isPrimitiveType(type) && ((isCloneableType(type) || (type.getModifiers() & ACC_FINAL) == 0));
}

private void checkClassForOverwritingFinal(ClassNode cn) {
  ClassNode superCN = cn.getSuperClass();
  if (superCN == null) return;
  if (!isFinal(superCN.getModifiers())) return;
  String msg = "You are not allowed to overwrite the final " + getDescription(superCN) + ".";
  addError(msg, cn);
}

private static int adjustedClassModifiersForClassWriting(ClassNode classNode) {
  int modifiers = classNode.getModifiers();
  boolean needsSuper = !classNode.isInterface();
  modifiers = needsSuper ? modifiers | ACC_SUPER : modifiers & ~ACC_SUPER;
  // eliminate static
  modifiers = modifiers & ~ACC_STATIC;
  modifiers = fixInnerClassModifiers(classNode, modifiers);
  modifiers = fixInterfaceModifiers(classNode, modifiers);
  return modifiers;
}

private void checkAbstractDeclaration(MethodNode methodNode) {
  if (!methodNode.isAbstract()) return;
  if (isAbstract(currentClass.getModifiers())) return;
  addError("Can't have an abstract method in a non-abstract class." +
      " The " + getDescription(currentClass) + " must be declared abstract or the method '" +
      methodNode.getTypeDescriptor() + "' must not be abstract.", methodNode);
}

private static void makeClassFinal(AbstractASTTransformation xform, ClassNode cNode) {
  int modifiers = cNode.getModifiers();
  if ((modifiers & ACC_FINAL) == 0) {
    if ((modifiers & (ACC_ABSTRACT | ACC_SYNTHETIC)) == (ACC_ABSTRACT | ACC_SYNTHETIC)) {
      xform.addError("Error during " + MY_TYPE_NAME + " processing: annotation found on inappropriate class " + cNode.getName(), cNode);
      return;
    }
    cNode.setModifiers(modifiers | ACC_FINAL);
  }
}

private static void checkForAbstractMethods(ClassNode enumClass) {
  List<MethodNode> methods = enumClass.getMethods();
  for (MethodNode m : methods) {
    if (m.isAbstract()) {
      // make the class abstract also see Effective Java p.152
      enumClass.setModifiers(enumClass.getModifiers() | Opcodes.ACC_ABSTRACT);
      break;
    }
  }
}

protected Expression transformConstructorCallExpression(ConstructorCallExpression cce) {
  ClassNode type = cce.getType();
  resolveOrFail(type, cce);
  if (Modifier.isAbstract(type.getModifiers())) {
    addError("You cannot create an instance from the abstract " + getDescription(type) + ".", cce);
  }
  return cce.transformExpression(this);
}

  protected static boolean shouldHandleImplicitThisForInnerClass(ClassNode cn) {
    if (cn.isEnum() || cn.isInterface()) return false;
    if ((cn.getModifiers() & Opcodes.ACC_STATIC) != 0) return false;

    if (!(cn instanceof InnerClassNode)) return false;
    InnerClassNode innerClass = (InnerClassNode) cn;
    // scope != null means aic, we don't handle that here
    if (innerClass.getVariableScope() != null) return false;
    // static inner classes don't need this$0
    return (innerClass.getModifiers() & Opcodes.ACC_STATIC) == 0;
  }
}

private void checkMethodModifiers(MethodNode node) {
  // don't check volatile here as it overlaps with ACC_BRIDGE
  // additional modifiers not allowed for interfaces
  if ((this.currentClass.getModifiers() & ACC_INTERFACE) != 0) {
    checkMethodForModifier(node, isStrict(node.getModifiers()), "strictfp");
    checkMethodForModifier(node, isSynchronized(node.getModifiers()), "synchronized");
    checkMethodForModifier(node, isNative(node.getModifiers()), "native");
  }
}