Refine search
public final MetaClass getMetaClass(Class theClass) { return ClassInfo.getClassInfo(theClass).getMetaClass(); }
public static CachedClass getCachedClass(Class klazz) { if (klazz == null) return null; return ClassInfo.getClassInfo(klazz).getCachedClass(); }
@Override public ClassInfo computeValue(Class<?> type) { ClassInfo ret = new ClassInfo(type); globalClassSet.add(ret); return ret; } });
public MetaClass getMetaClass(Object obj) { final MetaClass instanceMetaClass = getPerInstanceMetaClass(obj); if (instanceMetaClass != null) return instanceMetaClass; return getMetaClass(); }
public ClassMetaClassGetPropertySite(CallSite parent, Class aClass) { super(parent); this.aClass = aClass; classInfo = ClassInfo.getClassInfo(aClass); version = classInfo.getVersion(); metaClass = classInfo.getMetaClass(); }
public PojoMetaClassSite(CallSite site, MetaClass metaClass) { super(site, metaClass); classInfo = ClassInfo.getClassInfo(metaClass.getTheClass()); version = classInfo.getVersion(); }
public void setMetaClass(Object obj, MetaClass theMetaClass) { Class theClass = obj.getClass (); final ClassInfo info = ClassInfo.getClassInfo(theClass); MetaClass oldMC = null; info.lock(); try { oldMC = info.getPerInstanceMetaClass(obj); info.setPerInstanceMetaClass(obj, theMetaClass); } finally { info.unlock(); } fireConstantMetaClassUpdate(obj, theClass, oldMC, theMetaClass); }
/** * if oldMc is null, newMc will replace whatever meta class was used before. * if oldMc is not null, then newMc will be used only if he stored mc is * the same as oldMc */ private void setMetaClass(Class theClass, MetaClass oldMc, MetaClass newMc) { final ClassInfo info = ClassInfo.getClassInfo(theClass); MetaClass mc = null; info.lock(); try { mc = info.getStrongMetaClass(); info.setStrongMetaClass(newMc); } finally { info.unlock(); } if ((oldMc == null && mc != newMc) || (oldMc != null && mc != newMc && mc != oldMc)) { fireConstantMetaClassUpdate(null, theClass, mc, newMc); } }
ClassPropertyFetcher(final Class clazz) { this.clazz = clazz; this.classInfo = ClassInfo.getClassInfo(clazz); this.theMetaClass = classInfo.getMetaClass(); List<MetaProperty> properties = theMetaClass.getProperties(); this.metaProperties = new ArrayList<>(properties.size()); if(getter instanceof CachedMethod) { try { CachedClass cachedClass = classInfo.getCachedClass(); Method foundGetter = clazz.getDeclaredMethod(NameUtils.getGetterName(propertyName)); if(foundGetter != null) {
/** * 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(); }
ClassInfo.getClassInfo(ExpandoMetaClass.class).setStrongMetaClass(emcMetaClass);
private static <T> List<T> getStaticPropertyValuesFromInheritanceHierarchy(ClassInfo classInfo, String name, Class<T> c) { CachedClass cachedClass = classInfo.getCachedClass(); Collection<ClassInfo> hierarchy = cachedClass.getHierarchy(); Class javaClass = cachedClass.getTheClass(); for (ClassInfo current : hierarchy) { if(cachedClass.isInterface()) continue; MetaProperty metaProperty = current.getMetaClass().getMetaProperty(name); if(metaProperty != null && Modifier.isStatic(metaProperty.getModifiers())) { Class type = metaProperty.getType();
public static MethodHandle unreflect (Method method) { if (SunClassLoader.sunVM != null || checkAccessable(method)) { return createCompiledMethodHandle (method, ClassInfo.getClassInfo(method.getDeclaringClass()).getArtifactClassLoader()); } return new ReflectiveMethodHandle(method); }
/** * Stops profiling. */ public void stop() { MetaClassRegistry registry = GroovySystem.getMetaClassRegistry(); Set<ProfileMetaClass> proxyMetaClasses = new HashSet(); for (ClassInfo classInfo : ClassInfo.getAllClassInfo()) { /* $if version < 2.4 $ */ Class theClass = classInfo.get(); MetaClass metaClass = registry.getMetaClass(theClass); /* $endif */ /* $if version >= 2.4 $ */ MetaClass metaClass = classInfo.getMetaClass(); /* $endif */ if (metaClass instanceof ProfileMetaClass) { proxyMetaClasses.add((ProfileMetaClass) metaClass); } } // resetting the meta class creation handler clears all the meta classes. registry.setMetaClassCreationHandle(originalMetaClassCreationHandle); for (ProfileMetaClass proxyMetaClass : proxyMetaClasses) { registry.setMetaClass(proxyMetaClass.getTheClass(), proxyMetaClass.getAdaptee()); } }
private Set<Class> getLoadedClasses() { Set<Class> allClasses = new HashSet(); // ClassInfo.getAllClassInfo() returns cached class info and there is a case it doesn't return // all of the loaded classes. This is a hack to ignore the cache. try { Field classSetField = ClassInfo.class.getDeclaredField("globalClassSet"); classSetField.setAccessible(true); /* $if version < 2.4 $ */ ClassInfo.ClassInfoSet classSet = (ClassInfo.ClassInfoSet) classSetField.get(ClassInfo.class); for (ClassInfo classInfo : (Collection<ClassInfo>) classSet.values()) { allClasses.add(classInfo.get()); } /* $endif$ */ /* $if version >= 2.4 $ */ Object classSet = classSetField.get(ClassInfo.class); Method valuesMethod = classSet.getClass().getDeclaredMethod("values"); valuesMethod.setAccessible(true); for (ClassInfo classInfo : (Collection<ClassInfo>) valuesMethod.invoke(classSet)) { allClasses.add(classInfo.getMetaClass().getTheClass()); } /* $endif$ */ } catch (Exception e) { e.printStackTrace(); } return allClasses; }
public void setNewMopMethods(List<MetaMethod> arr) { final MetaClass metaClass = classInfo.getStrongMetaClass(); if (metaClass != null) { if (metaClass.getClass() == MetaClassImpl.class) { classInfo.setStrongMetaClass(null); updateSetNewMopMethods(arr); classInfo.setStrongMetaClass(new MetaClassImpl(metaClass.getTheClass())); return; } if (metaClass.getClass() == ExpandoMetaClass.class) { classInfo.setStrongMetaClass(null); updateSetNewMopMethods(arr); ExpandoMetaClass newEmc = new ExpandoMetaClass(metaClass.getTheClass()); newEmc.initialize(); classInfo.setStrongMetaClass(newEmc); return; } throw new GroovyRuntimeException("Can't add methods to class " + getTheClass().getName() + ". Strong custom meta class already set."); } classInfo.setWeakMetaClass(null); updateSetNewMopMethods(arr); }
/** * Returns the {@code MetaClass} for the {@code Class} associated with this {@code ClassInfo}. * If no {@code MetaClass} exists one will be created. * <p> * It is not safe to call this method without a {@code Class} associated with this {@code ClassInfo}. * It is advisable to aways retrieve a ClassInfo instance from the cache by using the static * factory method {@link ClassInfo#getClassInfo(Class)} to ensure the referenced Class is * strongly reachable. * * @return a {@code MetaClass} instance */ public final MetaClass getMetaClass() { MetaClass answer = getMetaClassForClass(); if (answer != null) return answer; lock(); try { return getMetaClassUnderLock(); } finally { unlock(); } }
public MetaClass getMetaClass(Object obj) { final MetaClass instanceMetaClass = getPerInstanceMetaClass(obj); if (instanceMetaClass != null) return instanceMetaClass; lock(); try { return getMetaClassUnderLock(); } finally { unlock(); } }
private MetaClass getMetaClassUnderLock() { MetaClass answer = getStrongMetaClass(); if (answer!=null) return answer; answer = getWeakMetaClass(); final MetaClassRegistry metaClassRegistry = GroovySystem.getMetaClassRegistry(); MetaClassRegistry.MetaClassCreationHandle mccHandle = metaClassRegistry.getMetaClassCreationHandler(); if (answer != null) { boolean enableGloballyOn = (mccHandle instanceof ExpandoMetaClassCreationHandle); boolean cachedAnswerIsEMC = (answer instanceof ExpandoMetaClass); // if EMC.enableGlobally() is OFF, return whatever the cached answer is. // but if EMC.enableGlobally() is ON and the cached answer is not an EMC, come up with a fresh answer if(!enableGloballyOn || cachedAnswerIsEMC) { return answer; } } answer = mccHandle.create(get(), metaClassRegistry); answer.initialize(); if (GroovySystem.isKeepJavaMetaClasses()) { setStrongMetaClass(answer); } else { setWeakMetaClass(answer); } return answer; }
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; }