org.codehaus.groovy.ast.ClassNode.declaresInterface java code examples

Common ways to obtain ClassNode

private void myMethod () {
 ClassNode c =Expression expression;expression.getType()
MethodNode methodNode;methodNode.getReturnType()
String name;ClassHelper.make(name)
Smart code suggestions by Tabnine
}

@Override
public boolean declaresInterface(final ClassNode classNode) {
  for (ClassNode delegate : delegates) {
    if (delegate.declaresInterface(classNode)) return true;
  }
  return false;
}

/**
 * @param classNode the class node for the interface
 * @return true if this class declares that it implements the given interface
 * or if one of its interfaces extends directly or indirectly the interface
 */
public boolean declaresInterface(ClassNode classNode) {
  ClassNode[] interfaces = redirect().getInterfaces();
  if (declaresInterfaceDirect(interfaces, classNode)) return true;
  List superInterfaces = Arrays.asList(interfaces);
  while (superInterfaces.size() > 0) {
    List keep = new ArrayList();
    for (int i = 0; i < superInterfaces.size(); i++) {
      ClassNode cn = (ClassNode) superInterfaces.get(i);
      if (cn.declaresInterface(classNode)) return true;
      keep.addAll(Arrays.asList(cn.getInterfaces()));
    }
    superInterfaces = keep;
  }
  return false;
}

/**
 * @param classNode the class node for the interface
 * @return true if this class or any base class implements the given interface
 */
public boolean implementsInterface(ClassNode classNode) {
  ClassNode node = redirect();
  do {
    if (node.declaresInterface(classNode)) {
      return true;
    }
    node = node.getSuperClass();
  }
  while (node != null);
  return false;
}

/**
 * @param classNode the class node for the interface
 * @return true if this class declares that it implements the given interface
 * or if one of its interfaces extends directly or indirectly the interface
 */
public boolean declaresInterface(ClassNode classNode) {
  ClassNode[] interfaces = redirect().getInterfaces();
  if (declaresInterfaceDirect(interfaces, classNode)) return true;
  List superInterfaces = Arrays.asList(interfaces);
  while (superInterfaces.size() > 0) {
    List keep = new ArrayList();
    for (int i = 0; i < superInterfaces.size(); i++) {
      ClassNode cn = (ClassNode) superInterfaces.get(i);
      if (cn.declaresInterface(classNode)) return true;
      keep.addAll(Arrays.asList(cn.getInterfaces()));
    }
    superInterfaces = keep;
  }
  return false;
}

/**
 * @param classNode the class node for the interface
 * @return true if this class declares that it implements the given interface
 * or if one of its interfaces extends directly or indirectly the interface
 *
 * NOTE: Doesn't consider an interface to implement itself.
 * I think this is intended to be called on ClassNodes representing
 * classes, not interfaces.
 * 
 */
public boolean declaresInterface(ClassNode classNode) {
  ClassNode[] interfaces = redirect().getInterfaces();
  for (ClassNode cn : interfaces) {
    if (cn.equals(classNode)) return true;
  }
  for (ClassNode cn : interfaces) {
    if (cn.declaresInterface(classNode)) return true;
  }
  return false;
}

/**
 * @param classNode the class node for the interface
 * @return true if this class declares that it implements the given interface
 * or if one of its interfaces extends directly or indirectly the interface
 */
public boolean declaresInterface(ClassNode classNode) {
  ClassNode[] interfaces = redirect().getInterfaces();
  if (declaresInterfaceDirect(interfaces, classNode)) return true;
  List superInterfaces = Arrays.asList(interfaces);
  while (superInterfaces.size() > 0) {
    List keep = new ArrayList();
    for (int i = 0; i < superInterfaces.size(); i++) {
      ClassNode cn = (ClassNode) superInterfaces.get(i);
      if (cn.declaresInterface(classNode)) return true;
      keep.addAll(Arrays.asList(cn.getInterfaces()));
    }
    superInterfaces = keep;
  }
  return false;
}

private MethodNode getCompatibleMethod(ClassNode current, String getAt, ClassNode aType) {
  // TODO this really should find "best" match or find all matches and complain about ambiguity if more than one
  // TODO handle getAt with more than one parameter
  // TODO handle default getAt methods on Java 8 interfaces
  for (MethodNode methodNode : current.getDeclaredMethods("getAt")) {
    if (methodNode.getParameters().length == 1) {
      ClassNode paramType = methodNode.getParameters()[0].getType();
      if (aType.isDerivedFrom(paramType) || aType.declaresInterface(paramType)) {
        return methodNode;
      }
    }
  }
  return null;
}

public void createMopMethods() {
  ClassNode classNode = controller.getClassNode();
  if (classNode.declaresInterface(ClassHelper.GENERATED_CLOSURE_Type)) {
    return;
  }
  Set<MopKey> currentClassSignatures = buildCurrentClassSignatureSet(classNode.getMethods());
  visitMopMethodList(classNode.getMethods(), true, Collections.EMPTY_SET, Collections.EMPTY_LIST);
  visitMopMethodList(classNode.getSuperClass().getAllDeclaredMethods(), false, currentClassSignatures, controller.getSuperMethodNames());
}

public boolean addGeneratedClosureConstructorCall(ConstructorCallExpression call) {
  ClassNode classNode = controller.getClassNode();
  if (!classNode.declaresInterface(ClassHelper.GENERATED_CLOSURE_Type)) return false;
  AsmClassGenerator acg = controller.getAcg();
  OperandStack operandStack = controller.getOperandStack();
  
  MethodVisitor mv = controller.getMethodVisitor();
  mv.visitVarInsn(ALOAD, 0);
  ClassNode callNode = classNode.getSuperClass();
  TupleExpression arguments = (TupleExpression) call.getArguments();
  if (arguments.getExpressions().size()!=2) throw new GroovyBugError("expected 2 arguments for closure constructor super call, but got"+arguments.getExpressions().size());
  arguments.getExpression(0).visit(acg);
  operandStack.box();
  arguments.getExpression(1).visit(acg);
  operandStack.box();
  //TODO: replace with normal String, p not needed
  Parameter p = new Parameter(ClassHelper.OBJECT_TYPE,"_p");
  String descriptor = BytecodeHelper.getMethodDescriptor(ClassHelper.VOID_TYPE, new Parameter[]{p,p});
  mv.visitMethodInsn(INVOKESPECIAL, BytecodeHelper.getClassInternalName(callNode), "<init>", descriptor, false);
  operandStack.remove(2);
  return true;
}

    staticInitCall
)), false);
if (fieldHelperClassNode != null && !cNode.declaresInterface(fieldHelperClassNode)) {

private boolean isTypeCompatible(ClassNode base, ClassNode target) {
  return target.equals(base) || target.implementsInterface(base) || target.declaresInterface(base);
}

/**
 * @param classNode the class node for the interface
 * @return true if this class or any base class implements the given interface
 */
public boolean implementsInterface(ClassNode classNode) {
  ClassNode node = redirect();
  do {
    if (node.declaresInterface(classNode)) {
      return true;
    }
    node = node.getSuperClass();
  }
  while (node != null);
  return false;
}

/**
 * @param classNode the class node for the interface
 * @return true if this class or any base class implements the given interface
 */
public boolean implementsInterface(ClassNode classNode) {
  ClassNode node = redirect();
  do {
    if (node.declaresInterface(classNode)) {
      return true;
    }
    node = node.getSuperClass();
  }
  while (node != null);
  return false;
}

/**
 * @param classNode the class node for the interface
 * @return true if this class or any base class implements the given interface
 */
public boolean implementsInterface(ClassNode classNode) {
  ClassNode node = redirect();
  do {
    if (node.declaresInterface(classNode)) {
      return true;
    }
    node = node.getSuperClass();
  }
  while (node != null);
  return false;
}

/**
 * @param classNode the class node for the interface
 * @return true if this class or any base class implements the given interface
 */
public boolean implementsInterface(ClassNode classNode) {
  ClassNode node = redirect();
  do {
    if (node.declaresInterface(classNode)) {
      return true;
    }
    node = node.getSuperClass();
  }
  while (node != null);
  return false;
}

/**
 * @param classNode the class node for the interface
 * @return true if this class declares that it implements the given interface
 * or if one of its interfaces extends directly or indirectly the interface
 *
 * NOTE: Doesn't consider an interface to implement itself.
 * I think this is intended to be called on ClassNodes representing
 * classes, not interfaces.
 * 
 */
public boolean declaresInterface(ClassNode classNode) {
  ClassNode[] interfaces = redirect().getInterfaces();
  for (ClassNode cn : interfaces) {
    if (cn.equals(classNode)) return true;
  }
  for (ClassNode cn : interfaces) {
    if (cn.declaresInterface(classNode)) return true;
  }
  return false;
}

  public void visitMethod(MethodNode node){
    if(isTag && !node.isStatic() && node.getName().equals(TAG) && node.getParameters().length==2 && node.getReturnType().equals(ClassHelper.OBJECT_TYPE)){
      ClassNode taggableNode = new ClassNode(Taggable.class);
      if(!classNode.declaresInterface(taggableNode)){
        classNode.addInterface(taggableNode);
      }
    }
    super.visitMethod(node);
  }
}

public void createMopMethods() {
  ClassNode classNode = controller.getClassNode();
  if (classNode.declaresInterface(ClassHelper.GENERATED_CLOSURE_Type)) {
    return;
  }
  visitMopMethodList(classNode.getMethods(), true);
  visitMopMethodList(classNode.getSuperClass().getAllDeclaredMethods(), false);
}

  public void visitMethod(MethodNode node){
    if(isTag && !node.isStatic() && node.getName().equals(TAG) && node.getParameters().length==2 && node.getReturnType().equals(ClassHelper.OBJECT_TYPE)){
      ClassNode taggableNode = new ClassNode(Taggable.class);
      if(!classNode.declaresInterface(taggableNode)){
        classNode.addInterface(taggableNode);
      }
    }
    super.visitMethod(node);
  }
}

public boolean addGeneratedClosureConstructorCall(ConstructorCallExpression call) {
  ClassNode classNode = controller.getClassNode();
  if (!classNode.declaresInterface(ClassHelper.GENERATED_CLOSURE_Type)) return false;
  AsmClassGenerator acg = controller.getAcg();
  OperandStack operandStack = controller.getOperandStack();
  
  MethodVisitor mv = controller.getMethodVisitor();
  mv.visitVarInsn(ALOAD, 0);
  ClassNode callNode = classNode.getSuperClass();
  TupleExpression arguments = (TupleExpression) call.getArguments();
  if (arguments.getExpressions().size()!=2) throw new GroovyBugError("expected 2 arguments for closure constructor super call, but got"+arguments.getExpressions().size());
  arguments.getExpression(0).visit(acg);
  operandStack.box();
  arguments.getExpression(1).visit(acg);
  operandStack.box();
  //TODO: replace with normal String, p not needed
  Parameter p = new Parameter(ClassHelper.OBJECT_TYPE,"_p");
  String descriptor = BytecodeHelper.getMethodDescriptor(ClassHelper.VOID_TYPE, new Parameter[]{p,p});
  mv.visitMethodInsn(INVOKESPECIAL, BytecodeHelper.getClassInternalName(callNode), "<init>", descriptor);
  operandStack.remove(2);
  return true;
}

Popular methods of ClassNode

getName
getMethods
This methods creates a list of all methods with this name of the current class and of all super clas
<init>
Constructor used by makeArray() if no real class is available
getSuperClass
equals
addMethod
getAnnotations
addField
getFields
Returns a list containing FieldNode objects for each field in the class represented by this ClassNod
getPlainNodeReference
getField
Finds a field matching the given name in this class or a parent class.
getMethod
Finds a method matching the given name and parameters in this class or any parent class.

Popular in Java

Parsing JSON documents to java classes using gson
setContentView (Activity)
getSharedPreferences (Context)
getOriginalFilename (MultipartFile)
Return the original filename in the client's filesystem.This may contain path information depending
ObjectMapper (com.fasterxml.jackson.databind)
ObjectMapper provides functionality for reading and writing JSON, either to and from basic POJOs (Pl
Proxy (java.net)
This class represents proxy server settings. A created instance of Proxy stores a type and an addres
Iterator (java.util)
An iterator over a sequence of objects, such as a collection.If a collection has been changed since
Pattern (java.util.regex)
Patterns are compiled regular expressions. In many cases, convenience methods such as String#matches
JComboBox (javax.swing)
XPath (javax.xml.xpath)
XPath provides access to the XPath evaluation environment and expressions. Evaluation of XPath Expr
21 Best IntelliJ Plugins

How to use declaresInterfacemethodin org.codehaus.groovy.ast.ClassNode

Best Java code snippets using org.codehaus.groovy.ast.ClassNode.declaresInterface (Showing top 20 results out of 315)

How to use
declaresInterface
method
in
org.codehaus.groovy.ast.ClassNode