org.codehaus.groovy.ast

## Class CompileUnit

- java.lang.Object
- - org.codehaus.groovy.ast.CompileUnit

- All Implemented Interfaces:
    NodeMetaDataHandler

      public class CompileUnit
      extends Object
      implements NodeMetaDataHandler

  Represents the entire contents of a compilation step which consists of one or more `ModuleNode` instances. There's one instance of this that's shared by all modules and classes compiled during a single invocation of the compiler.

  It's attached to MethodNodes and ClassNodes and is used to find fully qualified names of classes, resolve imports, and that sort of thing.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `CompileUnit.ConstructedOuterNestedClassNode` Represents a resolved type as a placeholder.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `CompileUnit(GroovyClassLoader classLoader, CodeSource codeSource, CompilerConfiguration config)`
    `CompileUnit(GroovyClassLoader classLoader, CompilerConfiguration config)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addClass(ClassNode node)` Adds a class to the unit.
    `void` | `addClassNodeToCompile(ClassNode node, SourceUnit location)` this method actually does not compile a class.
    `void` | `addClassNodeToResolve(CompileUnit.ConstructedOuterNestedClassNode cn)` Add a constructed class node as a placeholder to resolve outer nested class further.
    `void` | `addGeneratedInnerClass(InnerClassNode icn)`
    `void` | `addModule(ModuleNode node)`
    `ClassNode` | `getClass(String name)`
    `List<ClassNode>` | `getClasses()`
    `Map<String,ClassNode>` | `getClassesToCompile()`
    `Map<String,CompileUnit.ConstructedOuterNestedClassNode>` | `getClassesToResolve()`
    `GroovyClassLoader` | `getClassLoader()`
    `CodeSource` | `getCodeSource()`
    `CompilerConfiguration` | `getConfig()`
    `InnerClassNode` | `getGeneratedInnerClass(String name)`
    `Map<String,InnerClassNode>` | `getGeneratedInnerClasses()`
    `Map<?,?>` | `getMetaDataMap()`
    `List<ModuleNode>` | `getModules()`
    `SourceUnit` | `getScriptSourceLocation(String className)`
    `boolean` | `hasClassNodeToCompile()`
    `Iterator<String>` | `iterateClassNodeToCompile()`
    `void` | `setMetaDataMap(Map<?,?> metaDataMap)`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface org.codehaus.groovy.ast.NodeMetaDataHandler

      `copyNodeMetaData, getNodeMetaData, getNodeMetaData, getNodeMetaData, putNodeMetaData, removeNodeMetaData, setNodeMetaData`

- - ### Constructor Detail

    - #### CompileUnit

          public CompileUnit(GroovyClassLoader classLoader,
                             CompilerConfiguration config)

    - #### CompileUnit

          public CompileUnit(GroovyClassLoader classLoader,
                             CodeSource codeSource,
                             CompilerConfiguration config)

  - ### Method Detail

    - #### getModules

          public List<ModuleNode> getModules()

    - #### addModule

          public void addModule(ModuleNode node)

    - #### getClass

          public ClassNode getClass(String name)

      Returns:
        the ClassNode for the given qualified name or returns null if the name does not exist in the current compilation unit (ignoring the .class files on the classpath)

    - #### getClasses

          public List<ClassNode> getClasses()

      Returns:
        a list of all the classes in each module in the compilation unit

    - #### getConfig

          public CompilerConfiguration getConfig()

    - #### getClassLoader

          public GroovyClassLoader getClassLoader()

    - #### getCodeSource

          public CodeSource getCodeSource()

    - #### addClass

          public void addClass(ClassNode node)

      Adds a class to the unit.

    - #### addClassNodeToCompile

          public void addClassNodeToCompile(ClassNode node,
                                            SourceUnit location)

      this method actually does not compile a class. It's only a marker that this type has to be compiled by the CompilationUnit at the end of a parse step no node should be be left.

    - #### getScriptSourceLocation

          public SourceUnit getScriptSourceLocation(String className)

    - #### hasClassNodeToCompile

          public boolean hasClassNodeToCompile()

    - #### iterateClassNodeToCompile

          public Iterator<String> iterateClassNodeToCompile()

    - #### getGeneratedInnerClass

          public InnerClassNode getGeneratedInnerClass(String name)

    - #### addGeneratedInnerClass

          public void addGeneratedInnerClass(InnerClassNode icn)

    - #### getGeneratedInnerClasses

          public Map<String,InnerClassNode> getGeneratedInnerClasses()

    - #### getClassesToCompile

          public Map<String,ClassNode> getClassesToCompile()

    - #### getClassesToResolve

          public Map<String,CompileUnit.ConstructedOuterNestedClassNode> getClassesToResolve()

    - #### addClassNodeToResolve

          public void addClassNodeToResolve(CompileUnit.ConstructedOuterNestedClassNode cn)

      Add a constructed class node as a placeholder to resolve outer nested class further.
      Parameters:
        `cn` - the constructed class node

    - #### getMetaDataMap

          public Map<?,?> getMetaDataMap()

      Specified by:
        `getMetaDataMap` in interface `NodeMetaDataHandler`

    - #### setMetaDataMap

          public void setMetaDataMap(Map<?,?> metaDataMap)

      Specified by:
        `setMetaDataMap` in interface `NodeMetaDataHandler`