Groovy 1.7.10

## groovy.lang
[Java] Class Closure

    java.lang.Object
      groovy.lang.GroovyObjectSupport
          groovy.lang.Closure

All Implemented Interfaces:
  Cloneable, Runnable, Serializable

    public abstract class Closure
    extends GroovyObjectSupport

Represents any closure object in Groovy.

Groovy allows instances of Closures to be called in a short form. For example:

       def a = 1
       def c = {a}
       assert c() == 1

To be able to use a Closure in this way with your own subclass, you need to provide a doCall method with any signature you want to. This ensures that getMaximumNumberOfParameters() and getParameterTypes() will work too without any additional code. If no doCall method is provided a closure must be used in its long form like

       def a = 1
       def c = {a}
       assert c.call() == 1

Authors:
  James Strachan
  John Wilson
  Jochen Theodorou
  Graeme Rocher

Version:
  \$Revision: 21242 \$

Field Summary
`static int` | `DELEGATE_FIRST` With this resolveStrategy set the closure will attempt to resolve property references to the delegate first
`static int` | `DELEGATE_ONLY` With this resolveStrategy set the closure will resolve property references to the delegate only and entirely bypass the owner
`static int` | `DONE`
`static int` | `OWNER_FIRST` With this resolveStrategy set the closure will attempt to resolve property references to the owner first
`static int` | `OWNER_ONLY` With this resolveStrategy set the closure will resolve property references to the owner only and not call the delegate at all
`static int` | `SKIP`
`static int` | `TO_SELF` With this resolveStrategy set the closure will resolve property references to itself and go through the usual MetaClass look-up process.
`protected int` | `maximumNumberOfParameters`
`protected Class[]` | `parameterTypes`

Constructor Summary
`Closure(Object owner, Object thisObject)`
`Closure(Object owner)` Constructor used when the "this" object for the Closure is null.

Method Summary

`Closure`

`asWritable()`

Returns:
  a version of this closure which implements Writable.

`Object` | `call()` Invokes the closure without any parameters, returning any value if applicable.
`Object` | `call(Object[] args)`
`Object` | `call(Object arguments)` Invokes the closure, returning any value if applicable.
`Object` | `clone()`
`Closure` | `curry(Object[] arguments)` Support for Closure currying.
`Object` | `getDelegate()` @return the delegate Object to which method calls will go which is typically the outer class when the closure is constructed
`int` | `getDirective()` @return Returns the directive.
`int` | `getMaximumNumberOfParameters()` @return the maximum number of parameters a doCall method of this closure can take
`Object` | `getOwner()` @return the owner Object to which method calls will go which is typically the outer class when the closure is constructed
`Class[]` | `getParameterTypes()` @return the parameter types of the longest doCall method of this closure
`Object` | `getProperty(String property)`
`int` | `getResolveStrategy()` Gets the strategy which the closure users to resolve methods and properties
`Object` | `getThisObject()`
`boolean` | `isCase(Object candidate)`
`Closure` | `ncurry(int n, Object[] arguments)` Support for Closure currying at a given index.
`Closure` | `rcurry(Object[] arguments)` Support for Closure "right" currying.
`void` | `run()`
`void` | `setDelegate(Object delegate)` Allows the delegate to be changed such as when performing markup building
`void` | `setDirective(int directive)` @param directive The directive to set.
`void` | `setProperty(String property, Object newValue)`
`void` | `setResolveStrategy(int resolveStrategy)` Sets the strategy which the closure uses to resolve property references.
`protected static Object` | `throwRuntimeException(Throwable throwable)`

Methods inherited from class GroovyObjectSupport
getMetaClass, getProperty, invokeMethod, setMetaClass, setProperty

Methods inherited from class Object
wait, wait, wait, equals, toString, hashCode, getClass, notify, notifyAll

Field Detail

### DELEGATE_FIRST

    public static final int DELEGATE_FIRST

  With this resolveStrategy set the closure will attempt to resolve property references to the delegate first

### DELEGATE_ONLY

    public static final int DELEGATE_ONLY

  With this resolveStrategy set the closure will resolve property references to the delegate only and entirely bypass the owner

### DONE

    public static final int DONE

### OWNER_FIRST

    public static final int OWNER_FIRST

  With this resolveStrategy set the closure will attempt to resolve property references to the owner first

### OWNER_ONLY

    public static final int OWNER_ONLY

  With this resolveStrategy set the closure will resolve property references to the owner only and not call the delegate at all

### SKIP

    public static final int SKIP

### TO_SELF

    public static final int TO_SELF

  With this resolveStrategy set the closure will resolve property references to itself and go through the usual MetaClass look-up process. This allows the developer to override getProperty using ExpandoMetaClass of the closure itself

### maximumNumberOfParameters

    protected int maximumNumberOfParameters

### parameterTypes

    protected Class[] parameterTypes

Constructor Detail

### Closure

    public Closure(Object owner, Object thisObject)

### Closure

    public Closure(Object owner)

  Constructor used when the "this" object for the Closure is null. This is rarely the case in normal Groovy usage.
  Parameters:
    `owner` - the Closure owner

Method Detail

### asWritable

    public Closure asWritable()

  Returns:
    a version of this closure which implements Writable. Note that the returned Writable also overrides toString() in order to allow rendering the result directly to a String.

### call

    public Object call()

  Invokes the closure without any parameters, returning any value if applicable.
  Returns:
    the value if applicable or null if there is no return statement in the closure

### call

    public Object call(Object[] args)

### call

    public Object call(Object arguments)

  Invokes the closure, returning any value if applicable.
  Parameters:
    `arguments` - could be a single value or a List of values
  Returns:
    the value if applicable or null if there is no return statement in the closure

### clone

    public Object clone()

### curry

    public Closure curry(Object[] arguments)

  Support for Closure currying.

  Typical usage:

       def multiply = { a, b -> a * b }
       def doubler = multiply.curry(2)
       assert doubler(4) == 8

  Note: special treatment is given to Closure vararg-style capability. If you curry a vararg parameter, you don't consume the entire vararg array but instead the first parameter of the vararg array as the following example shows:

       def a = { one, two, Object[] others -> one + two + others.sum() }
       assert a.parameterTypes.name == ['java.lang.Object', 'java.lang.Object', '[Ljava.lang.Object;']
       assert a(1,2,3,4) == 10
       def b = a.curry(1)
       assert b.parameterTypes.name == ['java.lang.Object', '[Ljava.lang.Object;']
       assert b(2,3,4) == 10
       def c = b.curry(2)
       assert c.parameterTypes.name == ['[Ljava.lang.Object;']
       assert c(3,4) == 10
       def d = c.curry(3)
       assert d.parameterTypes.name == ['[Ljava.lang.Object;']
       assert d(4) == 10
       def e = d.curry(4)
       assert e.parameterTypes.name == ['[Ljava.lang.Object;']
       assert e() == 10
       assert e(5) == 15

  Parameters:
    `arguments` - the arguments to bind
  Returns:
    the new closure with its arguments bound

### getDelegate

    public Object getDelegate()

  Returns:
    the delegate Object to which method calls will go which is typically the outer class when the closure is constructed

### getDirective

    public int getDirective()

  Returns:
    Returns the directive.

### getMaximumNumberOfParameters

    public int getMaximumNumberOfParameters()

  Returns:
    the maximum number of parameters a doCall method of this closure can take

### getOwner

    public Object getOwner()

  Returns:
    the owner Object to which method calls will go which is typically the outer class when the closure is constructed

### getParameterTypes

    public Class[] getParameterTypes()

  Returns:
    the parameter types of the longest doCall method of this closure

### getProperty

    public Object getProperty(String property)

### getResolveStrategy

    public int getResolveStrategy()

  Gets the strategy which the closure users to resolve methods and properties
  Returns:
    The resolve strategy
  See Also:
    Closure.DELEGATE_FIRST
    Closure.DELEGATE_ONLY
    Closure.OWNER_FIRST
    Closure.OWNER_ONLY
    Closure.TO_SELF

### getThisObject

    public Object getThisObject()

### isCase

    public boolean isCase(Object candidate)

### ncurry

    public Closure ncurry(int n, Object[] arguments)

  Support for Closure currying at a given index. Parameters are supplied from index position "n". Typical usage:

       def caseInsensitive = { a, b -> a.toLowerCase() <=> b.toLowerCase() } as Comparator
       def caseSensitive = { a, b -> a <=> b } as Comparator
       def animals1 = ['ant', 'dog', 'BEE']
       def animals2 = animals1 + ['Cat']
       // curry middle param of this utility method:
       // Collections#binarySearch(List list, Object key, Comparator c)
       def catSearcher = Collections.&binarySearch.ncurry(1, "cat")
       [[animals1, animals2], [caseInsensitive, caseSensitive]].combinations().each{ a, c ->
         def idx = catSearcher(a.sort(c), c)
         print a.sort(c).toString().padRight(22)
         if (idx < 0) println "Not found but would belong in position ${-idx - 1}"
         else println "Found at index $idx"
       }
       // =>
       // [ant, BEE, dog]       Not found but would belong in position 2
       // [ant, BEE, Cat, dog]  Found at index 2
       // [BEE, ant, dog]       Not found but would belong in position 2
       // [BEE, Cat, ant, dog]  Not found but would belong in position 3

  Parameters:
    `n` - the index from which to bind parameters (may be -ve in which case it will be normalized)
    `arguments` - the arguments to bind
  Returns:
    the new closure with its arguments bound
  See Also:
    curry(Object[])

### rcurry

    public Closure rcurry(Object[] arguments)

  Support for Closure "right" currying. Parameters are supplied on the right rather than left as per the normal curry() method. Typical usage:

       def divide = { a, b -> a / b }
       def halver = divide.rcurry(2)
       assert halver(8) == 4

  Parameters:
    `arguments` - the arguments to bind
  Returns:
    the new closure with its arguments bound
  See Also:
    curry(Object[])

### run

    public void run()

### setDelegate

    public void setDelegate(Object delegate)

  Allows the delegate to be changed such as when performing markup building
  Parameters:
    `delegate` - the new delegate

### setDirective

    public void setDirective(int directive)

  Parameters:
    `directive` - The directive to set.

### setProperty

    public void setProperty(String property, Object newValue)

### setResolveStrategy

    public void setResolveStrategy(int resolveStrategy)

  Sets the strategy which the closure uses to resolve property references. The default is Closure.OWNER_FIRST
  Parameters:
    `resolveStrategy` - The resolve strategy to set
  See Also:
    Closure.DELEGATE_FIRST
    Closure.DELEGATE_ONLY
    Closure.OWNER_FIRST
    Closure.OWNER_ONLY
    Closure.TO_SELF

### throwRuntimeException

    protected static Object throwRuntimeException(Throwable throwable)

Copyright © 2003-2010 The Codehaus. All rights reserved.