Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.codehaus.groovy.ast
Class ClassNode

    java.lang.Object
      org.codehaus.groovy.ast.ASTNode
          org.codehaus.groovy.ast.AnnotatedNode
              org.codehaus.groovy.ast.ClassNode

All Implemented Interfaces:
  org.objectweb.asm.Opcodes

Direct Known Subclasses:
  InnerClassNode, MixinNode

    public class ClassNode
    extends AnnotatedNode
    implements org.objectweb.asm.Opcodes

Represents a class in the AST.
A ClassNode should be created using the methods in ClassHelper. This ClassNode may be used to represent a class declaration or any other type. This class uses a proxy mechanism allowing to create a class for a plain name at AST creation time. In another phase of the compiler the real ClassNode for the plain name may be found. To avoid the need of exchanging this ClassNode with an instance of the correct ClassNode the correct ClassNode is set as redirect. Most method calls are then redirected to that ClassNode.
There are three types of ClassNodes:

1. Primary ClassNodes:
   A primary ClassNode is one where we have a source representation which is to be compiled by Groovy and which we have an AST for. The groovy compiler will output one class for each such ClassNode that passes through AsmBytecodeGenerator... not more, not less. That means for example Closures become such ClassNodes too at some point.
2. ClassNodes create through different sources (typically created from a java.lang.reflect.Class object):
   The compiler will not output classes from these, the methods usually do not contain bodies. These kind of ClassNodes will be used in different checks, but not checks that work on the method bodies. For example if such a ClassNode is a super class to a primary ClassNode, then the abstract method test and others will be done with data based on these. Theoretically it is also possible to mix both (1 and 2) kind of classes in a hierarchy, but this probably works only in the newest Groovy versions. Such ClassNodes normally have to isResolved() returning true without having a redirect.In the Groovy compiler the only version of this, that exists, is a ClassNode created through a Class instance
3. Labels:
   ClassNodes created through ClassHelper.makeWithoutCaching. They are place holders, its redirect points to the real structure, which can be a label too, but following all redirects it should end with a ClassNode from one of the other two categories. If ResolveVisitor finds such a node, it tries to set the redirects. Any such label created after ResolveVisitor has done its work needs to have a redirect pointing to case 1 or 2. If not the compiler may react strange... this can be considered as a kind of dangling pointer.
   Note: the redirect mechanism is only allowed for classes that are not primary ClassNodes. Typically this is done for classes created by name only. The redirect itself can be any type of ClassNode.
   To describe generic type signature see `getGenericsTypes()` and `setGenericsTypes(GenericsType[])`. These methods are not proxied, they describe the type signature used at the point of declaration or the type signatures provided by the class. If the type signatures provided by the class are needed, then a call to `redirect()` will help.

   Version:
     $Revision: 21270 $
   Author:
     James Strachan, Jochen Theodorou
   See Also:
     `ClassHelper`

   Field Summary
   Modifier and Type | Field and Description
   --- | ---
   `protected Class` | `clazz`
   `static ClassNode[]` | `EMPTY_ARRAY`
   `protected List<InnerClassNode>` | `innerClasses`
   `protected boolean` | `isPrimaryNode`
   `protected Object` | `lazyInitLock`
   `static ClassNode` | `SUPER`
   `static ClassNode` | `THIS`

   Fields inherited from interface org.objectweb.asm.Opcodes
   `AALOAD, AASTORE, ACC_ABSTRACT, ACC_ANNOTATION, ACC_BRIDGE, ACC_DEPRECATED, ACC_ENUM, ACC_FINAL, ACC_INTERFACE, ACC_NATIVE, ACC_PRIVATE, ACC_PROTECTED, ACC_PUBLIC, ACC_STATIC, ACC_STRICT, ACC_SUPER, ACC_SYNCHRONIZED, ACC_SYNTHETIC, ACC_TRANSIENT, ACC_VARARGS, ACC_VOLATILE, ACONST_NULL, ALOAD, ANEWARRAY, ARETURN, ARRAYLENGTH, ASTORE, ATHROW, BALOAD, BASTORE, BIPUSH, CALOAD, CASTORE, CHECKCAST, D2F, D2I, D2L, DADD, DALOAD, DASTORE, DCMPG, DCMPL, DCONST_0, DCONST_1, DDIV, DLOAD, DMUL, DNEG, DOUBLE, DREM, DRETURN, DSTORE, DSUB, DUP, DUP_X1, DUP_X2, DUP2, DUP2_X1, DUP2_X2, F_APPEND, F_CHOP, F_FULL, F_NEW, F_SAME, F_SAME1, F2D, F2I, F2L, FADD, FALOAD, FASTORE, FCMPG, FCMPL, FCONST_0, FCONST_1, FCONST_2, FDIV, FLOAD, FLOAT, FMUL, FNEG, FREM, FRETURN, FSTORE, FSUB, GETFIELD, GETSTATIC, GOTO, I2B, I2C, I2D, I2F, I2L, I2S, IADD, IALOAD, IAND, IASTORE, ICONST_0, ICONST_1, ICONST_2, ICONST_3, ICONST_4, ICONST_5, ICONST_M1, IDIV, IF_ACMPEQ, IF_ACMPNE, IF_ICMPEQ, IF_ICMPGE, IF_ICMPGT, IF_ICMPLE, IF_ICMPLT, IF_ICMPNE, IFEQ, IFGE, IFGT, IFLE, IFLT, IFNE, IFNONNULL, IFNULL, IINC, ILOAD, IMUL, INEG, INSTANCEOF, INTEGER, INVOKEDYNAMIC, INVOKEDYNAMIC_OWNER, INVOKEINTERFACE, INVOKESPECIAL, INVOKESTATIC, INVOKEVIRTUAL, IOR, IREM, IRETURN, ISHL, ISHR, ISTORE, ISUB, IUSHR, IXOR, JSR, L2D, L2F, L2I, LADD, LALOAD, LAND, LASTORE, LCMP, LCONST_0, LCONST_1, LDC, LDIV, LLOAD, LMUL, LNEG, LONG, LOOKUPSWITCH, LOR, LREM, LRETURN, LSHL, LSHR, LSTORE, LSUB, LUSHR, LXOR, MONITORENTER, MONITOREXIT, MULTIANEWARRAY, NEW, NEWARRAY, NOP, NULL, POP, POP2, PUTFIELD, PUTSTATIC, RET, RETURN, SALOAD, SASTORE, SIPUSH, SWAP, T_BOOLEAN, T_BYTE, T_CHAR, T_DOUBLE, T_FLOAT, T_INT, T_LONG, T_SHORT, TABLESWITCH, TOP, UNINITIALIZED_THIS, V1_1, V1_2, V1_3, V1_4, V1_5, V1_6, V1_7`

   Constructor Summary
   Constructor and Description
   `ClassNode(Class c)` Creates a ClassNode from a real class.
   `ClassNode(String name, int modifiers, ClassNode superClass)`
   `ClassNode(String name, int modifiers, ClassNode superClass, ClassNode[] interfaces, MixinNode[] mixins)`

   Method Summary
   Modifier and Type | Method and Description
   --- | ---
   `void` | `addConstructor(ConstructorNode node)`
   `ConstructorNode` | `addConstructor(int modifiers, Parameter[] parameters, ClassNode[] exceptions, Statement code)`
   `void` | `addField(FieldNode node)`
   `FieldNode` | `addField(String name, int modifiers, ClassNode type, Expression initialValue)`
   `void` | `addFieldFirst(FieldNode node)`
   `FieldNode` | `addFieldFirst(String name, int modifiers, ClassNode type, Expression initialValue)`
   `void` | `addInterface(ClassNode type)`
   `void` | `addMethod(MethodNode node)`
   `MethodNode` | `addMethod(String name, int modifiers, ClassNode returnType, Parameter[] parameters, ClassNode[] exceptions, Statement code)` If a method with the given name and parameters is already defined then it is returned otherwise the given method is added to this node.
   `void` | `addMixin(MixinNode mixin)`
   `void` | `addObjectInitializerStatements(Statement statements)` Adds a statement to the object initializer.
   `void` | `addProperty(PropertyNode node)`
   `PropertyNode` | `addProperty(String name, int modifiers, ClassNode type, Expression initialValueExpression, Statement getterBlock, Statement setterBlock)`
   `void` | `addStaticInitializerStatements(List<Statement> staticStatements, boolean fieldInit)`
   `MethodNode` | `addSyntheticMethod(String name, int modifiers, ClassNode returnType, Parameter[] parameters, ClassNode[] exceptions, Statement code)` Adds a synthetic method as part of the compilation process
   `void` | `addTransform(Class<? extends ASTTransformation> transform, ASTNode node)`
   `boolean` | `declaresInterface(ClassNode classNode)`
   `boolean` | `equals(Object o)`
   `List<MethodNode>` | `getAbstractMethods()`
   `List<MethodNode>` | `getAllDeclaredMethods()`
   `Set<ClassNode>` | `getAllInterfaces()`
   `List<AnnotationNode>` | `getAnnotations()`
   `List<AnnotationNode>` | `getAnnotations(ClassNode type)`
   `CompileUnit` | `getCompileUnit()`
   `ClassNode` | `getComponentType()`
   `List<ConstructorNode>` | `getDeclaredConstructors()`
   `FieldNode` | `getDeclaredField(String name)` Finds a field matching the given name in this class.
   `MethodNode` | `getDeclaredMethod(String name, Parameter[] parameters)` Finds a method matching the given name and parameters in this class.
   `List<MethodNode>` | `getDeclaredMethods(String name)` This methods returns a list of all methods of the given name defined in the current class
   `Map<String,MethodNode>` | `getDeclaredMethodsMap()`
   `MethodNode` | `getEnclosingMethod()`
   `FieldNode` | `getField(String name)` Finds a field matching the given name in this class or a parent class.
   `List<FieldNode>` | `getFields()`
   `GenericsType[]` | `getGenericsTypes()`
   `MethodNode` | `getGetterMethod(String getterName)`
   `Iterator<InnerClassNode>` | `getInnerClasses()`
   `ClassNode[]` | `getInterfaces()`
   `MethodNode` | `getMethod(String name, Parameter[] parameters)` Finds a method matching the given name and parameters in this class or any parent class.
   `List<MethodNode>` | `getMethods()`
   `List<MethodNode>` | `getMethods(String name)` This methods creates a list of all methods with this name of the current class and of all super classes
   `MixinNode[]` | `getMixins()`
   `int` | `getModifiers()`
   `ModuleNode` | `getModule()`
   `String` | `getName()`
   `String` | `getNameWithoutPackage()`
   `List<Statement>` | `getObjectInitializerStatements()`
   `ClassNode` | `getOuterClass()` Helper method to avoid casting to inner class
   `FieldNode` | `getOuterField(String name)`
   `PackageNode` | `getPackage()`
   `String` | `getPackageName()`
   `ClassNode` | `getPlainNodeReference()`
   `List<PropertyNode>` | `getProperties()`
   `PropertyNode` | `getProperty(String name)`
   `MethodNode` | `getSetterMethod(String setterName)`
   `ClassNode` | `getSuperClass()`
   `Map<Class<? extends ASTTransformation>,Set<ASTNode>>` | `getTransforms(CompilePhase phase)`
   `Class` | `getTypeClass()`
   `ClassNode[]` | `getUnresolvedInterfaces()`
   `ClassNode[]` | `getUnresolvedInterfaces(boolean useRedirect)`
   `String` | `getUnresolvedName()`
   `ClassNode` | `getUnresolvedSuperClass()`
   `ClassNode` | `getUnresolvedSuperClass(boolean useRedirect)`
   `boolean` | `hasDeclaredMethod(String name, Parameter[] parameters)`
   `int` | `hashCode()`
   `boolean` | `hasMethod(String name, Parameter[] parameters)`
   `boolean` | `hasPackageName()`
   `boolean` | `hasPossibleMethod(String name, Expression arguments)` Returns true if the given method has a possibly matching instance method with the given name and arguments.
   `boolean` | `hasPossibleStaticMethod(String name, Expression arguments)` Returns true if the given method has a possibly matching static method with the given name and arguments.
   `boolean` | `hasProperty(String name)`
   `boolean` | `implementsInterface(ClassNode classNode)`
   `boolean` | `isAnnotated()`
   `boolean` | `isAnnotationDefinition()`
   `boolean` | `isArray()`
   `boolean` | `isDerivedFrom(ClassNode type)`
   `boolean` | `isDerivedFromGroovyObject()`
   `boolean` | `isEnum()`
   `boolean` | `isGenericsPlaceHolder()`
   `boolean` | `isInterface()`
   `boolean` | `isPrimaryClassNode()`
   `boolean` | `isResolved()`
   `boolean` | `isScript()`
   `boolean` | `isScriptBody()`
   `boolean` | `isStaticClass()` Is this class declared in a static method (such as a closure / inner class declared in a static method)
   `boolean` | `isUsingGenerics()`
   `ClassNode` | `makeArray()` Returns a ClassNode representing an array of the class represented by this ClassNode
   `protected boolean` | `parametersEqual(Parameter[] a, Parameter[] b)`
   `void` | `positionStmtsAfterEnumInitStmts(List<Statement> staticFieldStatements)`
   `ClassNode` | `redirect()` Returns the ClassNode this ClassNode is redirecting to.
   `void` | `removeField(String oldName)`
   `void` | `renameField(String oldName, String newName)`
   `void` | `setAnnotated(boolean flag)` Marks if the current class uses annotations or not
   `protected void` | `setCompileUnit(CompileUnit cu)`
   `void` | `setEnclosingMethod(MethodNode enclosingMethod)`
   `void` | `setGenericsPlaceHolder(boolean b)`
   `void` | `setGenericsTypes(GenericsType[] genericsTypes)`
   `void` | `setInterfaces(ClassNode[] interfaces)`
   `void` | `setModifiers(int modifiers)`
   `void` | `setModule(ModuleNode module)`
   `String` | `setName(String name)`
   `void` | `setRedirect(ClassNode cn)` Sets this instance as proxy for the given ClassNode.
   `void` | `setScript(boolean script)`
   `void` | `setScriptBody(boolean scriptBody)`
   `void` | `setStaticClass(boolean staticClass)`
   `void` | `setSuperClass(ClassNode superClass)` Sets the superclass of this ClassNode
   `void` | `setUnresolvedSuperClass(ClassNode sn)`
   `void` | `setUsingGenerics(boolean b)`
   `String` | `toString()`
   `MethodNode` | `tryFindPossibleMethod(String name, Expression arguments)`
   `void` | `visitContents(GroovyClassVisitor visitor)`

   Methods inherited from class org.codehaus.groovy.ast.AnnotatedNode
   `addAnnotation, addAnnotations, getDeclaringClass, hasNoRealSourcePosition, isSynthetic, setDeclaringClass, setHasNoRealSourcePosition, setSynthetic`

   Methods inherited from class org.codehaus.groovy.ast.ASTNode
   `copyNodeMetaData, getColumnNumber, getLastColumnNumber, getLastLineNumber, getLineNumber, getNodeMetaData, getText, removeNodeMetaData, setColumnNumber, setLastColumnNumber, setLastLineNumber, setLineNumber, setNodeMetaData, setSourcePosition, visit`

   Methods inherited from class java.lang.Object
   `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

   Field Detail

   ### EMPTY_ARRAY

       public static final ClassNode[] EMPTY_ARRAY

   ### THIS

       public static final ClassNode THIS

   ### SUPER

       public static final ClassNode SUPER

   ### isPrimaryNode

       protected boolean isPrimaryNode

   ### innerClasses

       protected List<InnerClassNode> innerClasses

   ### lazyInitLock

       protected Object lazyInitLock

   ### clazz

       protected Class clazz

   Constructor Detail

   ### ClassNode

       public ClassNode(Class c)

     Creates a ClassNode from a real class. The resulting ClassNode will not be a primary ClassNode.

   ### ClassNode

       public ClassNode(String name,
                        int modifiers,
                        ClassNode superClass)

     Parameters:
       `name` - is the full name of the class
       `modifiers` - the modifiers,
       `superClass` - the base class name - use "java.lang.Object" if no direct base class
     See Also:
       `Opcodes`

   ### ClassNode

       public ClassNode(String name,
                        int modifiers,
                        ClassNode superClass,
                        ClassNode[] interfaces,
                        MixinNode[] mixins)

     Parameters:
       `name` - is the full name of the class
       `modifiers` - the modifiers,
       `superClass` - the base class name - use "java.lang.Object" if no direct base class
       `interfaces` - the interfaces for this class
       `mixins` - the mixins for this class
     See Also:
       `Opcodes`

   Method Detail

   ### redirect

       public ClassNode redirect()

     Returns the ClassNode this ClassNode is redirecting to.

   ### setRedirect

       public void setRedirect(ClassNode cn)

     Sets this instance as proxy for the given ClassNode.

     Parameters:
       `cn` - the class to redirect to. If set to null the redirect will be removed

   ### makeArray

       public ClassNode makeArray()

     Returns a ClassNode representing an array of the class represented by this ClassNode

   ### isPrimaryClassNode

       public boolean isPrimaryClassNode()

     Returns:
       true if this instance is a primary ClassNode

   ### getEnclosingMethod

       public MethodNode getEnclosingMethod()

   ### setEnclosingMethod

       public void setEnclosingMethod(MethodNode enclosingMethod)

   ### setSuperClass

       public void setSuperClass(ClassNode superClass)

     Sets the superclass of this ClassNode

   ### getFields

       public List<FieldNode> getFields()

     Returns:
       the list of FieldNode's associated with this ClassNode

   ### getInterfaces

       public ClassNode[] getInterfaces()

     Returns:
       the array of interfaces which this ClassNode implements

   ### setInterfaces

       public void setInterfaces(ClassNode[] interfaces)

   ### getMixins

       public MixinNode[] getMixins()

     Returns:
       the array of mixins associated with this ClassNode

   ### getMethods

       public List<MethodNode> getMethods()

     Returns:
       the list of methods associated with this ClassNode

   ### getAbstractMethods

       public List<MethodNode> getAbstractMethods()

     Returns:
       the list of abstract methods associated with this ClassNode or null if there are no such methods

   ### getAllDeclaredMethods

       public List<MethodNode> getAllDeclaredMethods()

   ### getAllInterfaces

       public Set<ClassNode> getAllInterfaces()

   ### getDeclaredMethodsMap

       public Map<String,MethodNode> getDeclaredMethodsMap()

   ### getName

       public String getName()

   ### getUnresolvedName

       public String getUnresolvedName()

   ### setName

       public String setName(String name)

   ### getModifiers

       public int getModifiers()

   ### setModifiers

       public void setModifiers(int modifiers)

   ### getProperties

       public List<PropertyNode> getProperties()

   ### getDeclaredConstructors

       public List<ConstructorNode> getDeclaredConstructors()

   ### getModule

       public ModuleNode getModule()

   ### getPackage

       public PackageNode getPackage()

   ### setModule

       public void setModule(ModuleNode module)

   ### addField

       public void addField(FieldNode node)

   ### addFieldFirst

       public void addFieldFirst(FieldNode node)

   ### addProperty

       public void addProperty(PropertyNode node)

   ### addProperty

       public PropertyNode addProperty(String name,
                                       int modifiers,
                                       ClassNode type,
                                       Expression initialValueExpression,
                                       Statement getterBlock,
                                       Statement setterBlock)

   ### hasProperty

       public boolean hasProperty(String name)

   ### getProperty

       public PropertyNode getProperty(String name)

   ### addConstructor

       public void addConstructor(ConstructorNode node)

   ### addConstructor

       public ConstructorNode addConstructor(int modifiers,
                                             Parameter[] parameters,
                                             ClassNode[] exceptions,
                                             Statement code)

   ### addMethod

       public void addMethod(MethodNode node)

   ### addMethod

       public MethodNode addMethod(String name,
                                   int modifiers,
                                   ClassNode returnType,
                                   Parameter[] parameters,
                                   ClassNode[] exceptions,
                                   Statement code)

     If a method with the given name and parameters is already defined then it is returned otherwise the given method is added to this node. This method is useful for default method adding like getProperty() or invokeMethod() where there may already be a method defined in a class and so the default implementations should not be added if already present.

   ### hasDeclaredMethod

       public boolean hasDeclaredMethod(String name,
                                        Parameter[] parameters)

     See Also:
       `getDeclaredMethod(String, Parameter[])`

   ### hasMethod

       public boolean hasMethod(String name,
                                Parameter[] parameters)

     See Also:
       `getMethod(String, Parameter[])`

   ### addSyntheticMethod

       public MethodNode addSyntheticMethod(String name,
                                            int modifiers,
                                            ClassNode returnType,
                                            Parameter[] parameters,
                                            ClassNode[] exceptions,
                                            Statement code)

     Adds a synthetic method as part of the compilation process

   ### addField

       public FieldNode addField(String name,
                                 int modifiers,
                                 ClassNode type,
                                 Expression initialValue)

   ### addFieldFirst

       public FieldNode addFieldFirst(String name,
                                      int modifiers,
                                      ClassNode type,
                                      Expression initialValue)

   ### addInterface

       public void addInterface(ClassNode type)

   ### equals

       public boolean equals(Object o)

     Overrides:
       `equals` in class `Object`

   ### hashCode

       public int hashCode()

     Overrides:
       `hashCode` in class `Object`

   ### addMixin

       public void addMixin(MixinNode mixin)

   ### getDeclaredField

       public FieldNode getDeclaredField(String name)

     Finds a field matching the given name in this class.

     Parameters:
       `name` - the name of the field of interest
     Returns:
       the method matching the given name and parameters or null

   ### getField

       public FieldNode getField(String name)

     Finds a field matching the given name in this class or a parent class.

     Parameters:
       `name` - the name of the field of interest
     Returns:
       the method matching the given name and parameters or null

   ### getOuterField

       public FieldNode getOuterField(String name)

     Returns:
       the field node on the outer class or null if this is not an inner class

   ### getOuterClass

       public ClassNode getOuterClass()

     Helper method to avoid casting to inner class

   ### addObjectInitializerStatements

       public void addObjectInitializerStatements(Statement statements)

     Adds a statement to the object initializer.

     Parameters:
       `statements` - the statement to be added

   ### getObjectInitializerStatements

       public List<Statement> getObjectInitializerStatements()

   ### addStaticInitializerStatements

       public void addStaticInitializerStatements(List<Statement> staticStatements,
                                                  boolean fieldInit)

   ### positionStmtsAfterEnumInitStmts

       public void positionStmtsAfterEnumInitStmts(List<Statement> staticFieldStatements)

   ### getDeclaredMethods

       public List<MethodNode> getDeclaredMethods(String name)

     This methods returns a list of all methods of the given name defined in the current class

     Returns:
       the method list
     See Also:
       `getMethods(String)`

   ### getMethods

       public List<MethodNode> getMethods(String name)

     This methods creates a list of all methods with this name of the current class and of all super classes

     Returns:
       the methods list
     See Also:
       `getDeclaredMethods(String)`

   ### getDeclaredMethod

       public MethodNode getDeclaredMethod(String name,
                                           Parameter[] parameters)

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

     Returns:
       the method matching the given name and parameters or null

   ### getMethod

       public MethodNode getMethod(String name,
                                   Parameter[] parameters)

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

     Returns:
       the method matching the given name and parameters or null

   ### isDerivedFrom

       public boolean isDerivedFrom(ClassNode type)

     Parameters:
       `type` - the ClassNode of interest
     Returns:
       true if this node is derived from the given ClassNode

   ### isDerivedFromGroovyObject

       public boolean isDerivedFromGroovyObject()

     Returns:
       true if this class is derived from a groovy object i.e. it implements GroovyObject

   ### implementsInterface

       public boolean implementsInterface(ClassNode classNode)

     Parameters:
       `classNode` - the class node for the interface
     Returns:
       true if this class or any base class implements the given interface

   ### declaresInterface

       public boolean declaresInterface(ClassNode classNode)

     Parameters:
       `classNode` - the class node for the interface
     Returns:
       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.

   ### getSuperClass

       public ClassNode getSuperClass()

     Returns:
       the ClassNode of the super class of this type

   ### getUnresolvedSuperClass

       public ClassNode getUnresolvedSuperClass()

   ### getUnresolvedSuperClass

       public ClassNode getUnresolvedSuperClass(boolean useRedirect)

   ### setUnresolvedSuperClass

       public void setUnresolvedSuperClass(ClassNode sn)

   ### getUnresolvedInterfaces

       public ClassNode[] getUnresolvedInterfaces()

   ### getUnresolvedInterfaces

       public ClassNode[] getUnresolvedInterfaces(boolean useRedirect)

   ### getCompileUnit

       public CompileUnit getCompileUnit()

   ### setCompileUnit

       protected void setCompileUnit(CompileUnit cu)

   ### parametersEqual

       protected boolean parametersEqual(Parameter[] a,
                                         Parameter[] b)

     Returns:
       true if the two arrays are of the same size and have the same contents

   ### getPackageName

       public String getPackageName()

     Returns:
       the package name of this class

   ### getNameWithoutPackage

       public String getNameWithoutPackage()

   ### visitContents

       public void visitContents(GroovyClassVisitor visitor)

   ### getGetterMethod

       public MethodNode getGetterMethod(String getterName)

   ### getSetterMethod

       public MethodNode getSetterMethod(String setterName)

   ### isStaticClass

       public boolean isStaticClass()

     Is this class declared in a static method (such as a closure / inner class declared in a static method)

   ### setStaticClass

       public void setStaticClass(boolean staticClass)

   ### isScriptBody

       public boolean isScriptBody()

     Returns:
       Returns true if this inner class or closure was declared inside a script body

   ### setScriptBody

       public void setScriptBody(boolean scriptBody)

   ### isScript

       public boolean isScript()

   ### setScript

       public void setScript(boolean script)

   ### toString

       public String toString()

     Overrides:
       `toString` in class `Object`

   ### hasPossibleMethod

       public boolean hasPossibleMethod(String name,
                                        Expression arguments)

     Returns true if the given method has a possibly matching instance method with the given name and arguments.

     Parameters:
       `name` - the name of the method of interest
       `arguments` - the arguments to match against
     Returns:
       true if a matching method was found

   ### tryFindPossibleMethod

       public MethodNode tryFindPossibleMethod(String name,
                                               Expression arguments)

   ### hasPossibleStaticMethod

       public boolean hasPossibleStaticMethod(String name,
                                              Expression arguments)

     Returns true if the given method has a possibly matching static method with the given name and arguments.

     Parameters:
       `name` - the name of the method of interest
       `arguments` - the arguments to match against
     Returns:
       true if a matching method was found

   ### isInterface

       public boolean isInterface()

   ### isResolved

       public boolean isResolved()

   ### isArray

       public boolean isArray()

   ### getComponentType

       public ClassNode getComponentType()

   ### getTypeClass

       public Class getTypeClass()

   ### hasPackageName

       public boolean hasPackageName()

   ### setAnnotated

       public void setAnnotated(boolean flag)

     Marks if the current class uses annotations or not

     Parameters:
       `flag` -

   ### isAnnotated

       public boolean isAnnotated()

   ### getGenericsTypes

       public GenericsType[] getGenericsTypes()

   ### setGenericsTypes

       public void setGenericsTypes(GenericsType[] genericsTypes)

   ### setGenericsPlaceHolder

       public void setGenericsPlaceHolder(boolean b)

   ### isGenericsPlaceHolder

       public boolean isGenericsPlaceHolder()

   ### isUsingGenerics

       public boolean isUsingGenerics()

   ### setUsingGenerics

       public void setUsingGenerics(boolean b)

   ### getPlainNodeReference

       public ClassNode getPlainNodeReference()

   ### isAnnotationDefinition

       public boolean isAnnotationDefinition()

   ### getAnnotations

       public List<AnnotationNode> getAnnotations()

     Overrides:
       `getAnnotations` in class `AnnotatedNode`

   ### getAnnotations

       public List<AnnotationNode> getAnnotations(ClassNode type)

     Overrides:
       `getAnnotations` in class `AnnotatedNode`

   ### addTransform

       public void addTransform(Class<? extends ASTTransformation> transform,
                                ASTNode node)

   ### getTransforms

       public Map<Class<? extends ASTTransformation>,Set<ASTNode>> getTransforms(CompilePhase phase)

   ### renameField

       public void renameField(String oldName,
                               String newName)

   ### removeField

       public void removeField(String oldName)

   ### isEnum

       public boolean isEnum()

   ### getInnerClasses

       public Iterator<InnerClassNode> getInnerClasses()

     Returns:
       iterator of inner classes defined inside this one

   Overview | Package | Class | Tree | Deprecated | Index | Help
   | Copyright © 2003-2010 The Codehaus. All rights reserved.
   PREV CLASS NEXT CLASS | FRAMES NO FRAMES
   SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD