private MetaClass getMetaClass() { if (metaClass == null) { metaClass = GroovySystem.getMetaClassRegistry().getMetaClass(DummyResultSet.class); } return metaClass; }
public static void setMetaClass(Class<?> clazz, MetaClass metaClass) { GroovySystem.getMetaClassRegistry().setMetaClass(clazz, metaClass); }
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); }
private MetaClass getMetaClass(Object proxy) { MetaClass mc = metaClass; if (mc == null) { mc = ((MetaClassRegistryImpl) GroovySystem.getMetaClassRegistry()).getMetaClass(proxy); metaClass = mc; } return mc; } }
/** * For a constructor call we always use the static meta class from the registry */ @Override public void getMetaClass() { Object receiver = args[0]; mc = GroovySystem.getMetaClassRegistry().getMetaClass((Class) receiver); }
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(); } }
public DelegatingMetaClass(final Class theClass) { this(GroovySystem.getMetaClassRegistry().getMetaClass(theClass)); }
public MixedInMetaClass(Object instance, Object owner) { super(GroovySystem.getMetaClassRegistry().getMetaClass(instance.getClass())); this.owner = new WeakReference(owner); MetaClassHelper.doSetMetaClass(instance, this); }
/** * convenience factory method allowing interceptConstruction to be set. */ public static MockProxyMetaClass make(Class theClass, boolean interceptConstruction) throws IntrospectionException { MetaClassRegistry metaRegistry = GroovySystem.getMetaClassRegistry(); MetaClass meta = metaRegistry.getMetaClass(theClass); return new MockProxyMetaClass(metaRegistry, theClass, meta, interceptConstruction); }
public static MetaClass getMetaClass(Object object) { if (object instanceof GroovyObject) return ((GroovyObject) object).getMetaClass(); else return ((MetaClassRegistryImpl) GroovySystem.getMetaClassRegistry()).getMetaClass(object); }
/** * 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); }
/** * convenience factory method for the most usual case. */ public static ProxyMetaClass getInstance(Class theClass) { MetaClassRegistry metaRegistry = GroovySystem.getMetaClassRegistry(); MetaClass meta = metaRegistry.getMetaClass(theClass); return new ProxyMetaClass(metaRegistry, theClass, meta); }
private static boolean isValidWeakMetaClass(MetaClass metaClass) { return isValidWeakMetaClass(metaClass, GroovySystem.getMetaClassRegistry().getMetaClassCreationHandler()); }
public static void setMetaClass(Object object, MetaClass metaClass) { GroovyObject groovyObject = ObjectUtil.asInstance(object, GroovyObject.class); if (groovyObject != null) { groovyObject.setMetaClass(metaClass); return; } ((MetaClassRegistryImpl) GroovySystem.getMetaClassRegistry()).setMetaClass(object, metaClass); }
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); } }
public static void setProperty(Object object, String property, Object newValue) { if (object == null) { object = NullObject.getNullObject(); } if (object instanceof GroovyObject) { GroovyObject pogo = (GroovyObject) object; pogo.setProperty(property, newValue); } else if (object instanceof Class) { metaRegistry.getMetaClass((Class) object).setProperty((Class) object, property, newValue); } else { ((MetaClassRegistryImpl) GroovySystem.getMetaClassRegistry()).getMetaClass(object).setProperty(object, property, newValue); } }
public static int selectConstructorAndTransformArguments(Object[] arguments, int numberOfConstructors, Class which) throws Throwable { MetaClass metaClass = GroovySystem.getMetaClassRegistry().getMetaClass(which); try { return metaClass.selectConstructorAndTransformArguments(numberOfConstructors, arguments); } catch (GroovyRuntimeException gre) { throw unwrap(gre); } }
private static MetaMethod searchInterfacesForMetaMethod(Class instanceKlazz, String methodName, Class[] arguments, MetaClass metaClass) { Class[] interfaces = metaClass.getTheClass().getInterfaces(); MetaMethod method = null; for (Class anInterface : interfaces) { MetaClass infMetaClass = GroovySystem.getMetaClassRegistry().getMetaClass(anInterface); method = getMetaMethod(instanceKlazz, methodName, arguments, infMetaClass, method); } method = findSubClassMethod(instanceKlazz, methodName, arguments, metaClass, method); method = findOwnMethod(instanceKlazz, methodName, arguments, metaClass, method); return method; }
public static void disable() { final MetaClassRegistry metaClassRegistry = GroovySystem.getMetaClassRegistry(); synchronized (metaClassRegistry) { if (metaClassRegistry.getMetaClassCreationHandler() == instance) { ClassInfo.clearModifiedExpandos(); metaClassRegistry.setMetaClassCreationHandle(new MetaClassCreationHandle()); } } } }
@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); } } }