org.codehaus.groovy.ast.ClassNode.addConstructor 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 ConstructorNode addConstructor(final int modifiers, final Parameter[] parameters, final ClassNode[] exceptions, final Statement code) {
    return super.addConstructor(modifiers, parameters, exceptions, code);
  }
}

@Override
public void addConstructor(final ConstructorNode node) {
  super.addConstructor(node);
}

public ConstructorNode addConstructor(int modifiers, Parameter[] parameters, ClassNode[] exceptions, Statement code) {
  ConstructorNode node = new ConstructorNode(modifiers, parameters, exceptions, code);
  addConstructor(node);
  return node;
}

/**
 * Add a method that is marked as @Generated.
 *
 * @see ClassNode#addConstructor(ConstructorNode)
 */
public static void addGeneratedConstructor(ClassNode classNode, ConstructorNode consNode) {
  classNode.addConstructor(consNode);
  markAsGenerated(classNode, consNode);
}

/**
 * Add a method that is marked as @Generated.
 *
 * @see ClassNode#addConstructor(int, Parameter[], ClassNode[], Statement)
 */
public static ConstructorNode addGeneratedConstructor(ClassNode classNode, int modifiers, Parameter[] parameters, ClassNode[] exceptions, Statement code) {
  ConstructorNode consNode = classNode.addConstructor(modifiers, parameters, exceptions, code);
  markAsGenerated(classNode, consNode);
  return consNode;
}

protected void addConstructor(Parameter[] newParams, ConstructorNode ctor, Statement code, ClassNode node) {
  ConstructorNode genConstructor = node.addConstructor(ctor.getModifiers(), newParams, ctor.getExceptions(), code);
  markAsGenerated(node, genConstructor);
}

private static void createBuilderConstructors(ClassNode builder, ClassNode buildee, List<FieldNode> fields) {
  builder.addConstructor(ACC_PRIVATE, NO_PARAMS, NO_EXCEPTIONS, block(ctorSuperS()));
  final BlockStatement body = new BlockStatement();
  body.addStatement(ctorSuperS());
  initializeFields(fields, body, false);
  builder.addConstructor(ACC_PRIVATE, getParams(fields, buildee), NO_EXCEPTIONS, body);
}

protected void addDefaultConstructor(ClassNode node) {
  if (!node.getDeclaredConstructors().isEmpty()) return;
  BlockStatement empty = new BlockStatement();
  empty.setSourcePosition(node);
  ConstructorNode constructor = new ConstructorNode(ACC_PUBLIC, empty);
  constructor.setSourcePosition(node);
  constructor.setHasNoRealSourcePosition(true);
  node.addConstructor(constructor);
}

private static void doAddConstructor(final ClassNode cNode, final ConstructorNode constructorNode) {
  markAsGenerated(cNode, constructorNode);
  cNode.addConstructor(constructorNode);
  // GROOVY-5814: Immutable is not compatible with @CompileStatic
  Parameter argsParam = null;
  for (Parameter p : constructorNode.getParameters()) {
    if ("args".equals(p.getName())) {
      argsParam = p;
      break;
    }
  }
  if (argsParam != null) {
    final Parameter arg = argsParam;
    ClassCodeVisitorSupport variableExpressionFix = new ClassCodeVisitorSupport() {
      @Override
      protected SourceUnit getSourceUnit() {
        return cNode.getModule().getContext();
      }
      @Override
      public void visitVariableExpression(final VariableExpression expression) {
        super.visitVariableExpression(expression);
        if ("args".equals(expression.getName())) {
          expression.setAccessedVariable(arg);
        }
      }
    };
    variableExpressionFix.visitConstructor(constructorNode);
  }
}

private static ConstructorNode createInitializerConstructor(ClassNode buildee, ClassNode builder, List<FieldNode> fields) {
  ClassNode paramType = makeClassSafeWithGenerics(builder, setGenTypes(fields.size()));
  List<Expression> argsList = new ArrayList<Expression>();
  Parameter initParam = param(paramType, "initializer");
  for (FieldNode fieldNode : fields) {
    argsList.add(propX(varX(initParam), fieldNode.getName()));
  }
  return buildee.addConstructor(ACC_PUBLIC, params(param(paramType, "initializer")), NO_EXCEPTIONS, block(ctorThisS(args(argsList))));
}

private static void createNoArgConstructor(ClassNode cNode, int modifiers) {
  Statement body = stmt(ctorX(ClassNode.THIS, args(new MapExpression())));
  ConstructorNode consNode = new ConstructorNode(modifiers, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, body);
  markAsGenerated(cNode, consNode);
  cNode.addConstructor(consNode);
}

/**
 * Add map and no-arg constructor or mirror those of the superclass (i.e. base enum).
 */
private static void addImplicitConstructors(ClassNode enumClass, boolean aic) {
  if (aic) {
    ClassNode sn = enumClass.getSuperClass();
    List<ConstructorNode> sctors = new ArrayList<ConstructorNode>(sn.getDeclaredConstructors());
    if (sctors.isEmpty()) {
      addMapConstructors(enumClass);
    } else {
      for (ConstructorNode constructorNode : sctors) {
        ConstructorNode init = new ConstructorNode(ACC_PUBLIC, constructorNode.getParameters(), ClassNode.EMPTY_ARRAY, new BlockStatement());
        enumClass.addConstructor(init);
      }
    }
  } else {
    addMapConstructors(enumClass);
  }
}

private static void createBuildeeConstructors(BuilderASTTransformation transform, ClassNode buildee, ClassNode builder, List<FieldNode> fields, boolean needsConstructor, boolean useSetters) {
  ConstructorNode initializer = createInitializerConstructor(buildee, builder, fields);
  markAsGenerated(buildee, initializer);
  if (needsConstructor) {
    final BlockStatement body = new BlockStatement();
    body.addStatement(ctorSuperS());
    initializeFields(fields, body, useSetters);
    ConstructorNode helperCons = buildee.addConstructor(ACC_PRIVATE | ACC_SYNTHETIC, getParams(fields, buildee), NO_EXCEPTIONS, body);
    markAsGenerated(buildee, helperCons);
  }
}

  private void createConstructor(final ClassNode classNode) {
    Parameter[] params = new Parameter[]{
        new Parameter(MarkupTemplateEngine.MARKUPTEMPLATEENGINE_CLASSNODE, "engine"),
        new Parameter(ClassHelper.MAP_TYPE.getPlainNodeReference(), "model"),
        new Parameter(ClassHelper.MAP_TYPE.getPlainNodeReference(), "modelTypes"),
        new Parameter(TEMPLATECONFIG_CLASSNODE, "tplConfig")
    };
    List<Expression> vars = new LinkedList<Expression>();
    for (Parameter param : params) {
      vars.add(new VariableExpression(param));
    }
    ExpressionStatement body = new ExpressionStatement(
        new ConstructorCallExpression(ClassNode.SUPER, new ArgumentListExpression(vars)));
    ConstructorNode ctor = new ConstructorNode(Opcodes.ACC_PUBLIC, params, ClassNode.EMPTY_ARRAY, body);
    classNode.addConstructor(ctor);
  }
}

public void testNonLoop() throws Exception {
  ClassNode classNode = new ClassNode("Foo", ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
  classNode.addConstructor(new ConstructorNode(ACC_PUBLIC, null));
  Parameter[] parameters = {new Parameter(ClassHelper.OBJECT_TYPE, "coll")};
  Statement statement = createPrintlnStatement(new VariableExpression("coll"));
  classNode.addMethod(new MethodNode("oneParamDemo", ACC_PUBLIC, ClassHelper.VOID_TYPE, parameters, ClassNode.EMPTY_ARRAY, statement));
  Class fooClass = loadClass(classNode);
  assertTrue("Loaded a new class", fooClass != null);
  Object bean = fooClass.newInstance();
  assertTrue("Managed to create bean", bean != null);
  System.out.println("################ Now about to invoke a method without looping");
  Object value = new Integer(10000);
  try {
    InvokerHelper.invokeMethod(bean, "oneParamDemo", new Object[]{value});
  } catch (InvokerInvocationException e) {
    System.out.println("Caught: " + e.getCause());
    e.getCause().printStackTrace();
    fail("Should not have thrown an exception");
  }
  System.out.println("################ Done");
}

public static void addSpecialMapConstructors(int modifiers, ClassNode cNode, String message, boolean addNoArg) {
  Parameter[] parameters = params(new Parameter(LHMAP_TYPE, "__namedArgs"));
  BlockStatement code = new BlockStatement();
  VariableExpression namedArgs = varX("__namedArgs");
  namedArgs.setAccessedVariable(parameters[0]);
  code.addStatement(ifElseS(equalsNullX(namedArgs),
      illegalArgumentBlock(message),
      processArgsBlock(cNode, namedArgs)));
  ConstructorNode init = new ConstructorNode(modifiers, parameters, ClassNode.EMPTY_ARRAY, code);
  markAsGenerated(cNode, init);
  cNode.addConstructor(init);
  // potentially add a no-arg constructor too
  if (addNoArg) {
    code = new BlockStatement();
    code.addStatement(stmt(ctorX(ClassNode.THIS, ctorX(LHMAP_TYPE))));
    init = new ConstructorNode(modifiers, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, code);
    markAsGenerated(cNode, init);
    cNode.addConstructor(init);
  }
}

public void testLoop() throws Exception {
  ClassNode classNode = new ClassNode("Foo", ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
  classNode.addConstructor(new ConstructorNode(ACC_PUBLIC, null));
  Parameter[] parameters = {new Parameter(ClassHelper.OBJECT_TYPE.makeArray(), "coll")};
  Statement loopStatement = createPrintlnStatement(new VariableExpression("i"));
  ForStatement statement = new ForStatement(new Parameter(ClassHelper.OBJECT_TYPE, "i"), new VariableExpression("coll"), loopStatement);
  classNode.addMethod(new MethodNode("iterateDemo", ACC_PUBLIC, ClassHelper.VOID_TYPE, parameters, ClassNode.EMPTY_ARRAY, statement));
  Class fooClass = loadClass(classNode);
  assertTrue("Loaded a new class", fooClass != null);
  Object bean = fooClass.newInstance();
  assertTrue("Managed to create bean", bean != null);
  System.out.println("################ Now about to invoke a method with looping");
  Object[] array = {new Integer(1234), "abc", "def"};
  try {
    InvokerHelper.invokeMethod(bean, "iterateDemo", new Object[]{array});
  } catch (InvokerInvocationException e) {
    System.out.println("Caught: " + e.getCause());
    e.getCause().printStackTrace();
    fail("Should not have thrown an exception");
  }
  System.out.println("################ Done");
}

public void testManyParam() throws Exception {
  ClassNode classNode = new ClassNode("Foo", ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
  classNode.addConstructor(new ConstructorNode(ACC_PUBLIC, null));

protected void assertIterate(String methodName, Expression listExpression) throws Exception {
  ClassNode classNode = new ClassNode("Foo", ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
  classNode.addConstructor(new ConstructorNode(ACC_PUBLIC, null));
  classNode.addProperty(new PropertyNode("bar", ACC_PUBLIC, ClassHelper.STRING_TYPE, classNode, null, null, null));
  Statement loopStatement = createPrintlnStatement(new VariableExpression("i"));
  BlockStatement block = new BlockStatement();
  block.addStatement(new ExpressionStatement(new DeclarationExpression(new VariableExpression("list"), Token.newSymbol("=", 0, 0), listExpression)));
  block.addStatement(new ForStatement(new Parameter(ClassHelper.DYNAMIC_TYPE, "i"), new VariableExpression("list"), loopStatement));
  classNode.addMethod(new MethodNode(methodName, ACC_PUBLIC, ClassHelper.VOID_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, block));
  Class fooClass = loadClass(classNode);
  assertTrue("Loaded a new class", fooClass != null);
  Object bean = fooClass.newInstance();
  assertTrue("Managed to create bean", bean != null);
  System.out.println("################ Now about to invoke method");
  try {
    InvokerHelper.invokeMethod(bean, methodName, null);
  }
  catch (InvokerInvocationException e) {
    System.out.println("Caught: " + e.getCause());
    e.getCause().printStackTrace();
    fail("Should not have thrown an exception");
  }
  System.out.println("################ Done");
}

public void testMethods() throws Exception {
  ClassNode classNode = new ClassNode("Foo", ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
  classNode.addConstructor(new ConstructorNode(ACC_PUBLIC, null));
  Statement statementA = new ReturnStatement(new ConstantExpression("calledA"));
  Statement statementB = new ReturnStatement(new ConstantExpression("calledB"));
  Statement emptyStatement = new BlockStatement();
  classNode.addMethod(new MethodNode("a", ACC_PUBLIC, ClassHelper.OBJECT_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, statementA));
  classNode.addMethod(new MethodNode("b", ACC_PUBLIC, null, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, statementB));
  classNode.addMethod(new MethodNode("noReturnMethodA", ACC_PUBLIC, null, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, emptyStatement));
  classNode.addMethod(new MethodNode("noReturnMethodB", ACC_PUBLIC, ClassHelper.OBJECT_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, emptyStatement));
  classNode.addMethod(new MethodNode("c", ACC_PUBLIC, ClassHelper.VOID_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, emptyStatement));
  Class fooClass = loadClass(classNode);
  assertTrue("Loaded a new class", fooClass != null);
  Object bean = fooClass.newInstance();
  assertTrue("Created instance of class: " + bean, bean != null);
  assertCallMethod(bean, "a", "calledA");
  assertCallMethod(bean, "b", "calledB");
  assertCallMethod(bean, "noReturnMethodA", null);
  assertCallMethod(bean, "noReturnMethodB", null);
  assertCallMethod(bean, "c", null);
}

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

Reactive rest calls using spring rest template
scheduleAtFixedRate (Timer)
onRequestPermissionsResult (Fragment)
setRequestProperty (URLConnection)
BigDecimal (java.math)
An immutable arbitrary-precision signed decimal.A value is represented by an arbitrary-precision "un
Collection (java.util)
Collection is the root of the collection hierarchy. It defines operations on data collections and t
ThreadPoolExecutor (java.util.concurrent)
An ExecutorService that executes each submitted task using one of possibly several pooled threads, n
Cipher (javax.crypto)
This class provides access to implementations of cryptographic ciphers for encryption and decryption
JList (javax.swing)
Join (org.hibernate.mapping)
PhpStorm for WordPress

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

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

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