private ITypeHierarchy getTypeHierarchy() throws JavaModelException { if (fTypeHierarchy == null) { fTypeHierarchy = SuperTypeHierarchyCache.getTypeHierarchy(fStartingType); } return fTypeHierarchy; }
private MethodOverrideTester getOverrideTester() throws JavaModelException { if (fOverrideTester == null) { fOverrideTester = SuperTypeHierarchyCache.getMethodOverrideTester(fStartingType); } return fOverrideTester; } }
/** * Get a hierarchy for the given type */ public static ITypeHierarchy getTypeHierarchy(IType type, IProgressMonitor progressMonitor) throws JavaModelException { ITypeHierarchy hierarchy= findTypeHierarchyInCache(type); if (hierarchy == null) { fgCacheMisses++; hierarchy= type.newSupertypeHierarchy(progressMonitor); addTypeHierarchyToCache(hierarchy); } else { fgCacheHits++; } return hierarchy; }
ITypeHierarchy hierarchy= SuperTypeHierarchyCache.getTypeHierarchy(type); final MethodOverrideTester tester= SuperTypeHierarchyCache.getMethodOverrideTester(type);
private static void addTypeHierarchyToCache(ITypeHierarchy hierarchy) { synchronized (fgHierarchyCache) { int nEntries= fgHierarchyCache.size(); if (nEntries >= CACHE_SIZE) { // find obsolete entries or remove entry that was least recently accessed HierarchyCacheEntry oldest= null; ArrayList<HierarchyCacheEntry> obsoleteHierarchies= new ArrayList<>(CACHE_SIZE); for (int i= 0; i < nEntries; i++) { HierarchyCacheEntry entry= fgHierarchyCache.get(i); ITypeHierarchy curr= entry.getTypeHierarchy(); if (!curr.exists() || hierarchy.contains(curr.getType())) { obsoleteHierarchies.add(entry); } else { if (oldest == null || entry.getLastAccess() < oldest.getLastAccess()) { oldest= entry; } } } if (!obsoleteHierarchies.isEmpty()) { for (int i= 0; i < obsoleteHierarchies.size(); i++) { removeHierarchyEntryFromCache(obsoleteHierarchies.get(i)); } } else if (oldest != null) { removeHierarchyEntryFromCache(oldest); } } HierarchyCacheEntry newEntry= new HierarchyCacheEntry(hierarchy); fgHierarchyCache.add(newEntry); } }
private static void removeHierarchyEntryFromCache(HierarchyCacheEntry entry) { synchronized (fgHierarchyCache) { removeMethodOverrideTester(entry.getTypeHierarchy()); entry.dispose(); fgHierarchyCache.remove(entry); } }
/** * Check if the given type is in the hierarchy cache. * @param type a type * @return <code>true</code> if a hierarchy for the given type is cached */ public static boolean hasInCache(IType type) { return findTypeHierarchyInCache(type) != null; }
private boolean checkMethod(IMethod method) { try { int flags= method.getFlags(); if (!Flags.isStatic(flags) && !Flags.isPrivate(flags)) { IType declaringType= method.getDeclaringType(); if (SuperTypeHierarchyCache.hasInCache(declaringType)) { if (findSuperImplementation(method) == null) { return false; } } return true; } } catch (JavaModelException e) { if (!e.isDoesNotExist()) { JavaPlugin.log(e); } } return false; }
ITypeHierarchy hierarchy = SuperTypeHierarchyCache.getTypeHierarchy(type); final MethodOverrideTester tester = SuperTypeHierarchyCache.getMethodOverrideTester(type);
private static ITypeHierarchy findTypeHierarchyInCache(IType type) { synchronized (fgHierarchyCache) { for (int i= fgHierarchyCache.size() - 1; i>= 0; i--) { HierarchyCacheEntry curr= fgHierarchyCache.get(i); ITypeHierarchy hierarchy= curr.getTypeHierarchy(); if (!hierarchy.exists()) { removeHierarchyEntryFromCache(curr); } else { if (hierarchy.contains(type)) { curr.markAsAccessed(); return hierarchy; } } } } return null; }
private static void removeHierarchyEntryFromCache(HierarchyCacheEntry entry) { synchronized (fgHierarchyCache) { removeMethodOverrideTester(entry.getTypeHierarchy()); entry.dispose(); fgHierarchyCache.remove(entry); } }
/** * Check if the given type is in the hierarchy * @param type * @return Return <code>true</code> if a hierarchy for the given type is cached. */ public static boolean hasInCache(IType type) { return findTypeHierarchyInCache(type) != null; }
private boolean checkMethod(IMethod method) { try { int flags= method.getFlags(); if (!Flags.isStatic(flags) && !Flags.isPrivate(flags)) { IType declaringType= method.getDeclaringType(); if (SuperTypeHierarchyCache.hasInCache(declaringType)) { if (findSuperImplementation(method) == null) { return false; } } return true; } } catch (JavaModelException e) { if (!e.isDoesNotExist()) { JavaPlugin.log(e); } } return false; }
private ITypeHierarchy getTypeHierarchy() throws JavaModelException { if (fTypeHierarchy == null) fTypeHierarchy= SuperTypeHierarchyCache.getTypeHierarchy(fStartingType); return fTypeHierarchy; }
ITypeHierarchy hierarchy= SuperTypeHierarchyCache.getTypeHierarchy(type); final MethodOverrideTester tester= SuperTypeHierarchyCache.getMethodOverrideTester(type);
private MethodOverrideTester getOverrideTester() throws JavaModelException { if (fOverrideTester == null) fOverrideTester= SuperTypeHierarchyCache.getMethodOverrideTester(fStartingType); return fOverrideTester; } }
/** * Returns a super type hierarchy that contains the given type. * The returned hierarchy may actually be based on a subtype of the * requested type. Therefore, queries such as {@link ITypeHierarchy#getAllClasses()} * or {@link ITypeHierarchy#getRootInterfaces()} may return more types than the same * queries on a type hierarchy for just the given type. * * @param type the focus type * @param progressMonitor progress monitor * @return a supertype hierarchy that contains <code>type</code> * @throws JavaModelException if a problem occurs */ public static ITypeHierarchy getTypeHierarchy(IType type, IProgressMonitor progressMonitor) throws JavaModelException { ITypeHierarchy hierarchy= findTypeHierarchyInCache(type); if (hierarchy == null) { fgCacheMisses++; hierarchy= type.newSupertypeHierarchy(progressMonitor); addTypeHierarchyToCache(hierarchy); } else { fgCacheHits++; } return hierarchy; }
private static ITypeHierarchy findTypeHierarchyInCache(IType type) { synchronized (fgHierarchyCache) { for (int i= fgHierarchyCache.size() - 1; i>= 0; i--) { HierarchyCacheEntry curr= (HierarchyCacheEntry) fgHierarchyCache.get(i); ITypeHierarchy hierarchy= curr.getTypeHierarchy(); if (!hierarchy.exists()) { removeHierarchyEntryFromCache(curr); } else { if (hierarchy.contains(type)) { curr.markAsAccessed(); return hierarchy; } } } } return null; }
private static void removeHierarchyEntryFromCache(HierarchyCacheEntry entry) { synchronized (fgHierarchyCache) { removeMethodOverrideTester(entry.getTypeHierarchy()); entry.dispose(); fgHierarchyCache.remove(entry); } }
/** * Check if the given type is in the hierarchy cache. * @param type a type * @return <code>true</code> if a hierarchy for the given type is cached */ public static boolean hasInCache(IType type) { return findTypeHierarchyInCache(type) != null; }