public static MetaClass getMetaClass(Class cls) { return metaRegistry.getMetaClass(cls); }
public Object getProperty(Object object) { MetaClass mc = registry.getMetaClass(Class.class); return mc.getProperty(Class.class, object, name, useSuper, false); }
private MetaClass getMetaClass() { if (metaClass == null) { metaClass = GroovySystem.getMetaClassRegistry().getMetaClass(DummyResultSet.class); } return metaClass; }
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)); }
private Object invokeMethodClosure(MethodClosure object, Object[] arguments, Object owner) { String methodName; final MethodClosure mc = object; methodName = mc.getMethod(); final Class ownerClass = owner instanceof Class ? (Class) owner : owner.getClass(); final MetaClass ownerMetaClass = registry.getMetaClass(ownerClass); return ownerMetaClass.invokeMethod(ownerClass, owner, methodName, arguments, false, false); }
private MetaClass lookupObjectMetaClass(Object object) { if (object instanceof GroovyObject) { GroovyObject go = (GroovyObject) object; return go.getMetaClass(); } Class ownerClass = object.getClass(); if (ownerClass == Class.class) ownerClass = (Class) object; MetaClass metaClass = registry.getMetaClass(ownerClass); return metaClass; }
/** * 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); }
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); }
private MetaClass lookupObjectMetaClass(Object object) { if (object instanceof GroovyObject) { GroovyObject go = (GroovyObject) object; return go.getMetaClass(); } Class ownerClass = object.getClass(); if (ownerClass == Class.class) { ownerClass = (Class) object; return registry.getMetaClass(ownerClass); } MetaClass metaClass = InvokerHelper.getMetaClass(object); return metaClass; }
/** * 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); }
/** * 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); }
public static Object invokeStaticMethod(Class type, String method, Object arguments) { MetaClass metaClass = metaRegistry.getMetaClass(type); return metaClass.invokeStaticMethod(type, method, asArray(arguments)); }
public static Object getAttribute(Object object, String attribute) { if (object == null) { object = NullObject.getNullObject(); } if (object instanceof Class) { return metaRegistry.getMetaClass((Class) object).getAttribute(object, attribute); } else if (object instanceof GroovyObject) { return ((GroovyObject) object).getMetaClass().getAttribute(object, attribute); } else { return metaRegistry.getMetaClass(object.getClass()).getAttribute(object, attribute); } }
public static Object getProperty(Object object, String property) { if (object == null) { object = NullObject.getNullObject(); } if (object instanceof GroovyObject) { GroovyObject pogo = (GroovyObject) object; return pogo.getProperty(property); } else if (object instanceof Class) { Class c = (Class) object; return metaRegistry.getMetaClass(c).getProperty(object, property); } else { return ((MetaClassRegistryImpl) metaRegistry).getMetaClass(object).getProperty(object, property); } }
public static void setAttribute(Object object, String attribute, Object newValue) { if (object == null) { object = NullObject.getNullObject(); } if (object instanceof Class) { metaRegistry.getMetaClass((Class) object).setAttribute(object, attribute, newValue); } else if (object instanceof GroovyObject) { ((GroovyObject) object).getMetaClass().setAttribute(object, attribute, newValue); } else { metaRegistry.getMetaClass(object.getClass()).setAttribute(object, attribute, newValue); } }
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 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; }
@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); } } }