All Classes and Interfaces

Class
Description
 
 
 
Base class for all call sites
 
 
 
 
 
 
 
 
 
A base class dealing with common HTTP servlet API housekeeping aspects.
Base class for AST Transformations which will automatically throw an InterruptedException when some conditions are met.
For ReaderSources that can choose a parent class, a base that provides common functionality.
Created by IntelliJ IDEA.
An interface for MetaClass instances that "adapt" other MetaClass instances such as a proxy or delegating MetaClass.
An aggregation of multiple bindings
AllTestSuite can be used in extension of GroovyTestSuite to execute TestCases written in Groovy from inside a Java IDE.
Base class for any AST node which is capable of being annotated
Represents an annotation "constant" that may appear in annotation attributes (mainly used as a marker).
Represents an annotation which can be attached to interfaces, classes, methods and fields.
An Annotation visitor responsible with: - reading annotation metadata (@Retention, @Target, attribute types) - verify that an AnnotationNode conforms to annotation meta - enhancing an AnnotationNode AST to reflect real annotation meta
Allows Ant tasks to be used with a Groovy builder-style markup.
An interface for processing antlr AST objects
 
A parser plugin which adapts the JSR Antlr Parser to the Groovy runtime
 
 
Represents one or more arguments being passed into a method
 
 
Represents an array object construction either using a fixed size or an initializer expression
 
 
 
This is a generated class used internally during the writing of bytecode within the CallSiteWriter logic.
Generates Java class versions of Groovy classes using ASM.
Creates a string representation of an assertion and its recorded values.
 
Represents an assert statement such as assert i != 0 : "should never be zero";
Transformation to capture ASTBuilder from code statements.
A common base class of AST helper methods which can be shared across the classic and new parsers
Base class for any AST node.
Thrown when trying to parse the AST
 
Helper class for converting AST into text.
This class is instantiated and invoked when an AST transformation is activated.
This visitor walks the AST tree and collects references to Annotations that are annotated themselves by GroovyASTTransformation.
This class handles the invocation of the ASTAnnotationTransformation when it is encountered by a tree walk.
Lazy evaluated representation of a node attribute.
Represents an attribute access (accessing the field of a class) such as the expression "foo.@bar".
Note: This annotation is currently experimental! Use at your own risk!
Handles generation of code for the @AutoClone annotation.
Intended style to use for cloning when using the @AutoClone annotation.
Note: This annotation is currently experimental! Use at your own risk!
Handles generation of code for the @AutoExternalize annotation.
Base class for date and time durations.
 
 
Class which delegates to a PreparedStatement but keeps track of a batch count size.
Class which delegates to a Statement but keeps track of a batch count size.
Interceptor that registers the timestamp of each method call before and after invocation.
 
BigDecimal NumberMath operations
 
BigInteger NumberMath operations
 
 
Represents two expressions and an operation
 
This class is for internal use only! This class will dispatch to the right type adapters according to the kind of binary expression that is provided.
 
 
 
 
 
Annotates a groovy property or a class.
Handles generation of code for the @Bindable annotation when @Vetoable is not present.
Represents the variable bindings of a script which can be altered from outside the script object or created outside of a script and passed into it.
This class returns half bound FullBindings on the source half to the model object for every property reference (and I do mean every, valid or not, queried before or not).
 
The bind path object.
 
A list of statements and a scope.
 
 
 
Helper class for internal use only.
Represents a boolean expression
Helper class for internal use only.
 
Represents a break statement in a switch or loop statement
 
 
 
An abstract base class for creating arbitrary nested trees of objects or events
 
 
 
Represents some custom bytecode generation by the compiler
A helper class for bytecode generation with AsmClassGenerator.
Helper class used by the class generator.
This class contains methods special to optimizations used directly from bytecode in Groovy 1.8
This class represents a sequence of BytecodeInstructions or ASTNodes.
Represents compile time variable metadata while compiling a method.
 
 
 
 
 
 
 
 
A Caching implementation of the GroovyEngine
 
 
 
 
 
This class represents non public API used by AsmClassGenerator.
Class annotation used to assist in the creation of mutable classes.
Handles generation of code for the @Canonical annotation.
Represents a case statement in a switch statement
Represents a type cast expression
Represents a catch (Exception var) { } statement
Transforms an instance-style Groovy class or interface to become a static-style conventional Groovy category.
Handles generation of code for the @Category annotation.
 
 
 
Utility class to guess the encoding of a given text file.
 
Visitor to transform expressions in a whole class.
 
ClassCompletionVerifier
Represents access to a Java/Groovy class in an expression, such as when invoking a static method or accessing a static type
A helper class used by the runtime to allow Groovy classes to be extended at runtime
Abstract base class for generator of Java class versions of Groovy AST classes
An exception thrown by the class generator
This class is a Helper for ClassNode and classes handling ClassNodes.
Handle for all information we want to keep about the class
 
 
Represents a class in the AST.
A ClassNode should be created using the methods in ClassHelper.
This class is used as a plugable way to resolve class names.
Helper class to return either a SourceUnit or ClassNode.
 
Represents any closure object in Groovy.
A Comparator which uses a closure to compare 2 values being equal
An exception thrown by a closure invocation
Represents a closure expression such as { statement } or { i -> statement } or { i, x, String y -> statement }
An interface for MetaMethods that invoke closures to implements.
This class represents a list of expressions used to create closures.
A meta class for closures generated by the Groovy compiler.
A MetaMethod that accepts a closure in the constructor which is invoked when the MetaMethod is called.
Represents a value model using a closure to extract the value from some source model and an optional write closure for updating the value.
 
 
This class represents a MetaMethod that is a closure that pretends to be a static method.
 
 
 
Abstract base class for any GroovyCodeVisitor which by default just walks the code and expression tree
Provides the interface required for command extensions.
Thrown to indicate a problem with command execution.
This local transform adds a logging ability to your program using Apache Commons logging.
 
Users wanting to customize the configuration process such as adding imports, restricting the language features or apply AST transformations by default should implement this class, then call the CompilerConfiguration.addCompilationCustomizers(CompilationCustomizer...) method.
Thrown when compilation fails from source errors.
The CompilationUnit collects all compilation data as it is generated by the compiler system.
A callback interface you can use to "accompany" the classgen() code as it traverses the ClassNode tree.
 
An callback interface for use in the applyToSourceUnits loop driver.
A callback interface you can use to get a callback after every unit of the compile process.
An callback interface for use in the applyToSourceUnits loop driver.
The phases of the GroovyCompiler.
A convenience front end for getting standard compilations done.
Compilation control flags and coordination stuff.
This class is a helper for AsmClassGenerator.
 
 
Support for compilation related tasks.
Represents the entire contents of a compilation step which consists of one or more ModuleNode instances.
 
 
 
Deprecated.
This interface is no longer used internally and there exists no equivalent functionality Superceded by FactoryBuilderSupport handling.
A wrapper for Closure to support composition.
A composite of many visitors.
A hash table that supports mostly-concurrent reading, but exclusive writing.
A Serializable class for barrier lock
ConcurrentReaderHashMap collision list entry.
A ConfigObject at a simple level is a Map that creates configuration entries (other ConfigObjects) when referencing them.
Thrown when configuration data is invalid.
Base class for console
Component which provides a styled editor for the console.
Represents a constant expression such as null, true, false
A constructor call
 
Call site for invoking static methods meta class - cached method - not cached
Represents a constructor declaration
 
Call site where we know there is no need to unwrap arguments
Call site where we know there is no need neither unwrap nor coerce arguments
 
 
Deprecated.
This interface is no longer used internally and there exists no equivalent functionality Superceded by FactoryBuilderSupport handling.
Represents a continue statement in a loop statement
This class is a general adapter to map a call to a Java interface to a given delegate.
This class is a general adapter to adapt a closure to any Java interface.
This class is a general adapter to adapt a map of closures to any Java interface.
An abstract base class for nodes in the concrete syntax tree that is the result of parsing.
A wrapper for Closure to support currying.
An enhancement of Groovy's Sql class providing support for accessing and querying databases using POGO fields and operators rather than JDBC-level API calls and RDBMS column names.
This class defines new groovy methods which appear on normal JDK Date and Calendar classes inside the Groovy environment.
DatumDependentDuration represents durations whose length in milliseconds cannot be determined without knowing the datum point.
Represents one or more local variables.
A default action implementation
A default implementation of MethodKey
This class defines new groovy methods which appear on normal JDK classes inside the Groovy environment.
Support methods for DefaultGroovyMethods and PluginDefaultMethods.
 
This class defines all the new static groovy methods which appear on normal JDK classes inside the Groovy environment.
WARNING: This class is for internal use only! We use this class to store information about if a default MetaClass is used for certain primitives.
A default implementation of MethodKey
 
 
 
Represents a column using a ValueModel to extract the value.
A default table model made up of PropertyModels on a Value model.
 
Class providing various type conversions, coercions and boxing/unboxing operations.
Field annotation to automatically delegate part of the functionality of an owner class to the annotated field.
Handles generation of code for the @Delegate annotation
 
 
Use this exception to mark a method implementation as being deprecated.
 
A helper class for creating a W3C DOM tree
Category class which adds GPath style operations to Java's DOM classes.
A SAX handler for turning XML into Groovy scripts
 
 
 
 
 
 
Represents a do { ...
 
To generate a class that has all the fields and methods, except that fields are not initialized and methods are empty.
Duration represents time periods which have values independent of the context.
 
Represents a short ternary expression x ?: y, which is equal to
This class is a place holder for an empty expression.
Constructing Ranges like 0..<0
Represents an empty statement
A buffered writer only for OutputStreamWriter that is aware of the encoding of the OutputStreamWriter.
This class defines all the encoding/decoding groovy methods which enhance the normal JDK classes when inside the Groovy environment.
Keep this constant in a separate file as it is troublesome for Antlr to parse for doc purposes.
Enums have a parent constructor with two arguments from java.lang.Enum.
Represents the anonymous inner class for an enum constant This subtype is needed so that EnumVisitor can differentiate between the scenarios when a InnerClassNode represents anonymous inner class for an enu constant and when it represents an enum class defined inside another class
 
 
Class annotation used to assist in creating appropriate equals() and hashCode() methods.
 
A base class for collecting messages and errors during processing.
Provides services for reporting compilation errors to the user.
Allow easy integration from Groovy into Java through convenience methods.
 
A class for error messages produced by the parser system.
Identifies a variable to be expanded into the sql string rather than representing a placeholder.
Represents a dynamically expandable bean.
ExpandoMetaClass is a MetaClass that behaves like an Expando, allowing the addition or replacement of methods, properties and constructors on the fly.
A handle for the MetaClassRegistry that changes all classes loaded into the Grails VM to use ExpandoMetaClass instances
Represents a base class for expressions which evaluate as an object
A simple statement such as a method call where the return value is ignored
Provides a way to transform expressions
A specialized Groovy AST visitor meant to perform additional verifications upon the current AST.
Represents a class not in the codebase being processed.
 
Mix of BuilderSupport and SwingBuilder's factory support.
Support class for creating XML Factories
 
Variable annotation used for changing the scope of a variable within a script from being within the run method of the script to being at the class level for the script.
Handles transformation for the @Field annotation.
Represents a field access such as the expression "this.foo".
Represents a field (member variable)
FileIterator is an iterator over a number of files from a collection of FileSet instances.
 
A ReaderSource for source files.
FileScanner is a bean which allows the iteration over a number of files from a collection of FileSet instances.
Command-line compiler (aka.
This is a helper class, to provide a controlled entry point for the groovyc ant task forked mode.
 
Represents particular files of interest.
Represents special return values for the 'preDir', 'postDir' and 'visit'/supplied Closures used with DefaultGroovyMethods.traverse(java.io.File, java.util.Map, groovy.lang.Closure) and related methods to control subsequent traversal behavior.
Lazy evaluated representation of a node's attributes filtered by a Closure.
Lazy evaluated representation of child nodes filtered by a Closure.
 
 
A simple iterator over an ordered (flat) List of the nodes of the AST.
 
 
 
FloatingPoint (Double and Float) NumberMath operations
 
Stream writer which flushes after each write operation.
Represents a number of field models which can be ValueModel, PropertyModel, TableModel, TreeModel or nested FormModel instances
Represents a standard for loop in Groovy
 
Marker interface to identify closures generated by the groovy compiler.
 
 
 
Generates Java stubs from Groovy sources.
A context shared across generations of a class and its inner classes
This class is used to describe generic type signatures for ClassNodes.
class used to verify correct usage of generics in class header (class and superclass declaration)
 
 
Base class for representing lazy evaluated GPath expressions.
Used to grab the referenced artifact and its dependencies and make it available on the Classpath.
Transformation for declarative dependency management.
Used to modify the grape configuration for grab requests.
Used to exclude an indirectly referenced artifact from the classpath.
Used to add a repository for resolving Grape dependencies.
Facade to GrapeEngine.
 
Sometimes we will need more than one grab per class, but we can only add one annotation type per annotatable node.
 
Executes a series of Groovy statements.
 
This is an annotation on a class, currently just ASTTransformation.
This is an annotation on some item that indicates that an associated transform classes should be executed.
This class represents an error that is thrown when a bug is recognized inside the runtime.
Compiles Groovy source files.
A special "marker" style interface allowing Groovy classes to implement both Runnable and Callable yet give preference to Runnable (for backwards compatibility) for APIs having both Runnable and Callable methods.
 
 
 
 
 
 
A ClassLoader which can load Groovy classes.
 
 
A special visitor for working with the structure of a class.
CodeSource wrapper class that allows specific security policies to be associated with a class compiled from groovy source.
Permission required to explicitly specify a codebase for a groovy script whose codebase cannot be determined.
An implementation of the visitor pattern for working with ASTNodes
A Collections utility class
Used to represent compiled Groovy scripts.
 
Compiles Groovy source files.
Access to the GroovyDoc tool from Ant.
 
 
Process Groovydoc templates.
 
 
Write GroovyDoc resources to destination.
A BSF Engine for the Groovy scripting language.
 
An interface for use by all Groovy compiler exceptions.
 
 
 
Marker interface used to notify that all methods should be intercepted through the invokeMethod mechanism of GroovyObject.
 
Deprecated.
A Command line to execute groovy.
A GroovyObject facade for an underlying MBean which acts like a normal groovy object but which is actually implemented via an underlying JMX MBean.
 
 
The interface implemented by all Groovy objects.
A useful base class for Java objects wishing to be Groovy objects
 
 
 
A PrintStream that outputs objects in Groovy style.
A PrintWriter that outputs objects in Groovy style.
 
JSR-241 Groovy Recognizer.
Allows frameworks that integrate with Groovy to determine how Groovy files are resolved.
Represents an extent of objects
GroovyResultSetExtension implements additional logic for ResultSet.
GroovyResultSetProxy is used to create a proxy for GroovyResultSet.
 
 
Represents an extent of objects.
An exception thrown by the interpreter
Specific script engine able to reload modified scripts as well as dealing properly with dependent scripts.
A factory class conforming to JSR-223 which is used to instantiate Groovy ScriptEngines and also exposes metadata describing Groovy's engine class.
 
This servlet will run Groovy scripts as Groovlets.
Represents a groovy shell capable of running arbitrary groovy scripts
Simple server that executes supplied script against a socket.
We have an AST subclass so we can track source information.
This is a Token sub class to track line information
Helper class to help classworlds to load classes.
 
 
 
A default JUnit TestCase in Groovy.
A TestSuite which will run a Groovy unit test case inside any Java IDE either as a unit test case or as an application.
 
 
Represents a String which contains embedded values such as "hello there ${user} how are you?" which can be evaluated lazily.
Represents a String expression which contains embedded values inside it such as "hello there ${user} how are you" which is expanded lazily
Default implementation of a GString used by the compiler.
Processes template source files substituting variables and expressions into placeholders in a template source text to produce the desired output using a streaming approach.
 
An interface for things that need to be cleaned up after operations complete.
A utility class to help calculate hashcode values using an algorithm similar to that outlined in "Effective Java, Joshua Bloch, 2nd Edition".
 
Represents an if (condition) { ...
An exception occurred if a dynamic property dispatch fails with a field not accessible.
Deprecated.
use groovy.transform.Immutable
Class annotation used to assist in the creation of immutable classes.
Handles generation of code for the @Immutable annotation.
This compilation customizer allows addiing various types of imports to the compilation unit.
Represents an import statement of a single class
An exception occurred when invoking a Closure with the wrong number and/or types of arguments
A helper class for printing indented text.
Field annotation used with properties to provide an indexed getter and setter for the property.
Handles generation of code for the @IndexedProperty annotation.
Class annotation to make constructors from a super class available in a sub class.
Handles generation of code for the @InheritConstructors annotation.
 
Represents an inner class declaration
 
 
 
A typed parameter to pass to a query
A ReaderSource for source strings.
The Inspector provides a unified access to an object's information that can be determined by introspection.
 
 
 
 
Integer NumberMath operations
Deprecated.
Implementers of this interface can be registered in the ProxyMetaClass for notifications about method calls for objects managed by the ProxyMetaClass.
Represents an inner class defined as helper for an interface
Represents a list of Integer objects from a specified int up (or down) to and including a given to.
 
 
A static helper class to make bytecode generation easier and act as a facade over the Invoker
An exception thrown if a method is called and an exception occurred
Container for input/output handles.
 
A closure which stores calls in a List so that method calls can be iterated over in a 'yield' style way
An agent that can be used to defer cleanup operations to a later time.
 
 
java 4 based functions
java 5 based functions
Java 6 based functions
Java 7 based functions.
Created by IntelliJ IDEA.
 
 
 
 
 
 
Java 1.5 Recognizer Run 'java Main [-showtree] directory-full-of-java-files' [The -showtree option pops up a Swing frame that shows the AST constructed from the parser.] Run 'java Main ' Contributing authors: Jeremy Rayner groovy@ross-rayner.com John Mitchell johnm@non.net Terence Parr parrt@magelang.com John Lilley jlilley@empathy.com Scott Stanchfield thetick@magelang.com Markus Mohnen mohnen@informatik.rwth-aachen.de Peter Williams pete.williams@sun.com Allan Jacobs Allan.Jacobs@eng.sun.com Steve Messick messick@redhills.com John Pybus john@pybus.org Version 1.00 December 9, 1997 -- initial release Version 1.01 December 10, 1997 fixed bug in octal def (0..7 not 0..8) Version 1.10 August 1998 (parrt) added tree construction fixed definition of WS,comments for mac,pc,unix newlines added unary plus Version 1.11 (Nov 20, 1998) Added "shutup" option to turn off last ambig warning.
Compilation unit to only generate stubs.
 
 
 
 
Runtime exception used by JmxBuilder.
The JmxBuilderModelMBean is the MBean class that proxies exported POGO/POJO inside the MBeanServer.
The JmxEventEmitter is a JMX Broadcaster class that is used to send generic events on the MBeanServer's event bus.
This is the management interface for JmxEventEmitter.
The JmxEventListener class is used by the builder to listen to events on the event bus.
 
 
JsonException is the exception thrown by the JSON builder and slurper classes, whenever a problem occurs when creating or parsing JSON data structures.
The lexer reads JSON tokens in a streaming fashion from the underlying reader.
JSON slurper which parses text or reader content into a data structure of lists and maps.
A JSON token, with a type, line / column information, and the text of that token.
Enum listing all the possible JSON tokens that should be recognized by the lexer.
 
Created by IntelliJ IDEA.
 
Java 5 code for working with JUnit 4 tests.
This class checks the handling of labels in the AST
Field annotation to simplify lazy initialization.
Handles generation of code for the @Lazy annotation
Soft reference with lazy initialization under lock
 
An object representing a line and column position
The LineColumnReader is an extension to BufferedReader that keeps track of the line and column information of where the cursor is.
Represents a link pair (href, packages).
Represents a list expression [1, 2, 3] which creates a mutable List
This represents a
A wrapper for List which automatically grows the list when either ListWithDefault.get(int) or ListWithDefault.getAt(int) is called with an index greater than or equal to size().
Class used to configure a RootLoader from a stream or by using it's methods.
A base class for compilation messages.
A bit simplified lock designed to be inherited by.
This local transform adds a logging ability to your program using java.util.logging.
This class contains the logic of how to weave a Java Util Logging logger into the host class.
This local transform adds a logging ability to your program using Log4j logging.
 
This class provides an AST Transformation to add a log field to a class.
A LoggingStrategy defines how to wire a new logger instance into an existing class.
Provides a very, very basic logging API.
Helper to make logging from Ant easier.
 
 
 
Long NumberMath operations
 
This is an AST Node that provides some sort of looping mechanism.
A cache backed by a Collections.SynchronizedMap
 
 
 
 
This is a basic implementation of a map able to forget its values.
 
 
This class provides a very simple linked list of memory managed elements.
 
A Map.Entry implementation.
Represents an entry inside a map expression such as 1 : 2.
Represents a map expression [1 : 2, "a" : "b", x : y] which creates a mutable Map
A wrapper for Map which allows a default value to be specified.
A helper class for creating XML or HTML markup.
A helper class for MarkupBuilder.
Implements memoize for Closures.
Represents a memoize cache with its essential methods
A base class for compilation messages.
Message source backed up by one or more ResourceBundle instances for simple i18n support.
Represents a property on a bean which may have a getter and/or a setter
Represents a property on a bean which may have a getter and/or a setter
A MetaClass within Groovy defines the behaviour of any given Groovy or Java class.
Call site for constructor meta class - cached method - not cached
 
Allows methods to be dynamically added to existing classes at runtime
 
A MetaClassRegistry is an object that is responsible for managing the a cache of MetaClass instances.
Class used as base for the creation of MetaClass implementations.
An event used to propagate meta class updates
A listener called whenever a constant MetaClass is set, removed or replaced.
A registry of MetaClass instances which caches introspection & reflection information and allows methods to be dynamically added to existing classes at runtime
Call site which holds reference to meta class
Represents a property in an Expando object
Represents a Method on a Java object a little like Method except without using reflection to invoke the method
 
 
 
 
 
Call site which caches meta method
An interface that defines the API usable by clients of Groovy's Meta Object Protocol (MOP).
Represents a property on a bean which may have a getter and/or a setter
A helper class to invoke methods more easily in ASM
 
A method call on an object or class
Represents a method on an object using a closure which can be invoked at any time
Deprecated.
Deprecated.
Some reflection helper methods
An abstract base class for a key used for comparators and Map keys to lookup a method by name and parameter types
Represents a method declaration
Represents a method pointer on an object such as foo.&bar which means find the method pointer on foo for the method called "bar" which is equivalent to foo.metaClass.getMethodPointer(foo, "bar")
Utility class for MissingMethodException, MissingPropertyException etc.
This exception is thrown if the runtime is unable to select a method.
An antlr AST visitor that prints a format suitable for viewing in http://freemind.sourceforge.net
An exception occurred if a dynamic method dispatch fails with an unknown class.
An exception occurred if a dynamic field dispatch fails with an unknown field.
An exception occurred if a dynamic method dispatch fails with an unknown method.
 
A stack less exception used to indicate, that the execution of a missingMethod method failed with a MissingMethodException.
An exception occurred if a dynamic property dispatch fails with an unknown property.
 
 
Provides a mechanism for mixing in methods into a class.
 
 
MetaMethod for mixed in classes
MetaProperty for mixed in classes
Represents a mixin which can be applied to any ClassNode to implement mixins
 
The ProxyMetaClass for the MockInterceptor.
Represents a module, which consists typically of a class declaration but could include some imports, some statements and multiple classes intermixed with statements like scripts in Python or Ruby
 
 
An interface that defines methods that implementers of mutable Meta classes should specify.
 
Represents one or more arguments being passed into a method by name
A simple helper class which acts as a factory of QName instances.
A helper class for creating namespaces for GroovyMarkup
A helper class for creating namespaced GroovyMarkup
Represents a nested value model such as a PropertyModel or a ClosureModel
Annotation that supports writing constructor call expressions without the 'new' keyword.
Handles generation of code for the @Newify annotation.
A MetaMethod implementation where the underlying method is really a static helper method on some class but it appears to be an instance method on a class.
Base class for NewInstanceMetaMethod and NewStaticMetaMethod
A MetaMethod implementation where the underlying method is really a static helper method on some class.
Lazy evaluated representation of a GPath expression returning no children.
Represents an arbitrary tree node which can be used for structured metadata or any arbitrary XML-like tree.
Represents a node.
A visitor that prints a html tags of each node to the supplied PrintStream
A helper class for creating nested trees of Node objects for handling arbitrary data
Lazy evaluated representation of a child node.
A simple antlr AST visitor that collects all nodes into a List.
Helper class for iterating through nodes.
A List implementation which is returned by queries on a Node which provides some XPath like helper methods for GPath.
A helper class for creating nested trees of data
A simple antlr AST visitor that outputs the tokenName of each node in a pseudo xml style.
Custom security manager to System.exit(int) (and related) from being used.
Represents a sequence of objects which represents one or many instances of of objects of a given type.
 
Method annotation used to invert test case results.
Handles generation of code for the @NotYetImplemented annotation.
 
 
A NullObject pattern implementation for ProtectionStorage Doesn't protect any resources.
An Writer than eats its input.
Compares two objects using Groovy's friendly comparison algorithm, i.e.
 
Stateless objects used to perform math on the various Number subclasses.
 
 
 
 
 
 
 
Helper class for processing Groovy numeric literals.
 
 
 
A builder for creating object graphs.
Each node defines the class to be created and the property on its parent (if any) at the same time.
Strategy for setting a child node on its parent.
Useful for handling Lists/Arrays vs normal properties.
Strategy for resolving a classname.
Default impl that calls parent.propertyName = child
If parent.propertyName is a Collection it will try to add child to the collection.
Default impl that capitalizes the classname.
Default impl, always returns 'id'
Default impl that calls Class.newInstance()
Default impl, always returns 'refId'
Default impl that returns parentName & childName accordingly.
Strategy for picking the correct synthetic identifier.
Strategy for creating new instances of a class.
Useful for plug-in calls to non-default constructors.
Strategy for picking the correct synthetic reference identifier.
Strategy for resolving a relationship property name.
Represents an inclusive list of objects from a value to a value using comparators.
List decorator that will trigger PropertyChangeEvents when a value changes.
An optional Closure may be specified and will work as a filter, if it returns true the property will trigger an event (if the value indeed changed), otherwise it won't.
 
 
 
 
 
 
 
 
Map decorator that will trigger PropertyChangeEvents when a value changes.
An optional Closure may be specified and will work as a filter, if it returns true the property will trigger an event (if the value indeed changed), otherwise it won't.
 
 
 
 
 
 
 
 
Visitor to produce several optimizations - to replace numbered constants with references to static fields
A class to write out the optimized statements
 
 
A helper class for sorting objects via a closure to return the field or operation on which to sort.
A parameter to be returned from a CallableStatement.
 
 
Represents a package in the AST.
Deprecated.
use groovy.transform.PackageScope
Class, method or field annotation used for turning off Groovy's auto visibility conventions.
Handles transformation for the @PackageScope annotation.
Intended target when @PackageScope is placed at the class level.
Represents a parameter on a constructor or method call.
Distinguish a parameter array from Object[].
 
 
A simple extension point to allow us to switch between the classic Groovy parser and the new Antlr based parser
A factory of parser plugin instances
 
Systematically generate permutations.
Compilation phase identifiers.
A buffered writer that gobbles any \r characters and replaces every \n with a platform specific newline.
This class defines new Java 5 specific groovy methods which extend the normal JDK classes inside the Groovy environment.
This class defines new Java 6 specific groovy methods which extend the normal JDK classes inside the Groovy environment.
This class defines new Java 6 specific static groovy methods which extend the normal JDK classes inside the Groovy environment.
 
Call site for GroovyInterceptable
 
 
POGO call site meta class - cached method - cached
 
 
 
Call site where we know there is no need to unwrap arguments
Call site where we know there is no need neither unwrap nor coerce arguments
 
POJO call site meta class - cached method - not cached
POJO call site meta class - cached method - cached
 
 
 
Call site where we know there is no need to unwrap arguments
Call site where we know there is no need neither unwrap nor coerce arguments
 
Represents a postfix expression like foo++ or bar++
Indicates that a power assertion has failed.
Container for shell preferences.
Represents a prefix expression like ++foo or --bar
This class mutates the Java AST, whilst it is still a Java AST, in readiness for conversion to Groovy, yippee-ky-a !
A simple preorder traversal over the supplied antlr AST.
This class defines new groovy methods which appear on normal JDK classes related to process management.
A Runnable which waits for a process to complete together with a notification scheme allowing another thread to wait a maximum number of seconds for the process to complete before killing it.
A base class for data structures that can collect messages and errors during processing.
An interface that adds the ability to intercept property getters/setters
 
 
 
 
Represents a property access such as the expression "foo.bar".
Represents a property of a value as a model.
Represents a property (member variable, a getter and setter)
A property path full binding
 
 
 
Dynamic groovy proxy for another object.
Classes to generate 'Proxy' objects which implement interfaces, maps of closures and/or extend classes/delegates.
As subclass of MetaClass, ProxyMetaClass manages calls from Groovy Objects to POJOs.
QName class represents the value of a qualified name as specified in XML Schema Part2: Datatypes specification.
Range<T extends Comparable>
A Range represents the list of all items obtained by starting from a from value and calling next() successively until you reach the to value.
Represents a range expression such as for iterating.
An interface for things that can supply (and potentially resupply) a Reader on a source stream.
Encapsulates non-specific i/o exceptions.
This exception is thrown if an attempt is made to set a read only property
Handles generation of code for the @WithReadLock and @WithWriteLock annotation.
A syntax reduction, produced by the Parser.
Represents a reference to a value
 
 
 
 
 
 
Utility class to call methods through reflection, and falls through using the Invoker to call the method if it fails.
This class contains utility methods to determine which class called the current class to multiple levels of depth.
Provides as alternative to reflection using bytecode generation.
Reflector creation helper.
Used to store the last regex match.
Exposes the Groovy release information
Helper base class used for lazy updates.
Visitor to resolve Types and convert VariableExpression to ClassExpressions if needed.
Base interface for customizing where resources can be found for the GroovyScriptEngine.
 
 
This class defines a wrapper for accessing a specific column in ResultSetMetaData.
A ResultSet out parameter.
Utility class to add return statements.
A return statement
A reverse iterator over a list.
This ClassLoader should be used as root of class loaders.
Sets the RootLoader as reference.
A helper class to allow parser exceptions to be thrown anywhere in the code.
A builder for generating W3C SAX events.
This object represents a Groovy script
A static helper class to interface bytecode and runtime
 
Represents a reference to a variable in a script
An adapter to make any Groovy Script class an instance of a JUnit Test
This customizer allows securing source code by controlling what code constructs are allowed.
This interface allows the user to plugin custom expression checkers if expression blacklist or whitelist are not sufficient
This interface allows the user to plugin custom statement checkers if statement blacklist or whitelist are not sufficient
Represents a sequence of objects which represents zero or many instances of of objects of a given type.
Servlet-specific binding extension to lazy load the writer or the output stream from the response.
Servlet support.
 
 
 
 
 
 
Filter for elements in the completor.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Stores info about GroovyDoc tags.
 
A base class for compilation messages.
Processes template source files substituting variables and expressions into placeholders in a template source text to produce the desired output.
 
 
 
Class annotation to make class singleton.
Handles generation of code for the @Singleton annotation
This local transform adds a logging ability to your program using LogBack logging.
 
 
A simple buffer that provides line/col access to chunks of source code held within itself.
A treewalker for the antlr generated AST that attempts to visit the AST nodes in the order needed to generate valid groovy source code.
Looks for source file extensions in META-INF/services/org.codehaus.groovy.source.Extensions
 
An antlr AST visitor that prints groovy source code for each visited node to the supplied PrintStream.
Provides the source text for an assertion statement and translates coordinates in the original source text to coordinates relative to the assertion's (normalized) source text.
Indicates that the source text for an assertion statement is not available.
Provides an anchor for a single source unit (usually a script file) as it passes through the compiler system.
Represents a spread expression *x in the list expression [1, *x, 2].
 
Represents a spreadable map which extends java.util.HashMap.
 
Represents a spread map expression *:m in the map expression [1, *:m, 2, "c":100] or in the method invoke expression func(1, *:m, 2, "c":100).
A facade over Java's normal JDBC APIs providing greatly simplified resource management and result set handling.
This class defines all the new SQL-related groovy methods which enhance the normal JDK SQL classes when inside the Groovy environment.
 
 
 
Originally was grails.utils.GrailsUtils, removed some grails specific stuff.
Deprecated.
This interface is no longer used internally and there exists no equivalent functionality.
Base class for any statement
A TypeChooser which is aware of statement metadata.
 
Visitor to resolve constants and method calls from static Imports
Call site for invoking static methods meta class - cached method - not cached
POJO call site meta class - cached method - cached
Call site where we know there is no need to unwrap arguments
Call site where we know there is no need neither unwrap nor coerce arguments
A static method call on a class
Verifier to check non-static access in static contexts
 
This class codes around a silly limiation of StringWriter which doesn't allow a StringBuffer to be passed in as a constructor for some bizarre reason.
 
Escapes and unescapes Strings for Java, Java Script, HTML, XML, and SQL.
 
A ReaderSource for source strings.
 
An IO exception occurred trying to append to a StringWriter which should never happen.
 
 
Contains all the basic resources and values used by the utility frame work framework.
Special class loader, which when running on Sun VM allows to generate accessor classes for any method
This class defines all the new Swing-related groovy methods which enhance the normal JDK Swing classes when inside the Groovy environment.
 
Represents a switch (object) { case value: ...
Method annotation to make a method call synchronized for concurrency handling with some useful baked-in conventions.
Handles generation of code for the @Synchronized annotation.
Represents a synchronized statement
A class for error messages produced by the parser system.
Base exception indicating a syntax error.
Intercepts System.out/System.err.
Represents a HTML style table layout
Represents a cell in a table layout.
Represents a row in a table layout
 
 
 
A template is a block of text with an associated binding that can be output to a writer or evaluated to a string.
Represents an API to any template engine which is basically a factory of Template instances from a given text input.
A generic servlet for serving (mostly HTML) templates.
A temporary implementation of MethodKey used to perform a fast lookup for a method using a set of arguments to a method
Represents a ternary expression (booleanExpression) ? expression : expression
Java 5 code for working with TestNG tests.
A simple text pane that is printable and wrapping is optional.
To use this, simply drop this as an UndoableEditListener into your document, and then create actions to call undo/redo as needed (checking can undo/redo first, of course).
This MetaBeanProperty will create a pseudo property whose value is bound to an object using weak references.
Represents a throw statement
Apply a number of methods to allow convenient Date/Time manipulation,such as:
Deprecated.
in favor of TimeCategory
TimeDatumDuration represents a time period which results from an arithmetic operation between a TimeDuration object and a DatumDuration object
TimeDuration represents time periods expressed in units of hours, minutes, seconds and milliseconds.
A CSTNode produced by the Lexer.
 
 
Class annotation used to assist in the creation of toString() methods in classes.
Handles generation of code for the @ToString annotation.
 
A MetaMethod implementation useful for implementing coercion based invocations
Helper Class for Antlr AST traversal and visitation.
 
 
 
Represents a try { ...
Represents a list of Objects.
Class annotation used to assist in the creation of tuple constructors in classes.
Handles generation of code for the @TupleConstructor annotation.
Represents a tuple expression {1, 2, 3} which creates an immutable List
Interface for modules which are capable of resolving the type of an expression.
Typing information for the CST system.
Compiles Java and Groovy source files.
 
 
Translates GLS-defined unicode escapes into characters.
GRECLIPSE-805 Support for unicode escape sequences
A cache backed by a ConcurrentHashMap
A ReaderSource for source files hosted at a URL.
Various utility functions for use in the compiler.
A value recorded during evaluation of an assertion, along with the column it is associated with in the assertion's normalized source text.
A simple ValueModel implementation which is a holder of an object value.
Represents a model of a value
Records values produced during evaluation of an assertion statement's truth expression.
interface to mark a AstNode as Variable.
Represents a local variable name, the simplest form of expression.
Represents a variable scope.
goes through an AST and initializes the scopes
 
Verifies the AST node and adds any defaulted AST code before bytecode generation occurs.
 
Performs various checks on code inside methods and constructors including checking for valid field, variables names etc.
Verify Class files.
Annotates a groovy property or a class.
Handles generation of code for the @Vetoable annotation, and @Bindable if also present.
An interface for visiting a GroovySourceAST node.
A default implementation of all visitor methods.
Interface to access VM version based actions.
factory class to get functionality based on the VM version.
A class for warning messages.
Represents a while (condition) { ...
This class provides helper methods to determine the type from a widening operation for example for a plus operation.
To determine the resulting type of for example a=exp1+exp2 we look at the conditions WideningCategories.isIntCategory(ClassNode), WideningCategories.isLongCategory(ClassNode), WideningCategories.isBigIntCategory(ClassNode), WideningCategories.isDoubleCategory(ClassNode) and WideningCategories.isBigDecCategory(ClassNode) in that order.
This annotation is used in conjunction with WithWriteLock to support read and write synchronization on a method.

To use this annotation, declare @WithReadLock on your method.
This annotation is used in conjunction with WithReadLock to support read and write synchronization on a method.

To use this annotation, declare @WithWriteLock on your method.
 
Represents an object which is capable of writing itself to a text stream in a more efficient format than just creating a toString() representation of itself.
A Writable File.
 
This class defines all the new XML-related groovy methods which enhance the normal JDK XML classes when inside the Groovy environment.
Prints a groovy.util.Node (as used with XmlParser) including all children in XML format.
A helper class for parsing XML into a tree of Node instances for a simple way of processing XML.
Parse XML into a document tree that may be traversed similar to XPath expressions.
Template engine for use in templating scenarios where both the template source and the expected output are intended to be XML.
Used for pretty printing XML content.