All Classes

Base class for all call sites

A base class dealing with common HTTP servlet API housekeeping aspects.

For ReaderSources that can choose a parent class, a base that provides common functionality.

Custom type checking extensions may extend this method in order to benefit from a lot of support methods.

An aggregation of multiple bindings

The AnnotationCollector can be used to define aliases for groups of annotations.

Class used by CompilationUnit to transform the alias class into what is needed by the compiler.

Visitor to resolve constants in annotation definitions.

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

An interface for processing antlr AST objects

A parser plugin which adapts the JSR Antlr Parser to the Groovy runtime

Represents an array object construction either using a fixed size or an initializer expression

Creates a string representation of an assertion and its recorded values.

Represents an assert statement.

A common base class of AST helper methods which can be shared across the classic and new parsers

Thrown when trying to parse the AST

This AST transformation aims at helping in debugging other AST transformations.

This class is instantiated and invoked when an AST transformation is activated.

Stores state information about global AST transformations applied to a compilation unit.

Lazy evaluated representation of a node attribute.

Lazy evaluated representation of a node's attributes.

Handles generation of code for the @AutoClone annotation.

Base class for date and time durations.

Base JSON parser.

Variable annotation used for changing the base script class of the current script.

All templates compiled through MarkupTemplateEngine extend this abstract class, which provides a number of utility methods to generate markup.

Class which delegates to a Statement but keeps track of a batch count size.

Binary write operations specialised for Booleans

Represents two expressions and an operation

This class is for internal use only! This class will dispatch to the right type adapters according to the kind of binary expression that is provided.

Handles generation of code for the @Bindable annotation when @Vetoable is not present.

This class returns half bound FullBindings on the source half to the model object for every property reference (and I do mean every, valid or not, queried before or not).

The bind path object.

A list of statements and a scope.

Helper class for internal use only.

Handles generation of code for the Builder annotation.

An abstract base class for creating arbitrary nested trees of objects or events

An utility class which can be used in test cases to dump generated bytecode.

A helper class for bytecode generation with AsmClassGenerator.

This class contains methods special to optimizations used directly from bytecode in Groovy 1.8

This class represents a sequence of BytecodeInstructions or ASTNodes.

Cache

Class annotation used to assist in the creation of mutable classes.

Represents a case statement in a switch statement

Transforms an instance-style Groovy class or interface to become a static-style conventional Groovy category.

Reader implementation that can read from String, StringBuffer, StringBuilder, CharBuffer or GString.

Utility class to guess the encoding of a given text file.

Represents access to a Java/Groovy class in an expression, such as when invoking a static method or accessing a static type

Abstract base class for generator of Java class versions of Groovy AST classes

This class is a Helper for ClassNode and classes handling ClassNodes.

Represents a class in the AST.

Helper class to return either a SourceUnit or ClassNode.

A Comparator which uses a closure to compare 2 values being equal

Represents a closure expression such as { statement } or { i -> statement } or { i, x, String y -> statement }

An interface for MetaMethods that invoke closures to implements.

A meta class for closures generated by the Groovy compiler.

Represents a value model using a closure to extract the value from some source model and an optional write closure for updating the value.

Abstract base class for any GroovyCodeVisitor which by default just walks the code and expression tree

Thrown when compilation fails from source errors.

A callback interface you can use to "accompany" the classgen() code as it traverses the ClassNode tree.

An callback interface for use in the applyToPrimaryClassNodes loop driver.

An callback interface for use in the applyToSourceUnits loop driver.

A convenience front end for getting standard compilations done.

This class is a helper for AsmClassGenerator.

Support for compilation related tasks.

A composite of many visitors.

A Serializable class for barrier lock

A ConfigObject at a simple level is a Map that creates configuration entries (other ConfigObjects) when referencing them.

Base class for console

Represents a constant expression such as null, true, false

Call site for invoking static methods meta class - cached method - not cached

Call site where we know there is no need neither unwrap nor coerce arguments

This class is a general adapter to map a call to a Java interface to a given delegate.

This class is a general adapter to adapt a map of closures to any Java interface.

A wrapper for Closure to support currying.

An enhancement of Groovy's Sql class providing support for accessing and querying databases using POGO fields and operators rather than JDBC-level API calls and RDBMS column names.

Represents one or more local variables.

A default implementation of MethodKey

Support methods for DefaultGroovyMethods and PluginDefaultMethods.

WARNING: This class is for internal use only! We use this class to store information about if a default MetaClass is used for certain primitives.

A default implementation of MethodKey

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.

A default table model made up of PropertyModels on a Value model.

The default type checking handler is used by the standard type checker and doesn't handle any of the type checking errors by default.

Field annotation to automatically delegate part of the functionality of an owner class to the annotated field.

This annotation can be used by API or DSL writers to document parameters which accept a closure.

This class will delegate all calls to a WriterController given in the constructor.

A writer which delegates to another writer and supports an additional indenting level.

Script that performs method invocations and property access like Closure does.

Use this exception to mark a method implementation as being deprecated.

A helper class for creating a W3C DOM tree

A SAX handler for turning XML into Groovy scripts

Duration represents time periods which have values independent of the context.

Represents a short ternary expression x ?: y, which is equal to

Constructing Ranges like 0..<0

A buffered writer only for OutputStreamWriter that is aware of the encoding of the OutputStreamWriter.

Keep this constant in a separate file as it is troublesome for Antlr to parse for doc purposes.

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

Provides services for reporting compilation errors to the user.

Identifies a variable to be expanded into the sql string rather than representing a placeholder.

ExpandoMetaClass is a MetaClass that behaves like an Expando, allowing the addition or replacement of methods, properties and constructors on the fly.

Represents a base class for expressions which evaluate as an object

A simple statement such as a method call where the return value is ignored

A specialized Groovy AST visitor meant to perform additional verifications upon the current AST.

An extension module is a class responsible for providing a list of meta methods to the Groovy compiler and runtime.

A module extension scanner is responsible for searching classpath modules, loading metadata from module descriptors, then perform custom tasks for each module.

Represents a class not in the codebase being processed.

Handles generation of code for the @ExternalizeMethods annotation.

Support class for creating XML Factories

Internal class for fast processing of Strings during JSON parsing

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.

Represents a field access such as the expression "this.foo".

FileIterator is an iterator over a number of files from a collection of FileSet instances.

A ReaderSource for source files.

Command-line compiler (aka.

Represents special return values for the 'preDir', 'postDir' and 'visit'/supplied Closures used with DefaultGroovyMethods.traverse(java.io.File, java.util.Map, groovy.lang.Closure) and related methods to control subsequent traversal behavior.

Lazy evaluated representation of child nodes filtered by a Closure.

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:

A hint used to instruct the type checker to pick the second generic type of the first parameter type.

A simple iterator over an ordered (flat) List of the nodes of the AST.

FloatingPoint (Double and Float) NumberMath operations

Stream writer which flushes after each write operation.

Represents a standard for loop in Groovy

A closure parameter hint class that is convenient if you want to use a String representation of the signature.

Handy methods when working with the Groovy AST

An interface implemented by some Groovy proxies which gives access to the proxied object.

Generates Java stubs from Groovy sources.

This class is used to describe generic type signatures for ClassNodes.

class used to verify correct usage of generics in class header (class and superclass declaration)

Used to grab the referenced artifact and its dependencies and make it available on the Classpath.

Used to modify the grape configuration for grab requests.

Used to add a repository for resolving Grape dependencies.

Executes a series of Groovy statements.

GroovyAssert contains a set of static assertion and test helper methods and is supposed to be a Groovy extension of JUnit 4's Assert class.

This is an annotation on a class, currently just ASTTransformation.

This class represents an error that is thrown when a bug is recognized inside the runtime.

A special "marker" style interface allowing Groovy classes to implement both Runnable and Callable yet give preference to Runnable (for backwards compatibility) for APIs having both Runnable and Callable methods.

A ClassLoader which can load Groovy classes.

A special visitor for working with the structure of a class.

Permission required to explicitly specify a codebase for a groovy script whose codebase cannot be determined.

A Collections utility class

Access to the GroovyDoc tool from Ant.

Write GroovyDoc resources to destination.

DO NOT USE.

A Command line to execute groovy.

The interface implemented by all Groovy objects.

A PrintStream that outputs objects in Groovy style.

Allows frameworks that integrate with Groovy to determine how Groovy files are resolved.

GroovyResultSetExtension implements additional logic for ResultSet.

Represents an extent of objects.

An exception thrown by the interpreter

A factory class conforming to JSR-223 which is used to instantiate Groovy ScriptEngines and also exposes metadata describing Groovy's engine class.

This servlet will run Groovy scripts as Groovlets.

Simple server that executes supplied script against a socket.

This is a Token sub class to track line information

A TestSuite which will run a Groovy unit test case inside any Java IDE either as a unit test case or as an application.

Represents a String expression which contains embedded values inside it such as "hello there ${user} how are you" which is expanded lazily

Processes template source files substituting variables and expressions into placeholders in a template source text to produce the desired output using a streaming approach.

An interface for things that need to be cleaned up after operations complete.

An exception occurred if a dynamic property dispatch fails with a field not accessible.

Handles generation of code for the @Immutable annotation.

This factory allows the generation of an import customizer.

An exception occurred when invoking a Closure with the wrong number and/or types of arguments

A helper class for printing indented text.

Handles generation of code for the @IndexedProperty annotation.

Dummy class used by the indy implementation.

Bytecode level interface for bootstrap methods used by invokedynamic.

This class contains math operations used by indy instead of the normal meta method and call site caching system.

Handles generation of code for the @InheritConstructors annotation.

Internal phantom type used by the InitializerStrategy to indicate that a property has been set.

This factory lets a user define a compilation customizer without having to define an anonymous inner class.

Represents an inner class declaration

A typed parameter to pass to a query

The Inspector provides a unified access to an object's information that can be determined by introspection.

Implementers of this interface can be registered in the ProxyMetaClass for notifications about method calls for objects managed by the ProxyMetaClass.

Represents a list of Integer objects from a specified int up (or down) to and including a given to.

A static helper class to make bytecode generation easier and act as a facade over the Invoker

A closure which stores calls in a List so that method calls can be iterated over in a 'yield' style way

Java 6 based functions.

No additional Java 8 based functionality in 2_4_X

Java 1.5 Recognizer Run 'java Main [-showtree] directory-full-of-java-files' [The -showtree option pops up a Swing frame that shows the AST constructed from the parser.] Run 'java Main ' Contributing authors: Jeremy Rayner groovy@ross-rayner.com John Mitchell johnm@non.net Terence Parr parrt@magelang.com John Lilley jlilley@empathy.com Scott Stanchfield thetick@magelang.com Markus Mohnen mohnen@informatik.rwth-aachen.de Peter Williams pete.williams@sun.com Allan Jacobs Allan.Jacobs@eng.sun.com Steve Messick messick@redhills.com John Pybus john@pybus.org Version 1.00 December 9, 1997 -- initial release Version 1.01 December 10, 1997 fixed bug in octal def (0..7 not 0..8) Version 1.10 August 1998 (parrt) added tree construction fixed definition of WS,comments for mac,pc,unix newlines added unary plus Version 1.11 (Nov 20, 1998) Added "shutup" option to turn off last ambig warning.

Runtime exception used by JmxBuilder.

The JmxEventEmitter is a JMX Broadcaster class that is used to send generic events on the MBeanServer's event bus.

The JmxEventListener class is used by the builder to listen to events on the event bus.

Utility class used as delegate of closures representing JSON objects.

This works in index overlay mode or chop mode.

Class responsible for the actual String serialization of the possible values of a JSON structure.

This is the parser interface that backs the new JsonSlurper.

Converts an input JSON String into Java objects works with String or char array as input.

This is the original slurper included in case someone relies on its exact behavior.

A JSON token, with a type, line / column information, and the text of that token.

This class checks the handling of labels in the AST

Handles generation of code for the @Lazy annotation

Soft reference with lazy initialization under lock

The LineColumnReader is an extension to BufferedReader that keeps track of the line and column information of where the cursor is.

Represents a list expression [1, 2, 3] which creates a mutable List

This class represents a Map that is optimized for a small number of entries.

A wrapper for List which automatically grows the list when either ListWithDefault.get(int) or ListWithDefault.getAt(int) is called with an index greater than or equal to size().

Class used to configure a RootLoader from a stream or by using its methods.

A bit simplified lock designed to be inherited by.

This class contains the logic of how to weave a Java Util Logging logger into the host class.

Provides a very, very basic logging API.

A cache backed by a Collections.SynchronizedMap

This is a basic implementation of a map able to forget its values.

Represents an entry inside a map expression such as 1 : 2.

Represents a map expression [1 : 2, "a" : "b", x : y] which creates a mutable Map

A wrapper for Map which allows a default value to be specified.

A helper class for MarkupBuilder.

A template resolver which avoids calling ClassLoader.getResource(String) if a template path already has been queried before.

Represents a memoize cache with its essential methods

Handles generation of code for the Memoized annotation.

Message source backed up by one or more ResourceBundle instances for simple i18n support.

Represents a property on a bean which may have a getter and/or a setter

Call site for constructor meta class - cached method - not cached

Allows methods to be dynamically added to existing classes at runtime

This is a helper class introduced in Groovy 2.1.0, which is used only by indy.

Class used as base for the creation of MetaClass implementations.

A listener called whenever a constant MetaClass is set, removed or replaced.

Call site which holds reference to meta class

A SimpleExtensionModule implementation which reads extension classes metadata from META-INF.

An interface that defines the API usable by clients of Groovy's Meta Object Protocol (MOP).

Interface defining common methods for method calls.

Some reflection helper methods

Wrapper for a method for a property get or set.

Wrapper for a method realizing the property get.

Represents a method pointer on an object such as foo.&bar which means find the method pointer on foo for the method called "bar" which is equivalent to foo.metaClass.getMethodPointer(foo, "bar")

This exception is thrown if the runtime is unable to select a method.

An exception occurred if a dynamic method dispatch fails with an unknown class.

An exception occurred if a dynamic method dispatch fails with an unknown method.

A stack less exception used to indicate, that the execution of a missingMethod method failed with a MissingMethodException.

MetaProperty for mixed in classes

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

This class represents a property with multiple setters.

A simple helper class which acts as a factory of QName instances.

A helper class for creating namespaces for GroovyMarkup

Represents a nested value model such as a PropertyModel or a ClosureModel

Handles generation of code for the @Newify AST transform.

Base class for NewInstanceMetaMethod and NewStaticMetaMethod

This class defines new groovy methods for Readers, Writers, InputStreams and OutputStreams which appear on normal JDK classes inside the Groovy environment.

Represents an arbitrary tree node which can be used for structured metadata or any arbitrary XML-like tree.

A visitor that prints a html tags of each node to the supplied PrintStream

Lazy evaluated representation of a child node.

A simple antlr AST visitor that collects all nodes into a List.

A List implementation which is returned by queries on a Node which provides some XPath like helper methods for GPath.

A helper class for creating nested trees of data

Represents a sequence of objects which represents one or many instances of of objects of a given type.

Method annotation used to invert test case results.

A NullObject pattern implementation for ProtectionStorage Doesn't protect any resources.

Compares two objects using Groovy's friendly comparison algorithm, i.e.

Stateless objects used to perform math on the various Number subclasses.

Helper class for processing Groovy numeric literals.

Strategy for setting a child node on its parent.
Useful for handling Lists/Arrays vs normal properties.

Default impl that calls parent.propertyName = child
If parent.propertyName is a Collection it will try to add child to the collection.

Default impl, always returns 'id'

Default impl, always returns 'refId'

Strategy for picking the correct synthetic identifier.

Strategy for picking the correct synthetic reference identifier.

Represents an inclusive list of objects from a value to a value using comparators.

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.

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.

A class to write out the optimized statements

A parameter to be returned from a CallableStatement.

Annotation used for turning off Groovy's auto visibility conventions.

Intended target when @PackageScope is placed at the class level.

Distinguish a parameter array from Object[].

A simple extension point to allow us to switch between the classic Groovy parser and the new Antlr based parser

Compilation phase identifiers.

A buffered writer that gobbles any \r characters and replaces every \n with a platform specific newline.

POGO call site meta class - cached method - cached

Call site where we know there is no need to unwrap arguments

POJO call site meta class - cached method - cached

Call site where we know there is no need to unwrap arguments

Represents a postfix expression like foo++ or bar++

Container for shell preferences.

This class mutates the Java AST, whilst it is still a Java AST, in readiness for conversion to Groovy, yippee-ky-a !

This class defines new groovy methods which appear on normal JDK classes related to process management.

A base class for data structures that can collect messages and errors during processing.

An interface that adds the ability to intercept property getters/setters

Represents a property of a value as a model.

Classes to generate 'Proxy' objects which implement interfaces, maps of closures and/or extend classes/delegates.

As subclass of MetaClass, ProxyMetaClass manages calls from Groovy Objects to POJOs.

A Range represents the list of all items obtained by starting from a from value and calling next() successively until you reach the to value.

This transformer focuses on ranges to produce optimized bytecode.

Encapsulates non-specific i/o exceptions.

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

A syntax reduction, produced by the Parser.

Utility class to call methods through reflection, and falls through using the Invoker to call the method if it fails.

Provides as alternative to reflection using bytecode generation.

Used to store the last regex match.

Helper base class used for lazy updates.

Base interface for customizing where resources can be found for the GroovyScriptEngine.

This class defines new groovy methods for Readers, Writers, InputStreams and OutputStreams which appear on normal JDK classes inside the Groovy environment.

This class defines a wrapper for accessing a specific column in ResultSetMetaData.

Utility class to add return statements.

A return statement

This ClassLoader should be used as root of class loaders.

A helper class to allow parser exceptions to be thrown anywhere in the code.

This object represents a Groovy script

Represents a reference to a variable in a script

An adapter to make any Groovy Script class an instance of a JUnit Test

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:

A hint used to instruct the type checker to pick the second generic type of the second parameter type.

This customizer allows securing source code by controlling what code constructs are allowed.

This interface allows the user to plugin custom statement checkers if statement blacklist or whitelist are not sufficient

Represents a sequence of objects which represents zero or many instances of of objects of a given type.

Servlet support.

First implementation of an inferred type signature codec.

An extension module which provides extension methods using a DefaultGroovyMethods-like implementation, that is to say using static methods defined in an "extension class".

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.

A simplified version of a ClosureSignatureHint which is suitable for monomorphic closures, that is to say closures which only respond to a single signature.

Handles generation of code for the @Singleton annotation

A class annotation used to make a class Comparable by multiple Comparators.

A base class for customizers which only have to be applied on specific source units.

A simple buffer that provides line/col access to chunks of source code held within itself.

Looks for source file extensions in META-INF/services/org.codehaus.groovy.source.Extensions

An antlr AST visitor that prints groovy source code for each visited node to the supplied PrintStream.

Indicates that the source text for an assertion statement is not available.

Variable annotation used for getting the URI of the current script.

Represents a spread expression *x in the list expression [1, *x, 2].

Helper to turn a list with an even number of elements into a Map.

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).

This class defines all the new SQL-related groovy methods which enhance the normal JDK SQL classes when inside the Groovy environment.

Originally was grails.utils.GrailsUtils, removed some grails specific stuff.

Base class for any statement

A MOP Writer that skips the generation of MOP methods.

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.

Visitor to resolve constants and method calls from static Imports

Call site for invoking static methods meta class - cached method - not cached

Call site where we know there is no need to unwrap arguments

A static method call on a class

Contains helper methods aimed at facilitating the generation of statically compiled bytecode for property access.

The main class code visitor responsible for static type checking.

A specialized version of the multi type binary expression dispatcher which is aware of static compilation.

Writer responsible for generating closure classes in statically compiled mode.

A class to write out the optimized statements

A TypeChooser which reads type information from node metadata generated by the CompileStatic annotation.

An alternative WriterController which handles static types and method dispatch.

Verifier to check non-static access in static contexts

The delegate used when invoking closures

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.

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.

Escapes and unescapes Strings for Java, Java Script, HTML, XML, and SQL.

Contains all the basic resources and values used by the utility frame work framework.

This class defines all the new Swing-related groovy methods which enhance the normal JDK Swing classes when inside the Groovy environment.

Represents a switch (object) { case value: ...

Handles generation of code for the @Synchronized annotation.

A class for error messages produced by the parser system.

Intercepts System.out/System.err.

Represents a HTML style table layout

Represents a row in a table layout

A sorter for TableModels.

A template is a block of text with an associated binding that can be output to a writer or evaluated to a string.

Represents an API to any template engine which is basically a factory of Template instances from a given text input.

A custom exception class to flag template parsing errors

A generic servlet for serving (mostly HTML) templates.

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.

Integration code for running TestNG tests in Groovy.

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).

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:

A hint used to instruct the type checker to pick the second generic type of the third parameter type.

This MetaBeanProperty will create a pseudo property whose value is bound to an object using weak references.

Apply a number of methods to allow convenient Date/Time manipulation,such as:

TimeDuration represents time periods expressed in units of hours, minutes, seconds and milliseconds.

Utility methods for working with Tokens.

Handles generation of code for the @ToString annotation.

Used to mark a class as being a trait.

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.

Internal annotation used to indicate which methods in a trait interface have a default implementation.

A type checking extension that will take care of handling errors which are specific to traits.

Helper Class for Antlr AST traversal and visitation.

Represents a try { ...

Represents a list of 2 typed Objects.

Handles generation of code for the @TupleConstructor annotation.

This annotation is added by @TypeChecked on methods which have type checking turned on.

Represents the context of an enclosing closure.

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".

This class contains helper methods for converting and comparing types.

This class contains several transformers for used during method invocation.

A helper class used to generate bytecode for unary expressions.

GRECLIPSE-805 Support for unicode escape sequences

A ReaderSource for source files hosted at a URL.

This map is for object serialization mainly.

Records values produced during evaluation of an assertion statement's truth expression.

Represents a local variable name, the simplest form of expression.

Represents a variable scope.

Verify Class files.

Handles generation of code for the @Vetoable annotation, and @Bindable if also present.

A default implementation of all visitor methods.

Factory class to get functionality based on the VM version.

Represents a while (condition) { ...

This ClassNode specialization is used when the lowest upper bound of two types cannot be represented by an existing type.

This annotation is used in conjunction with WithReadLock to support read and write synchronization on a method.

Represents an object which is capable of writing itself to a text stream in a more efficient format than just creating a toString() representation of itself.

A Writable Path.

A non static factory to get alternative writer controller to be stored in the meta data

Prints a groovy.util.Node (as used with XmlParser) including all children in XML format.

A helper class for parsing XML into a tree of Node instances for a simple way of processing XML.

Template engine for use in templating scenarios where both the template source and the expected output are intended to be XML.