How to use

addConstructor

method

in

org.codehaus.groovy.ast.ClassNode

  @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);
}