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
 

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

Authors:

James Strachan

John Wilson

Jochen Theodorou

Graeme Rocher

Version:

\$Revision\$

DELEGATE_FIRST

public static final int DELEGATE_FIRST

With this resolveStrategy set the closure will attempt to resolve property references to the delegate first then the owner. For example the following code :

  class Test {
    def x = 30
    def y = 40

    def run() {
        def data = [ x: 10, y: 20 ]
        def cl = { y = x + y }
        cl.delegate = data
        cl.resolveStrategy = Closure.DELEGATE_FIRST
        cl()
        println x
        println y
        println data
    }
  }

  new Test().run()
 

will output :

     30
     40
     [x:10, y:30]
 

because the x and y variables declared in the delegate shadow the fields in the owner class.

Note that local variables are always looked up first, independently of the resolution strategy.

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. For example the following code :

  class Test {
    def x = 30
    def y = 40
    def z = 50

    def run() {
        def data = [ x: 10, y: 20 ]
        def cl = { y = x + y + z}
        cl.delegate = data
        cl.resolveStrategy = Closure.DELEGATE_ONLY
        cl()
        println x
        println y
        println data
    }
  }

  new Test().run()
 

will throw an error because even if the owner declares a "z" field, the resolution strategy will bypass lookup in the owner.

Note that local variables are always looked up first, independently of the resolution strategy.

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, then the delegate (this is the default strategy). For example the following code :

  class Test {
    def x = 30
    def y = 40

    def run() {
        def data = [ x: 10, y: 20 ]
        def cl = { y = x + y }
        cl.delegate = data
        cl()
        println x
        println y
        println data
    }
  }

  new Test().run()
 

will output :

     30
     70
     [x:10, y:20]
 

because the x and y fields declared in the Test class the variables in the delegate.

Note that local variables are always looked up first, independently of the resolution strategy.

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. For example the following code :

  class Test {
    def x = 30
    def y = 40

    def run() {
        def data = [ x: 10, y: 20, z: 30 ]
        def cl = { y = x + y }
        cl.delegate = data
        cl.resolveStrategy = Closure.OWNER_ONLY
        cl()
        println x
        println y
        println data
    }
  }

  new Test().run()
 

will throw "No such property: z" error because even if the z variable is declared in the delegate, no lookup is made.

Note that local variables are always looked up first, independently of the resolution strategy.

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 means that properties are neither resolved from the owner nor the delegate, but only on the closure object itself. This allows the developer to override getProperty using ExpandoMetaClass of the closure itself.

Note that local variables are always looked up first, independently of the resolution strategy.

maximumNumberOfParameters

protected int maximumNumberOfParameters

parameterTypes

protected Class[] parameterTypes

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

asWritable

public Closure asWritable()

call

public Object call()

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)

getDelegate

public Object getDelegate()

getDirective

public int getDirective()

getMaximumNumberOfParameters

public int getMaximumNumberOfParameters()

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

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)

rcurry

public Closure rcurry(Object[] arguments)

run

public void run()

setDelegate

public void setDelegate(Object delegate)

setDirective

public void setDirective(int directive)

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.