See: Description
| Interface | Description |
|---|---|
| AdaptingMetaClass |
An interface for MetaClass instances that "adapt" other MetaClass instances such as a proxy or
delegating MetaClass.
|
| Buildable | |
| ClosureInvokingMethod |
An interface for MetaMethods that invoke closures to implements.
|
| GeneratedGroovyProxy |
An interface implemented by some Groovy proxies which gives access to the proxied object.
|
| 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.
|
| GroovyInterceptable |
Marker interface used to notify that all methods should be intercepted through the
invokeMethod mechanism
of GroovyObject. |
| GroovyObject |
The interface implemented by all Groovy objects.
|
| GroovyResourceLoader |
Allows frameworks that integrate with Groovy to determine how Groovy files are resolved.
|
| Interceptor |
Implementers of this interface can be registered in the ProxyMetaClass for
notifications about method calls for objects managed by the ProxyMetaClass.
|
| MetaClass |
A MetaClass within Groovy defines the behaviour of any given Groovy or Java class.
|
| MetaClassRegistry |
A MetaClassRegistry is an object that is responsible for managing the a cache of MetaClass instances.
|
| MetaClassRegistryChangeEventListener |
A listener called whenever a constant MetaClass is set, removed or replaced.
|
| MetaObjectProtocol |
An interface that defines the API usable by clients of Groovy's Meta Object Protocol (MOP).
|
| MutableMetaClass |
An interface that defines methods that implementers of mutable Meta classes should specify.
|
| PropertyAccessInterceptor |
An interface that adds the ability to intercept
property getters/setters
|
| Range<T extends Comparable> |
A Range represents the list of all items obtained by starting from a
from value and calling next() successively
until you reach the to value. |
| 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.
|
| Class | Description |
|---|---|
| BenchmarkInterceptor |
Interceptor that registers the timestamp of each method call
before and after invocation.
|
| 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.
|
| Closure<V> |
Represents any closure object in Groovy.
|
| DelegatingMetaClass | |
| EmptyRange |
Constructing Ranges like 0..<0
|
| 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
|
| GroovyClassLoader |
A ClassLoader which can load Groovy classes.
|
| GroovyClassLoader.ClassCollector | |
| GroovyClassLoader.InnerLoader | |
| GroovyCodeSource |
CodeSource wrapper class that allows specific security policies to be associated with a class
compiled from groovy source.
|
| GroovyObjectSupport |
A useful base class for Java objects wishing to be Groovy objects
|
| GroovyShell |
Represents a groovy shell capable of running arbitrary groovy scripts
|
| GroovySystem | |
| GString |
Represents a String which contains embedded values such as "hello there
${user} how are you?" which can be evaluated lazily.
|
| IntRange |
Represents a list of Integer objects from a specified int up (or down) to and including
a given to.
|
| 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(). |
| MapWithDefault<K,V> |
A wrapper for Map which allows a default value to be specified.
|
| MetaArrayLengthProperty |
Represents a property on a bean which may have a getter and/or a setter
|
| MetaBeanProperty |
Represents a property on a bean which may have a getter and/or a setter
|
| MetaClassImpl |
Allows methods to be dynamically added to existing classes at runtime
|
| MetaClassImpl.Index | |
| MetaClassImpl.MetaConstructor |
This is a helper class introduced in Groovy 2.1.0, which is used only by
indy.
|
| MetaClassRegistry.MetaClassCreationHandle |
Class used as base for the creation of MetaClass implementations.
|
| MetaClassRegistryChangeEvent |
An event used to propagate meta class updates
|
| MetaExpandoProperty |
Represents a property in an Expando object
|
| MetaMethod |
Represents a Method on a Java object a little like
Method
except without using reflection to invoke the method |
| MetaProperty |
Represents a property on a bean which may have a getter and/or a setter
|
| NonEmptySequence |
Represents a sequence of objects which represents one or many instances of
of objects of a given type.
|
| ObjectRange |
Represents an inclusive list of objects from a value to a value using
comparators.
|
| ParameterArray |
Distinguish a parameter array from Object[].
|
| PropertyValue | |
| ProxyMetaClass |
As subclass of MetaClass, ProxyMetaClass manages calls from Groovy Objects to POJOs.
|
| Reference<T> |
Represents a reference to a value
|
| Script |
This object represents a Groovy script
|
| Sequence |
Represents a sequence of objects which represents zero or many instances of
of objects of a given type.
|
| SpreadMap |
Helper to turn a list with an even number of elements into a Map.
|
| TracingInterceptor | |
| Tuple |
Represents a list of Objects.
|
| Exception | Description |
|---|---|
| ClosureException |
An exception thrown by a closure invocation
|
| DeprecationException |
Use this exception to mark a method implementation as being deprecated.
|
| GroovyRuntimeException |
An exception thrown by the interpreter
|
| IllegalPropertyAccessException |
An exception occurred if a dynamic property dispatch fails with a
field not accessible.
|
| IncorrectClosureArgumentsException |
An exception occurred when invoking a Closure with the wrong number and/or
types of arguments
|
| 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.
|
| MissingPropertyException |
An exception occurred if a dynamic property dispatch fails with an unknown property.
|
| ReadOnlyPropertyException |
This exception is thrown if an attempt is made to set a read only property
|
| SpreadListEvaluatingException | |
| SpreadMapEvaluatingException | |
| StringWriterIOException |
An IO exception occurred trying to append to a StringWriter which should never happen.
|
| Annotation Type | Description |
|---|---|
| Category |
Transforms an instance-style Groovy class or interface to become a static-style
conventional Groovy category.
|
| Delegate |
Field annotation to automatically delegate part of the functionality of an owner class to the annotated field.
|
| DelegatesTo |
This annotation can be used by API or DSL writers to document parameters which accept a closure.
|
| DelegatesTo.Target | |
| Grab |
Used to grab the referenced artifact and its dependencies and make it available on the Classpath.
|
| 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.
|
| Grapes |
Sometimes we will need more than one grab per class, but we can only add
one annotation type per annotatable node.
|
| Lazy |
Field annotation to simplify lazy initialization.
|
| Mixin | Deprecated
static mixins have been deprecated in favour of traits (trait keyword).
|
| Newify |
Annotation that supports writing constructor call expressions without the 'new'
keyword.
|
| Singleton |
Class annotation to make a singleton class.
|
Core Groovy language classes for implementing data structures, closures, metadata and so forth.