Field Detail

• public static final int DELEGATE_FIRST

  With this resolveStrategy set the closure will attempt to resolve property references and methods 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.

• public static final int DELEGATE_ONLY

  With this resolveStrategy set the closure will resolve property references and methods 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.

• public static final int DONE

• public static final Closure IDENTITY

• public static final int OWNER_FIRST

  With this resolveStrategy set the closure will attempt to resolve property references and methods 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.

• public static final int OWNER_ONLY

  With this resolveStrategy set the closure will resolve property references and methods 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 + z }
           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.

• public static final int SKIP

• 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 and methods 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.

• protected int maximumNumberOfParameters

• protected Class[] parameterTypes

Constructor Detail

• public Closure(Object owner, Object thisObject)

• 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

• public Closure asWritable()

• public Object call()

• @SuppressWarnings} public Object call(Object... args)

• 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

• public Object clone()

• public Closure curry(Object... arguments)

• public Closure curry(Object argument)

• @SuppressWarnings* Returns a copy of this closure for which the delegate, owner and thisObject are public Closure dehydrate()

• public Object getDelegate()

  Allows the delegate to be changed such as when performing markup building

  Parameters:

  delegate - the new delegate

• public int getDirective()

  Parameters:

  directive - The directive to set.

• public int getMaximumNumberOfParameters()

  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.

• public Object getOwner()

  Returns:

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

• public Class[] getParameterTypes()

  Returns:

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

• public Object getProperty(String property)

• 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

• public Object getThisObject()

• public boolean isCase(Object candidate)

• public Closure leftShift(Closure other)

• public Object leftShift(Object arg)

• public Closure memoize()

• public Closure memoizeAtLeast(int protectedCacheSize)

• public Closure memoizeAtMost(int maxCacheSize)

• public Closure memoizeBetween(int protectedCacheSize, int maxCacheSize)

• public Closure ncurry(int n, Object... arguments)

• public Closure ncurry(int n, Object argument)

• public Closure rcurry(Object... arguments)

• public Closure rcurry(Object argument)

• @SuppressWarnings public Closure rehydrate(Object delegate, Object owner, Object thisObject)

• public Closure rightShift(Closure other)

• public void run()

• public void setDelegate(Object delegate)

  Returns:

  the parameter types of the longest doCall method of this closure

• public void setDirective(int directive)

• public void setProperty(String property, Object newValue)

• public void setResolveStrategy(int resolveStrategy)

  Sets the strategy which the closure uses to resolve property references and methods. 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

• protected static Object throwRuntimeException(Throwable throwable)

• public Closure trampoline(Object... args)

• public Closure trampoline()