@Override public Object invokeMethod(String name, Object args) { try { if (delegate instanceof GroovyObject) { return ((GroovyObject) delegate).invokeMethod(name, args); } return metaClass.invokeMethod(delegate, name, args); } catch (MissingMethodException mme) { return super.invokeMethod(name, args); } }
public Object getProperty(String property) { try { return getMetaClass().getProperty(this, property); } catch (MissingPropertyException e) { if (delegate instanceof GroovyObject) return ((GroovyObject) delegate).getProperty(property); else throw e; } }
public void setProperty(String property, Object newValue) { try { getMetaClass().setProperty(this, property, newValue); } catch (MissingPropertyException e) { if (delegate instanceof GroovyObject) ((GroovyObject) delegate).setProperty(property, newValue); else throw e; } }
public void build(final GroovyObject builder) { builder.getProperty("mkp"); builder.invokeMethod("yield", new Object[]{this.value}); }
/** * Use the ProxyMetaClass for the given Closure. * Cares for balanced setting/unsetting ProxyMetaClass. * * @param closure piece of code to be executed with ProxyMetaClass */ public Object use(GroovyObject object, Closure closure) { // grab existing meta (usually adaptee but we may have nested use calls) MetaClass origMetaClass = object.getMetaClass(); object.setMetaClass(this); try { return closure.call(); } finally { object.setMetaClass(origMetaClass); } }
@Override public void customize(GroovyObject goo) { DelegatingMetaClass dmc = new DelegatingMetaClass(goo.getMetaClass()) { @Override public Object invokeMethod(Object arg0, String mName, Object[] arg2) { if (mName.contains("Missing")) { throw new IllegalStateException("Gotcha"); } else { return super.invokeMethod(arg0, mName, arg2); } } }; dmc.initialize(); goo.setMetaClass(dmc); } }
public final Object callCurrent(GroovyObject receiver, Object[] args) throws Throwable { if (checkCall(receiver)) { try { try { return metaClass.invokeMethod(array.owner, receiver, name, args, false, true); } catch (MissingMethodException e) { if (e instanceof MissingMethodExecutionFailed) { throw (MissingMethodException)e.getCause(); } else if (receiver.getClass() == e.getType() && e.getMethod().equals(name)) { // in case there's nothing else, invoke the object's own invokeMethod() return ((GroovyObject)receiver).invokeMethod(name, args); } else { throw e; } } } catch (GroovyRuntimeException gre) { throw ScriptBytecodeAdapter.unwrap(gre); } } else { return CallSiteArray.defaultCallCurrent(this, receiver, args); } } }
public static Object invokeMethodOnSuperN(Class senderClass, GroovyObject receiver, String messageName, Object[] messageArguments) throws Throwable { MetaClass metaClass = receiver.getMetaClass(); // ignore interception and missing method fallback Object result = null; try { result = metaClass.invokeMethod(senderClass, receiver, messageName, messageArguments, true, true); } catch (GroovyRuntimeException gre) { throw unwrap(gre); } return result; }
public Object getProperty(String property) { if(ExpandoMetaClass.isValidExpandoProperty(property)) { if(property.equals(ExpandoMetaClass.STATIC_QUALIFIER) || property.equals(ExpandoMetaClass.CONSTRUCTOR) || Holder.META_CLASS.hasProperty(this, property) == null) { return replaceDelegate().getProperty(property); } } return Holder.META_CLASS.getProperty(this, property); }
public static Object invokeMethodOnCurrentN(Class senderClass, GroovyObject receiver, String messageName, Object[] messageArguments) throws Throwable { Object result = null; boolean intercepting = receiver instanceof GroovyInterceptable; try { try { // if it's a pure interceptable object (even intercepting toString(), clone(), ...) if (intercepting) { result = receiver.invokeMethod(messageName, messageArguments); } //else if there's a statically typed method or a GDK method else { result = receiver.getMetaClass().invokeMethod(senderClass, receiver, messageName, messageArguments, false, true); } } catch (MissingMethodException e) { if (e instanceof MissingMethodExecutionFailed) { throw (MissingMethodException)e.getCause(); } else if (!intercepting && receiver.getClass() == e.getType() && e.getMethod().equals(messageName)) { // in case there's nothing else, invoke the object's own invokeMethod() result = receiver.invokeMethod(messageName, messageArguments); } else { throw e; } } } catch (GroovyRuntimeException gre) { throw unwrap(gre); } return result; }
public void testCompile() throws Exception { Class groovyClass = loader.parseClass(new File("src/test/org/codehaus/groovy/classgen/Main.groovy")); System.out.println("Invoking main..."); GroovyObject object = (GroovyObject) groovyClass.newInstance(); assertTrue(object != null); MetaClass metaClass = object.getMetaClass(); System.out.println("Metaclass: " + metaClass); Class type = object.getClass(); System.out.println("Type: " + type); // invoke via metaclass metaClass.invokeMethod(object, "main", null); // invoke directly object.invokeMethod("main", null); } }
private void proxyPerInstanceMetaClasses(List<Reference> refs) { for (Reference ref : refs) { Object obj = ref.get(); if (obj != null) { Class theClass = obj.getClass(); if (obj instanceof GroovyObject) { GroovyObject gobj = (GroovyObject) obj; MetaClass metaClass = gobj.getMetaClass(); MetaClass proxyMetaClass = proxyMetaClass(theClass, metaClass); DefaultGroovyMethods.setMetaClass(gobj, proxyMetaClass); } else { MetaClass metaClass = DefaultGroovyMethods.getMetaClass(obj); MetaClass proxyMetaClass = proxyMetaClass(theClass, metaClass); MetaClassHelper.doSetMetaClass(obj, proxyMetaClass); } } } }
tagLib.setProperty(OUT_PROPERTY, out); Object tagLibProp; final Map tagLibProperties = DefaultGroovyMethods.getProperties(tagLib); if (tagLibProperties.containsKey(getTagName())) { tagLibProp = tagLibProperties.get(getTagName()); if (tag.getParameterTypes().length == 1) { tag.call(new Object[]{ attributes }); if (body != null) { body.call();
public static Object getGroovyObjectProperty(Class senderClass, GroovyObject receiver, String messageName) throws Throwable { return receiver.getProperty(messageName); }
final GroovyObject script = (GroovyObject) groovyClass.newInstance(); this.template = (Closure) script.invokeMethod("getTemplate", null); this.template.setResolveStrategy(Closure.DELEGATE_FIRST); } catch (InstantiationException e) { throw new ClassNotFoundException(e.getMessage());
public Object getProperty(Object receiver) throws Throwable { try{ return ((GroovyObject)receiver).getProperty(name); } catch (GroovyRuntimeException gre) { throw ScriptBytecodeAdapter.unwrap(gre); } } }
public void testProperty() throws Exception { GroovyObject object = compile("src/test/org/codehaus/groovy/classgen/MyBean.groovy"); System.out.println("Got object: " + object); Object value = object.getProperty("name"); assertEquals("name property", "James", value); object.setProperty("name", "Bob"); assertEquals("name property", "Bob", object.getProperty("name")); } }
@Override public Object invokeMethod(String name, Object args) { try { return delegate.invokeMethod(name,args); } catch (MissingMethodException mme) { return super.invokeMethod(name, args); } }
private Closure createTemplateClosure(List<StringSection> sections, final ClassLoader parentLoader, StringBuilder target) throws ClassNotFoundException { final GroovyClassLoader loader = AccessController.doPrivileged(new PrivilegedAction<GroovyClassLoader>() { public GroovyClassLoader run() { return new GroovyClassLoader(parentLoader); } }); final Class groovyClass; try { groovyClass = loader.parseClass(new GroovyCodeSource(target.toString(), TEMPLATE_SCRIPT_PREFIX + counter++ + ".groovy", "x")); } catch (MultipleCompilationErrorsException e) { throw mangleMultipleCompilationErrorsException(e, sections); } catch (Exception e) { throw new GroovyRuntimeException("Failed to parse template script (your template may contain an error or be trying to use expressions not currently supported): " + e.getMessage()); } Closure result; try { final GroovyObject object = (GroovyObject) groovyClass.newInstance(); Closure chicken = (Closure) object.invokeMethod("getTemplate", null); //bind the two first parameters of the generated closure to this class and the sections list result = chicken.curry(this, sections); } catch (InstantiationException e) { throw new ClassNotFoundException(e.getMessage()); } catch (IllegalAccessException e) { throw new ClassNotFoundException(e.getMessage()); } return result; }
public static void setGroovyObjectField(Object messageArgument, Class senderClass, GroovyObject receiver, String messageName) throws Throwable { try { receiver.getMetaClass().setAttribute(receiver, messageName, messageArgument); } catch (GroovyRuntimeException gre) { throw unwrap(gre); } }