All Classes

Class	Description
AbstractASTTransformation
AbstractButtonProperties
AbstractCallSite	Base class for all call sites.
AbstractComparator<T>
AbstractConcurrentMap<K,V>	Deprecated.
AbstractConcurrentMap.Entry<K,V>
AbstractConcurrentMap.Segment<K,V>
AbstractConcurrentMapBase	Deprecated.
AbstractConcurrentMapBase.Entry<V>
AbstractConcurrentMapBase.Segment
AbstractExtensionMethodCache
AbstractFactory
AbstractFullBinding
AbstractFunctionalInterfaceWriter	Represents functional interface writer which contains some common methods to complete generating bytecode
AbstractGinqExpression	Represents GINQ expression which could hold meta data
AbstractHttpServlet	A base class dealing with common HTTP servlet API housekeeping aspects.
AbstractInterruptibleASTTransformation	Base class for AST Transformations which will automatically throw an InterruptedException when some conditions are met.
AbstractLexer	Because antlr4 does not support generating lexer with specified interface, we have to create a super class for it and implement the interface.
AbstractParser	Because antlr4 does not support generating parser with specified interface, we have to create a super class for it and implement the interface.
AbstractReaderSource	For ReaderSources that can choose a parent class, a base that provides common functionality.
AbstractSyntheticBinding
AbstractTypeCheckingExtension	Custom type checking extensions may extend this method in order to benefit from a lot of support methods.
AdaptingMetaClass	An interface for MetaClass instances that "adapt" other MetaClass instances such as a proxy or delegating MetaClass.
AggregateBinding	An aggregation of multiple bindings
AllControlToUndefined
AllTestSuite	AllTestSuite can be used in extension of GroovyTestSuite to execute TestCases written in Groovy from inside a Java IDE.
AndroidSupport
AnnotatedNode	Base class for any AST node which is capable of being annotated
AnnotatedNodeUtils	Utility class for working with AnnotatedNodes
AnnotationClosureVisitor	Visits interfaces & classes and looks for @Requires or @Ensures and creates Closure classes for the annotation closures.
AnnotationCollector	The AnnotationCollector can be used to define aliases for groups of annotations.
AnnotationCollectorMode
AnnotationCollectorTransform	This class is the base for any annotation alias processor.
AnnotationCollectorTransform.ClassChanger	Class used by CompilationUnit to transform the alias class into what is needed by the compiler.
AnnotationConstantExpression	Represents an annotation "constant" that may appear in annotation attributes (mainly used as a marker).
AnnotationConstantsVisitor	Visitor to resolve constants in annotation definitions.
AnnotationContractParameterVisitor	This BaseVisitor walks up the class hierarchy for the given ClassNode and adds ContractElement annotations to method parameters.
AnnotationNode	Represents an annotation which can be attached to interfaces, classes, methods, fields, parameters, and other places.
AnnotationProcessor	Base class for modifying the internal domain model, starting at Contract, and adding parts to it.
AnnotationProcessorImplementation	Indicates what AnnotationProcessor implementation should be used to process the correlating annotation.
AnnotationProcessorVisitor	Visits annotations of meta-type ContractElement and applies the AST transformations of the underlying AnnotationProcessor implementation.
AnnotationUtils	Helper methods for reading/getting AnnotationNode instances.
AnnotationVisitor	An Annotation visitor responsible for: reading annotation metadata (@Retention, @Target, attribute types) verify that an AnnotationNode conforms to annotation meta enhancing an AnnotationNode AST to reflect real annotation meta
AntBuilder	Allows Ant tasks to be used with a Groovy builder-style markup.
Antlr4ParserPlugin	A parser plugin for the new parser.
Antlr4PluginFactory	A parser plugin factory for the new parser.
AntProjectPropertiesDelegate
ArgumentListExpression	Represents one or more arguments being passed into a method
ArrayCachedClass
ArrayClassDocWrapper
ArrayExpression	Represents an array object construction.
ArrayGetAtMetaMethod
ArrayIterator<T>
ArrayMetaMethod
ArrayPutAtMetaMethod
Arrays	Array utilities.
ArrayTypeUtils	Utilities for handling array types
ArrayUtil	This is a generated class used internally during the writing of bytecode within the CallSiteWriter logic.
ArrayUtils
AsmClassGenerator	Generates Java class versions of Groovy classes using ASM.
AsmDecompiler	A utility class responsible for decompiling JVM class files and producing ClassStub objects reflecting their structure.
AsmReferenceResolver	A helper class used to resolve references found in ASM-decompiled classes.
Assertion<T extends Assertion>	Base class for all assertion types.
AssertionMap<T extends Assertion<T>>
AssertionRenderer	Creates a string representation of an assertion and its recorded values.
AssertionViolation	Abstract base class for all assertion violations.
AssertionWriter
AssertStatement	Represents an assert statement.
AssertStatementCreationUtility	Central place to create AssertStatement instances in groovy-contracts.
AssertStatementCreationUtility.AddAssertionCallStatementToReturnStatementVisitor	Replaces a given ReturnStatement with the appropriate assertion call statement and returns a result variable expression.
AssertStatementCreationUtility.AddResultReturnStatementVisitor	Replaces a given ReturnStatement with the appropriate assertion call statement and returns a result variable expression.
AssertStatementCreationUtility.ReturnStatementVisitor	Collects all ReturnStatement instances from a given code block.
AstBuilder	Builds the AST from the parse tree generated by Antlr4.
AstBuilderTransformation	Transformation to capture ASTBuilder from code statements.
ASTHelper	A common base class of AST helper methods which can be shared across the classic and new parsers
ASTNode	Base class for any AST node.
ASTNodeMetaData	Holds all constants to be used as AST node meta data keys.
ASTNodePredicate
AstStringCompiler	This class handles converting Strings to ASTNode lists.
ASTTest	This AST transformation aims at helping in debugging other AST transformations.
AstToTextHelper	Helper class for converting AST into text.
ASTTransformation	This class is instantiated and invoked when an AST transformation is activated.
ASTTransformationCollectorCodeVisitor	Walks the AST and collects references to annotations that are annotated themselves by GroovyASTTransformation.
ASTTransformationsContext	Stores state information about global AST transformations applied to a compilation unit.
ASTTransformationVisitor	This class handles the invocation of the ASTAnnotationTransformation when it is encountered by a tree walk.
AtnManager	Manage ATN to avoid memory leak
Attribute	Lazy evaluated representation of a node attribute.
AttributeExpression	Represents an attribute access (accessing the field of a class) such as the expression "foo.@bar".
Attributes	Lazy evaluated representation of a node's attributes.
AutoClone	Class annotation used to assist in the creation of Cloneable classes.
AutoCloneASTTransformation	Handles generation of code for the @AutoClone annotation.
AutoCloneStyle	Intended style to use for cloning when using the @AutoClone annotation.
AutoFinal	Annotation to automatically add the final qualifier to method, constructor, and closure parameters.
AutoFinalASTTransformation	Handles generation of code for the AutoFinal annotation.
AutoImplement	Class annotation used to provide default dummy methods for a class extending an abstract super class or implementing one or more interfaces.
AutoImplementASTTransformation	Generates code for the @AutoImplement annotation.
BaseASTTransformation	Base AST transformation encapsulating all common helper methods and implementing ASTTransformation.
BaseDuration	Base class for date and time durations.
BaseDuration.From
BaseGenerator	Base class for groovy-contracts code generators.
BaseJsonParser	Base JSON parser.
BaseLifecycle	Base implementation class for interface Lifecycle.
BaseMarkupBuilder
BaseScript	Variable annotation used for changing the base script class of the current script.
BaseScriptASTTransformation	Handles transformation for the @BaseScript annotation.
BaseTemplate	All templates compiled through MarkupTemplateEngine extend this abstract class, which provides a number of utility methods to generate markup.
BaseVisitor	Base class for ClassCodeVisitorSupport descendants.
BatchingPreparedStatementWrapper	Class which delegates to a PreparedStatement but keeps track of a batch count size.
BatchingStatementWrapper	Class which delegates to a Statement but keeps track of a batch count size.
BeanUtils
BeanUtils
BenchmarkInterceptor	Interceptor that registers the timestamp of each method call before and after invocation.
BigDecimalCachedClass
BigDecimalMath	BigDecimal NumberMath operations
BigIntegerCachedClass
BigIntegerMath	BigInteger NumberMath operations
BinaryBooleanExpressionHelper	Binary write operations specialised for Booleans
BinaryDoubleExpressionHelper
BinaryExpression	Represents two expressions and an operation
BinaryExpressionHelper
BinaryExpressionMultiTypeDispatcher	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.
BinaryExpressionTransformer
BinaryExpressionWriter	Base class for writing primitive typed operations
BinaryFloatExpressionHelper
BinaryIntExpressionHelper
BinaryLongExpressionHelper
BinaryObjectExpressionHelper
Bindable	Annotates a groovy property or a class.
BindableASTTransformation	Handles generation of code for the @Bindable annotation when @Vetoable is not present.
Binding	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.
BindingProxy	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).
BindingUpdatable
BindPath	The bind path object.
BitwiseNegationExpression
BlockStatement	A list of statements and a scope.
BooleanArrayGetAtMetaMethod
BooleanArrayPutAtMetaMethod
BooleanCachedClass
BooleanClosureWrapper	Helper class for internal use only.
BooleanExpression	Represents a boolean expression
BooleanExpressionTransformer
BooleanReturningMethodInvoker	Helper class for internal use only.
BooleanWrapper
BreakStatement	Represents a break statement in a switch or loop statement
BufferedIterator<T>	An iterator that allows examining the next element without consuming it.
Buildable
Builder	The @Builder AST transformation is used to help write classes that can be created using fluent api calls. The transform supports multiple building strategies to cover a range of cases and there are a number of configuration options to customize the building process.
Builder
Builder.Built
BuilderASTTransformation	Handles generation of code for the Builder annotation.
BuilderASTTransformation.AbstractBuilderStrategy
BuilderASTTransformation.AbstractBuilderStrategy.PropertyInfo
BuilderASTTransformation.BuilderStrategy
BuilderSupport	Base class for creating arbitrary nested trees of objects or events.
ByteArrayGetAtMetaMethod
ByteArrayPutAtMetaMethod
ByteCachedClass
BytecodeDumper	An utility class which can be used in test cases to dump generated bytecode.
BytecodeExpression	Represents some custom bytecode generation by the compiler.
BytecodeHelper	A helper class for bytecode generation with AsmClassGenerator.
BytecodeInstruction	Helper class used by the class generator.
BytecodeInterface8	This class contains methods special to optimizations used directly from bytecode in Groovy 1.8
BytecodeProcessor
BytecodeSequence	This class represents a sequence of BytecodeInstructions or ASTNodes.
BytecodeVariable	Represents compile time variable metadata while compiling a method.
ByteScanner
ByteWrapper
Cache<KEY,VALUE>	Cache
CacheableCallSite	Represents a cacheable call site, which can reduce the cost of resolving methods
CacheAccessControlException
CachedClass
CachedClass.CachedMethodComparatorByName
CachedClass.CachedMethodComparatorWithString
CachedClosureClass
CachedConstructor
CachedField
CachedMethod
CachedSAMClass
CacheType
CachingGroovyEngine	A Caching implementation of the GroovyEngine
CallSite
CallSiteArray
CallSiteAwareMetaMethod
CallSiteClassLoader
CallSiteGenerator
CallSiteWriter	This class represents non public API used by AsmClassGenerator.
CandidateChecks	Functions in this class are used to determine whether a certain AST node fulfills certain assertion requirements.
CaseStatement	Represents a case statement in a switch statement
CastExpression	Represents a typecast expression.
CastExpressionOptimizer
CatchStatement	Represents a catch (Exception var) { } statement
Category	Transforms an instance-style Groovy class or interface to become a static-style conventional Groovy category.
CategoryASTTransformation	Handles generation of code for the @Category annotation.
CharacterArrayGetAtMetaMethod
CharacterArrayPutAtMetaMethod
CharacterCachedClass
CharacterSource
CharBuf
CharScanner
CharSequenceReader	Reader implementation that can read from String, StringBuffer, StringBuilder, CharBuffer or GString.
CharSequenceValue
CharsetToolkit	Utility class to guess the encoding of a given text file.
CharWrapper
Chr
CircularAssertionCallException	Thrown whenever pre- or post-conditions are called in a cyclic way.
ClassCodeExpressionTransformer	Transforms expressions in a whole class.
ClassCodeVisitorSupport
ClassCompletionVerifier	Checks that a class satisfies various conditions including: Incorrect class or method access modifiers No abstract methods appear in a non-abstract class Existence and correct visibility for inherited members Invalid attempts to override final members
ClassExpression	Represents access to a Java/Groovy class in an expression, such as when invoking a static method or accessing a static type
ClassFinder	Find classes under the specified package via some classpath entry Usage:
ClassFindFailedException	Represents error occurred during finding classes
ClassGenerator	Abstract base class for generator of Java class versions of Groovy AST classes
ClassGeneratorException	An exception thrown by the class generator
ClassHelper	Helper for ClassNode and classes handling them.
ClassInfo	Handle for all information we want to keep about the class
ClassInfo.ClassInfoAction
ClassInvariant	Indicates that annotations being marked as @ClassInvariant are to be treated as class invariant modifying annotations.
ClassInvariant	A class-invariant assertion.
ClassInvariantAnnotationProcessor	Internal AnnotationProcessor implementation for class-invariants.
ClassInvariantGenerator	Code generator for class invariants.
ClassInvariantLifecycle	Internal Lifecycle implementation for class-invariants.
ClassInvariantViolation	Thrown whenever a class invariant violation occurs.
ClassLoaderForClassArtifacts
ClassNode	Represents a class in the AST.
ClassNodeResolver	This class is used as a pluggable way to resolve class names.
ClassNodeResolver.LookupResult	Helper class to return either a SourceUnit or ClassNode.
ClassNodeUtils	Utility class for working with ClassNodes
ClasspathResourceManager
ClassStub	Data structures holding class info to enable lazy loading
Closure<V>	Represents any closure object in Groovy.
ClosureComparator<T>	A Comparator which uses a closure to compare 2 values being equal
ClosureException	An exception thrown by a closure invocation
ClosureExpression	Represents a closure expression such as
ClosureExpressionEvaluationASTTransformation	Evaluates ClosureExpression instances in as actual annotation parameters and generates special contract closure classes from them.
ClosureExpressionTransformer
ClosureInvokingMethod	An interface for MetaMethods that invoke closures to implements.
ClosureListExpression	This class represents a list of expressions used to create closures.
ClosureMetaClass	A meta class for closures generated by the Groovy compiler.
ClosureMetaMethod	A MetaMethod that accepts a closure in the constructor which is invoked when the MetaMethod is called.
ClosureModel	Represents a value model using a closure to extract the value from some source model and an optional write closure for updating the value.
ClosureParams	Parameter annotation aimed at helping IDEs or the static type checker to infer the parameter types of a closure.
ClosureRenderer
ClosureSignatureConflictResolver	If multiple candidate signatures are found after applying type hints, a conflict resolver can attempt to resolve the ambiguity.
ClosureSignatureHint	A closure signature hint class is always used in conjunction with the ClosureParams annotation.
ClosureSourceBinding
ClosureStaticMetaMethod	This class represents a MetaMethod that is a closure that pretends to be a static method.
ClosureTriggerBinding
ClosureUtils	Handy methods when working with Closure AST data structures.
ClosureWriter
ClosureWriter.CorrectAccessedVariableVisitor
ClosureWriter.UseExistingReference
CodeVisitorSupport	Abstract base class for any GroovyCodeVisitor which by default just walks the code and expression tree
CommonCache<K,V>	Represents a simple key-value cache, which is NOT thread safe and backed by a Map instance
Commons	This local transform adds a logging ability to your program using Apache Commons logging.
Commons.CommonsLoggingStrategy
CompareIdentityExpression	Compares two objects using identity comparison.
CompareToNullExpression
CompilationCustomizer	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.
CompilationFailedException	Thrown when compilation fails from source errors.
CompilationUnit	The CompilationUnit collects all compilation data as it is generated by the compiler system.
CompilationUnit.ClassgenCallback	A callback interface you can use to "accompany" the classgen() code as it traverses the ClassNode tree.
CompilationUnit.GroovyClassOperation	Deprecated.
CompilationUnit.IGroovyClassOperation
CompilationUnit.IPrimaryClassNodeOperation
CompilationUnit.ISourceUnitOperation
CompilationUnit.PrimaryClassNodeOperation	Deprecated.
CompilationUnit.ProgressCallback	A callback interface you can use to get a callback after every unit of the compile process.
CompilationUnit.SourceUnitOperation	Deprecated.
CompilationUnitAware	This interface is for AST transformations which must be aware of the compilation unit where they are applied.
CompileDynamicProcessor
CompilePhase	The phases of the GroovyCompiler.
Compiler	A convenience front end for getting standard compilations done.
CompilerConfiguration	Compilation control flags and coordination stuff.
CompileStack	Manages different aspects of the code of a code block like handling labels, defining variables, and scopes.
CompileStack.BlockRecorder
CompileStack.LabelRange
CompileStatic	This will let the Groovy compiler use compile time checks in the style of Java then perform static compilation, thus bypassing the Groovy meta object protocol.
CompileTaskSupport	Support for compilation related tasks.
CompileUnit	Represents the entire contents of a compilation step which consists of one or more ModuleNode instances.
CompileUnit.ConstructedOuterNestedClassNode	Represents a resolved type as a placeholder.
ComplexKeyHashMap	Deprecated.
ComplexKeyHashMap.Entry
ComplexKeyHashMap.EntryIterator
ComposedClosure<V>	A wrapper for Closure to support composition.
ConcurrentCommonCache<K,V>	Represents a simple key-value cache, which is thread safe and backed by a Map instance
ConcurrentLinkedHashMap<K,V>	A hash table supporting full concurrency of retrievals, adjustable expected concurrency for updates, and a maximum capacity to bound the map by.
ConcurrentLinkedHashMap.Builder<K,V>	A builder that creates ConcurrentLinkedHashMap instances.
ConcurrentReaderHashMap	A hash table that supports mostly-concurrent reading, but exclusive writing.
ConcurrentReaderHashMap.BarrierLock	A Serializable class for barrier lock
ConcurrentReaderHashMap.Entry	ConcurrentReaderHashMap collision list entry.
ConcurrentReferenceHashMap<K,V>	An advanced hash table supporting configurable garbage collection semantics of keys and values, optional referential-equality, full concurrency of retrievals, and adjustable expected concurrency for updates.
ConcurrentReferenceHashMap.InitializableEntry<K,V>
ConcurrentReferenceHashMap.Option	Behavior-changing configuration options for the map
ConcurrentReferenceHashMap.ReferenceType	An option specifying which Java reference type should be used to refer to a key and/or value.
ConcurrentReferenceHashMap.SimpleEntry<K,V>
ConcurrentSoftCache<K,V>	Represents concurrent cache holding SoftReference instance as value
ConfigObject	A ConfigObject at a simple level is a Map that creates configuration entries (other ConfigObjects) when referencing them.
ConfigurationException	Thrown when configuration data is invalid.
ConfigurationSetup	Makes some initialization in order to use the Configurator for determining which assertions in what packages will be executed.
Configurator	Handles -ea and -da runtime input arguments for enabling and disabling contract elements.
ConsoleSupport	Base class for console
ConsoleTextEditor	Component which provides a styled editor for the console.
ConstantExpression	Represents a constant expression such as null, true, false.
ConstructorCallExpression	A constructor call.
ConstructorCallTransformer
ConstructorMetaClassSite
ConstructorMetaMethodSite	Call site for invoking static methods meta class - cached method - not cached
ConstructorNode	Represents a constructor declaration
ConstructorNodeUtils	Utility class for working with ConstructorNodes
ConstructorSite
ConstructorSite.ConstructorSiteNoUnwrap	Call site where we know there is no need to unwrap arguments
ConstructorSite.ConstructorSiteNoUnwrapNoCoerce	Call site where we know there is no need neither unwrap nor coerce arguments
ConstructorSite.NoParamSite
ConstructorSite.NoParamSiteInnerClass
ContextualClassCodeVisitor	A class code visitor which is capable of remembering the context of the current visit.
ContinueStatement	Represents a continue statement in a loop statement
Contract	Represents a contract between a supplier and a customer of a class.
ContractClosureWriter	Replaces annotation closures with closure implementation classes.
Contracted	Package-level and class-level annotation indicating that the package is enabled for class-invariants, pre- and post-conditions.
ContractElement	Indicates that annotations being marked as @ContractElement are to be used by some contract element being either a class-invariant, pre- or post-condition.
ContractElementVisitor	Checks whether the given ClassNode is relevant for further processing.
ContractExecutionTracker	Keeps track of contract executions to avoid cyclic contract checks.
ContractExecutionTracker.ContractExecution
ConversionHandler	This class is a general adapter to map a call to a Java interface to a given delegate.
ConvertedClosure	This class is a general adapter to adapt a closure to any Java interface.
ConvertedMap	This class is a general adapter to adapt a map of closures to any Java interface.
CSTNode	An abstract base class for nodes in the concrete syntax tree that is the result of parsing.
CurriedClosure<V>	A wrapper for Closure to support currying.
CustomizersFactory	This factory generates an array of compilation customizers.
DataSet	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.
DataSourceExpression	Represents data source expression
DataSourceHolder	Represents data source holder, e.g.
Dates
DateTimeExtensions	This class defines new Groovy methods which appear on normal JDK Date/Time API (java.time) classes inside the Groovy environment.
DateTimeStaticExtensions	This class defines new static extension methods which appear on normal JDK Date/Time API (java.time) classes inside the Groovy environment.
DateUtilExtensions	This class defines new groovy methods which appear on normal JDK Date and Calendar classes inside the Groovy environment.
DateUtilStaticExtensions	This class defines new groovy static methods which appear on normal JDK Date and Calendar classes inside the Groovy environment.
DatumDependentDuration	DatumDependentDuration represents durations whose length in milliseconds cannot be determined without knowing the datum point.
DeclarationExpression	Represents one or more local variables.
DecompiledClassNode	A ClassNode kind representing the classes coming from *.class files decompiled using ASM.
DefaultAction	A default action implementation
DefaultCachedMethodKey	A default implementation of MethodKey
DefaultFastStringService	Internal class for fast processing of Strings during JSON parsing - default version
DefaultFastStringServiceFactory
DefaultGroovyMethods	This class defines new groovy methods which appear on normal JDK classes inside the Groovy environment.
DefaultGroovyMethodsSupport	Support methods for DefaultGroovyMethods and PluginDefaultMethods.
DefaultGroovyStaticMethods	This class defines all the new static groovy methods which appear on normal JDK classes inside the Groovy environment.
DefaultJsonGenerator	A JsonGenerator that can be configured with various JsonGenerator.Options.
DefaultJsonGenerator.ClosureConverter	A converter that handles converting a given type using a closure.
DefaultMetaClassInfo	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.
DefaultMetaClassInfo.ConstantMetaClassVersioning
DefaultMethodKey	A default implementation of MethodKey
DefaultPropertyAccessor
DefaultPropertyHandler
DefaultPropertyReader
DefaultPropertyWriter
DefaultStrategy	This strategy is used with the Builder AST transform to create a builder helper class for the fluent creation of instances of a specified class. It can be used at the class, static method or constructor levels.
DefaultTableColumn	Represents a column using a ValueModel to extract the value.
DefaultTableModel	A default table model made up of PropertyModels on a Value model.
DefaultTableModel.MyTableColumnModel
DefaultTypeCheckingExtension	The default type checking handler is used by the standard type checker and doesn't handle any of the type checking errors by default.
DefaultTypeTransformation	Class providing various type conversions, coercions and boxing/unboxing operations.
Delegate	Annotation to automatically delegate part of the functionality of an owner class to the annotated delegation target.
DelegateASTTransformation	Handles generation of code for the @Delegate annotation
DelegatesTo	This annotation can be used by API or DSL writers to document parameters which accept a closure.
DelegatesTo.Target	Parameter annotation used to specify the delegate for a @DelegatesTo annotated parameter of the same method.
DelegatingController	This class will delegate all calls to a WriterController given in the constructor.
DelegatingCustomizer	Base class for compilation customizers which delegate to another customizer.
DelegatingIndentWriter	A writer which delegates to another writer and supports an additional indenting level.
DelegatingMetaClass
DelegatingScript	Script that performs method invocations and property access like Closure does.
DependencyTracker
DeprecationException	Use this exception to mark a method implementation as being deprecated.
DescriptiveErrorStrategy	Provide friendly error messages when parsing errors occurred.
DgmConverter
DomainModelInjectionVisitor	Visits the given ClassNode and injects the current Contract into the given AST nodes.
DOMBuilder	A helper class for creating a W3C DOM tree
DOMCategory	Category class which adds GPath style operations to Java's DOM classes.
DomToGroovy	A SAX handler for turning XML into Groovy scripts
DoubleArrayGetAtMetaMethod
DoubleArrayPutAtMetaMethod
DoubleCachedClass
DoubleQuoteFilter
DoubleWrapper
DoWhileStatement	Represents a do { ...
DummyCallSite
DummyClassGenerator	To generate a class that has all the fields and methods, except that fields are not initialized and methods are empty.
Duration	Duration represents time periods which have values independent of the context.
DynamicSetterInjectionVisitor	Implements contract support for setter methods and default constructors of POGOs.
DynamicVariable
ElvisOperatorExpression	Represents a short ternary expression x ?: y, which is equal to
EmptyExpression	Placeholder for an empty expression.
EmptyRange<T extends Comparable>	Constructing Ranges like 0..<0
EmptyStatement
EncodingAwareBufferedWriter	A buffered writer only for OutputStreamWriter that is aware of the encoding of the OutputStreamWriter.
EncodingGroovyMethods	This class defines all the encoding/decoding groovy methods which enhance the normal JDK classes when inside the Groovy environment.
EncodingGroovyMethodsSupport	Keep this constant in a separate file as it is troublesome for Antlr to parse for doc purposes.
Ensures	Represents a method postcondition.
EnsuresAnnotationProcessor	Internal AnnotationProcessor implementation for post-conditions.
EntryWeigher<K,V>	A class that can determine the weight of an entry.
EnumCompletionVisitor	Enums have a parent constructor with two arguments from java.lang.Enum.
EnumConstantClassNode	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
EnumHelper
EnumTypeCheckingExtension	A type checking extension that will take care of handling errors which are specific to enums.
EnumVisitor
EqualsAndHashCode	Class annotation used to assist in creating appropriate equals() and hashCode() methods.
EqualsAndHashCodeASTTransformation
ErrorCollecting	An AST transform with the ability to report errors.
ErrorCollector	A base class for collecting messages and errors during processing.
ErrorReporter	Provides services for reporting compilation errors to the user.
Eval	Allow easy integration from Groovy into Java through convenience methods.
EventTriggerBinding
EvictableCache<K,V>	Represents an evictable memoize cache with its essential methods
EvictableCache.Action<K,V,R>	Represents the action to deal with the cache
EvictableCache.EvictionStrategy	Represents a eviction strategy for the cache with limited size
EvictionListener<K,V>	A listener registered for notification when an entry is evicted.
ExceptionMessage	A class for error messages produced by the parser system.
Exceptions
Exceptions.JsonInternalException
ExpandedVariable	Identifies a variable to be expanded into the sql string rather than representing a placeholder.
Expando	Represents a dynamically expandable bean.
ExpandoMetaClass	ExpandoMetaClass is a MetaClass that behaves like an Expando, allowing the addition or replacement of methods, properties and constructors on the fly.
ExpandoMetaClassCreationHandle	A handle for the MetaClassRegistry that changes all classes loaded into the Grails VM to use ExpandoMetaClass instances
Expression	Represents a base class for expressions which evaluate as an object
ExpressionAsVariableSlot	Helper class that takes an Expression and if visited will load it normally, storing the result in a helper variable, which then can be requested after the visit is completed.
ExpressionStatement	A simple statement such as a method call where the return value is ignored
ExpressionTransformer	Provides a way to transform expressions
ExpressionUtils
ExpressionUtils	Internal utility class for extracting a boolean expression from the given expression or statement.
ExtendedVerifier	A specialized Groovy AST visitor meant to perform additional verifications upon the current AST.
ExtensionMethodCache	This class is used to make extension methods lookup faster.
ExtensionMethodNode	Represents method nodes which are used by the static type checker to virtually add methods coming from DGM-like methods.
ExtensionModule	An extension module is a class responsible for providing a list of meta methods to the Groovy compiler and runtime.
ExtensionModuleRegistry	The extension method registry is responsible for collecting methods (or static methods) which are added to existing classes and may be called like regular methods.
ExtensionModuleScanner	A module extension scanner is responsible for searching classpath modules, loading metadata from module descriptors, then perform custom tasks for each module.
ExtensionModuleScanner.ExtensionModuleListener
ExternalGroovyClassDoc	Represents a class not in the codebase being processed.
ExternalizeMethods	Class annotation used to assist in the creation of Externalizable classes.
ExternalizeMethodsASTTransformation	Handles generation of code for the @ExternalizeMethods annotation.
ExternalizeVerifier	Class annotation used to assist in the creation of Externalizable classes.
ExternalizeVerifierASTTransformation
ExternalStrategy	This strategy is used with the Builder AST transform to populate a builder helper class so that it can be used for the fluent creation of instances of a specified class. The specified class is not modified in any way and may be a Java class.
Factory
FactoryBuilderSupport	Mix of BuilderSupport and SwingBuilder's factory support.
FactorySupport	Support class for creating XML Factories
FastArray
FastStringService
FastStringServiceFactory	Factory method to create the service.
FastStringUtils	Internal class for fast processing of Strings during JSON parsing
Field	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.
FieldASTTransformation	Handles transformation for the @Field annotation.
FieldExpression	Represents a field access such as the expression "this.foo".
FieldNode	Represents a field (member variable)
FieldValues	This utility is meant to be used to replace direct calls to private field variables in class invariants.
FileIterator	FileIterator is an iterator over a number of files from a collection of FileSet instances.
FileOutputTool
FileReaderSource	A ReaderSource for source files.
FileScanner	FileScanner is a bean which allows the iteration over a number of files from a collection of FileSet instances.
FileSystemCompiler	Command-line compiler (aka.
FileSystemCompiler.CompilationOptions
FileSystemCompiler.VersionProvider
FileSystemCompilerFacade	This is a helper class, to provide a controlled entry point for the groovyc ant task forked mode.
FileSystemResourceManager
FileType	Represents particular files of interest.
FileVisitResult	Represents special return values for the 'preDir', 'postDir' and 'visit'/supplied Closures used with ResourceGroovyMethods.traverse(java.io.File, java.util.Map, groovy.lang.Closure) and related methods to control subsequent traversal behavior.
FilteredAttributes	Lazy evaluated representation of a node's attributes filtered by a Closure.
FilteredNodeChildren	Lazy evaluated representation of child nodes filtered by a Closure.
FilterExpression	Represents filter expression
Finalizable
FinalVariableAnalyzer
FinalVariableAnalyzer.VariableNotFinalCallback
FindReplaceUtility
FirstParam	A hint used to instruct the type checker to pick the first parameter type.
FirstParam.Component	A hint used to instruct the type checker to pick the type of the component of the first parameter type, which is therefore expected to be an array, like in this example:
FirstParam.FirstGenericType	A hint used to instruct the type checker to pick the first generic type of the first parameter type.
FirstParam.SecondGenericType	A hint used to instruct the type checker to pick the second generic type of the first parameter type.
FirstParam.ThirdGenericType	A hint used to instruct the type checker to pick the third generic type of the first parameter type.
FloatArrayGetAtMetaMethod
FloatArrayPutAtMetaMethod
FloatCachedClass
FloatingPointMath	FloatingPoint (Double and Float) NumberMath operations
FloatWrapper
FlushingStreamWriter	Stream writer which flushes after each write operation.
FormModel	Represents a number of field models which can be ValueModel, PropertyModel, TableModel, TreeModel or nested FormModel instances
ForStatement	Represents a standard for loop in Groovy
FromAbstractTypeMethods	This signature hint uses abstract methods from some type (abstract class or interface) in order to infer the expected parameter types.
FromExpression	Represents the from expression
FromString	A closure parameter hint class that is convenient if you want to use a String representation of the signature.
FullBinding
Function<T,R>	Backport of Java8 Function.
GContractsASTTransformation	Custom AST transformation that removes closure annotations of Invariant, Requires and Ensures and adds Java assertions executing the closure-code.
GeneralUtils	Handy methods when working with the Groovy AST
Generated	The Generated annotation is used to mark members that have been generated.
GeneratedClosure	Marker interface to identify closures generated by the groovy compiler.
GeneratedGroovyProxy	An interface implemented by some Groovy proxies which gives access to the proxied object.
GeneratedLambda	Marker interface to identify lambda generated by the groovy compiler.
GeneratedMetaMethod
GeneratedMetaMethod.DgmMethodRecord
GeneratedMetaMethod.Proxy
GenerateStubsTask	Generates Java stubs from Groovy sources.
GeneratorContext	A context shared across generations of a class and its inner classes
GenericsType	This class is used to describe generic type signatures for ClassNodes.
GenericsType.GenericsTypeName	Represents GenericsType name TODO In order to distinguish GenericsType with same name(See GROOVY-8409), we should add a property to keep the declaring class.
GenericsUtils	Utility methods to deal with generic types.
GenericsVisitor	Verify correct usage of generics.
GetEffectivePogoFieldSite
GetEffectivePojoPropertySite
GinqAstBuilder	Build the AST for GINQ
GinqAstVisitor<R>	Represents the visitor for AST of GINQ
GinqExpression	Represents GINQ expression, which has the following structure:
GinqSyntaxError	Represents GINQ syntax error
GPathResult	Base class for representing lazy evaluated GPath expressions.
Grab	Used to grab the referenced artifact and its dependencies and make it available on the Classpath.
GrabAnnotationTransformation	Transformation for declarative dependency management.
GrabConfig	Used to modify the grape configuration for grab requests.
GrabExclude	Used to exclude an indirectly referenced artifact (a transitive dependency) from the classpath.
GrabResolver	Used to add a repository for resolving Grape dependencies.
Grape	Facade to GrapeEngine.
GrapeEngine
Grapes	Sometimes we will need more than one grab per class, but we can only add one annotation type per annotatable node.
GrapeUtil
Groovy	Executes a series of Groovy statements.
GroovyAnnotationRef
GroovyAssert	GroovyAssert contains a set of static assertion and test helper methods for JUnit 4+.
GroovyASTTransformation	This is an annotation on a class, currently just ASTTransformation.
GroovyASTTransformationClass	This is an annotation on some item that indicates that an associated transform classes should be executed.
GroovyBugError	This class represents an error that is thrown when a bug is recognized inside the runtime.
Groovyc	Compiles Groovy source files using Ant.
GroovyCallable<V>	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.
GroovyCastException
GroovyCategorySupport	Support methods for Groovy category usage
GroovyCategorySupport.CategoryMethod
GroovyCategorySupport.CategoryMethodList
GroovyCategorySupport.ThreadCategoryInfo
GroovyClass
GroovyClassDoc
GroovyClassLoader	A ClassLoader which can load Groovy classes.
GroovyClassLoader.ClassCollector
GroovyClassLoader.InnerLoader
GroovyClassValue<T>	Abstraction for Java version dependent ClassValue implementations.
GroovyClassValue.ComputeValue<T>
GroovyClassValueJava7<T>	GroovyClassValue implementaion that simply delegates to Java 7's java.lang.ClassValue
GroovyClassVisitor	A special visitor for working with the structure of a class.
GroovyCodeSource	CodeSource wrapper class that allows specific security policies to be associated with a class compiled from groovy source.
GroovyCodeSourcePermission	Permission required to explicitly specify a codebase for a groovy script whose codebase cannot be determined.
GroovyCodeVisitor	An implementation of the visitor pattern for working with ASTNodes.
GroovyCollections	A Collections utility class
GroovyCompiledScript	Used to represent compiled Groovy scripts.
GroovyConstructorDoc
GroovycTask	Compiles Groovy source files.
Groovydoc	An annotation to hold the groovydoc for the annotated element at runtime, we call it "Runtime Groovydoc".
Groovydoc	Represents groovydoc
Groovydoc	Access to the GroovyDoc tool from Ant.
GroovyDoc
GroovyDocErrorReporter
GroovydocHolder<T>	Represents Groovydoc Holder
GroovydocJavaVisitor
GroovydocManager	A utilities for managing groovydoc, e.g.
GroovyDocParser
GroovyDocParserI
GroovydocTag	TODO parse groovydoc to get tag content
GroovyDocTemplateEngine	Process Groovydoc templates.
GroovyDocTemplateInfo
GroovyDocTool
GroovyDocUtil
GroovydocVisitor	A visitor which collects Groovydoc information.
GroovyDocWriter	Write GroovyDoc resources to destination.
GroovyEngine	A BSF Engine for the Groovy scripting language.
GroovyException
GroovyExceptionInterface	An interface for use by all Groovy compiler exceptions.
GroovyExecutableMemberDoc
GroovyFieldDoc
GroovyFilter
GroovyInterceptable	Marker interface used to notify that all methods should be intercepted through the invokeMethod mechanism of GroovyObject.
GroovyLangLexer	The lexer for Groovy programming language, which is based on the lexer generated by Antlr4
GroovyLangParser	The parser for Groovy programming language, which is based on the parser generated by Antlr4
GroovyMain	A Command line to execute groovy.
GroovyMain.VersionProvider
GroovyMBean	A GroovyObject facade for an underlying MBean which acts like a normal groovy object but which is actually implemented via an underlying JMX MBean.
GroovyMemberDoc
GroovyMethodDoc
GroovyObject	The interface implemented by all Groovy objects.
GroovyObjectSupport	Base class for Java objects wishing to be Groovy objects.
GroovyObjectWrapper
GroovyPackageDoc
GroovyParameter
GroovyPrintStream	A PrintStream that outputs objects in Groovy style.
GroovyPrintWriter	A PrintWriter that outputs objects in Groovy style.
GroovyProgramElementDoc
GroovyResourceLoader	Allows frameworks that integrate with Groovy to determine how Groovy files are resolved.
GroovyResultSet	Represents an extent of objects
GroovyResultSetExtension	GroovyResultSetExtension implements additional logic for ResultSet.
GroovyResultSetProxy	GroovyResultSetProxy is used to create a proxy for GroovyResultSet.
GroovyRootDoc
GroovyRootDocBuilder
GroovyRowResult	Represents an extent of objects.
GroovyRunner	Classes which can run scripts should implement this interface.
GroovyRunnerRegistry	Registry of services that implement the GroovyRunner interface.
GroovyRuntimeException	An exception thrown by the interpreter
GroovyScriptEngine	Specific script engine able to reload modified scripts as well as dealing properly with dependent scripts.
GroovyScriptEngineFactory	A factory class conforming to JSR-223 which is used to instantiate Groovy ScriptEngines and also exposes metadata describing Groovy's engine class.
GroovyScriptEngineImpl	JSR-223 Engine implementation.
GroovyServlet	This servlet will run Groovy scripts as Groovlets.
GroovyShell	Represents a groovy shell capable of running arbitrary groovy scripts
GroovySocketServer	Simple server that executes supplied script against a socket.
GroovyStarter	Helper class to initialize the Groovy runtime.
GroovySunClassLoader
GroovySyntaxError	Represents a syntax error of groovy program
GroovySystem
GroovyTag
GroovyTestCase	A JUnit 3 TestCase base class in Groovy.
GroovyTestSuite	A TestSuite which will run a Groovy unit test case inside any Java IDE either as a unit test case or as an application.
GroovyType
GroovyTypeCheckingExtensionSupport	Base class for type checking extensions written in Groovy.
GroovyTypeCheckingExtensionSupport.TypeCheckingDSL
GroupExpression	Represents group by expression
GString	Represents a String which contains embedded values such as "hello there ${user} how are you?" which can be evaluated lazily.
GStringExpression	Represents a String expression which contains embedded values inside it such as "hello there ${user} how are you" which is expanded lazily
GStringImpl	Default implementation of a GString used by the compiler.
GStringTemplateEngine	Processes template source files substituting variables and expressions into placeholders in a template source text to produce the desired output using a streaming approach.
GStringUtil	This class is primarily intended for INTERNAL USE.
HandleMetaClass
HasCleanup	An interface for things that need to be cleaned up after operations complete.
HashCodeHelper	A utility class to help calculate hashcode values using an algorithm similar to that outlined in "Effective Java, Joshua Bloch, 2nd Edition".
HavingExpression	Represents having expression
IFileNameFinder
IfStatement	Represents an if (condition) { ...
IllegalPropertyAccessException	An exception occurred if a dynamic property dispatch fails with a field not accessible.
ImmutableASTTransformation	Handles generation of code for the @Immutable annotation.
ImmutableBase	Class annotation used to assist in the creation of immutable classes.
ImmutableOptions	Class annotation used to assist in the creation of immutable classes.
ImmutablePropertyHandler
ImmutablePropertyUtils
ImportCustomizer	This compilation customizer allows addiing various types of imports to the compilation unit.
ImportCustomizerFactory	This factory allows the generation of an import customizer.
ImportNode	Represents an import statement.
IncorrectClosureArgumentsException	An exception occurred when invoking a Closure with the wrong number and/or types of arguments
IncorrectTypeHintException
Incubating	Annotation to indicate experimental and still to be refined API, which may change at any time
IndentPrinter	A helper class for printing indented text.
IndexedProperty	Field annotation used with properties to provide an indexed getter and setter for the property.
IndexedPropertyASTTransformation	Handles generation of code for the @IndexedProperty annotation.
IndyArrayAccess	Class for handling array access through invokedynamic using static callsite information
IndyBinHelper
IndyCallSiteWriter	Dummy class used by the indy implementation.
IndyGuardsFiltersAndSignatures	This class contains guards, runtime filters and MethodType signatures used by indy.
IndyInterface	Bytecode level interface for bootstrap methods used by invokedynamic.
IndyInterface.CallType	Enum for easy differentiation between call types
IndyMath	This class contains math operations used by indy instead of the normal meta method and call site caching system.
IndyStaticTypesMultiTypeDispatcher	Multi type dispatcher for binary expression backend combining indy and static compilation
InheritConstructors	Class annotation to make constructors from a super class available in a sub class.
InheritConstructorsASTTransformation	Handles generation of code for the @InheritConstructors annotation.
InitializerStrategy	This strategy is used with the Builder AST transform to create a builder helper class for the fluent and type-safe creation of instances of a specified class.
InitializerStrategy.SET	Internal phantom type used by the InitializerStrategy to indicate that a property has been set.
InitializerStrategy.UNSET	Internal phantom type used by the InitializerStrategy to indicate that a property remains unset.
InlinedASTCustomizerFactory	This factory lets a user define a compilation customizer without having to define an anonymous inner class.
InnerClassCompletionVisitor
InnerClassNode	Represents an inner class declaration
InnerClassVisitor
InnerClassVisitorHelper
InOutParameter	A typed parameter passed to, and returned from a CallableStatement.
InParameter	A typed parameter to pass to a query
InputStreamReaderSource	A ReaderSource for source strings.
Inspector	The Inspector provides a unified access to an object's information that can be determined by introspection.
Inspector.MemberComparator
InstanceOfVerifier
IntegerArrayGetAtMetaMethod
IntegerArrayPutAtMetaMethod
IntegerCachedClass
IntegerMath	Integer NumberMath operations
Interceptor	Implementers of this interface can be registered in the ProxyMetaClass for notifications about method calls for objects managed by the ProxyMetaClass.
InterfaceHelperClassNode	Represents an inner class defined as helper for an interface
Internal	The Internal annotation is used to mark members that are internal.
IntRange	Represents a list of Integer objects starting at a specified from value up (or down) to and potentially including a given to value.
IntWrapper
Invariant	Represents a class-invariant.
InvocationWriter
InvokeDynamicWriter	This Writer is used to generate the call invocation byte codes for usage by invokedynamic.
InvokerHelper	A static helper class to make bytecode generation easier and act as a facade over the Invoker
InvokerInvocationException	An exception thrown if a method is called and an exception occurred
IO
IO	Container for input/output handles.
IO.Verbosity	Verbosity for simple logging: QUIET, INFO, VERBOSE, DEBUG
IOGroovyMethods	This class defines new groovy methods for Files, URLs, URIs which appear on normal JDK classes inside the Groovy environment.
IteratorBufferedIterator<T>	An implementation for BufferedIterator wraps Iterator.
IteratorClosureAdapter<T>	A closure which stores calls in a List so that method calls can be iterated over in a 'yield' style way
Janitor	An agent that can be used to defer cleanup operations to a later time.
Java8	Java 8 based functions.
Java9	Additional Java 9 based functions will be added here as needed.
JavaAwareCompilationUnit	Compilation Unit capable of compiling Java source files.
JavaAwareResolveVisitor
JavacCompilerFactory
JavacJavaCompiler
JavaCompiler
JavaCompilerFactory
JavaShell	A shell for compiling or running pure Java code
JavaShellCompilationException
JavaStubCompilationUnit	Compilation unit to only generate stubs.
JavaStubGenerator
JaxbExtensions	This class defines new groovy methods which appear on Jaxb-related JDK classes (JAXBContext, Marshaller) inside the Groovy environment.
JComboBoxProperties
JComponentProperties
JmxBuilderException	Runtime exception used by JmxBuilder.
JmxBuilderModelMBean	The JmxBuilderModelMBean is the MBean class that proxies exported POGO/POJO inside the MBeanServer.
JmxEventEmitter	The JmxEventEmitter is a JMX Broadcaster class that is used to send generic events on the MBeanServer's event bus.
JmxEventEmitterMBean	This is the management interface for JmxEventEmitter.
JmxEventListener	The JmxEventListener class is used by the builder to listen to events on the event bus.
JoinExpression	Represents join expression
JScrollBarProperties
JSliderProperties
JsonBuilder	A builder for creating JSON payloads.
JsonDelegate	Utility class used as delegate of closures representing JSON objects.
JsonException	JsonException is the exception thrown by the JSON builder and slurper classes, whenever a problem occurs when creating or parsing JSON data structures.
JsonFastParser	This works in index overlay mode or chop mode.
JsonGenerator	Generates JSON from objects.
JsonGenerator.Converter	Handles converting a given type.
JsonGenerator.Options	A builder used to construct a JsonGenerator instance that allows control over the serialized JSON output.
JsonLexer	The lexer reads JSON tokens in a streaming fashion from the underlying reader.
JsonOutput	Class responsible for the actual String serialization of the possible values of a JSON structure.
JsonOutput.JsonUnescaped	Represents unescaped JSON
JsonParser	This is the parser interface that backs the new JsonSlurper.
JsonParserCharArray	Converts an input JSON String into Java objects works with String or char array as input.
JsonParserLax
JsonParserType	Allows selection of parser type for new new JsonSlurper.
JsonParserUsingCharacterSource	Converts an input JSON String into Java objects works with String or char array as input.
JsonSlurper	This has the same interface as the original JsonSlurper written for version 1.8.0, but its implementation has completely changed.
JsonSlurperClassic	This is the original slurper included in case someone relies on its exact behavior.
JsonStringDecoder
JsonToken	A JSON token, with a type, line / column information, and the text of that token.
JsonTokenType	The original slurper and lexer use this class.
JSpinnerProperties
JTableProperties
JTextComponentProperties
JUnit5Runner	Integration code for running JUnit5 tests in Groovy.
KnownImmutable	Class annotation used as a marker for immutable classes.
LabelVerifier	This class checks the handling of labels in the AST
LambdaExpression	Represents a lambda expression such as one of these:
LambdaWriter
Lazy	Field annotation to simplify lazy initialization.
LazyASTTransformation	Handles generation of code for the @Lazy annotation
LazyInitializable	A LazyInitializable is an object that can be initialized lazily.
LazyMap	This maps only builds once you ask for a key for the first time.
LazyReference<T>	Soft reference with lazy initialization under lock
LazyValueMap	This class is important to the performance of the parser.
LegacyHashMapPropertyHandler	The @Immutable transformation in earlier versions of Groovy tried to be smart in the case of an immutable class with a single HashMap property, the supplied Map constructor tried to be compatible with both expected tuple behavior and expected named-argument behavior by peeking into the supplied map and guessing as to which approach might be applicable.
LexerAtnManager	Manage ATN for lexer to avoid memory leak
LexerFrame	Swing application to graphically display the tokens produced by the lexer.
Lifecycle	Specifies life-cycle hook-ins for applying AST transformation logic before and after the annotation processors have been run.
LifecycleAfterTransformationVisitor	AST transformation visitor which is triggered after applying AnnotationProcessor related transformations.
LifecycleBeforeTransformationVisitor	AST transformation visitor which is triggered before applying AnnotationProcessor related transformations.
LifecycleImplementationLoader<S>	Finds and loads implementation classes of interface Lifecycle.
LimitExpression	Represents limit expression
LineColumnReader	The LineColumnReader is an extension to BufferedReader that keeps track of the line and column information of where the cursor is.
LinkArgument	Represents a link pair (href, packages).
ListBufferedIterator<T>	An implementation for BufferedIterator wraps ListIterator.
ListExpression	Represents a list expression [1, 2, 3] which creates a mutable List
ListExpressionTransformer
ListHashMap<K,V>	This class represents a Map that is optimized for a small number of entries.
ListOfExpressionsExpression	This class is used internally by the compiler to transform expressions like multiple assignments into a list of assignments.
ListWithDefault<T>	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().
ListWrapperListModel<E>	A ListModel implementation that's backed by a live List.
LoaderConfiguration	Class used to configure a RootLoader from a stream or by using its methods.
LocatedMessage	A base class for compilation messages.
LockableObject	A bit simplified lock designed to be inherited by.
Log	This local transform adds a logging ability to your program using java.util.logging.
Log.JavaUtilLoggingStrategy	This class contains the logic of how to weave a Java Util Logging logger into the host class.
Log4j	This local transform adds a logging ability to your program using Log4j logging.
Log4j.Log4jLoggingStrategy
Log4j2	This local transform adds a logging ability to your program using Log4j2 logging.
Log4j2.Log4j2LoggingStrategy
LogASTTransformation	This class provides an AST Transformation to add a log field to a class.
LogASTTransformation.AbstractLoggingStrategy
LogASTTransformation.AbstractLoggingStrategyV2
LogASTTransformation.LoggingStrategy	A LoggingStrategy defines how to wire a new logger instance into an existing class.
LogASTTransformation.LoggingStrategyV2	A LoggingStrategy defines how to wire a new logger instance into an existing class.
LoggableClassVisitor	A ClassVisitor proxy, which can log bytecode generation
LoggableTextifier	Logging bytecode generation, which can make debugging easy
Logger	Provides a very, very basic logging API.
LoggingHelper	Helper to make logging from Ant easier.
LongArrayGetAtMetaMethod
LongArrayPutAtMetaMethod
LongCachedClass
LongMath	Long NumberMath operations
LongWrapper
LoopingStatement	This is an AST Node that provides some sort of looping mechanism.
LRUCache<K,V>	A cache backed by a ConcurrentLinkedHashMap
Macro
MacroBuilder	Runtime support for
MacroClass	since 2.5.0
MacroClassTransformation	Transforms MacroClass calls into its ClassNode
MacroContext	Macro method context.
MacroGroovyMethods
MacroGroovyMethods.MacroValuePlaceholder
MacroLibGroovyMethods
MacroStub	Stub for macro calls.
MacroTransformation
ManagedConcurrentLinkedQueue<T>	A queue that stores values wrapped in a Reference, the type of which is determined by the provided ReferenceBundle.
ManagedConcurrentMap<K,V>	Deprecated.
ManagedConcurrentMap.Entry<K,V>
ManagedConcurrentMap.EntryWithValue<K,V>
ManagedConcurrentMap.Segment<K,V>
ManagedConcurrentValueMap<K,V>	This is a basic implementation of a map able to forget its values.
ManagedIdentityConcurrentMap<K,V>	This is a basic implementation of a map able to forget its keys could be weak/soft/strong references.
ManagedLinkedList<T>	Deprecated. replaced by ManagedConcurrentLinkedQueue
ManagedReference<T>
MapConstructor	Class annotation used to assist in the creation of map constructors in classes.
MapConstructorASTTransformation	Handles generation of code for the @MapConstructor annotation.
MapEntry	A Map.Entry implementation.
MapEntryExpression	Represents an entry inside a map expression such as 1 : 2.
MapEntryOrKeyValue	A special hint which handles a common use case in the Groovy methods that work on maps.
MapExpression	Represents a map expression [1 : 2, "a" : "b", x : y] which creates a mutable Map
MapItemValue	This holds a mapping from value key to value value to maximize laziness.
Maps	Map utilities.
MapWithDefault<K,V>	A wrapper for Map which allows a default value to be specified.
MarkupBuilder	A helper class for creating XML or HTML markup.
MarkupBuilder.CharFilter
MarkupBuilder.DefaultXmlEscapingFunction
MarkupBuilderHelper	A helper class for MarkupBuilder.
MarkupTemplateEngine	A template engine which leverages StreamingMarkupBuilder to generate XML/XHTML.
MarkupTemplateEngine.CachingTemplateResolver	A template resolver which avoids calling ClassLoader.getResource(String) if a template path already has been queried before.
MarkupTemplateEngine.DefaultTemplateResolver
MarkupTemplateEngine.TemplateResource
MatchingHighlighter	Represents highlighter to highlight matched parentheses, brackets and curly braces when caret touching them
MemJavaFileObject	Represents a Java source file in memory to compile
Memoize	Implements memoize for Closures.
MemoizeCache<K,V>	Represents a memoize cache with its essential methods
MemoizeCache.ValueProvider<K,V>	Represents a provider used to create value
Memoized	Method annotation that creates a cache for the results of the execution of the annotated method.
MemoizedASTTransformation	Handles generation of code for the Memoized annotation.
Message	A base class for compilation messages.
MessageSource	Message source backed up by one or more ResourceBundle instances for simple i18n support.
MetaArrayLengthProperty	Represents the length property of an array
MetaBeanProperty	Represents a property on a bean which may have a getter and/or a setter
MetaClass	A MetaClass within Groovy defines the behaviour of any given Groovy or Java class.
MetaClass<T>	A MetaClass within Groovy defines the behaviour of any given Groovy or Java class
MetaClassConstant<T>	The one and only implementation of a meta class.
MetaClassConstructorSite	Call site for constructor meta class - cached method - not cached
MetaClassHelper
MetaClassImpl	Allows methods to be dynamically added to existing classes at runtime
MetaClassImpl.Index	Deprecated. use LinkedHashMap instead
MetaClassImpl.MetaConstructor	This is a helper class introduced in Groovy 2.1.0, which is used only by indy.
MetaClassRegistry	A MetaClassRegistry is an object that is responsible for managing the a cache of MetaClass instances.
MetaClassRegistry.MetaClassCreationHandle	Class used as base for the creation of MetaClass implementations.
MetaClassRegistryChangeEvent	An event used to propagate meta class updates
MetaClassRegistryChangeEventListener	A listener called whenever a constant MetaClass is set, removed or replaced.
MetaClassRegistryImpl	A registry of MetaClass instances which caches introspection and reflection information and allows methods to be dynamically added to existing classes at runtime
MetaClassSite	Call site which holds reference to meta class.
MetaExpandoProperty	Represents a property in an Expando object
MetaInfExtensionModule	A SimpleExtensionModule implementation which reads extension classes metadata from META-INF.
MetaMethod	Represents a Method on a Java object a little like Method except without using reflection to invoke the method
MetaMethodIndex
MetaMethodIndex.CacheEntry
MetaMethodIndex.Entry
MetaMethodIndex.EntryIterator
MetaMethodIndex.Header
MetaMethodSite	Call site which caches meta method
MetaObjectProtocol	An interface that defines the API usable by clients of Groovy's Meta Object Protocol (MOP).
MetaProperty	Represents a property on a bean which may have a getter and/or a setter
MethodCall	Interface defining common methods for method calls.
MethodCaller	A helper class to invoke methods more easily in ASM
MethodCallerMultiAdapter
MethodCallExpression	A method call on an object or class.
MethodCallExpressionTransformer
MethodCallTransformation
MethodClosure	Represents a method on an object using a closure which can be invoked at any time
MethodHelper	Some reflection helper methods
MethodInvocationTrap
MethodKey	An abstract base class for a key used for comparators and Map keys to lookup a method by name and parameter types
MethodMetaProperty	Wrapper for a method for a property get or set.
MethodMetaProperty.GetBeanMethodMetaProperty	Wrapper for a method realizing the property getter.
MethodMetaProperty.GetMethodMetaProperty	Wrapper for a method realizing the property get.
MethodNode	Represents a method declaration.
MethodNodeUtils	Utility class for working with MethodNodes
MethodPointerExpression	Represents a method pointer on an object such as foo.&bar which means find the method pointer for the bar method on the foo instance.
MethodPointerExpressionWriter	A helper class used to generate bytecode for method pointer expressions.
MethodRankHelper	Utility class for MissingMethodException, MissingPropertyException etc.
MethodReferenceExpression	Represents a method reference or a constructor reference, e.g.
MethodReferenceExpressionWriter	A helper class used to generate bytecode for method reference expressions.
MethodSelectionException	This exception is thrown if the runtime is unable to select a method.
MissingClassException	An exception occurred if a dynamic method dispatch fails with an unknown class.
MissingFieldException	An exception occurred if a dynamic field dispatch fails with an unknown field.
MissingMethodException	An exception occurred if a dynamic method dispatch fails with an unknown method.
MissingMethodExceptionNoStack
MissingMethodExecutionFailed	A stack less exception used to indicate, that the execution of a missingMethod method failed with a MissingMethodException.
MissingPropertyException	An exception occurred if a dynamic property dispatch fails with an unknown property.
MissingPropertyExceptionNoStack
MixedInMetaClass
Mixin	Deprecated. static mixins have been deprecated in favour of traits (trait keyword).
MixinASTTransformation	Deprecated. static mixins have been deprecated in favour of traits (trait keyword).
MixinInMetaClass
MixinInstanceMetaMethod	MetaMethod for mixed in classes
MixinInstanceMetaProperty	MetaProperty for mixed in classes
MixinNode	Represents a mixin which can be applied to any ClassNode to implement mixins
MockOutputTool
MockProxyMetaClass	The ProxyMetaClass for the MockInterceptor.
ModifierNode	Represents a modifier
ModuleNode	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
MopWriter
MopWriter.Factory
MultipleCompilationErrorsException	Represents multiple other exceptions
MultipleSetterProperty	This class represents a property with multiple setters.
MutableMetaClass	An interface that defines methods that implementers of mutable Meta classes should specify.
MutualPropertyBinding
NamedArgumentListExpression	Represents one or more arguments being passed into a method by name
NamedDelegate	Marker interface used to indicate that the property names of the annotated parameter represent valid key names when using named arguments and that the property types are applicable for type checking purposes.
NamedParam	Marker interface used to indicate that the name of the annotated parameter (or specified optional name) is a valid key name when using named arguments and that the parameter type is applicable for type checking purposes.
NamedParams	Collector annotation for NamedParam.
NamedVariant	Allows construction of a named-arg equivalent method or constructor.
NamedVariantASTTransformation
Namespace	A simple helper class which acts as a factory of QName instances.
NamespaceAwareHashMap
NamespaceBuilder	A helper class for creating namespaces for GroovyMarkup
NamespaceBuilderSupport	A helper class for creating namespaced GroovyMarkup
NestedValueModel	Represents a nested value model such as a PropertyModel or a ClosureModel
Newify	Annotation that supports writing constructor call expressions without the 'new' keyword.
NewifyASTTransformation	Handles generation of code for the @Newify AST transform.
NewInstanceMetaMethod	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.
NewMetaMethod	Base class for NewInstanceMetaMethod and NewStaticMetaMethod
NewStaticMetaMethod	A MetaMethod implementation where the underlying method is really a static helper method on some class.
NioExtensions	This class defines new groovy methods for Readers, Writers, InputStreams and OutputStreams which appear on normal JDK classes inside the Groovy environment.
NoChildren	Lazy evaluated representation of a GPath expression returning no children.
Node	Represents an arbitrary tree node which can be used for structured metadata or any arbitrary XML-like tree.
Node	Represents a node.
NodeBuilder	A helper class for creating nested trees of Node objects for handling arbitrary data
NodeChild	Lazy evaluated representation of a child node.
NodeChildren	Lazy evaluated representation of child nodes.
NodeComparator
NodeIterator	Helper class for iterating through nodes.
NodeList	A List implementation which is returned by queries on a Node which provides some XPath like helper methods for GPath.
NodeMetaDataHandler	An interface to mark a node being able to handle metadata.
NodeParents	Lazy evaluated representation of parent nodes without duplicates
NodePrinter	A helper class for creating nested trees of data
NonEmptySequence	Represents a sequence of one or more objects of a given type.
NotExpression
NotYetImplemented	Method annotation used to invert test case results.
NotYetImplementedASTTransformation	Generates code for the @NotYetImplemented annotation.
NullCallSite
NullCheck	Class, method or constructor annotation which indicates that each parameter should be checked to ensure it isn't null.
NullCheckASTTransformation	Handles generation of code for the @NullCheck annotation.
NullObject
NullProtectionStorage	A NullObject pattern implementation for ProtectionStorage Doesn't protect any resources.
NullWriter	An Writer than eats its input.
NumberAwareComparator<T>	Compares two objects using Groovy's friendly comparison algorithm, i.e.
NumberCachedClass
NumberMath	Stateless objects used to perform math on the various Number subclasses.
NumberMathModificationInfo
NumberNumberDiv
NumberNumberMetaMethod
NumberNumberMetaMethod.NumberNumberCallSite
NumberNumberMinus
NumberNumberMultiply
NumberNumberPlus
NumberRange	Represents an immutable list of Numbers from a value to a value with a particular step size.
Numbers	Helper class for processing Groovy numeric literals.
NumberValue
ObjectArrayGetAtMetaMethod
ObjectArrayPutAtMetaMethod
ObjectCachedClass
ObjectGraphBuilder	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.
ObjectGraphBuilder.ChildPropertySetter	Strategy for setting a child node on its parent. Useful for handling Lists/Arrays vs normal properties.
ObjectGraphBuilder.ClassNameResolver	Strategy for resolving a classname.
ObjectGraphBuilder.DefaultChildPropertySetter	Default impl that calls parent.propertyName = child If parent.propertyName is a Collection it will try to add child to the collection.
ObjectGraphBuilder.DefaultClassNameResolver	Default impl that capitalizes the classname.
ObjectGraphBuilder.DefaultIdentifierResolver	Default impl, always returns 'id'
ObjectGraphBuilder.DefaultNewInstanceResolver	Default impl that calls Class.newInstance()
ObjectGraphBuilder.DefaultReferenceResolver	Default impl, always returns 'refId'
ObjectGraphBuilder.DefaultRelationNameResolver	Default impl that returns parentName and childName accordingly.
ObjectGraphBuilder.IdentifierResolver	Strategy for picking the correct synthetic identifier.
ObjectGraphBuilder.NewInstanceResolver	Strategy for creating new instances of a class. Useful for plug-in calls to non-default constructors.
ObjectGraphBuilder.ReferenceResolver	Strategy for picking the correct synthetic reference identifier.
ObjectGraphBuilder.RelationNameResolver	Strategy for resolving a relationship property name.
ObjectHolder<T>	Just hold an object
ObjectRange	Represents an inclusive list of objects from a value to a value using comparators.
ObservableList	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.
ObservableList.ChangeType
ObservableList.ElementAddedEvent
ObservableList.ElementClearedEvent
ObservableList.ElementEvent
ObservableList.ElementRemovedEvent
ObservableList.ElementUpdatedEvent
ObservableList.MultiElementAddedEvent
ObservableList.MultiElementRemovedEvent
ObservableMap	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.
ObservableMap.ChangeType
ObservableMap.MultiPropertyEvent
ObservableMap.PropertyAddedEvent
ObservableMap.PropertyClearedEvent
ObservableMap.PropertyEvent
ObservableMap.PropertyRemovedEvent
ObservableMap.PropertyUpdatedEvent
ObservableSet<E>	Set 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.
ObservableSet.ChangeType
ObservableSet.ElementAddedEvent
ObservableSet.ElementClearedEvent
ObservableSet.ElementEvent
ObservableSet.ElementRemovedEvent
ObservableSet.MultiElementAddedEvent
ObservableSet.MultiElementRemovedEvent
OldVariableGenerationUtility	Central place where code generation for the old closure variable takes place.
OnExpression	Represents on expression
OperandStack
OptimizerVisitor	Visitor to produce several optimizations: to replace numbered constants with references to static fields remove superfluous references to GroovyObject interface
OptimizingStatementWriter
OptimizingStatementWriter.ClassNodeSkip
OptimizingStatementWriter.StatementMeta
Option	Indicates that a method or property can be used to set a CLI option.
OrderBy<T>	A helper class for sorting objects via a closure to return the field or operation on which to sort.
OrderExpression	Represents order by expression
OutParameter	A parameter to be returned from a CallableStatement.
OutputTool
OwnedMetaClass
PackageNode	Represents a package in the AST.
PackageScope	Annotation used for turning off Groovy's auto visibility conventions.
PackageScopeASTTransformation	Handles transformation for the @PackageScope annotation.
PackageScopeTarget	Intended target when @PackageScope is placed at the class level.
Parameter	Represents a parameter on a constructor or method call.
ParameterTypes
ParameterUtils
ParserAtnManager	Manage ATN for parser to avoid memory leak
ParserException
ParserPlugin	A simple extension point to allow us to switch between the classic Groovy parser and the new Antlr based parser(s).
ParserPluginFactory	A factory of parser plugin instances.
PerInstancePojoMetaClassSite
PermutationGenerator<E>	Systematically generate permutations.
Phases	Compilation phase identifiers.
PickAnyArgumentHint	Base class for hints which use the type of a parameter of the annotated method as the signature.
PickFirstResolver	Returns the first of several candidates found.
PlainObjectMetaMethodSite	Plain ordinary object call site meta class - cached method - cached
PlatformLineWriter	A buffered writer that gobbles any \r characters and replaces every \n with a platform specific newline.
PlatformLog	This local transform adds a logging ability to your program using java.logging.
PlatformLog.JavaUtilLoggingStrategy	This class contains the logic of how to weave a Java platform logger into the host class.
PluginDefaultGroovyMethods	Defines new Groovy methods which appear on standard Java 8 classes within the Groovy environment.
PluginDefaultGroovyMethods	Defines new Groovy methods which appear on normal JDK 9 classes inside the Groovy environment.
PogoGetPropertySite
PogoInterceptableSite	Call site for GroovyInterceptable
PogoMetaClassGetPropertySite
PogoMetaClassSite
PogoMetaMethodSite	POGO call site meta class - cached method - cached
PogoMetaMethodSite.PogoCachedMethodSite
PogoMetaMethodSite.PogoCachedMethodSiteNoUnwrap
PogoMetaMethodSite.PogoCachedMethodSiteNoUnwrapNoCoerce
PogoMetaMethodSite.PogoMetaMethodSiteNoUnwrap	Call site where we know there is no need to unwrap arguments
PogoMetaMethodSite.PogoMetaMethodSiteNoUnwrapNoCoerce	Call site where we know there is no need neither unwrap nor coerce arguments
POJO	Marker interface to indicate that the normal GroovyObject methods should not be added.
PojoMetaClassGetPropertySite
PojoMetaClassSite	POJO call site meta class - cached method - not cached
PojoMetaMethodSite	POJO call site meta class - cached method - cached
PojoMetaMethodSite.PojoCachedMethodSite
PojoMetaMethodSite.PojoCachedMethodSiteNoUnwrap
PojoMetaMethodSite.PojoCachedMethodSiteNoUnwrapNoCoerce
PojoMetaMethodSite.PojoMetaMethodSiteNoUnwrap	Call site where we know there is no need to unwrap arguments
PojoMetaMethodSite.PojoMetaMethodSiteNoUnwrapNoCoerce	Call site where we know there is no need neither unwrap nor coerce arguments
PojoWrapper
PositionConfigureUtils	Utilities for configuring node positions
PositionInfo
PostCompletionFactory	A helper interface for factories which require post processing of generated nodes.
Postcondition	Indicates that annotations being marked as @Postcondition are to be treated as post-condition modifying annotations.
Postcondition	A post-condition assertion.
PostconditionGenerator	Code generator for postconditions.
PostconditionLifecycle	Internal Lifecycle implementation for post-conditions.
PostconditionViolation	Thrown whenever a postcondition violation occurs.
PostfixExpression	Represents a postfix expression like foo++ or bar++
PowerAssertionError	Indicates that a power assertion has failed.
Precondition	Indicates that annotations being marked as @Precondition are to be treated as pre-condition modifying annotations.
Precondition	A pre-condition assertion.
PreconditionGenerator	Code generator for preconditions.
PreconditionLifecycle	Internal Lifecycle implementation for pre-conditions.
PreconditionViolation	Thrown whenever a precondition violation occurs.
Preferences	Container for shell preferences.
PrefixExpression	Represents a prefix expression like ++foo or --bar
PrimitiveHelper
ProcessExpression	Represents process expression, e.g.
ProcessGroovyMethods	This class defines new groovy methods which appear on normal JDK classes related to process management.
ProcessGroovyMethods.ProcessRunner	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.
ProcessingContextInformation	Holds all context-specific information which is needed during the transformation phase of a single Contract and its related ClassNode.
ProcessingUnit	A base class for data structures that can collect messages and errors during processing.
PropertiesModuleFactory	This is the base class for classes responsible for creating modules using properties.
PropertyAccessInterceptor	An interface that adds the ability to intercept property getters/setters
PropertyAccessor
PropertyBinding
PropertyBinding.UpdateStrategy
PropertyChangeProxyTargetBinding
PropertyExpression	Represents a property access such as the expression "foo.bar".
PropertyHandler	Used to provide custom property handling when getting, setting or initializing properties.
PropertyModel	Represents a property of a value as a model.
PropertyNode	Represents a property (member variable, a getter and setter)
PropertyNodeUtils
PropertyOptions	Marker annotation used to indicate that special property handling code will be generated for this class.
PropertyPathFullBinding	A property path full binding
PropertyReader
PropertyValue
PropertyWriter
Proxy	Dynamic groovy proxy for another object.
ProxyGenerator	Classes to generate 'Proxy' objects which implement interfaces, maps of closures and/or extend classes/delegates.
ProxyGeneratorAdapter	A proxy generator responsible for mapping a map of closures to a class implementing a list of interfaces.
ProxyMetaClass	As subclass of MetaClass, ProxyMetaClass manages calls from Groovy Objects to POJOs.
QName	QName class represents the value of a qualified name as specified in XML Schema Part2: Datatypes specification.
Queryable<T>	Represents the queryable objects, e.g.
Queryable.Order<T,U extends Comparable<? super U>>	Represents an order rule
Range<T extends Comparable>	A Range represents the list of discrete items between some starting (or from) value and working up towards some ending (or to) value.
RangeExpression	Represents a range expression such as for iterating.
RangeExpressionTransformer	This transformer focuses on ranges to produce optimized bytecode.
RangeInfo
RawJavaFileObject	Represents a Java source file in file to compile
ReaderCharacterSource
ReaderSource	An interface for things that can supply (and potentially resupply) a Reader on a source stream.
ReadException	Encapsulates non-specific i/o exceptions.
ReadOnlyPropertyException	This exception is thrown if an attempt is made to set a read only property
ReadWriteLockASTTransformation	Handles generation of code for the @WithReadLock and @WithWriteLock annotation. This transformation adds an instance of ReentrantReadWriteLock to the class. Any method annotated with @WithReadLock will obtain a read lock and release it in a finally block. Any method annotated with @WithWriteLock will obtain a write lock and release it in a finally block. For more information see WithReadLock and WithWriteLock
Realm	A Realm is the representation of a metaclass layer in a tree of realm objects.
Receiver<T>
RecordBase	Class annotation used to assist in the creation of record-like classes.
RecordTypeASTTransformation	Handles generation of code for the @RecordType annotation.
Reduction	A syntax reduction, produced by the Parser.
ReevaluatingReference<T>	This class represents a reference to the most actual incarnation of a Metaclass.
Reference<T>	Represents a reference to a value
Reference<T,V extends Finalizable>
ReferenceBundle
ReferenceManager
ReferenceType
ReflectionCache
ReflectionMetaMethod
ReflectionMethodInvoker	Utility class to call methods through reflection, and falls through using the Invoker to call the method if it fails.
ReflectionUtils	This class contains utility methods to determine which class called the current class to multiple levels of depth.
Reflector	Provides as alternative to reflection using bytecode generation.
ReflectorLoader	Reflector creation helper.
RegexSupport	Used to store the last regex match.
ReleaseInfo	Exposes the Groovy release information
ReplacementNode	Helper base class used for lazy updates.
Requires	Represents a method precondition.
RequiresAnnotationProcessor	Internal AnnotationProcessor implementation for pre-conditions.
ResolveVisitor	Visitor to resolve Types and convert VariableExpression to ClassExpressions if needed.
ResourceConnector	Base interface for customizing where resources can be found for the GroovyScriptEngine.
ResourceException
ResourceGroovyMethods	This class defines new groovy methods for Readers, Writers, InputStreams and OutputStreams which appear on normal JDK classes inside the Groovy environment.
ResourceManager
ResultSetMetaDataWrapper	This class defines a wrapper for accessing a specific column in ResultSetMetaData.
ResultSetOutParameter	A ResultSet out parameter.
ReturnAdder	Utility class to add return statements.
ReturnAdder.ReturnStatementListener
ReturnStatement	A return statement
ReverseListIterator<T>	A reverse iterator over a list.
RootLoader	This ClassLoader should be used as root of class loaders.
RootLoaderRef	Sets the RootLoader as reference.
RuntimeParserException	A helper class to allow parser exceptions to be thrown anywhere in the code.
SAXBuilder	A builder for generating W3C SAX events.
Script	This object represents a Groovy script
ScriptBytecodeAdapter	A static helper class to interface bytecode and runtime
ScriptException
ScriptExtensions	This class defines new Java 6 specific groovy methods which extend the normal JDK classes inside the Groovy environment.
ScriptReference	Represents a reference to a variable in a script
ScriptRunner	The tool to simulate running script files via groovy command
ScriptStaticExtensions	This class defines new Java 6 specific static groovy methods which extend the normal JDK classes inside the Groovy environment.
ScriptTestAdapter	An adapter to make any Groovy Script class an instance of a JUnit Test
SecondParam	A hint used to instruct the type checker to pick the second parameter type.
SecondParam.Component	A hint used to instruct the type checker to pick the type of the component of the second parameter type, which is therefore expected to be an array, like in this example:
SecondParam.FirstGenericType	A hint used to instruct the type checker to pick the first generic type of the second parameter type.
SecondParam.SecondGenericType	A hint used to instruct the type checker to pick the second generic type of the second parameter type.
SecondParam.ThirdGenericType	A hint used to instruct the type checker to pick the second generic type of the second parameter type.
SecureASTCustomizer	This customizer allows securing source code by controlling what code constructs are permitted.
SecureASTCustomizer.ExpressionChecker	This interface allows the user to provide a custom expression checker if the dis/allowed expression lists are not sufficient
SecureASTCustomizer.StatementChecker	This interface allows the user to provide a custom statement checker if the dis/allowed statement lists are not sufficient
SecureASTCustomizerFactory	This factory allows the generation of a SecureASTCustomizer.
SelectExpression	Represents the select expression
Selector
SelfType	This annotation can be added on a trait to declare the list of types that a class implementing that trait is supposed to extend.
SemanticPredicates	Some semantic predicates for altering the behaviour of the lexer and parser
Sequence	Represents a sequence of zero or more objects of a given type.
ServletBinding	Servlet-specific binding extension to lazy load the writer or the output stream from the response.
ServletCategory	Servlet support.
SharedVariableCollector	A visitor which collects the list of variable expressions which are closure shared.
ShortArrayGetAtMetaMethod
ShortArrayPutAtMetaMethod
ShortCachedClass
ShortTypeHandling	Class providing various short paths for type conversions.
ShortWrapper
SignatureCodec	A signature codec is responsible for encoding and decoding of inferred returned types as stored in bytecode.
SignatureCodecVersion1	First implementation of an inferred type signature codec.
SimpleCache<K,V>
SimpleExtensionModule	An extension module which provides extension methods using a DefaultGroovyMethods-like implementation, that is to say using static methods defined in an "extension class".
SimpleGroovyAbstractableElementDoc
SimpleGroovyAnnotationRef
SimpleGroovyClassDoc
SimpleGroovyConstructorDoc
SimpleGroovyDoc
SimpleGroovyExecutableMemberDoc
SimpleGroovyFieldDoc
SimpleGroovyMemberDoc
SimpleGroovyMethodDoc
SimpleGroovyPackageDoc
SimpleGroovyParameter
SimpleGroovyProgramElementDoc
SimpleGroovyRootDoc
SimpleGroovyTag	Stores info about GroovyDoc tags.
SimpleGroovyType
SimpleMessage	A base class for compilation messages.
SimpleStrategy	This strategy is used with the Builder AST transform to modify your Groovy objects so that the setter methods for properties return the original object, thus allowing chained usage of the setters.
SimpleTemplateEngine	Processes template source files substituting variables and expressions into placeholders in a template source text to produce the desired output.
SimpleType
SingleKeyHashMap	Deprecated.
SingleKeyHashMap.Copier
SingleKeyHashMap.Entry
SingleQuoteFilter
SingleSignatureClosureHint	A simplified version of a ClosureSignatureHint which is suitable for monomorphic closures, that is to say closures which only respond to a single signature.
Singleton	Class annotation to make a singleton class.
SingletonASTTransformation	Handles generation of code for the @Singleton annotation
Slf4j	This local transform adds a logging ability to your program using LogBack logging.
Slf4j.Slf4jLoggingStrategy
SmartDocumentFilter	The document filter based on Parrot's lexer is for highlighting the content of text editor
SocketGroovyMethods	This class defines new groovy methods for Sockets which enhance JDK classes inside the Groovy environment.
Sortable	A class annotation used to make a class Comparable by (potentially) multiple Comparators.
SortableASTTransformation	Injects a set of Comparators and sort methods.
SourceAwareCustomizer	A base class for customizers which only have to be applied on specific source units.
SourceAwareCustomizerFactory	Factory for use with CompilerCustomizationBuilder.
SourceAwareCustomizerFactory.SourceOptions
SourceBinding
SourceExtensionHandler	Looks for source file extensions in META-INF/services/org.codehaus.groovy.source.Extensions
SourceText	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.
SourceTextNotAvailableException	Indicates that the source text for an assertion statement is not available.
SourceUnit	Provides an anchor for a single source unit (usually a script file) as it passes through the compiler system.
SourceURI	Variable annotation used for getting the URI of the current script.
SourceURIASTTransformation	Handles transformation for the @SourceURI annotation.
SpreadExpression	Represents a spread expression *x in the list expression [1, *x, 2].
SpreadListEvaluatingException
SpreadMap	Helper to turn a list with an even number of elements into a Map.
SpreadMapEvaluatingException
SpreadMapExpression	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).
Sql	A facade over Java's normal JDBC APIs providing greatly simplified resource management and result set handling.
SqlExtensions	This class defines all the new SQL-related groovy methods which enhance the normal JDK SQL classes when inside the Groovy environment.
SqlOrderByVisitor
SqlWhereVisitor
SqlWithParams
StackTraceUtils	Originally was grails.utils.GrailsUtils, removed some grails specific stuff.
StampedCommonCache<K,V>	Represents a simple key-value cache, which is thread safe and backed by a Map instance.
StandardControlToUndefined
StandardPropertiesModuleFactory	This is the standard Groovy module factory.
StandardXmlAttributeFilter
StandardXmlFilter
Statement	Base class for any statement.
StatementMetaTypeChooser	A TypeChooser which is aware of statement metadata.
StatementWriter
StaticCompilationMetadataKeys	Static compilation AST node metadata keys.
StaticCompilationMopWriter	A MOP Writer that skips the generation of MOP methods.
StaticCompilationTransformer	Some expressions use symbols as aliases to method calls (<<, +=, ...).
StaticCompilationVisitor	This visitor is responsible for amending the AST with static compilation metadata or transform the AST so that a class or a method can be statically compiled.
StaticCompileTransformation	Handles the implementation of the CompileStatic transformation.
StaticImportVisitor	Visitor to resolve constants and method calls from static imports.
StaticInvocationWriter
StaticMetaClassSite	Call site for invoking static methods meta class - cached method - not cached
StaticMetaMethodSite	POJO call site meta class - cached method - cached
StaticMetaMethodSite.StaticMetaMethodSiteNoUnwrap	Call site where we know there is no need to unwrap arguments
StaticMetaMethodSite.StaticMetaMethodSiteNoUnwrapNoCoerce	Call site where we know there is no need neither unwrap nor coerce arguments
StaticMethodCallExpression	A static method call on a class
StaticMethodCallExpressionTransformer
StaticPropertyAccessHelper	Facilitates the generation of statically-compiled bytecode for property access.
StaticTypeCheckingSupport	Support methods for StaticTypeCheckingVisitor.
StaticTypeCheckingSupport.BooleanArrayStaticTypesHelper
StaticTypeCheckingSupport.ByteArrayStaticTypesHelper
StaticTypeCheckingSupport.CharArrayStaticTypesHelper
StaticTypeCheckingSupport.DoubleArrayStaticTypesHelper
StaticTypeCheckingSupport.FloatArrayStaticTypesHelper
StaticTypeCheckingSupport.IntArrayStaticTypesHelper
StaticTypeCheckingSupport.LongArrayStaticTypesHelper
StaticTypeCheckingSupport.ObjectArrayStaticTypesHelper	A DGM-like class which adds support for method calls which are handled specifically by the Groovy compiler.
StaticTypeCheckingSupport.ShortArrayStaticTypesHelper
StaticTypeCheckingVisitor	The main class code visitor responsible for static type checking.
StaticTypeCheckingVisitor.SignatureCodecFactory
StaticTypesBinaryExpressionMultiTypeDispatcher	A specialized version of the multi type binary expression dispatcher which is aware of static compilation.
StaticTypesCallSiteWriter	A call site writer which replaces call site caching with static calls.
StaticTypesClosureWriter	Writer responsible for generating closure classes in statically compiled mode.
StaticTypesLambdaWriter	Writer responsible for generating lambda classes in statically compiled mode.
StaticTypesMarker	This enumeration is used by the AST transformations which rely on static type checking, either to store or to retrieve information from AST node metadata.
StaticTypesMethodReferenceExpressionWriter	Writer responsible for generating method reference in statically compiled mode.
StaticTypesStatementWriter	A class to write out the optimized statements.
StaticTypesTransformation	Handles the implementation of the TypeChecked transformation.
StaticTypesTypeChooser	A TypeChooser which reads type information from node metadata generated by the static type checker.
StaticTypesUnaryExpressionHelper	An expression helper which generates optimized bytecode depending on the current type on top of the operand stack.
StaticTypesWriterController	An alternative WriterController which handles static types and method dispatch.
StaticTypesWriterControllerFactoryImpl
StaticVerifier	Checks for dynamic variables in static contexts.
StreamingJsonBuilder	A builder for creating JSON payloads.
StreamingJsonBuilder.StreamingJsonDelegate	The delegate used when invoking closures
StreamingMarkupWriter
StreamingTemplateEngine	Processes template source files substituting variables and expressions into placeholders in a template source text to produce the desired output using a closure based approach.
StringBufferWriter	This class codes around a silly limitation of StringWriter which doesn't allow a StringBuffer to be passed in as a constructor for some bizarre reason.
StringBuilderWriter	Copied from https://github.com/apache/commons-io/blob/master/src/main/java/org/apache/commons/io/output/StringBuilderWriter.java Writer implementation that outputs to a StringBuilder.
StringCachedClass
StringEscapeUtils	Escapes and unescapes Strings for Java, Java Script, HTML, XML, and SQL.
StringGroovyMethods	This class defines new groovy methods which appear on String-related JDK classes (String, CharSequence, Matcher) inside the Groovy environment.
StringHelper
StringReaderSource	A ReaderSource for source strings.
StringSetMap
StringUtils	Utilities for handling strings
StringWriterIOException	An IO exception occurred trying to append to a StringWriter which should never happen.
StructuredSyntaxDocumentFilter
StructuredSyntaxHandler
StructuredSyntaxResources	Contains all the basic resources and values used by the utility frame work framework.
SunClassLoader	Special class loader, which when running on Sun VM allows to generate accessor classes for any method
Supplier<T>	Backport of Java8 Supplier.
SurrogateToUndefined	Convert surrogate chars to XML undefined character.
SwingExtensions	This class defines all the new Swing-related groovy methods which enhance the normal JDK Swing classes when inside the Groovy environment.
SwingTimerTriggerBinding
SwitchStatement	Represents a switch (object) { case value: ...
Synchronized	Method annotation to make a method call synchronized for concurrency handling with some useful baked-in conventions.
SynchronizedASTTransformation	Handles generation of code for the @Synchronized annotation.
SynchronizedStatement	Represents a synchronized statement
SyntaxErrorMessage	A class for error messages produced by the parser system.
SyntaxErrorReportable	Supports reporting the syntax error of GINQ
SyntaxErrorReportable	A SyntaxErrorReportable is a recognizer that can report syntax error
SyntaxException	Base exception indicating a syntax error.
SystemOutputInterceptor	Intercepts System.out/System.err.
SystemUtil
TableLayout	Represents a HTML style table layout
TableLayoutCell	Represents a cell in a table layout.
TableLayoutRow	Represents a row in a table layout
TableMap	In a chain of data manipulators some behaviour is common.
TableSorter	A sorter for TableModels.
TargetBinding
Template	A template is a block of text with an associated binding that can be output to a writer or evaluated to a string.
TemplateConfiguration	Configuration options for the markup template engine.
TemplateEngine	A template engine is a factory for creating a Template instance for a given text input.
TemplateExecutionException	A custom exception class to flag template execution errors
TemplateParseException	A custom exception class to flag template parsing errors
TemplateResolver	Interface for template resolvers, which, given a template identifier, return an URL where the template can be loaded.
TemplateServlet	A generic servlet for serving (mostly HTML) templates.
TemporaryMethodKey	A temporary implementation of MethodKey used to perform a fast lookup for a method using a set of arguments to a method
TemporaryVariableExpression	A front-end class for ExpressionAsVariableSlot which allows defining temporary variables loaded from variable slots directly at the AST level, without any knowledge of AsmClassGenerator.
TernaryExpression	Represents a ternary expression (booleanExpression) ? expression : expression
TestNgRunner	Integration code for running TestNG tests in Groovy.
TextEditor	A simple text pane that is printable and wrapping is optional.
TextUndoManager	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).
ThirdParam	A hint used to instruct the type checker to pick the third parameter type.
ThirdParam.Component	A hint used to instruct the type checker to pick the type of the component of the third parameter type, which is therefore expected to be an array, like in this example:
ThirdParam.FirstGenericType	A hint used to instruct the type checker to pick the first generic type of the third parameter type.
ThirdParam.SecondGenericType	A hint used to instruct the type checker to pick the second generic type of the third parameter type.
ThirdParam.ThirdGenericType	A hint used to instruct the type checker to pick the second generic type of the third parameter type.
ThreadManagedMetaBeanProperty	This MetaBeanProperty will create a pseudo property whose value is bound to an object using weak references.
ThrowStatement	Represents a throw statement
TimeCategory	Apply a number of methods to allow convenient Date/Time manipulation,such as:
TimeDatumDependentDuration	TimeDatumDuration represents a time period which results from an arithmetic operation between a TimeDuration object and a DatumDuration object
TimeDuration	TimeDuration represents time periods expressed in units of hours, minutes, seconds and milliseconds.
Token	A CSTNode produced by the Lexer.
TokenException
TokenMismatchException
TokenUtil	Utility methods for working with Tokens.
TooManyValuesException	Thrown when too many values returned by sub-query in the select clause
ToString	Class annotation used to assist in the creation of toString() methods in classes.
ToStringASTTransformation	Handles generation of code for the @ToString annotation.
TracingInterceptor
Trait	Used to mark a class as being a trait.
TraitASTTransformation	Handles generation of code for the traits (trait keyword is equivalent to using the @Trait annotation).
TraitComposer	This class contains a static utility method TraitComposer.doExtendTraits(org.codehaus.groovy.ast.ClassNode, org.codehaus.groovy.control.SourceUnit, org.codehaus.groovy.control.CompilationUnit) aimed at generating code for a classnode implementing a trait.
Traits	A collection of utility methods used to deal with traits.
Traits.Implemented	Internal annotation used to indicate which methods in a trait interface have a default implementation.
Traits.TraitBridge	Internal annotation used to indicate that a method is a bridge method to a trait default implementation.
TraitTypeCheckingExtension	A type checking extension that will take care of handling errors which are specific to traits.
TransformingCodeVisitor
TransformMetaMethod	A MetaMethod implementation useful for implementing coercion based invocations
TreeContext
TreeContextAction
TriggerBinding
TripleKeyHashMap	Deprecated.
TripleKeyHashMap.Entry
TryCatchBlockGenerator	Creates a try-catch block around a given AssertStatement and catches a PowerAssertionError to reuse the generated visual output.
TryCatchStatement	Represents a try { ...
TryWithResourcesASTTransformation	Transform try-with-resources to try-catch-finally Reference JLS "14.20.3.
Tuple<E>	Represents a list of Objects.
Tuple0	Represents a list of 0 typed Object.
Tuple1<T1>	Represents a list of 1 typed Object.
Tuple10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>	Represents a list of 10 typed Objects.
Tuple11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>	Represents a list of 10 typed Objects.
Tuple12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>	Represents a list of 12 typed Objects.
Tuple13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>	Represents a list of 13 typed Objects.
Tuple14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>	Represents a list of 14 typed Objects.
Tuple15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>	Represents a list of 15 typed Objects.
Tuple16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>	Represents a list of 16 typed Objects.
Tuple2<T1,T2>	Represents a list of 2 typed Objects.
Tuple3<T1,T2,T3>	Represents a list of 3 typed Objects.
Tuple4<T1,T2,T3,T4>	Represents a list of 4 typed Objects.
Tuple5<T1,T2,T3,T4,T5>	Represents a list of 5 typed Objects.
Tuple6<T1,T2,T3,T4,T5,T6>	Represents a list of 6 typed Objects.
Tuple7<T1,T2,T3,T4,T5,T6,T7>	Represents a list of 7 typed Objects.
Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>	Represents a list of 8 typed Objects.
Tuple9<T1,T2,T3,T4,T5,T6,T7,T8,T9>	Represents a list of 9 typed Objects.
TupleConstructor	Class annotation used to assist in the creation of tuple constructors in classes.
TupleConstructorASTTransformation	Handles generation of code for the @TupleConstructor annotation.
TupleExpression
Type
TypeChecked	This will let the Groovy compiler use compile time checks in the style of Java.
TypeChecked.TypeCheckingInfo	This annotation is added by @TypeChecked on methods which have type checking turned on.
TypeCheckingContext
TypeCheckingContext.EnclosingClosure	Represents the context of an enclosing closure.
TypeCheckingExtension	This interface defines a high-level API for handling type checking errors.
TypeCheckingMode	This enumeration can be used whenever it is preferred to annotate a class as TypeChecked in general, but where only one or more methods are "dynamic".
TypeChooser	Interface for modules which are capable of resolving the type of an expression.
TypedOption<T>
TypeHelper	This class contains helper methods for converting and comparing types.
Types	Typing information for the CST system.
TypeTransformers	This class contains several transformers for used during method invocation.
TypeUtil	A utility for getting information of types
UberCompileTask	Compiles Java and Groovy source files.
UnaryExpressionHelper	A helper class used to generate bytecode for unary expressions.
UnaryMinusExpression
UnaryPlusExpression
UncheckedThrow	Allows to throw a checked exception unchecked.
Undefined	Java doesn't allow you to have null as an attribute value.
Undefined.CLASS
Undefined.EXCEPTION
UnicodeConst
UnlimitedConcurrentCache<K,V>	A cache backed by a ConcurrentHashMap
Unparsed	Indicates that a method or property will contain the remaining arguments.
URLReaderSource	A ReaderSource for source files hosted at a URL.
URLStreams
Utilities	Various utility functions for use in the compiler.
Validate	Internal utility class for in-code assertion checks.
Value
Value	A value recorded during evaluation of an assertion, along with the column it is associated with in the assertion's normalized source text.
ValueContainer
ValueConvertable<V1,V2>	To support caches whose values are convertable, e.g.
ValueHolder	A simple ValueModel implementation which is a holder of an object value.
ValueList
ValueMap<K,V>
ValueMapImpl	This map is for object serialization mainly.
ValueModel	Represents a model of a value
ValueRecorder	Records values produced during evaluation of an assertion statement's truth expression.
Variable	interface to mark a AstNode as Variable.
VariableExpression	Represents a local variable name, the simplest form of expression.
VariableExpressionTransformer	Transformer for VariableExpression the bytecode backend wouldn't be able to handle otherwise.
VariableScope	Records declared and referenced variabes for a given scope.
VariableScopeVisitor	Initializes the variable scopes for an AST.
VariableSlotLoader
Verifier	Verifies the AST node and adds any default AST code before bytecode generation occurs.
Verifier.DefaultArgsAction
VerifierCodeVisitor	Performs various checks on code inside methods and constructors including checking for valid field, variables names etc.
VerifyClass	Verify Class files.
Vetoable	Annotates a groovy property or a class.
VetoableASTTransformation	Handles generation of code for the @Vetoable annotation, and @Bindable if also present.
ViolationTracker	A violation tracker is used to keep a list of pre-, post-condition or class-invariant violations in chronological order.
Visibility	Indicates the visibility of a node.
VisibilityOptions	Marker annotation used in the context of AST transformations to provide a custom visibility.
VisibilityUtils
VMPlugin	Interface to access VM version based actions.
VMPluginFactory	Factory class to get functionality based on the VM version.
WarningMessage	A class for warning messages.
Weigher<V>	A class that can determine the weight of a value.
Weighers	A common set of Weigher and EntryWeigher implementations.
WhereExpression	Represent the where expression
WhileStatement	Represents a while (condition) { ...
WideningCategories	This class provides helper methods to determine the type from a widening operation for example for a plus operation.
WideningCategories.LowestUpperBoundClassNode	This ClassNode specialization is used when the lowest upper bound of two types cannot be represented by an existing type.
WithReadLock	This annotation is used in conjunction with WithWriteLock to support read and write synchronization on a method.
WithWriteLock	This annotation is used in conjunction with WithReadLock to support read and write synchronization on a method.
Wrapper
Writable	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.
WritableFile	A Writable File.
WritablePath	A Writable Path.
WriterController
WriterControllerFactory	A non static factory to get alternative writer controller to be stored in the meta data
XmlExtensions	This class defines all the new XML-related groovy methods which enhance the normal JDK XML classes when inside the Groovy environment.
XmlNodePrinter	Prints a groovy.util.Node (as used with XmlParser) including all children in XML format.
XmlNodePrinter.NamespaceContext
XmlParser	A helper class for parsing XML into a tree of Node instances for a simple way of processing XML.
XmlSlurper	Parse XML into a document tree that may be traversed similar to XPath expressions.
XmlTemplateEngine	Template engine for use in templating scenarios where both the template source and the expected output are intended to be XML.
XmlUtil	Used for pretty printing XML content and other XML related utilities.
XStreamUtils
YamlBuilder	A builder for creating YAML payloads.
YamlConverter	A converter for converting YAML to JSON, vice versa
YamlRuntimeException	Represents runtime exception occurred when parsing or building YAML
YamlSlurper	Represents a YAML parser