Codota Logo
ClassNode.getMethod
Code IndexAdd Codota to your IDE (free)

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

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

  • Common ways to obtain ClassNode
private void myMethod () {
ClassNode c =
  • Codota IconExpression expression;expression.getType()
  • Codota IconMethodNode methodNode;methodNode.getReturnType()
  • Codota IconString name;ClassHelper.make(name)
  • Smart code suggestions by Codota
}
origin: org.codehaus.groovy/groovy

/**
 * @see #getMethod(String, Parameter[])
 */
public boolean hasMethod(String name, Parameter[] parameters) {
  MethodNode other = getMethod(name, parameters);
  return other != null;
}
origin: org.codehaus.groovy/groovy

List<MethodNode> traitMethods = node.getMethods();
for (MethodNode traitMethod : traitMethods) {
  MethodNode method = classNode.getMethod(traitMethod.getName(), traitMethod.getParameters());
  if (method == null) {
    for (MethodNode methodNode : propertyMethods) {
origin: org.codehaus.groovy/groovy

BlockStatement code = new BlockStatement();
MethodCallExpression cloneCall = new MethodCallExpression(new FieldExpression(values), "clone", MethodCallExpression.NO_ARGUMENTS);
cloneCall.setMethodTarget(values.getType().getMethod("clone", Parameter.EMPTY_ARRAY));
code.addStatement(new ReturnStatement(cloneCall));
valuesMethod.setCode(code);
origin: org.codehaus.groovy/groovy

private static String getterName(ClassNode annotatedNode, PropertyNode pNode) {
  String getterName = "get" + MetaClassHelper.capitalize(pNode.getName());
  boolean existingExplicitGetter = annotatedNode.getMethod(getterName, Parameter.EMPTY_ARRAY) != null;
  if (ClassHelper.boolean_TYPE.equals(pNode.getOriginType()) && !existingExplicitGetter) {
    getterName = "is" + MetaClassHelper.capitalize(pNode.getName());
  }
  return getterName;
}
origin: org.codehaus.griffon/griffon-groovy-compile

public static boolean addMethod(ClassNode classNode, MethodNode methodNode, boolean replace) {
  MethodNode oldMethod = classNode.getMethod(methodNode.getName(), methodNode.getParameters());
  if (oldMethod == null) {
    classNode.addMethod(methodNode);
    return true;
  } else if (replace) {
    classNode.getMethods().remove(oldMethod);
    classNode.addMethod(methodNode);
    return true;
  }
  return false;
}
origin: org.codehaus.groovy/groovy

cn.getModule().addClass(helper);
helper.addAnnotation(new AnnotationNode(COMPILESTATIC_CLASSNODE));
MethodNode serializeClass = collector.getClassNode().getMethod("serializeClass", Parameter.EMPTY_ARRAY);
collector.setMember("serializeClass", new ClassExpression(helper.getPlainNodeReference()));
origin: org.codehaus.groovy/groovy

private void checkNoAbstractMethodsNonabstractClass(ClassNode node) {
  if (isAbstract(node.getModifiers())) return;
  List<MethodNode> abstractMethods = node.getAbstractMethods();
  if (abstractMethods == null) return;
  for (MethodNode method : abstractMethods) {
    MethodNode sameArgsMethod = node.getMethod(method.getName(), method.getParameters());
    if (sameArgsMethod==null || method.getReturnType().equals(sameArgsMethod.getReturnType())) {
      addError("Can't have an abstract method in a non-abstract class." +
          " The " + getDescription(node) + " must be declared abstract or" +
          " the " + getDescription(method) + " must be implemented.", node);
    } else {
      addError("Abstract "+getDescription(method)+" is not implemented but a " +
              "method of the same name but different return type is defined: "+
              (sameArgsMethod.isStatic()?"static ":"")+
              getDescription(sameArgsMethod), method
      );
    }
  }
}
origin: org.codehaus.groovy/groovy

ClassNode type;
if (isMethod) {
  target = node.getMethod(name, paraTypes);
  if (target==null) return;
  if (!target.getDeclaringClass().equals(node)) return;
origin: org.codehaus.groovy/groovy

System.arraycopy(methodNode.getParameters(), 1, params, 0, params.length);
Map<String,ClassNode> methodGenericsSpec = new LinkedHashMap<String, ClassNode>(genericsSpec);
MethodNode originalMethod = trait.getMethod(name, params);
origin: spockframework/spock

private void createSharedFieldGetter(Field field) {
 String getterName = "get" + MetaClassHelper.capitalize(field.getName());
 MethodNode getter = spec.getAst().getMethod(getterName, Parameter.EMPTY_ARRAY);
 if (getter != null) {
  errorReporter.error(field.getAst(),
    "@Shared field '%s' conflicts with method '%s'; please rename either of them",
    field.getName(), getter.getName());
  return;
 }
 BlockStatement getterBlock = new BlockStatement();
 getter = new MethodNode(getterName, determineVisibilityForSharedFieldAccessor(field) | Opcodes.ACC_SYNTHETIC,
   field.getAst().getType(), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, getterBlock);
 getterBlock.addStatement(
   new ReturnStatement(
     new ExpressionStatement(
       new AttributeExpression(
         getSharedInstance(),
         // use internal name
         new ConstantExpression(field.getAst().getName())))));
 getter.setSourcePosition(field.getAst());
 spec.getAst().addMethod(getter);
}
origin: spockframework/spock

private void createSharedFieldSetter(Field field) {
 String setterName = "set" + MetaClassHelper.capitalize(field.getName());
 Parameter[] params = new Parameter[] { new Parameter(field.getAst().getType(), "$spock_value") };
 MethodNode setter = spec.getAst().getMethod(setterName, params);
 if (setter != null) {
  errorReporter.error(field.getAst(),
       "@Shared field '%s' conflicts with method '%s'; please rename either of them",
       field.getName(), setter.getName());
  return;
 }
 BlockStatement setterBlock = new BlockStatement();
 setter = new MethodNode(setterName, determineVisibilityForSharedFieldAccessor(field) | Opcodes.ACC_SYNTHETIC,
   ClassHelper.VOID_TYPE, params, ClassNode.EMPTY_ARRAY, setterBlock);
 setterBlock.addStatement(
   new ExpressionStatement(
     new BinaryExpression(
       new AttributeExpression(
         getSharedInstance(),
         // use internal name
         new ConstantExpression(field.getAst().getName())),
       Token.newSymbol(Types.ASSIGN, -1, -1),
       new VariableExpression("$spock_value"))));
 setter.setSourcePosition(field.getAst());
 spec.getAst().addMethod(setter);
}
origin: org.codehaus.groovy/groovy

iterator.setMethodTarget(collectionType.getMethod("iterator", Parameter.EMPTY_ARRAY));
iterator.setImplicitThis(false);
iterator.visit(controller.getAcg());
origin: crashub/crash

 @Override
 public void visit(ASTNode[] nodes, SourceUnit source) {
  for (ClassNode classNode : source.getAST().getClasses()) {
   if (classNode.isDerivedFrom(GROOVY_SCRIPT_COMMAND)) {
    MethodNode run = classNode.getMethod("run", new Parameter[0]);
    Statement code = run.getCode();
    if (code instanceof BlockStatement) {
     BlockStatement block = (BlockStatement)code;
     List<Statement> statements = block.getStatements();
     int size = statements.size();
     if (size > 0) {
      Statement last = statements.get(size - 1);
      if (last instanceof ReturnStatement) {
       classNode.addField(new FieldNode(
         FIELD_NAME,
         Modifier.PUBLIC | Modifier.STATIC,
         ClassHelper.Boolean_TYPE,
         classNode,
         null));
      }
     }
    }
   }
  }
 }
}
origin: com.thinkaurelius.groovy-shaded-asm/groovy-shaded-asm

/**
 * @see #getMethod(String, Parameter[])
 */
public boolean hasMethod(String name, Parameter[] parameters) {
  MethodNode other = getMethod(name, parameters);
  return other != null;
}
origin: org.codehaus.groovy/groovy-jdk14

/**
 * @see #getMethod(String, Parameter[])
 */
public boolean hasMethod(String name, Parameter[] parameters) {
  MethodNode other = getMethod(name, parameters);
  return other != null;
}
origin: org.codehaus.groovy/groovy-all-minimal

/**
 * @see #getMethod(String, Parameter[])
 */
public boolean hasMethod(String name, Parameter[] parameters) {
  MethodNode other = getMethod(name, parameters);
  return other != null;
}
origin: org.kohsuke.droovy/groovy

/**
 * @see #getMethod(String, Parameter[])
 */
public boolean hasMethod(String name, Parameter[] parameters) {
  MethodNode other = getMethod(name, parameters);
  return other != null;
}
origin: org.codehaus.gpars/gpars

private static void validatePoolClass(final Expression classExpression, final AnnotatedNode fieldNode, final SourceUnit source) {
  final Parameter[] parameters = {new Parameter(ClassHelper.CLOSURE_TYPE, "a1"),
      new Parameter(ClassHelper.boolean_TYPE, "a2")};
  final MethodNode asyncFunMethod = classExpression.getType().getMethod("asyncFun", parameters);
  if (asyncFunMethod == null || !asyncFunMethod.isStatic())
    addError("Supplied pool class has no static asyncFun(Closure, boolean) method", fieldNode, source);
}
origin: org.chromattic/chromattic.groovy

 public static boolean isChromatticAnnotedInHierarchy(ClassNode classNode, FieldNode fieldNode) {
  if (classNode == null) classNode = fieldNode.getDeclaringClass();
  ClassNode superClassNode = classNode.getSuperClass(); 
  if (!superClassNode.equals(ClassHelper.OBJECT_TYPE)) {
   MethodNode superMethodNode = superClassNode.getMethod(getsetName(GetSet.GET, fieldNode.getName()), new Parameter[]{});
   if (superMethodNode != null) return true;
   else isChromatticAnnotedInHierarchy(superClassNode, fieldNode);
  }
  return false;
 }
}
origin: org.gcontracts/gcontracts-core

@Override
public void visitProperty(PropertyNode node) {
  final ClassNode classNode = node.getDeclaringClass();
  final String setterName = "set" + MetaClassHelper.capitalize(node.getName());
  final Statement setterBlock = node.getSetterBlock();
  final Parameter parameter = new Parameter(node.getType(), "value");
  if (CandidateChecks.isClassInvariantCandidate(node) && (setterBlock == null && classNode.getMethod(setterName, new Parameter[]{ parameter } ) == null)) {
    final Statement setterBlockStatement = createSetterBlock(classNode, node.getField(), parameter);
    node.setSetterBlock(setterBlockStatement);
  }
}
org.codehaus.groovy.astClassNodegetMethod

Javadoc

Finds a method matching the given name and parameters in this class or any parent class.

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.
  • isInterface
  • getField,
  • isInterface,
  • getNameWithoutPackage,
  • isScript,
  • getDeclaredMethod,
  • getGenericsTypes,
  • getDeclaredConstructors,
  • getModifiers,
  • getTypeClass

Popular in Java

  • Reading from database using SQL prepared statement
  • startActivity (Activity)
  • getResourceAsStream (ClassLoader)
    Returns a stream for the resource with the specified name. See #getResource(String) for a descriptio
  • setRequestProperty (URLConnection)
    Sets the general request property. If a property with the key already exists, overwrite its value wi
  • Font (java.awt)
    The Font class represents fonts, which are used to render text in a visible way. A font provides the
  • RandomAccessFile (java.io)
    Allows reading from and writing to a file in a random-access manner. This is different from the uni-
  • InetAddress (java.net)
    This class represents an Internet Protocol (IP) address. An IP address is either a 32-bit or 128-bit
  • SecureRandom (java.security)
    This class generates cryptographically secure pseudo-random numbers. It is best to invoke SecureRand
  • JFileChooser (javax.swing)
  • Reflections (org.reflections)
    Reflections one-stop-shop objectReflections scans your classpath, indexes the metadata, allows you t
Codota Logo
  • Products

    Search for Java codeSearch for JavaScript codeEnterprise
  • IDE Plugins

    IntelliJ IDEAWebStormAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogCodota Academy Plugin user guide Terms of usePrivacy policyJava Code IndexJavascript Code Index
Get Codota for your IDE now