# Package groovy.lang

Core Groovy language classes for implementing data structures, closures, metadata and so forth.

See: Description

Interface Summary
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 java.lang.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 Summary
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 the length property of an array
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.
Tuple2<T1,T2>: Represents a list of 2 typed Objects.

Exception Summary
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 Types Summary
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: Parameter annotation used to specify the delegate for a `@DelegatesTo` annotated parameter of the same method.
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.

## Package groovy.lang Description

Core Groovy language classes for implementing data structures, closures, metadata and so forth.