congrats Icon
New! Tabnine Pro 14-day free trial
Start a free trial
Tabnine Logo
ClassNode.addConstructor
Code IndexAdd Tabnine to your IDE (free)

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

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

origin: org.codehaus.groovy/groovy

  @Override
  public ConstructorNode addConstructor(final int modifiers, final Parameter[] parameters, final ClassNode[] exceptions, final Statement code) {
    return super.addConstructor(modifiers, parameters, exceptions, code);
  }
}
origin: org.codehaus.groovy/groovy

@Override
public void addConstructor(final ConstructorNode node) {
  super.addConstructor(node);
}
origin: org.codehaus.groovy/groovy

public ConstructorNode addConstructor(int modifiers, Parameter[] parameters, ClassNode[] exceptions, Statement code) {
  ConstructorNode node = new ConstructorNode(modifiers, parameters, exceptions, code);
  addConstructor(node);
  return node;
}
origin: org.codehaus.groovy/groovy

/**
 * 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);
}
origin: org.codehaus.groovy/groovy

/**
 * 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;
}
origin: org.codehaus.groovy/groovy

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

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);
}
origin: org.codehaus.groovy/groovy

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);
}
origin: org.codehaus.groovy/groovy

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);
  }
}
origin: org.codehaus.groovy/groovy

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))));
}
origin: org.codehaus.groovy/groovy

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);
}
origin: org.codehaus.groovy/groovy

/**
 * 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);
  }
}
origin: org.codehaus.groovy/groovy

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);
  }
}
origin: groovy/groovy-core

  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);
  }
}
origin: groovy/groovy-core

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");
}
origin: org.codehaus.groovy/groovy

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);
  }
}
origin: groovy/groovy-core

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");
}
origin: groovy/groovy-core

public void testManyParam() throws Exception {
  ClassNode classNode = new ClassNode("Foo", ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
  classNode.addConstructor(new ConstructorNode(ACC_PUBLIC, null));
origin: groovy/groovy-core

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");
}
origin: groovy/groovy-core

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);
}
org.codehaus.groovy.astClassNodeaddConstructor

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

Popular in Java

  • Start an intent from android
  • orElseThrow (Optional)
    Return the contained value, if present, otherwise throw an exception to be created by the provided s
  • getSystemService (Context)
  • getExternalFilesDir (Context)
  • BufferedInputStream (java.io)
    A BufferedInputStream adds functionality to another input stream-namely, the ability to buffer the i
  • Enumeration (java.util)
    A legacy iteration interface.New code should use Iterator instead. Iterator replaces the enumeration
  • Executor (java.util.concurrent)
    An object that executes submitted Runnable tasks. This interface provides a way of decoupling task s
  • Collectors (java.util.stream)
  • JLabel (javax.swing)
  • FileUtils (org.apache.commons.io)
    General file manipulation utilities. Facilities are provided in the following areas: * writing to a
  • PhpStorm for WordPress
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyStudentsTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now