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.
| Modifiers | Name | Description | 
|---|---|---|
static class  | 
                            CompileUnit.ConstructedOuterNestedClassNode | 
                            Represents a resolved type as a placeholder, SEE GROOVY-7812 | 
| Type | Name and description | 
|---|---|
T  | 
                            nodeMetaData | 
                        
Object  | 
                            nodeMetaData | 
                        
| Constructor and description | 
|---|
                                CompileUnit
                                (GroovyClassLoader classLoader, CompilerConfiguration config) | 
                        
                                CompileUnit
                                (GroovyClassLoader classLoader, CodeSource codeSource, CompilerConfiguration config) | 
                        
| Type Params | Return Type | Name 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)@return 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)  | 
                        
 | 
                            GroovyClassLoader | 
                            getClassLoader() | 
                        
 | 
                            List<ClassNode> | 
                            getClasses()@return a list of all the classes in each module in the compilation unit  | 
                        
 | 
                            Map<String, ClassNode> | 
                            getClassesToCompile() | 
                        
 | 
                            Map<String, ConstructedOuterNestedClassNode> | 
                            getClassesToResolve() | 
                        
 | 
                            CodeSource | 
                            getCodeSource() | 
                        
 | 
                            CompilerConfiguration | 
                            getConfig() | 
                        
 | 
                            InnerClassNode | 
                            getGeneratedInnerClass(String name) | 
                        
 | 
                            Map<String, InnerClassNode> | 
                            getGeneratedInnerClasses() | 
                        
 | 
                            ListHashMap | 
                            getMetaDataMap() | 
                        
 | 
                            List<ModuleNode> | 
                            getModules() | 
                        
<T> | 
                            T | 
                            getNodeMetaData(Object key)Gets the node meta data for the provided key.  | 
                        
 | 
                            Map<?, ?> | 
                            getNodeMetaData()Returns an unmodifiable view of the current node metadata.  | 
                        
 | 
                            SourceUnit | 
                            getScriptSourceLocation(String className) | 
                        
 | 
                            boolean | 
                            hasClassNodeToCompile() | 
                        
 | 
                            Iterator<String> | 
                            iterateClassNodeToCompile() | 
                        
 | 
                            Object | 
                            putNodeMetaData(Object key, Object value)Sets the node meta data but allows overwriting values.  | 
                        
 | 
                            void | 
                            removeNodeMetaData(Object key)Removes a node meta data entry.  | 
                        
 | 
                            void | 
                            setNodeMetaData(Object key, Object value)Sets the node meta data for the provided key.  | 
                        
Adds a class to the unit.
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.
Add a constructed class node as a placeholder to resolve outer nested class further.
cn -  the constructed class node
Gets the node meta data for the provided key.
key -  - the meta data keyReturns an unmodifiable view of the current node metadata.
Sets the node meta data but allows overwriting values.
key -    - the meta data keyvalue -  - the meta data valueRemoves a node meta data entry.
key -  - the meta data keyCopyright © 2003-2021 The Apache Software Foundation. All rights reserved.