Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2003-2007 the original author or authors.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.codehaus.groovy.runtime.metaclass;
 
 
 import java.util.List;

A MetaMethod that accepts a closure in the constructor which is invoked when the MetaMethod is called. The delegate of the closure is set to the instance that the MetaMethod is invoked on when called.

Author(s):
Graeme Rocher
Since:
1.1
 
 public class ClosureMetaMethod extends MetaMethod implements ClosureInvokingMethod {
 
 	private final Closure callable;
     private final CachedMethod doCall;
     private final String name;
     private final CachedClass declaringClass;
 
     public ClosureMetaMethod(String nameClosure cCachedMethod doCall) {
 		this(namec.getOwner().getClass(), cdoCall);
 	}
 
     public ClosureMetaMethod(String nameClass declaringClassClosure cCachedMethod doCall) {
         super (doCall.getNativeParameterTypes());
         this. = name;
          = c;
         this. = doCall;
         this. = ReflectionCache.getCachedClass(declaringClass);
     }
 
 
     public int getModifiers() {
         return .;
     }
 
     public String getName() {
         return ;
     }
 
     public Class getReturnType() {
         return Object.class;
     }
 
 		return ;
 	}
 
 	public Object invoke(final Object objectObject[] arguments) {
 		Closure cloned = (Closure.clone();
 		cloned.setDelegate(object);
 
         arguments = coerceArgumentsToClasses(arguments);
         return .invoke(clonedarguments);
 	}

  
Retrieves the closure that is invoked by this MetaMethod

Returns:
The closure
 
     public Closure getClosure() {
 		return ;
 	}
 
     public static List<MetaMethodcreateMethodList(final String namefinal Class declaringClassfinal Closure closure) {
         ArrayList<MetaMethodres = new ArrayList<MetaMethod>();
         if (closure instanceof MethodClosure) {
             MethodClosure methodClosure = (MethodClosureclosure;
             Object owner = closure.getOwner();
             Class ownerClass = (Class) (owner instanceof Class ? owner : owner.getClass());
             for (CachedMethod method : ReflectionCache.getCachedClass(ownerClass).getMethods() ) {
                if (method.getName().equals(methodClosure.getMethod())) {
                    res.add(new MethodClosureMetaMethod(namedeclaringClassclosuremethod));
                }
            }
        }
        else {
            if (closure instanceof GeneratedClosure) {
                for (CachedMethod method : ReflectionCache.getCachedClass(closure.getClass()).getMethods() ) {
                    if (method.getName().equals("doCall")) {
                        res.add(new ClosureMetaMethod(namedeclaringClassclosuremethod));
                    }
                }
            }
            else {
                res.add(new MetaMethod(closure.getParameterTypes()){
                    public int getModifiers() {
                        return .;
                    }
                    public String getName() {
                        return name;
                    }
                    public Class getReturnType() {
                        return Object.class;
                    }
                    public CachedClass getDeclaringClass() {
                        return ReflectionCache.getCachedClass(declaringClass);
                    }
                    public Object invoke(Object objectObject[] arguments) {
                        Closure cloned = (Closureclosure.clone();
                        cloned.setDelegate(object);
                        arguments = coerceArgumentsToClasses(arguments);
                        return InvokerHelper.invokeMethod(cloned"call"arguments);
                    }
                });
            }
        }
        return res;
    }
    public CachedMethod getDoCall() {
        return ;
    }
    public static ClosureMetaMethod copy(ClosureMetaMethod closureMethod) {
        if (closureMethod instanceof MethodClosureMetaMethod)
          return new MethodClosureMetaMethod(closureMethod.getName(), closureMethod.getDeclaringClass().getTheClass(), closureMethod.getClosure(), closureMethod.getDoCall());
        else
          return new ClosureMetaMethod(closureMethod.getName(), closureMethod.getDeclaringClass().getTheClass(), closureMethod.getClosure(), closureMethod.getDoCall());
    }
    private static class MethodClosureMetaMethod extends ClosureMetaMethod {
        public MethodClosureMetaMethod(String nameClass declaringClassClosure closureCachedMethod method) {
            super(namedeclaringClassclosuremethod);
        }
        public Object invoke(Object objectObject[] arguments) {
            return getDoCall().invoke(getClosure().getOwner(), arguments);
        }
    }
New to GrepCode? Check out our FAQ X