ClassNode (groovy 2.5.23 API)

org.codehaus.groovy.ast.ClassNode

All Implemented Interfaces and Traits:

org.objectweb.asm.Opcodes
```
public class ClassNode
extends AnnotatedNode
```
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.
See Also:
ClassHelper

Field Summary

Fields
Modifiers	Name	Description
`static ClassNode[]`	`EMPTY_ARRAY`
`static ClassNode`	`SUPER`
`static ClassNode`	`THIS`
`protected Class`	`clazz`
`protected List<InnerClassNode>`	`innerClasses`
`protected boolean`	`isPrimaryNode`
`protected Object`	`lazyInitLock`

Properties Summary

Properties
Type	Name and description
`boolean`	`annotated`
`MethodNode`	`enclosingMethod`
`boolean`	`genericsPlaceHolder`
`GenericsType[]`	`genericsTypes`
`ClassNode[]`	`interfaces`
`int`	`modifiers`
`ModuleNode`	`module`
`String`	`name`
`boolean`	`script`
`boolean`	`scriptBody`
`boolean`	`staticClass`
`ClassNode`	`superClass`
`boolean`	`syntheticPublic`
`ClassNode`	`unresolvedSuperClass`
`boolean`	`usingGenerics`

Methods Summary

Methods
Type Params	Return Type	Name and description
	`def`	`ClassNode(Class c)` Creates a non-primary `ClassNode` from a real class.
	`def`	`ClassNode(String name, int modifiers, ClassNode superClass)` @param name the fully-qualified name of the class
	`def`	`ClassNode(String name, int modifiers, ClassNode superClass, ClassNode[] interfaces, MixinNode[] mixins)` @param name the fully-qualified name of the class
	`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)`
	`GenericsType`	`asGenericsType()`
	`boolean`	`declaresInterface(ClassNode classNode)` @param classNode the class node for the interface
	`boolean`	`equals(Object that)`
	`List<MethodNode>`	`getAbstractMethods()` @return the abstract methods associated with this `ClassNode`
	`List<MethodNode>`	`getAllDeclaredMethods()`
	`Set<ClassNode>`	`getAllInterfaces()`
	`List<AnnotationNode>`	`getAnnotations()`
	`List<AnnotationNode>`	`getAnnotations(ClassNode type)`
	`CompileUnit`	`getCompileUnit()`
	`ClassNode`	`getComponentType()`
	`ConstructorNode`	`getDeclaredConstructor(Parameter[] parameters)` @return the constructor matching the given parameters or `null`
	`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.
	`Map<String, FieldNode>`	`getFieldIndex()`
	`List<FieldNode>`	`getFields()` @return the fields associated with this `ClassNode`
	`GenericsType[]`	`getGenericsTypes()`
	`MethodNode`	`getGetterMethod(String getterName)`
	`MethodNode`	`getGetterMethod(String getterName, boolean searchSuperClasses)`
	`Iterator<InnerClassNode>`	`getInnerClasses()` @return iterator of inner classes defined inside this one
	`ClassNode[]`	`getInterfaces()` @return the array of interfaces which this ClassNode implements
	`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()` @return the methods associated with this `ClassNode`
	`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()` @return the mixins associated with this `ClassNode`
	`int`	`getModifiers()`
	`ModuleNode`	`getModule()`
	`String`	`getName()`
	`String`	`getNameWithoutPackage()`
	`List<Statement>`	`getObjectInitializerStatements()`
	`ClassNode`	`getOuterClass()`
	`List<ClassNode>`	`getOuterClasses()`
	`FieldNode`	`getOuterField(String name)` @return the field on the outer class or `null` if this is not an inner class
	`PackageNode`	`getPackage()`
	`String`	`getPackageName()`
	`ClassNode`	`getPlainNodeReference()`
	`List<PropertyNode>`	`getProperties()`
	`PropertyNode`	`getProperty(String name)`
	`MethodNode`	`getSetterMethod(String setterName)`
	`MethodNode`	`getSetterMethod(String setterName, boolean voidOnly)`
	`ClassNode`	`getSuperClass()` @return the `ClassNode` of the super class of this type
	`String`	`getText()`
	`Map<Class<? extends ASTTransformation>, Set<ASTNode>>`	`getTransforms(CompilePhase phase)`
	`Class`	`getTypeClass()` Returns the concrete class this classnode relates to.
	`ClassNode[]`	`getUnresolvedInterfaces()`
	`ClassNode[]`	`getUnresolvedInterfaces(boolean useRedirect)`
	`String`	`getUnresolvedName()`
	`ClassNode`	`getUnresolvedSuperClass()`
	`ClassNode`	`getUnresolvedSuperClass(boolean useRedirect)`
	`boolean`	`hasDeclaredMethod(String name, Parameter[] parameters)` @see #getDeclaredMethod(String, Parameter[])
	`boolean`	`hasMethod(String name, Parameter[] parameters)` @see #getMethod(String, Parameter[])
	`boolean`	`hasPackageName()`
	`boolean`	`hasPossibleMethod(String name, Expression arguments)` Determines if the type has a possibly-matching instance method with the given name and arguments.
	`boolean`	`hasPossibleStaticMethod(String name, Expression arguments)` Checks if the given method has a possibly matching static method with the given name and arguments.
	`boolean`	`hasProperty(String name)`
	`int`	`hashCode()`
	`boolean`	`implementsInterface(ClassNode classNode)` @param classNode the class node for the interface
	`boolean`	`isAbstract()`
	`boolean`	`isAnnotated()`
	`boolean`	`isAnnotationDefinition()`
	`boolean`	`isArray()`
	`boolean`	`isDerivedFrom(ClassNode type)` @param type the ClassNode of interest
	`boolean`	`isDerivedFromGroovyObject()` @return `true` if this type implements `GroovyObject`
	`boolean`	`isEnum()`
	`boolean`	`isGenericsPlaceHolder()`
	`boolean`	`isInterface()`
	`boolean`	`isPrimaryClassNode()` @return `true` if this instance is a primary `ClassNode`
	`boolean`	`isRedirectNode()`
	`boolean`	`isResolved()`
	`boolean`	`isScript()`
	`boolean`	`isScriptBody()` @return `true` if this inner class or closure was declared inside a script body
	`boolean`	`isStaticClass()` Is this class declared in a static method (such as a closure / inner class declared in a static method)
	`boolean`	`isSyntheticPublic()` Indicates that this class has been "promoted" to public by Groovy when in fact there was no public modifier explicitly in the source code.
	`boolean`	`isUsingGenerics()`
	`ClassNode`	`makeArray()` Returns a `ClassNode` representing an array of the type represented by this.
	`protected boolean`	`parametersEqual(Parameter[] a, Parameter[] b)` @deprecated Returns: `true` if the two arrays are of the same size and have the same contents
	`void`	`positionStmtsAfterEnumInitStmts(List<Statement> staticFieldStatements)`
	`ClassNode`	`redirect()` Returns the `ClassNode` this node is a proxy for or the node itself.
	`void`	`removeConstructor(ConstructorNode node)`
	`void`	`removeField(String oldName)`
	`void`	`removeMethod(MethodNode node)`
	`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`	`setSyntheticPublic(boolean syntheticPublic)`
	`void`	`setUnresolvedSuperClass(ClassNode sn)`
	`void`	`setUsingGenerics(boolean b)`
	`String`	`toString()`
	`String`	`toString(boolean showRedirect)`
	`MethodNode`	`tryFindPossibleMethod(String name, Expression arguments)`
	`void`	`visitContents(GroovyClassVisitor visitor)`

Inherited Methods Summary

Inherited Methods
Methods inherited from class	Name
`class AnnotatedNode`	`addAnnotation, addAnnotations, getAnnotations, getAnnotations, getDeclaringClass, hasNoRealSourcePosition, isSynthetic, setDeclaringClass, setHasNoRealSourcePosition, setSynthetic`
`class ASTNode`	`copyNodeMetaData, getColumnNumber, getLastColumnNumber, getLastLineNumber, getLineNumber, getMetaDataMap, getNodeMetaData, getNodeMetaData, getText, putNodeMetaData, removeNodeMetaData, setColumnNumber, setLastColumnNumber, setLastLineNumber, setLineNumber, setNodeMetaData, setSourcePosition, visit`

- Field Detail
  - public static final ClassNode[] EMPTY_ARRAY
  - public static final ClassNode SUPER
  - public static final ClassNode THIS
  - protected Class clazz
  - protected List<InnerClassNode> innerClasses
  - protected boolean isPrimaryNode
  - protected final Object lazyInitLock
- Property Detail
  - boolean annotated
  - MethodNode enclosingMethod
  - boolean genericsPlaceHolder
  - GenericsType[] genericsTypes
  - ClassNode[] interfaces
  - int modifiers
  - ModuleNode module
  - String name
  - boolean script
  - boolean scriptBody
  - boolean staticClass
  - ClassNode superClass
  - boolean syntheticPublic
  - ClassNode unresolvedSuperClass
  - boolean usingGenerics
- Method Detail
  - public def ClassNode(Class c)
    
    Creates a non-primary ClassNode from a real class.
  - public def ClassNode(String name, int modifiers, ClassNode superClass)
    
    Parameters:
    name - the fully-qualified name of the class
    modifiers - the modifiers; see org.objectweb.asm.Opcodes
    superClass - the base class; use "java.lang.Object" if no direct base class
  - public def ClassNode(String name, int modifiers, ClassNode superClass, ClassNode[] interfaces, MixinNode[] mixins)
    
    Parameters:
    name - the fully-qualified name of the class
    modifiers - the modifiers; see org.objectweb.asm.Opcodes
    superClass - the base class; use "java.lang.Object" if no direct base class
    interfaces - the interfaces for this class
    mixins - the mixins for this class
    See Also:
    org.objectweb.asm.Opcodes
  - public void addConstructor(ConstructorNode node)
  - public ConstructorNode addConstructor(int modifiers, Parameter[] parameters, ClassNode[] exceptions, Statement code)
  - public void addField(FieldNode node)
  - public FieldNode addField(String name, int modifiers, ClassNode type, Expression initialValue)
  - public void addFieldFirst(FieldNode node)
  - public FieldNode addFieldFirst(String name, int modifiers, ClassNode type, Expression initialValue)
  - public void addInterface(ClassNode type)
  - public void addMethod(MethodNode node)
  - 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.
  - public void addMixin(MixinNode mixin)
  - public void addObjectInitializerStatements(Statement statements)
    
    Adds a statement to the object initializer.
    Parameters:
    statements - the statement to be added
  - public void addProperty(PropertyNode node)
  - public PropertyNode addProperty(String name, int modifiers, ClassNode type, Expression initialValueExpression, Statement getterBlock, Statement setterBlock)
  - public void addStaticInitializerStatements(List<Statement> staticStatements, boolean fieldInit)
  - 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.
  - public void addTransform(Class<? extends ASTTransformation> transform, ASTNode node)
  - public GenericsType asGenericsType()
  - 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/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.
  - public boolean equals(Object that)
  - public List<MethodNode> getAbstractMethods()
    
    Returns:
    the abstract methods associated with this ClassNode
  - public List<MethodNode> getAllDeclaredMethods()
  - public Set<ClassNode> getAllInterfaces()
  - public List<AnnotationNode> getAnnotations()
  - public List<AnnotationNode> getAnnotations(ClassNode type)
  - public CompileUnit getCompileUnit()
  - public ClassNode getComponentType()
  - public ConstructorNode getDeclaredConstructor(Parameter[] parameters)
    
    Returns:
    the constructor matching the given parameters or null
  - public List<ConstructorNode> getDeclaredConstructors()
  - 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
  - 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
  - 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)
  - public Map<String, MethodNode> getDeclaredMethodsMap()
  - public MethodNode getEnclosingMethod()
  - 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
  - public Map<String, FieldNode> getFieldIndex()
  - public List<FieldNode> getFields()
    
    Returns:
    the fields associated with this ClassNode
  - public GenericsType[] getGenericsTypes()
  - public MethodNode getGetterMethod(String getterName)
  - public MethodNode getGetterMethod(String getterName, boolean searchSuperClasses)
  - public Iterator<InnerClassNode> getInnerClasses()
    
    Returns:
    iterator of inner classes defined inside this one
  - public ClassNode[] getInterfaces()
    
    Returns:
    the array of interfaces which this ClassNode implements
  - 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
  - public List<MethodNode> getMethods()
    
    Returns:
    the methods associated with this ClassNode
  - 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)
  - public MixinNode[] getMixins()
    
    Returns:
    the mixins associated with this ClassNode
  - public int getModifiers()
  - public ModuleNode getModule()
  - public String getName()
  - public String getNameWithoutPackage()
  - public List<Statement> getObjectInitializerStatements()
  - public ClassNode getOuterClass()
  - public List<ClassNode> getOuterClasses()
  - public FieldNode getOuterField(String name)
    
    Returns:
    the field on the outer class or null if this is not an inner class
  - public PackageNode getPackage()
  - public String getPackageName()
  - public ClassNode getPlainNodeReference()
  - public List<PropertyNode> getProperties()
  - public PropertyNode getProperty(String name)
  - public MethodNode getSetterMethod(String setterName)
  - public MethodNode getSetterMethod(String setterName, boolean voidOnly)
  - public ClassNode getSuperClass()
    
    Returns:
    the ClassNode of the super class of this type
  - @Override public String getText()
  - public Map<Class<? extends ASTTransformation>, Set<ASTNode>> getTransforms(CompilePhase phase)
  - public Class getTypeClass()
    
    Returns the concrete class this classnode relates to. However, this method is inherently unsafe as it may return null depending on the compile phase you are using. AST transformations should never use this method directly, but rather obtain a new class node using getPlainNodeReference().
    Returns:
    the class this classnode relates to. May return null.
  - public ClassNode[] getUnresolvedInterfaces()
  - public ClassNode[] getUnresolvedInterfaces(boolean useRedirect)
  - public String getUnresolvedName()
  - public ClassNode getUnresolvedSuperClass()
  - public ClassNode getUnresolvedSuperClass(boolean useRedirect)
  - public boolean hasDeclaredMethod(String name, Parameter[] parameters)
    
    See Also:
    getDeclaredMethod(String, Parameter[])
  - public boolean hasMethod(String name, Parameter[] parameters)
    
    See Also:
    getMethod(String, Parameter[])
  - public boolean hasPackageName()
  - public boolean hasPossibleMethod(String name, Expression arguments)
    
    Determines if the type 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
  - public boolean hasPossibleStaticMethod(String name, Expression arguments)
    
    Checks 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
  - public boolean hasProperty(String name)
  - public int hashCode()
  - public boolean implementsInterface(ClassNode classNode)
    
    Parameters:
    classNode - the class node for the interface
    Returns:
    true if this type implements the given interface
  - public boolean isAbstract()
  - public boolean isAnnotated()
  - public boolean isAnnotationDefinition()
  - public boolean isArray()
  - public boolean isDerivedFrom(ClassNode type)
    
    Parameters:
    type - the ClassNode of interest
    Returns:
    true if this node is derived from the given ClassNode
  - public boolean isDerivedFromGroovyObject()
    
    Returns:
    true if this type implements GroovyObject
  - public boolean isEnum()
  - public boolean isGenericsPlaceHolder()
  - public boolean isInterface()
  - public boolean isPrimaryClassNode()
    
    Returns:
    true if this instance is a primary ClassNode
  - public boolean isRedirectNode()
  - public boolean isResolved()
  - public boolean isScript()
  - public boolean isScriptBody()
    
    Returns:
    true if this inner class or closure was declared inside a script body
  - public boolean isStaticClass()
    
    Is this class declared in a static method (such as a closure / inner class declared in a static method)
  - public boolean isSyntheticPublic()
    
    Indicates that this class has been "promoted" to public by Groovy when in fact there was no public modifier explicitly in the source code. That is, it remembers that it has applied Groovy's "public classes by default" rule. This property is typically only of interest to AST transform writers.
    Returns:
    true if node is public but had no explicit public modifier
  - public boolean isUsingGenerics()
  - public ClassNode makeArray()
    
    Returns a ClassNode representing an array of the type represented by this.
  - @Deprecated protected boolean parametersEqual(Parameter[] a, Parameter[] b)
    
    deprecated:
    
    Returns:
    true if the two arrays are of the same size and have the same contents
  - public void positionStmtsAfterEnumInitStmts(List<Statement> staticFieldStatements)
  - public ClassNode redirect()
    
    Returns the ClassNode this node is a proxy for or the node itself.
  - public void removeConstructor(ConstructorNode node)
  - public void removeField(String oldName)
  - public void removeMethod(MethodNode node)
  - public void renameField(String oldName, String newName)
  - public void setAnnotated(boolean flag)
    
    Marks if the current class uses annotations or not.
  - protected void setCompileUnit(CompileUnit cu)
  - public void setEnclosingMethod(MethodNode enclosingMethod)
  - public void setGenericsPlaceHolder(boolean b)
  - public void setGenericsTypes(GenericsType[] genericsTypes)
  - public void setInterfaces(ClassNode[] interfaces)
  - public void setModifiers(int modifiers)
  - public void setModule(ModuleNode module)
  - public String setName(String name)
  - public void setRedirect(ClassNode cn)
    
    Sets this instance as proxy for the given ClassNode.
    Parameters:
    node - the class to redirect to; if null the redirect is removed
  - public void setScript(boolean script)
  - public void setScriptBody(boolean scriptBody)
  - public void setStaticClass(boolean staticClass)
  - public void setSuperClass(ClassNode superClass)
    
    Sets the superclass of this ClassNode.
  - public void setSyntheticPublic(boolean syntheticPublic)
  - public void setUnresolvedSuperClass(ClassNode sn)
  - public void setUsingGenerics(boolean b)
  - public String toString()
  - public String toString(boolean showRedirect)
  - public MethodNode tryFindPossibleMethod(String name, Expression arguments)
  - public void visitContents(GroovyClassVisitor visitor)

Summary:
Field
Property
Method

| Detail:
Field
Property
Method

[Java] Class ClassNode

Field Summary

Properties Summary

Methods Summary

Inherited Methods Summary

Field Detail

public static final ClassNode[] EMPTY_ARRAY

public static final ClassNode SUPER

public static final ClassNode THIS

protected Class clazz

protected List<InnerClassNode> innerClasses

protected boolean isPrimaryNode

protected final Object lazyInitLock

Property Detail

boolean annotated

MethodNode enclosingMethod

boolean genericsPlaceHolder

GenericsType[] genericsTypes

ClassNode[] interfaces

int modifiers

ModuleNode module

String name

boolean script

boolean scriptBody

boolean staticClass

ClassNode superClass

boolean syntheticPublic

ClassNode unresolvedSuperClass

boolean usingGenerics

Method Detail

public def ClassNode(Class c)

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

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

public void addConstructor(ConstructorNode node)

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

public void addField(FieldNode node)

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

public void addFieldFirst(FieldNode node)

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

public void addInterface(ClassNode type)

public void addMethod(MethodNode node)

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

public void addMixin(MixinNode mixin)

public void addObjectInitializerStatements(Statement statements)

public void addProperty(PropertyNode node)

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

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

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

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

public GenericsType asGenericsType()

public boolean declaresInterface(ClassNode classNode)

public boolean equals(Object that)

public List<MethodNode> getAbstractMethods()

public List<MethodNode> getAllDeclaredMethods()

public Set<ClassNode> getAllInterfaces()

public List<AnnotationNode> getAnnotations()

public List<AnnotationNode> getAnnotations(ClassNode type)

public CompileUnit getCompileUnit()

public ClassNode getComponentType()

public ConstructorNode getDeclaredConstructor(Parameter[] parameters)

public List<ConstructorNode> getDeclaredConstructors()

public FieldNode getDeclaredField(String name)

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

public List<MethodNode> getDeclaredMethods(String name)

public Map<String, MethodNode> getDeclaredMethodsMap()

public MethodNode getEnclosingMethod()

public FieldNode getField(String name)

public Map<String, FieldNode> getFieldIndex()

public List<FieldNode> getFields()

public GenericsType[] getGenericsTypes()

public MethodNode getGetterMethod(String getterName)

public MethodNode getGetterMethod(String getterName, boolean searchSuperClasses)

public Iterator<InnerClassNode> getInnerClasses()

public ClassNode[] getInterfaces()

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

public List<MethodNode> getMethods()

public List<MethodNode> getMethods(String name)

public MixinNode[] getMixins()

public int getModifiers()

public ModuleNode getModule()