protected LinkedList<CachedClass> getSuperClasses() { LinkedList<CachedClass> superClasses = new LinkedList<CachedClass>(); if (theClass.isInterface()) { superClasses.addFirst(ReflectionCache.OBJECT_CLASS); } else { for (CachedClass c = theCachedClass; c != null; c = c.getCachedSuperClass()) { superClasses.addFirst(c); } if (theCachedClass.isArray && theClass != Object[].class && !theClass.getComponentType().isPrimitive()) { superClasses.addFirst(ReflectionCache.OBJECT_ARRAY_CLASS); } } return superClasses; }
public LinkedList<ClassInfo> initValue() { Set<ClassInfo> res = new LinkedHashSet<ClassInfo> (); res.add(classInfo); for (CachedClass iface : getDeclaredInterfaces()) res.addAll(iface.getHierarchy()); final CachedClass superClass = getCachedSuperClass(); if (superClass != null) res.addAll(superClass.getHierarchy()); if (isInterface) res.add(ReflectionCache.OBJECT_CLASS.classInfo); return new LinkedList<ClassInfo> (res); } };
private void use(Class categoryClass) { CachedClass cachedClass = ReflectionCache.getCachedClass(categoryClass); LinkedList<CachedClass> classStack = new LinkedList<CachedClass>(); for (CachedClass superClass = cachedClass; superClass.getTheClass()!=Object.class; superClass = superClass.getCachedSuperClass()) { classStack.add(superClass); } while (!classStack.isEmpty()) { CachedClass klazz = classStack.removeLast(); applyUse(klazz); } }
public CachedClass(Class klazz, ClassInfo classInfo) { cachedClass = klazz; this.classInfo = classInfo; isArray = klazz.isArray(); isPrimitive = klazz.isPrimitive(); modifiers = klazz.getModifiers(); isInterface = klazz.isInterface(); isNumber = Number.class.isAssignableFrom(klazz); for (CachedClass inf : getInterfaces()) { ReflectionCache.isAssignableFrom(klazz, inf.cachedClass); } for (CachedClass cur = this; cur != null; cur = cur.getCachedSuperClass()) { ReflectionCache.setAssignableFrom(cur.cachedClass, klazz); } }
public Set<CachedClass> initValue() { Set<CachedClass> res = new HashSet<CachedClass> (0); if (getTheClass().isInterface()) res.add(CachedClass.this); Class[] classes = getTheClass().getInterfaces(); for (Class cls : classes) { final CachedClass aClass = ReflectionCache.getCachedClass(cls); if (!res.contains(aClass)) res.addAll(aClass.getInterfaces()); } final CachedClass superClass = getCachedSuperClass(); if (superClass != null) res.addAll(superClass.getInterfaces()); return res; } };
private CachedClass calcFirstGroovySuperClass(Collection superClasses) { if (theCachedClass.isInterface) return ReflectionCache.OBJECT_CLASS; CachedClass firstGroovy = null; Iterator iter = superClasses.iterator(); for (; iter.hasNext();) { CachedClass c = (CachedClass) iter.next(); if (GroovyObject.class.isAssignableFrom(c.getTheClass())) { firstGroovy = c; break; } } if (firstGroovy == null) firstGroovy = theCachedClass; else { if (firstGroovy.getTheClass() == GroovyObjectSupport.class && iter.hasNext()) { firstGroovy = (CachedClass) iter.next(); if (firstGroovy.getTheClass() == Closure.class && iter.hasNext()) { firstGroovy = (CachedClass) iter.next(); } } } return GroovyObject.class.isAssignableFrom(firstGroovy.getTheClass()) ? firstGroovy.getCachedSuperClass() : firstGroovy; }
Arrays.sort(resMethods); final CachedClass superClass = getCachedSuperClass(); if (superClass != null) { superClass.getMethods();
public MetaMethod[] getNewMetaMethods() { List<MetaMethod> arr = new ArrayList<MetaMethod>(Arrays.asList(classInfo.newMetaMethods)); final MetaClass metaClass = classInfo.getStrongMetaClass(); if (metaClass instanceof ExpandoMetaClass) { arr.addAll(((ExpandoMetaClass)metaClass).getExpandoMethods()); } if (isInterface) { MetaClass mc = ReflectionCache.OBJECT_CLASS.classInfo.getStrongMetaClass(); addSubclassExpandos(arr, mc); } else { for (CachedClass cls = this; cls != null; cls = cls.getCachedSuperClass()) { MetaClass mc = cls.classInfo.getStrongMetaClass(); addSubclassExpandos(arr, mc); } } for (CachedClass inf : getInterfaces()) { MetaClass mc = inf.classInfo.getStrongMetaClass(); addSubclassExpandos(arr, mc); } return arr.toArray(MetaMethod.EMPTY_ARRAY); }
protected MetaBeanProperty findPropertyInClassHierarchy(String propertyName, CachedClass theClass) { MetaBeanProperty property= null; if (theClass == null) return null; final CachedClass superClass = theClass.getCachedSuperClass(); if (superClass == null) return null; MetaClass metaClass = this.registry.getMetaClass(superClass.getTheClass()); if(metaClass instanceof MutableMetaClass) { property = getMetaPropertyFromMutableMetaClass(propertyName,metaClass); if(property == null) { if(superClass != ReflectionCache.OBJECT_CLASS) { property = findPropertyInClassHierarchy(propertyName, superClass); } if(property == null) { final Class[] interfaces = theClass.getTheClass().getInterfaces(); property = searchInterfacesForMetaProperty(propertyName, interfaces); } } } return property; }
public MetaMethodIndex(CachedClass theCachedClass) { init(DEFAULT_CAPACITY); CachedClass last = null; if (!theCachedClass.isInterface()) { for (CachedClass c = theCachedClass; c != null; c = c.getCachedSuperClass()) { final SingleKeyHashMap.Entry e = methodHeaders.getOrPut(c.getTheClass()); e.value = new Header (c.getTheClass(), last == null ? null : last.getTheClass()); last = c; } } else { final SingleKeyHashMap.Entry e = methodHeaders.getOrPut(Object.class); e.value = new Header (Object.class, theCachedClass.getTheClass()); } }
if (metaMethod == null && metaClass instanceof MetaClassImpl) { MetaClassImpl mc = (MetaClassImpl) metaClass; for (CachedClass cl = mc.getTheCachedClass().getCachedSuperClass(); cl != null; cl = cl.getCachedSuperClass()) { metaMethod = mc.getMethodWithoutCaching(cl.getTheClass(), methodName, arguments, false); if (metaMethod != null)
/** * @see MetaObjectProtocol#getMetaProperty(String) */ public MetaProperty getMetaProperty(String name) { SingleKeyHashMap propertyMap = classPropertyIndex.getNotNull(theCachedClass); if (propertyMap.containsKey(name)) { return (MetaProperty) propertyMap.get(name); } else if (staticPropertyIndex.containsKey(name)) { return (MetaProperty) staticPropertyIndex.get(name); } else { propertyMap = classPropertyIndexForSuper.getNotNull(theCachedClass); if (propertyMap.containsKey(name)) return (MetaProperty) propertyMap.get(name); else { CachedClass superClass = theCachedClass; while (superClass != null && superClass != ReflectionCache.OBJECT_CLASS) { final MetaBeanProperty property = findPropertyInClassHierarchy(name, superClass); if (property != null) { onSuperPropertyFoundInHierarchy(property); return property; } superClass = superClass.getCachedSuperClass(); } return null; } } }
superClass = superClass.getCachedSuperClass();
protected LinkedList<CachedClass> getSuperClasses() { LinkedList<CachedClass> superClasses = new LinkedList<CachedClass>(); if (theClass.isInterface()) { superClasses.addFirst(ReflectionCache.OBJECT_CLASS); } else { for (CachedClass c = theCachedClass; c != null; c = c.getCachedSuperClass()) { superClasses.addFirst(c); } if (theCachedClass.isArray && theClass != Object[].class && !theClass.getComponentType().isPrimitive()) { superClasses.addFirst(ReflectionCache.OBJECT_ARRAY_CLASS); } } return superClasses; }
public LinkedList<ClassInfo> initValue() { LinkedHashSet<ClassInfo> res = new LinkedHashSet<ClassInfo> (); res.add(classInfo); for (CachedClass iface : getDeclaredInterfaces()) res.addAll(iface.getHierarchy()); final CachedClass superClass = getCachedSuperClass(); if (superClass != null) res.addAll(superClass.getHierarchy()); if (isInterface) res.add(ReflectionCache.OBJECT_CLASS.classInfo); return new LinkedList<ClassInfo> (res); } };
private void use(Class categoryClass) { CachedClass cachedClass = ReflectionCache.getCachedClass(categoryClass); LinkedList<CachedClass> classStack = new LinkedList<CachedClass>(); for (CachedClass superClass = cachedClass; superClass.getTheClass()!=Object.class; superClass = superClass.getCachedSuperClass()) { classStack.add(superClass); } while (!classStack.isEmpty()) { CachedClass klazz = classStack.removeLast(); applyUse(klazz); } }
public LinkedList<ClassInfo> initValue() { Set<ClassInfo> res = new LinkedHashSet<ClassInfo> (); res.add(classInfo); for (CachedClass iface : getDeclaredInterfaces()) res.addAll(iface.getHierarchy()); final CachedClass superClass = getCachedSuperClass(); if (superClass != null) res.addAll(superClass.getHierarchy()); if (isInterface) res.add(ReflectionCache.OBJECT_CLASS.classInfo); return new LinkedList<ClassInfo> (res); } };
public LinkedList<ClassInfo> initValue() { LinkedHashSet<ClassInfo> res = new LinkedHashSet<ClassInfo> (); res.add(classInfo); for (CachedClass iface : getDeclaredInterfaces()) res.addAll(iface.getHierarchy()); final CachedClass superClass = getCachedSuperClass(); if (superClass != null) res.addAll(superClass.getHierarchy()); if (isInterface) res.add(ReflectionCache.OBJECT_CLASS.classInfo); return new LinkedList<ClassInfo> (res); } };
private void use(Class categoryClass) { CachedClass cachedClass = ReflectionCache.getCachedClass(categoryClass); LinkedList<CachedClass> classStack = new LinkedList<CachedClass>(); for (CachedClass superClass = cachedClass; superClass.getTheClass()!=Object.class; superClass = superClass.getCachedSuperClass()) { classStack.add(superClass); } while (!classStack.isEmpty()) { CachedClass klazz = classStack.removeLast(); applyUse(klazz); } }
private void use(Class categoryClass) { CachedClass cachedClass = ReflectionCache.getCachedClass(categoryClass); LinkedList classStack = new LinkedList(); for (CachedClass superClass = cachedClass; superClass.getTheClass()!=Object.class; superClass = superClass.getCachedSuperClass()) { classStack.add(superClass); } while (!classStack.isEmpty()) { CachedClass klazz = (CachedClass) classStack.removeLast(); applyUse(klazz); } }