platform/platform-impl/src/com/intellij/util/CachedValuesManagerImpl.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.util;
  17
  18 import com.intellij.openapi.util.UserDataHolder;
  19 import com.intellij.openapi.util.Key;
  20 import com.intellij.openapi.util.UserDataHolderEx;
  21 import com.intellij.openapi.project.Project;
  22 import com.intellij.psi.util.*;
  23 import org.jetbrains.annotations.NotNull;
  24 import org.jetbrains.annotations.Nullable;
  25
  26 /**
  27  * @author ven
  28  */
  29 public class CachedValuesManagerImpl extends CachedValuesManager {
  30
  31   private final Project myProject;
  32   private final CachedValuesFactory myFactory;
  33
  34   public CachedValuesManagerImpl(Project project, CachedValuesFactory factory) {
  35     myProject = project;
  36     myFactory = factory == null ? new DefaultCachedValuesFactory(project) : factory;
  37   }
  38
  39   public <T> CachedValue<T> createCachedValue(@NotNull CachedValueProvider<T> provider, boolean trackValue) {
  40     return myFactory.createCachedValue(provider, trackValue);
  41   }
  42
  43   public <T,P> ParameterizedCachedValue<T,P> createParameterizedCachedValue(@NotNull ParameterizedCachedValueProvider<T,P> provider, boolean trackValue) {
  44     return myFactory.createParameterizedCachedValue(provider, trackValue);
  45   }
  46
  47   @Override
  48   @Nullable
  49   public <T, D extends UserDataHolder> T getCachedValue(@NotNull D dataHolder,
  50                               @NotNull Key<CachedValue<T>> key,
  51                               @NotNull CachedValueProvider<T> provider,
  52                               boolean trackValue) {
  53
  54     CachedValue<T> value;
  55     if (dataHolder instanceof UserDataHolderEx) {
  56       UserDataHolderEx dh = (UserDataHolderEx)dataHolder;
  57       value = dh.getUserData(key);
  58       if (value instanceof CachedValueBase && !((CachedValueBase)value).isFromMyProject(myProject)) {
  59         value = null;
  60         dataHolder.putUserData(key, null);
  61       }
  62       if (value == null) {
  63         value = createCachedValue(provider, trackValue);
  64         assert ((CachedValueBase)value).isFromMyProject(myProject);
  65         value = dh.putUserDataIfAbsent(key, value);
  66       }
  67     }
  68     else {
  69       synchronized (dataHolder) {
  70         value = dataHolder.getUserData(key);
  71         if (value instanceof CachedValueBase && !((CachedValueBase)value).isFromMyProject(myProject)) {
  72           value = null;
  73         }
  74         if (value == null) {
  75           value = createCachedValue(provider, trackValue);
  76           dataHolder.putUserData(key, value);
  77         }
  78       }
  79     }
  80     return value.getValue();
  81   }
  82
  83   public Project getProject() {
  84     return myProject;
  85   }
  86 }