public ClosureMetaMethod(String name,
    Closure c,
    CachedMethod doCall) 
{
		this(name, c.getOwner().getClass(), c, doCall);
}

 public ClosureMetaMethod(String name,
    Class declaringClass,
    Closure c,
    CachedMethod doCall) 
{
        super (doCall.getNativeParameterTypes());
        this.name = name;
        callable = c;
        this.doCall = doCall;
        this.declaringClass = ReflectionCache.getCachedClass(declaringClass);
}

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

 public static List<MetaMethod> createMethodList(String name,
    Class declaringClass,
    Closure closure) 
{
        ArrayList< MetaMethod > res = new ArrayList< MetaMethod >();
        if (closure instanceof MethodClosure) {
            MethodClosure methodClosure = (MethodClosure) closure;
            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())) {
                	MetaMethod metaMethod = new MethodClosureMetaMethod(name, declaringClass, closure, method); 
                	res.add(adjustParamTypesForStdMethods(metaMethod, name));
                }
            }
        }
        else {
            if (closure instanceof GeneratedClosure) {
                for (CachedMethod method : ReflectionCache.getCachedClass(closure.getClass()).getMethods() ) {
                    if (method.getName().equals("doCall")) {
                    	MetaMethod metaMethod = new ClosureMetaMethod(name, declaringClass, closure, method);
                    	res.add(adjustParamTypesForStdMethods(metaMethod, name));
                    }
                }
            }
            else {
            	MetaMethod metaMethod = 
            	new MetaMethod(closure.getParameterTypes()){
                    public int getModifiers() {
                        return Modifier.PUBLIC;
                    }
                    public String getName() {
                        return name;
                    }
                    public Class getReturnType() {
                        return Object.class;
                    }
                    public CachedClass getDeclaringClass() {
                        return ReflectionCache.getCachedClass(declaringClass);
                    }
                    public Object invoke(Object object, Object[] arguments) {
                        Closure cloned = (Closure) closure.clone();
                        cloned.setDelegate(object);
                        arguments = coerceArgumentsToClasses(arguments);
                        return InvokerHelper.invokeMethod(cloned, "call", arguments);
                    }
                };
                res.add(adjustParamTypesForStdMethods(metaMethod, name));
            }
        }
        return res;
}

 public Closure getClosure() 
{
		return callable;
}

Retrieves the closure that is invoked by this MetaMethod

 public CachedClass getDeclaringClass() 
{
		return declaringClass;
}

 public CachedMethod getDoCall() 
{
        return doCall;
}

 public int getModifiers() 
{
        return Modifier.PUBLIC;
}

 public String getName() 
{
        return name;
}

 public Class getReturnType() 
{
        return Object.class;
}

 public Object invoke(Object object,
    Object[] arguments) 
{
		Closure cloned = (Closure) callable.clone();
		cloned.setDelegate(object);
        arguments = coerceArgumentsToClasses(arguments);
        return doCall.invoke(cloned, arguments);
}