@NotNull
 private InspectionTreeNode getToolParentNode(
     @NotNull String groupName, HighlightDisplayLevel errorLevel, boolean groupedBySeverity) {
   if (groupName.isEmpty()) {
     return getRelativeRootNode(groupedBySeverity, errorLevel);
   }
   ConcurrentMap<String, InspectionGroupNode> map = myGroups.get(errorLevel);
   if (map == null) {
     map =
         ConcurrencyUtil.cacheOrGet(
             myGroups, errorLevel, ContainerUtil.<String, InspectionGroupNode>newConcurrentMap());
   }
   InspectionGroupNode group;
   if (groupedBySeverity) {
     group = map.get(groupName);
   } else {
     group = null;
     for (Map<String, InspectionGroupNode> groupMap : myGroups.values()) {
       if ((group = groupMap.get(groupName)) != null) break;
     }
   }
   if (group == null) {
     group = ConcurrencyUtil.cacheOrGet(map, groupName, new InspectionGroupNode(groupName));
     addChildNodeInEDT(getRelativeRootNode(groupedBySeverity, errorLevel), group);
   }
   return group;
 }
  public PsiJavaPackage findPackage(@NotNull String qualifiedName, GlobalSearchScope searchScope) {
    PackageCache cache = SoftReference.dereference(packageCache);
    if (cache == null) {
      packageCache = new SoftReference<PackageCache>(cache = new PackageCache());
    }

    Pair<String, GlobalSearchScope> key =
        new Pair<String, GlobalSearchScope>(qualifiedName, searchScope);
    PsiJavaPackage aPackage = cache.packageInScopeCache.get(key);
    if (aPackage != null) {
      return aPackage;
    }

    KotlinPsiElementFinderWrapper[] finders = filteredFinders();

    Boolean packageFoundInAllScope = cache.hasPackageInAllScopeCache.get(qualifiedName);
    if (packageFoundInAllScope != null) {
      if (!packageFoundInAllScope.booleanValue()) return null;

      // Package was found in AllScope with some of finders but is absent in packageCache for
      // current scope.
      // We check only finders that depend on scope.
      for (KotlinPsiElementFinderWrapper finder : finders) {
        if (!finder.isSameResultForAnyScope()) {
          aPackage = finder.findPackage(qualifiedName, searchScope);
          if (aPackage != null) {
            return ConcurrencyUtil.cacheOrGet(cache.packageInScopeCache, key, aPackage);
          }
        }
      }
    } else {
      for (KotlinPsiElementFinderWrapper finder : finders) {
        aPackage = finder.findPackage(qualifiedName, searchScope);

        if (aPackage != null) {
          return ConcurrencyUtil.cacheOrGet(cache.packageInScopeCache, key, aPackage);
        }
      }

      boolean found = false;
      for (KotlinPsiElementFinderWrapper finder : finders) {
        if (!finder.isSameResultForAnyScope()) {
          aPackage = finder.findPackage(qualifiedName, GlobalSearchScope.allScope(project));
          if (aPackage != null) {
            found = true;
            break;
          }
        }
      }

      cache.hasPackageInAllScopeCache.put(qualifiedName, found);
    }

    return null;
  }
 @Override
 protected PsiFile getPsiInner(@NotNull final Language target) {
   PsiFileImpl file = myRoots.get(target);
   if (file == null) {
     if (isPhysical()) {
       VirtualFile virtualFile = getVirtualFile();
       if (isIgnored()) return null;
       VirtualFile parent = virtualFile.getParent();
       if (parent != null) {
         getManager().findDirectory(parent);
       }
     }
     if (target != getBaseLanguage() && !getLanguages().contains(target)) {
       return null;
     }
     file = (PsiFileImpl) createFile(target);
     if (file == null) return null;
     if (myOriginal != null) {
       final PsiFile originalFile = myOriginal.getPsi(target);
       if (originalFile != null) {
         file.setOriginalFile(originalFile);
       }
     }
     file = ConcurrencyUtil.cacheOrGet(myRoots, target, file);
   }
   return file;
 }
 @Override
 public RefModule getRefModule(Module module) {
   if (module == null) {
     return null;
   }
   RefModule refModule = myModules.get(module);
   if (refModule == null) {
     refModule = ConcurrencyUtil.cacheOrGet(myModules, module, new RefModuleImpl(module, this));
   }
   return refModule;
 }
示例#5
0
 public Server(File systemDir, boolean cachesInMemory) {
   Utils.setSystemRoot(systemDir);
   final ExecutorService threadPool = Executors.newCachedThreadPool();
   myScheduler =
       ConcurrencyUtil.newSingleScheduledThreadExecutor(
           "Client activity checker", Thread.MIN_PRIORITY);
   myBuildsExecutor = Executors.newFixedThreadPool(MAX_SIMULTANEOUS_BUILD_SESSIONS);
   myChannelFactory = new NioServerSocketChannelFactory(threadPool, threadPool, 1);
   final ChannelRegistrar channelRegistrar = new ChannelRegistrar();
   myMessageHandler =
       new ServerMessageHandler(
           this,
           new AsyncTaskExecutor() {
             @Override
             public void submit(final Runnable runnable) {
               myBuildsExecutor.submit(
                   new Runnable() {
                     @Override
                     public void run() {
                       try {
                         runnable.run();
                       } finally {
                         Thread.interrupted(); // clear interrupted status before returning to pull
                       }
                     }
                   });
             }
           });
   myPipelineFactory =
       new ChannelPipelineFactory() {
         public ChannelPipeline getPipeline() throws Exception {
           return Channels.pipeline(
               channelRegistrar,
               new ProtobufVarint32FrameDecoder(),
               new ProtobufDecoder(JpsRemoteProto.Message.getDefaultInstance()),
               new ProtobufVarint32LengthFieldPrepender(),
               new ProtobufEncoder(),
               myMessageHandler);
         }
       };
   ServerState.getInstance().setKeepTempCachesInMemory(cachesInMemory);
   Runtime.getRuntime()
       .addShutdownHook(
           new Thread("Shutdown hook thread") {
             public void run() {
               try {
                 myMessageHandler.cancelAllBuildsAndClearState();
               } finally {
                 Server.this.stop();
               }
             }
           });
 }
示例#6
0
 @Nullable
 public static Icon findIcon(URL url, boolean useCache) {
   if (url == null) {
     return null;
   }
   CachedImageIcon icon = ourIconsCache.get(url);
   if (icon == null) {
     icon = new CachedImageIcon(url);
     if (useCache) {
       icon = ConcurrencyUtil.cacheOrGet(ourIconsCache, url, icon);
     }
   }
   return icon;
 }
    static void registerDisposable(
        @NotNull Disposable parentDisposable, @NotNull VirtualFilePointerImpl pointer) {
      DelegatingDisposable result = ourInstances.get(parentDisposable);
      if (result == null) {
        DelegatingDisposable newDisposable = new DelegatingDisposable(parentDisposable);
        result = ConcurrencyUtil.cacheOrGet(ourInstances, parentDisposable, newDisposable);
        if (result == newDisposable) {
          Disposer.register(parentDisposable, result);
        }
      }

      synchronized (result) {
        result.myCounts.put(pointer, result.myCounts.get(pointer) + 1);
      }
    }
 @NotNull
 private InspectionTreeNode getRelativeRootNode(
     boolean isGroupedBySeverity, HighlightDisplayLevel level) {
   if (isGroupedBySeverity) {
     InspectionSeverityGroupNode severityGroupNode = mySeverityGroupNodes.get(level);
     if (severityGroupNode == null) {
       InspectionSeverityGroupNode newNode = new InspectionSeverityGroupNode(myProject, level);
       severityGroupNode = ConcurrencyUtil.cacheOrGet(mySeverityGroupNodes, level, newNode);
       if (severityGroupNode == newNode) {
         InspectionTreeNode root = myTree.getRoot();
         addChildNodeInEDT(root, severityGroupNode);
       }
     }
     return severityGroupNode;
   }
   return myTree.getRoot();
 }
 protected PsiFile getPsiInner(final Language target) {
   PsiFile file = myRoots.get(target);
   if (file == null) {
     if (isPhysical()) {
       VirtualFile virtualFile = getVirtualFile();
       VirtualFile parent = virtualFile.getParent();
       if (parent != null) {
         getManager().findDirectory(parent);
       }
     }
     file = createFile(target);
     if (file == null) return null;
     if (myOriginal != null) {
       final PsiFile originalFile = myOriginal.getPsi(target);
       if (originalFile != null) {
         ((PsiFileImpl) file).setOriginalFile(originalFile);
       }
     }
     file = ConcurrencyUtil.cacheOrGet(myRoots, target, file);
   }
   return file;
 }
 @NotNull
 @Override
 public PsiClassType createTypeByFQClassName(
     @NotNull final String qName, @NotNull final GlobalSearchScope resolveScope) {
   if (CommonClassNames.JAVA_LANG_OBJECT.equals(qName)) {
     PsiClassType cachedObjectType = myCachedObjectType.get(resolveScope);
     if (cachedObjectType != null) {
       return cachedObjectType;
     }
     PsiClass aClass =
         JavaPsiFacade.getInstance(myManager.getProject())
             .findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
     if (aClass != null) {
       cachedObjectType = new PsiImmediateClassType(aClass, PsiSubstitutor.EMPTY);
       cachedObjectType =
           ConcurrencyUtil.cacheOrGet(myCachedObjectType, resolveScope, cachedObjectType);
       return cachedObjectType;
     }
   }
   return new PsiClassReferenceType(
       createReferenceElementByFQClassName(qName, resolveScope), null);
 }
示例#11
0
/**
 * Base class for the actions, which update() method might be potentially slow to be executed
 * synchronously in Swing UI thread.
 *
 * @author max
 */
public abstract class AsyncUpdateAction<T> extends AnAction {
  private static final Logger LOG =
      Logger.getInstance("#com.intellij.openapi.actionSystem.AsyncUpdateAction");

  private static final ExecutorService ourUpdaterService =
      ConcurrencyUtil.newSingleThreadExecutor("Action Updater");

  // Async update
  @Override
  public final void update(AnActionEvent e) {
    final T data = prepareDataFromContext(e);
    final Presentation originalPresentation = e.getPresentation();
    if (!forceSyncUpdate(e) && isDumbAware()) {
      final Presentation realPresentation = (Presentation) originalPresentation.clone();
      ourUpdaterService.submit(
          new Runnable() {
            @Override
            public void run() {
              performUpdate(realPresentation, data);
              SwingUtilities.invokeLater(
                  new Runnable() {
                    @Override
                    public void run() {
                      if (originalPresentation.isVisible() != realPresentation.isVisible()) {
                        LOG.error(
                            "Async update is not supported for actions that change their visibility."
                                + "Either stop extending AsyncUpdateAction or override forceSyncUpdate() to return true."
                                + "Action class is: "
                                + AsyncUpdateAction.this.getClass().getName());
                      }
                      originalPresentation.copyFrom(realPresentation);
                    }
                  });
            }
          });

      originalPresentation.setVisible(true);
      originalPresentation.setEnabled(false);
    } else {
      performUpdate(originalPresentation, data);
    }
  }

  // Sync update
  @Override
  public final void beforeActionPerformedUpdate(@NotNull AnActionEvent e) {
    performUpdate(e.getPresentation(), prepareDataFromContext(e));
  }

  /**
   * Get all necessary data from event's DataContext to be used in <code>performUpdate()</code>,
   * which is called asynchronously.
   *
   * @param e action event original update() method have been called with.
   * @return prepared data for {@link #performUpdate} method.
   */
  protected abstract T prepareDataFromContext(final AnActionEvent e);

  /**
   * Perform real presentation tweaking here. Be aware of the fact this method may be called in
   * thread other than Swing UI thread thus probable restrictions like necessity to call
   * ApplcationManager.getApplication().runReadAction() apply.
   *
   * @param presentation Presentation object to be tweaked.
   * @param data necessary data calculated by {@link #prepareDataFromContext(AnActionEvent)}.
   */
  protected abstract void performUpdate(Presentation presentation, T data);

  /**
   * Override this method to return <code>true</code> value if update method cannot be called
   * asynchronously for whatever reason.
   *
   * @param e action event original update() method have been called with.
   * @return <code>false</code> if async update is possible and <code>false</code> otherwise.
   */
  protected boolean forceSyncUpdate(AnActionEvent e) {
    return false;
  }
}
 private static int getThreadNum() {
   return ConcurrencyUtil.cacheOrGet(threads, Thread.currentThread(), threads.size());
 }