/** * Use the ProxyMetaClass for the given Closure. * Cares for balanced register/unregister. * * @param closure piece of code to be executed with registered ProxyMetaClass */ public Object use(Closure closure) { // grab existing meta (usually adaptee but we may have nested use calls) MetaClass origMetaClass = registry.getMetaClass(theClass); registry.setMetaClass(theClass, this); try { return closure.call(); } finally { registry.setMetaClass(theClass, origMetaClass); } }
private static void setMetaClass(final MetaClass metaClass) { final MetaClass newMetaClass = new DelegatingMetaClass(metaClass) { @Override public Object invokeStaticMethod(Object object, String methodName, Object[] arguments) { return InvokerHelper.invokeMethod(INSTANCE, methodName, arguments); } }; GroovySystem.getMetaClassRegistry().setMetaClass(ProxyGenerator.class, newMetaClass); }
public static void setMetaClass(Class<?> clazz, MetaClass metaClass) { GroovySystem.getMetaClassRegistry().setMetaClass(clazz, metaClass); }
private void revertMetaClassesFromAndClear(Map<Class<?>, MetaClass> savedMetaClasses) { MetaClassRegistry registry = GroovySystem.getMetaClassRegistry(); for (Entry<Class<?>, MetaClass> entry : savedMetaClasses.entrySet()) { Class<?> clazz = entry.getKey(); MetaClass originalMetaClass = entry.getValue(); registry.removeMetaClass(clazz); registry.setMetaClass(clazz, originalMetaClass); } savedMetaClasses.clear(); } }
GroovySystem.getMetaClassRegistry().setMetaClass(nodelistClass, newMetaClass);
private static boolean metaRelationship() { GroovySystem.getMetaClassRegistry().setMetaClass(Relationship.class, new DelegatingMetaClass(Relationship.class) { @Override public Object invokeMethod(Object object, String methodName, Object[] args) {
/** * Registers a modified ExpandoMetaClass with the creation handle * * @param emc The EMC */ public void registerModifiedMetaClass(ExpandoMetaClass emc) { final Class klazz = emc.getJavaClass(); GroovySystem.getMetaClassRegistry().setMetaClass(klazz,emc); }
GroovySystem.getMetaClassRegistry().setMetaClass(nodeClass, newMetaClass);
private void saveMetaClassesInto(Set<Class<?>> toSave, Map<Class<?>, MetaClass> into) { MetaClassRegistry registry = GroovySystem.getMetaClassRegistry(); for (Class<?> clazz : toSave) { into.put(clazz, registry.getMetaClass(clazz)); MetaClass newMetaClass = new ExpandoMetaClass(clazz, true, true); newMetaClass.initialize(); registry.setMetaClass(clazz, newMetaClass); } }
@Override public void intercept(IMethodInvocation invocation) throws Throwable { MetaClassRegistry registry = GroovySystem.getMetaClassRegistry(); for (Class<?> clazz : classes) { originalMetaClasses.add(registry.getMetaClass(clazz)); MetaClass temporaryMetaClass = new ExpandoMetaClass(clazz, true, true); temporaryMetaClass.initialize(); registry.setMetaClass(clazz, temporaryMetaClass); } try { invocation.proceed(); } finally { for (MetaClass original : originalMetaClasses) registry.setMetaClass(original.getTheClass(), original); } } }
/** * Sets the metaclass for a given class. * * @param self the class whose metaclass we wish to set * @param metaClass the new MetaClass * @since 1.6.0 */ public static void setMetaClass(Class self, MetaClass metaClass) { final MetaClassRegistry metaClassRegistry = GroovySystem.getMetaClassRegistry(); if (metaClass == null) metaClassRegistry.removeMetaClass(self); else { if (metaClass instanceof HandleMetaClass) { metaClassRegistry.setMetaClass(self, ((HandleMetaClass)metaClass).getAdaptee()); } else { metaClassRegistry.setMetaClass(self, metaClass); } if (self==NullObject.class) { NullObject.getNullObject().setMetaClass(metaClass); } } }
/** * Set the metaclass for an object. * @param self the object whose metaclass we want to set * @param metaClass the new metaclass value * @since 1.6.0 */ public static void setMetaClass(Object self, MetaClass metaClass) { if (metaClass instanceof HandleMetaClass) metaClass = ((HandleMetaClass)metaClass).getAdaptee(); if (self instanceof Class) { GroovySystem.getMetaClassRegistry().setMetaClass((Class) self, metaClass); } else { ((MetaClassRegistryImpl)GroovySystem.getMetaClassRegistry()).setMetaClass(self, metaClass); } }
private void performRegistryCallbacks() { MetaClassRegistry registry = GroovySystem.getMetaClassRegistry(); incVersion(); if (!modified) { modified = true; // Implementation note: By default Groovy uses soft references to store MetaClass // this insures the registry doesn't grow and get out of hand. By doing this we're // saying this this EMC will be a hard reference in the registry. As we're only // going have a small number of classes that have modified EMC this is ok if (inRegistry) { MetaClass currMetaClass = registry.getMetaClass(theClass); if (!(currMetaClass instanceof ExpandoMetaClass) && currMetaClass instanceof AdaptingMetaClass) { ((AdaptingMetaClass) currMetaClass).setAdaptee(this); } else { registry.setMetaClass(theClass, this); } } } }
mc.initialize(); ((ExpandoMetaClass)mc).define(closure); metaClassRegistry.setMetaClass(self, mc); return mc;
private static void setMetaClass(final MetaClass metaClass) { final MetaClass newMetaClass = new DelegatingMetaClass(metaClass) { /* (non-Javadoc) * @see groovy.lang.MetaClass#invokeStaticMethod(java.lang.Object, java.lang.String, java.lang.Object[]) */ public Object invokeStaticMethod(Object object, String methodName, Object[] arguments) { return InvokerHelper.invokeMethod(INSTANCE, methodName, arguments); } }; GroovySystem.getMetaClassRegistry().setMetaClass(ProxyGenerator.class, newMetaClass); }
private static void setMetaClass(final MetaClass metaClass) { final MetaClass newMetaClass = new DelegatingMetaClass(metaClass) { @Override public Object invokeStaticMethod(Object object, String methodName, Object[] arguments) { return InvokerHelper.invokeMethod(INSTANCE, methodName, arguments); } }; GroovySystem.getMetaClassRegistry().setMetaClass(ProxyGenerator.class, newMetaClass); }
/** * Registers a modified ExpandoMetaClass with the creation handle * * @param emc The EMC */ public void registerModifiedMetaClass(ExpandoMetaClass emc) { final Class klazz = emc.getJavaClass(); GroovySystem.getMetaClassRegistry().setMetaClass(klazz,emc); }
private void registerNodeImplementation(MetaClassRegistry registry, Class<? extends Node> nodeClass) throws IntrospectionException { NodeMetaClass mc2 = new NodeMetaClass(registry, nodeClass); mc2.initialize(); registry.setMetaClass(nodeClass, mc2); } }
public static void startProxy(Class clazz, Class adapteeClass) throws IntrospectionException { MetaClassRegistry registry = GroovySystem.getMetaClassRegistry(); MetaClass metaClass = registry.getMetaClass(clazz); if (!(metaClass instanceof GeneratedClassProxyMetaClass)) { // has not started proxy yet metaClass = new GeneratedClassProxyMetaClass(registry, clazz, adapteeClass); metaClass.initialize(); registry.setMetaClass(clazz, metaClass); } }
public void startProxy(){ if (!empty()) { mockClass = theClass; Collection<MetaClassRegistryChangeEventListener> cleaners = disableMetaClassRegistryCleaners(); try { adaptee = registry.getMetaClass(theClass); registry.setMetaClass(theClass, this); } finally { enableMetaClassRegistryCleaners(cleaners); } } }