Refine search
public Object getProperty(Object object) { MetaClass mc = registry.getMetaClass(Class.class); return mc.getProperty(Class.class, object, name, useSuper, false); }
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); } }
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(); } }
/** * 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); } }
MetaClass mc = registry.getMetaClass(sender); return mc.invokeStaticMethod(sender, methodName, arguments); Class[] argClasses = MetaClassHelper.convertToTypeArray(arguments); while (superClass != Object.class && superClass != null) { MetaClass mc = registry.getMetaClass(superClass); method = mc.getStaticMetaMethod(methodName, argClasses); if (method != null) return method.doMethodInvoke(object, arguments); prop = mc.getProperty(superClass, superClass, methodName, false, false); } catch (MissingPropertyException mpe) { MetaClass propMC = registry.getMetaClass(prop.getClass()); return propMC.invokeMethod(prop, CLOSURE_CALL_METHOD, arguments);
public static Object invokeSuperMethod(Object object, String methodName, Object arguments) { if (object == null) { throw new NullPointerException("Cannot invoke method " + methodName + "() on null object"); } Class theClass = object.getClass(); MetaClass metaClass = metaRegistry.getMetaClass(theClass.getSuperclass()); return metaClass.invokeMethod(object, methodName, asArray(arguments)); }
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); } }
final MetaClass ownerMetaClass = registry.getMetaClass(ownerClass); return ownerMetaClass.invokeMethod(owner, methodName, curriedArguments); method = closure.getMetaClass().pickMethod(methodName, argClasses); if (method != null) return method.invoke(closure, arguments); break; if (method == null && delegate != closure && delegate != null) { MetaClass delegateMetaClass = lookupObjectMetaClass(delegate); method = delegateMetaClass.pickMethod(methodName, argClasses); if (method != null) return delegateMetaClass.invokeMethod(delegate, methodName, originalArguments);
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() { if (metaClass == null) { metaClass = GroovySystem.getMetaClassRegistry().getMetaClass(DummyResultSet.class); } return metaClass; }
/** * <p>Enables the ExpandoMetaClassCreationHandle with the registry * * <code>ExpandoMetaClassCreationHandle.enable();</code> * */ public static void enable() { final MetaClassRegistry metaClassRegistry = GroovySystem.getMetaClassRegistry(); synchronized (metaClassRegistry) { if (metaClassRegistry.getMetaClassCreationHandler() != instance) { ClassInfo.clearModifiedExpandos(); metaClassRegistry.setMetaClassCreationHandle(instance); } } }
private void proxyMetaClasses() { Set<Class> allClasses = getLoadedClasses(); MetaClassRegistry registry = GroovySystem.getMetaClassRegistry(); Map<Class, MetaClass> originalMetaClasses = new HashMap(); for (Class theClass : allClasses) { MetaClass originalMetaClass = registry.getMetaClass(theClass); originalMetaClasses.put(theClass, originalMetaClass); } originalMetaClassCreationHandle = registry.getMetaClassCreationHandler(); registry.setMetaClassCreationHandle(this); // creates and sets meta classes from the original meta classes for (Map.Entry<Class, MetaClass> e : originalMetaClasses.entrySet()) { Class theClass = e.getKey(); MetaClass metaClass = e.getValue(); MetaClass proxyMetaClass = proxyMetaClass(theClass, metaClass); registry.setMetaClass(theClass, proxyMetaClass); } }
public static void mixinClassesToMetaClass(MetaClass self, List<Class> categoryClasses) { final Class selfClass = self.getTheClass(); final MixinInMetaClass mixin = new MixinInMetaClass(mc, cachedCategoryClass); final MetaClass metaClass = GroovySystem.getMetaClassRegistry().getMetaClass(categoryClass); final List<MetaProperty> propList = metaClass.getProperties(); for (MetaProperty prop : propList) if (self.getMetaProperty(prop.getName()) == null) { mc.registerBeanProperty(prop.getName(), new MixinInstanceMetaProperty(prop, mixin));
private MetaClass getMetaClassUnderLock() { MetaClass answer = getStrongMetaClass(); if (answer!=null) return answer; answer = getWeakMetaClass(); final MetaClassRegistry metaClassRegistry = GroovySystem.getMetaClassRegistry(); MetaClassRegistry.MetaClassCreationHandle mccHandle = metaClassRegistry.getMetaClassCreationHandler(); if (isValidWeakMetaClass(answer, mccHandle)) { return answer; } answer = mccHandle.create(classRef.get(), metaClassRegistry); answer.initialize(); if (GroovySystem.isKeepJavaMetaClasses()) { setStrongMetaClass(answer); } else { setWeakMetaClass(answer); } return answer; }
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; }
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); } } } }
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); } }
/** * Gives the meta class to an Object. */ public void getMetaClass() { Object receiver = args[0]; if (receiver == null) { mc = NullObject.getNullObject().getMetaClass(); } else if (receiver instanceof GroovyObject) { mc = ((GroovyObject) receiver).getMetaClass(); } else if (receiver instanceof Class) { Class c = (Class) receiver; ClassLoader cl = c.getClassLoader(); try { Class.forName(c.getName(), true, cl); } catch (ClassNotFoundException e) {} mc = GroovySystem.getMetaClassRegistry().getMetaClass(c); this.cache &= !ClassInfo.getClassInfo(c).hasPerInstanceMetaClasses(); } else { mc = ((MetaClassRegistryImpl) GroovySystem.getMetaClassRegistry()).getMetaClass(receiver); this.cache &= !ClassInfo.getClassInfo(receiver.getClass()).hasPerInstanceMetaClasses(); } mc.initialize(); }
public static ExpandoMetaClass getExpandoMetaClass(Class<?> aClass) { MetaClassRegistry registry = GroovySystem.getMetaClassRegistry(); MetaClass mc = registry.getMetaClass(aClass); if (mc instanceof ExpandoMetaClass) { ExpandoMetaClass emc = (ExpandoMetaClass) mc; registry.setMetaClass(aClass, emc); // make permanent return emc; } registry.removeMetaClass(aClass); mc = registry.getMetaClass(aClass); if (mc instanceof ExpandoMetaClass) { return (ExpandoMetaClass)mc; } ExpandoMetaClass emc = new ExpandoMetaClass(aClass, true, true); emc.initialize(); registry.setMetaClass(aClass, emc); return emc; }
MetaClass metaClass = mixinClass.classInfo.getMetaClassForClass(); if (metaClass == null) { metaClass = GroovySystem.getMetaClassRegistry().getMetaClass(mixinClass.getTheClass()); MetaMethod metaMethod = metaClass.pickMethod(methodName, arguments); if (metaMethod == null && metaClass instanceof MetaClassImpl) { MetaClassImpl mc = (MetaClassImpl) metaClass;