From bb35b2626c1710ab56bce1dcf7453ce815413ffc Mon Sep 17 00:00:00 2001 From: Roman Shevchenko Date: Thu, 5 Jun 2014 11:50:41 +0400 Subject: [PATCH] Cleanup (cached value manager instead of boilerplate) --- .../psi/impl/source/ClassInnerStuffCache.java | 255 +++++++----------- 1 file changed, 100 insertions(+), 155 deletions(-) diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/ClassInnerStuffCache.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/ClassInnerStuffCache.java index 88f0ce8a92a3..33fe5b6658f4 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/ClassInnerStuffCache.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/ClassInnerStuffCache.java @@ -23,205 +23,147 @@ import com.intellij.psi.PsiMethod; import com.intellij.psi.augment.PsiAugmentProvider; import com.intellij.psi.impl.PsiClassImplUtil; import com.intellij.psi.impl.PsiImplUtil; -import com.intellij.psi.util.CachedValue; import com.intellij.psi.util.CachedValueProvider; import com.intellij.psi.util.CachedValuesManager; -import com.intellij.psi.util.PsiModificationTracker; import com.intellij.util.ArrayUtil; +import com.intellij.util.containers.ContainerUtil; import gnu.trove.THashMap; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.ArrayList; +import java.util.Collections; import java.util.List; import java.util.Map; +import static com.intellij.psi.util.PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT; + public class ClassInnerStuffCache { private final PsiExtensibleClass myClass; - private final SimpleModificationTracker myTreeChangeTracker; + private final SimpleModificationTracker myTracker; - private CachedValue myConstructorsCache; - private CachedValue myFieldsCache; - private CachedValue myMethodsCache; - private CachedValue myInnerClassesCache; - private CachedValue> myFieldsMapCache; - private CachedValue>> myMethodsMapCache; - private CachedValue> myInnerClassesMapCache; - - public ClassInnerStuffCache(final PsiExtensibleClass aClass) { + public ClassInnerStuffCache(@NotNull PsiExtensibleClass aClass) { myClass = aClass; - myTreeChangeTracker = new SimpleModificationTracker(); + myTracker = new SimpleModificationTracker(); } @NotNull public PsiMethod[] getConstructors() { - CachedValue cache = myConstructorsCache; - if (cache == null) { - final CachedValuesManager manager = CachedValuesManager.getManager(myClass.getProject()); - final Object[] dependencies = {PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT, myTreeChangeTracker}; - - myConstructorsCache = cache = manager.createCachedValue(new CachedValueProvider() { - @Override - public Result compute() { - return Result.create(PsiImplUtil.getConstructors(myClass), dependencies); - } - }, false); - } - - final PsiMethod[] constructors = cache.getValue(); - return constructors != null ? constructors : PsiMethod.EMPTY_ARRAY; + return CachedValuesManager.getCachedValue(myClass, new CachedValueProvider() { + @Nullable + @Override + public Result compute() { + return Result.create(PsiImplUtil.getConstructors(myClass), OUT_OF_CODE_BLOCK_MODIFICATION_COUNT, myTracker); + } + }); } @NotNull public PsiField[] getFields() { - CachedValue cache = myFieldsCache; - if (cache == null) { - final CachedValuesManager manager = CachedValuesManager.getManager(myClass.getProject()); - final Object[] dependencies = {PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT, myTreeChangeTracker}; - - myFieldsCache = cache = manager.createCachedValue(new CachedValueProvider() { - @Override - public Result compute() { - return Result.create(getAllFields(), dependencies); - } - }, false); - } - final PsiField[] fields = cache.getValue(); - return fields != null ? fields : PsiField.EMPTY_ARRAY; + return CachedValuesManager.getCachedValue(myClass, new CachedValueProvider() { + @Nullable + @Override + public Result compute() { + return Result.create(getAllFields(), OUT_OF_CODE_BLOCK_MODIFICATION_COUNT, myTracker); + } + }); } @NotNull public PsiMethod[] getMethods() { - CachedValue cache = myMethodsCache; - if (cache == null) { - final CachedValuesManager manager = CachedValuesManager.getManager(myClass.getProject()); - final Object[] dependencies = {PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT, myTreeChangeTracker}; - - myMethodsCache = cache = manager.createCachedValue(new CachedValueProvider() { - @Override - public Result compute() { - return Result.create(getAllMethods(), dependencies); - } - }, false); - } - final PsiMethod[] methods = cache.getValue(); - return methods != null ? methods : PsiMethod.EMPTY_ARRAY; + return CachedValuesManager.getCachedValue(myClass, new CachedValueProvider() { + @Nullable + @Override + public Result compute() { + return Result.create(getAllMethods(), OUT_OF_CODE_BLOCK_MODIFICATION_COUNT, myTracker); + } + }); } @NotNull public PsiClass[] getInnerClasses() { - CachedValue cache = myInnerClassesCache; - if (cache == null) { - final CachedValuesManager manager = CachedValuesManager.getManager(myClass.getProject()); - final Object[] dependencies = {PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT, myTreeChangeTracker}; - - myInnerClassesCache = cache = manager.createCachedValue(new CachedValueProvider() { - @Override - public Result compute() { - return Result.create(getAllInnerClasses(), dependencies); - } - }, false); - } - final PsiClass[] classes = cache.getValue(); - return classes != null ? classes : PsiClass.EMPTY_ARRAY; + return CachedValuesManager.getCachedValue(myClass, new CachedValueProvider() { + @Nullable + @Override + public Result compute() { + return Result.create(getAllInnerClasses(), OUT_OF_CODE_BLOCK_MODIFICATION_COUNT, myTracker); + } + }); } @Nullable - public PsiField findFieldByName(final String name, final boolean checkBases) { - if (!checkBases) { - CachedValue> cache = myFieldsMapCache; - if (cache == null) { - final CachedValuesManager manager = CachedValuesManager.getManager(myClass.getProject()); - final Object[] dependencies = {PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT, myTreeChangeTracker}; - - myFieldsMapCache = cache = manager.createCachedValue(new CachedValueProvider>() { - @Override - public Result> compute() { - return Result.create(getFieldsMap(), dependencies); - } - }, false); - } - final Map cachedFields = cache.getValue(); - return cachedFields != null ? cachedFields.get(name) : null; + public PsiField findFieldByName(String name, boolean checkBases) { + if (checkBases) { + return PsiClassImplUtil.findFieldByName(myClass, name, true); + } + else { + return CachedValuesManager.getCachedValue(myClass, new CachedValueProvider>() { + @Nullable + @Override + public Result> compute() { + return Result.create(getFieldsMap(), OUT_OF_CODE_BLOCK_MODIFICATION_COUNT, myTracker); + } + }).get(name); } - return PsiClassImplUtil.findFieldByName(myClass, name, checkBases); } @NotNull - public PsiMethod[] findMethodsByName(final String name, final boolean checkBases) { - if (!checkBases) { - CachedValue>> cache = myMethodsMapCache; - if (cache == null) { - final CachedValuesManager manager = CachedValuesManager.getManager(myClass.getProject()); - final Object[] dependencies = {PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT, myTreeChangeTracker}; - - myMethodsMapCache = cache = manager.createCachedValue(new CachedValueProvider>>() { - @Override - public Result>> compute() { - return Result.create(getMethodsMap(), dependencies); - } - }, false); - } - final Map> cachedMethods = cache.getValue(); - if (cachedMethods != null) { - final List methods = cachedMethods.get(name); - if (methods != null && !methods.isEmpty()) { - return methods.toArray(new PsiMethod[methods.size()]); + public PsiMethod[] findMethodsByName(String name, boolean checkBases) { + if (checkBases) { + return PsiClassImplUtil.findMethodsByName(myClass, name, true); + } + else { + PsiMethod[] methods = CachedValuesManager.getCachedValue(myClass, new CachedValueProvider>() { + @Nullable + @Override + public Result> compute() { + return Result.create(getMethodsMap(), OUT_OF_CODE_BLOCK_MODIFICATION_COUNT, myTracker); } - } - return PsiMethod.EMPTY_ARRAY; + }).get(name); + return methods != null ? methods : PsiMethod.EMPTY_ARRAY; } - return PsiClassImplUtil.findMethodsByName(myClass, name, checkBases); } @Nullable public PsiClass findInnerClassByName(final String name, final boolean checkBases) { - if (!checkBases) { - CachedValue> cache = myInnerClassesMapCache; - if (cache == null) { - final CachedValuesManager manager = CachedValuesManager.getManager(myClass.getProject()); - final Object[] dependencies = {PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT, myTreeChangeTracker}; - - myInnerClassesMapCache = cache = manager.createCachedValue(new CachedValueProvider>() { - @Override - public Result> compute() { - return Result.create(getInnerClassesMap(), dependencies); - } - }, false); - } - - final Map inners = cache.getValue(); - return inners != null ? inners.get(name) : null; + if (checkBases) { + return PsiClassImplUtil.findInnerByName(myClass, name, true); + } + else { + return CachedValuesManager.getCachedValue(myClass, new CachedValueProvider>() { + @Nullable + @Override + public Result> compute() { + return Result.create(getInnerClassesMap(), OUT_OF_CODE_BLOCK_MODIFICATION_COUNT, myTracker); + } + }).get(name); } - return PsiClassImplUtil.findInnerByName(myClass, name, checkBases); } private PsiField[] getAllFields() { - final List own = myClass.getOwnFields(); - final List ext = PsiAugmentProvider.collectAugments(myClass, PsiField.class); + List own = myClass.getOwnFields(); + List ext = PsiAugmentProvider.collectAugments(myClass, PsiField.class); return ArrayUtil.mergeCollections(own, ext, PsiField.ARRAY_FACTORY); } private PsiMethod[] getAllMethods() { - final List own = myClass.getOwnMethods(); - final List ext = PsiAugmentProvider.collectAugments(myClass, PsiMethod.class); + List own = myClass.getOwnMethods(); + List ext = PsiAugmentProvider.collectAugments(myClass, PsiMethod.class); return ArrayUtil.mergeCollections(own, ext, PsiMethod.ARRAY_FACTORY); } private PsiClass[] getAllInnerClasses() { - final List own = myClass.getOwnInnerClasses(); - final List ext = PsiAugmentProvider.collectAugments(myClass, PsiClass.class); + List own = myClass.getOwnInnerClasses(); + List ext = PsiAugmentProvider.collectAugments(myClass, PsiClass.class); return ArrayUtil.mergeCollections(own, ext, PsiClass.ARRAY_FACTORY); } - @Nullable private Map getFieldsMap() { - final PsiField[] fields = getFields(); - if (fields.length == 0) return null; + PsiField[] fields = getFields(); + if (fields.length == 0) return Collections.emptyMap(); - final Map cachedFields = new THashMap(); - for (final PsiField field : fields) { - final String name = field.getName(); + Map cachedFields = new THashMap(); + for (PsiField field : fields) { + String name = field.getName(); if (!(field instanceof ExternallyDefinedPsiElement) || !cachedFields.containsKey(name)) { cachedFields.put(name, field); } @@ -229,30 +171,34 @@ public class ClassInnerStuffCache { return cachedFields; } - @Nullable - private Map> getMethodsMap() { - final PsiMethod[] methods = getMethods(); - if (methods.length == 0) return null; + private Map getMethodsMap() { + PsiMethod[] methods = getMethods(); + if (methods.length == 0) return Collections.emptyMap(); - final Map> cachedMethods = new THashMap>(); - for (final PsiMethod method : methods) { - List list = cachedMethods.get(method.getName()); + Map> collectedMethods = ContainerUtil.newHashMap(); + for (PsiMethod method : methods) { + List list = collectedMethods.get(method.getName()); if (list == null) { - cachedMethods.put(method.getName(), list = new ArrayList(1)); + collectedMethods.put(method.getName(), list = ContainerUtil.newSmartList()); } list.add(method); } + + Map cachedMethods = ContainerUtil.newTroveMap(); + for (Map.Entry> entry : collectedMethods.entrySet()) { + List list = entry.getValue(); + cachedMethods.put(entry.getKey(), list.toArray(new PsiMethod[list.size()])); + } return cachedMethods; } - @Nullable private Map getInnerClassesMap() { - final PsiClass[] classes = getInnerClasses(); - if (classes.length == 0) return null; + PsiClass[] classes = getInnerClasses(); + if (classes.length == 0) return Collections.emptyMap(); - final Map cachedInners = new THashMap(); - for (final PsiClass psiClass : classes) { - final String name = psiClass.getName(); + Map cachedInners = new THashMap(); + for (PsiClass psiClass : classes) { + String name = psiClass.getName(); if (!(psiClass instanceof ExternallyDefinedPsiElement) || !cachedInners.containsKey(name)) { cachedInners.put(name, psiClass); } @@ -261,7 +207,6 @@ public class ClassInnerStuffCache { } public void dropCaches() { - myTreeChangeTracker.incModificationCount(); + myTracker.incModificationCount(); } - }