Java OrderEnumerator类代码示例

import com.intellij.openapi.roots.OrderEnumerator; //导入依赖的package包/类
public Map<String, HotSwapFile> scanForModifiedClasses( DebuggerSession session, HotSwapProgress progress )
{
  DebuggerManagerThreadImpl.assertIsManagerThread();

  Map<String, HotSwapFile> modifiedClasses = new HashMap<>();

  List<File> outputRoots = new ArrayList<>();
  ApplicationManager.getApplication().runReadAction(
    () -> {
       VirtualFile[] allDirs = OrderEnumerator.orderEntries( getIjProject() ).getAllSourceRoots();
       for( VirtualFile dir : allDirs )
       {
         outputRoots.add( new File( dir.getPath() ) );
       }
     } );
  long timeStamp = getTimeStamp( session );
  for( File root : outputRoots )
  {
    String rootPath = FileUtil.toCanonicalPath( root.getPath() );
    collectModifiedClasses( root, rootPath, modifiedClasses, progress, timeStamp );
  }
  setTimeStamp( session, System.currentTimeMillis() );
  return modifiedClasses;
}
 

import com.intellij.openapi.roots.OrderEnumerator; //导入依赖的package包/类
private URL[] makeClassLoaderClassPath()
{
  List<URL> outputRoots = new ArrayList<>();
      ApplicationManager.getApplication().runReadAction(
        () -> {
           final List<VirtualFile> allDirs = OrderEnumerator.orderEntries( getIjProject() ).withoutSdk().getPathsList().getRootDirs();
           for( VirtualFile dir : allDirs )
           {
             try
             {
               outputRoots.add( new File( getPath( dir ) ).toURI().toURL() );
             }
             catch( MalformedURLException e )
             {
               throw new RuntimeException( e );
             }
           }
         } );
      return outputRoots.toArray( new URL[outputRoots.size()] );
}
 

import com.intellij.openapi.roots.OrderEnumerator; //导入依赖的package包/类
@Nullable
private static String getMuleHome(@NotNull Module module) {
    if (!DumbService.isDumb(module.getProject())) {
        final OrderEnumerator enumerator = ModuleRootManager.getInstance(module)
                .orderEntries().recursively().librariesOnly().exportedOnly();
        final String[] home = new String[1];
        enumerator.forEachLibrary(library -> {
            if (MuleLibraryKind.MULE_LIBRARY_KIND.equals(((LibraryEx) library).getKind()) &&
                    library.getFiles(OrderRootType.CLASSES) != null &&
                    library.getFiles(OrderRootType.CLASSES).length > 0) {
                home[0] = getMuleHome(library.getFiles(OrderRootType.CLASSES)[0]);
                return false;
            } else {
                return true;
            }
        });

        return home[0];
    }
    return null;
}
 

import com.intellij.openapi.roots.OrderEnumerator; //导入依赖的package包/类
public static void processClassPathItems(final VirtualFile virtualFile, final Module module, final Consumer<VirtualFile> consumer,
                                         boolean includeModuleOutput) {
  if (isJarFile(virtualFile)){
    consumer.consume(virtualFile);
  }

  if (module != null) {
    OrderEnumerator enumerator = ModuleRootManager.getInstance(module).orderEntries().recursively();
    if (!includeModuleOutput) {
      enumerator = enumerator.withoutModuleSourceEntries();
    }
    for (VirtualFile root : enumerator.getClassesRoots()) {
      final VirtualFile file;
      if (root.getFileSystem().getProtocol().equals(JarFileSystem.PROTOCOL)) {
        file = JarFileSystem.getInstance().getVirtualFileForJar(root);
      }
      else {
        file = root;
      }
      consumer.consume(file);
    }
  }
}
 

import com.intellij.openapi.roots.OrderEnumerator; //导入依赖的package包/类
/**
 * Tries to return gradle home that is defined as a dependency to the given module.
 *
 * @param module target module
 * @return file handle that points to the gradle installation home defined as a dependency of the given module (if any)
 */
@Nullable
public VirtualFile getGradleHome(@Nullable Module module) {
  if (module == null) {
    return null;
  }
  final VirtualFile[] roots = OrderEnumerator.orderEntries(module).getAllLibrariesAndSdkClassesRoots();
  if (roots == null) {
    return null;
  }
  for (VirtualFile root : roots) {
    if (root != null && isGradleSdkHome(root)) {
      return root;
    }
  }
  return null;
}
 

import com.intellij.openapi.roots.OrderEnumerator; //导入依赖的package包/类
public static boolean isRoboVmModule(Module module) {
    // HACK! to identify if the module uses a robovm sdk
    if (ModuleRootManager.getInstance(module).getSdk() != null) {
        if (ModuleRootManager.getInstance(module).getSdk().getSdkType().getName().toLowerCase().contains("robovm")) {
            return true;
        }
    }

    // check if there's any RoboVM RT libs in the classpath
    OrderEnumerator classes = ModuleRootManager.getInstance(module).orderEntries().recursively().withoutSdk().compileOnly();
    for (String path : classes.getPathsList().getPathList()) {
        if (isSdkLibrary(path)) {
            return true;
        }
    }

    // check if there's a robovm.xml file in the root of the module
    for(VirtualFile file: ModuleRootManager.getInstance(module).getContentRoots()) {
        if(file.findChild("robovm.xml") != null) {
            return true;
        }
    }

    return false;
}
 

import com.intellij.openapi.roots.OrderEnumerator; //导入依赖的package包/类
/**
 * Tries to return gradle home that is defined as a dependency to the given module.
 *
 * @param module  target module
 * @return file handle that points to the gradle installation home defined as a dependency of the given module (if any)
 */
@Nullable
public VirtualFile getGradleHome(@Nullable Module module) {
  if (module == null) {
    return null;
  }
  final VirtualFile[] roots = OrderEnumerator.orderEntries(module).getAllLibrariesAndSdkClassesRoots();
  if (roots == null) {
    return null;
  }
  for (VirtualFile root : roots) {
    if (root != null && isGradleSdkHome(root)) {
      return root;
    }
  }
  return null;
}
 

import com.intellij.openapi.roots.OrderEnumerator; //导入依赖的package包/类
private void assertClasspath(String moduleName, Scope scope, Type type, String... expectedPaths) throws Exception {
  createOutputDirectories();

  PathsList actualPathsList;
  Module module = getModule(moduleName);

  if (scope == Scope.RUNTIME) {
    JavaParameters params = new JavaParameters();
    params.configureByModule(module, type == Type.TESTS ? JavaParameters.CLASSES_AND_TESTS : JavaParameters.CLASSES_ONLY);
    actualPathsList = params.getClassPath();
  }
  else {
    OrderEnumerator en = OrderEnumerator.orderEntries(module).recursively().withoutSdk().compileOnly();
    if (type == Type.PRODUCTION) en.productionOnly();
    actualPathsList = en.classes().getPathsList();
  }

  assertPaths(expectedPaths, actualPathsList.getPathList());
}
 

import com.intellij.openapi.roots.OrderEnumerator; //导入依赖的package包/类
@Nullable
protected static VirtualFile findGroovyJar(@NotNull Module module) {
  final VirtualFile[] files = OrderEnumerator.orderEntries(module).getAllLibrariesAndSdkClassesRoots();
  for (VirtualFile root : files) {
    if (root.getName().matches(GroovyConfigUtils.GROOVY_JAR_PATTERN)
        || GroovyConfigUtils.matchesGroovyAll(root.getName()))
    {
      return root;
    }
  }
  for (VirtualFile file : files) {
    if (file.getName().contains("groovy") && "jar".equals(file.getExtension())) {
      return file;
    }
  }
  return null;
}
 

import com.intellij.openapi.roots.OrderEnumerator; //导入依赖的package包/类
private HaxeSourceRootModel resolveSdkRoot() {
  final VirtualFile[] roots;

  if (ApplicationManager.getApplication().isUnitTestMode()) {
    roots = OrderEnumerator.orderEntries(project).getAllSourceRoots();
    if (roots.length > 0) {
      VirtualFile stdRootForTests = roots[0].findChild("std");
      if (stdRootForTests != null) {
        return new HaxeSourceRootModel(this, stdRootForTests);
      }
    }
  } else {
    roots = OrderEnumerator.orderEntries(project).sdkOnly().getAllSourceRoots();
    if (roots.length > 0) {
      return new HaxeSourceRootModel(this, roots[0]);
    }
  }
  return HaxeSourceRootModel.DUMMY;
}
 

import com.intellij.openapi.roots.OrderEnumerator; //导入依赖的package包/类
private Sdk getJdkToRunModule(Module module) {
    final Sdk moduleSdk = ModuleRootManager.getInstance(module).getSdk();
    if (moduleSdk == null) {
        return null;
    }

    final Set<Sdk> sdksFromDependencies = new LinkedHashSet<>();
    OrderEnumerator enumerator = OrderEnumerator.orderEntries(module).runtimeOnly().recursively();
    enumerator = enumerator.productionOnly();
    enumerator.forEachModule(module1 -> {
        Sdk sdk = ModuleRootManager.getInstance(module1).getSdk();
        if (sdk != null && sdk.getSdkType().equals(moduleSdk.getSdkType())) {
            sdksFromDependencies.add(sdk);
        }
        return true;
    });
    return findLatestVersion(moduleSdk, sdksFromDependencies);
}
 

import com.intellij.openapi.roots.OrderEnumerator; //导入依赖的package包/类
public static ClassLoader createUsersClassLoader(JavaTestConfigurationBase configuration)
{
	Module module = configuration.getConfigurationModule().getModule();
	List<URL> urls = new ArrayList<>();

	PathsList pathsList = ReadAction.compute(() -> (module == null || configuration.getTestSearchScope() == TestSearchScope.WHOLE_PROJECT ? OrderEnumerator.orderEntries(configuration.getProject
			()) : OrderEnumerator.orderEntries(module)).runtimeOnly().recursively().getPathsList()); //include jdk to avoid NoClassDefFoundError for classes inside tools.jar
	for(VirtualFile file : pathsList.getVirtualFiles())
	{
		try
		{
			urls.add(VfsUtilCore.virtualToIoFile(file).toURI().toURL());
		}
		catch(MalformedURLException ignored)
		{
			LOG.info(ignored);
		}
	}

	return UrlClassLoader.build().allowLock().useCache().urls(urls).get();
}
 

import com.intellij.openapi.roots.OrderEnumerator; //导入依赖的package包/类
private Map<String, HotSwapFile> scanForModifiedClasses(final DebuggerSession session, final HotSwapProgress progress)
{
	DebuggerManagerThreadImpl.assertIsManagerThread();

	final long timeStamp = getTimeStamp(session);
	final Map<String, HotSwapFile> modifiedClasses = new HashMap<>();

	List<File> outputRoots = ApplicationManager.getApplication().runReadAction((Computable<List<File>>) () -> {
		final List<VirtualFile> allDirs = OrderEnumerator.orderEntries(session.getProject()).withoutSdk().withoutLibraries().getPathsList().getRootDirs();
		return allDirs.stream().map(VfsUtil::virtualToIoFile).collect(Collectors.toList());
	});

	for(File root : outputRoots)
	{
		final String rootPath = FileUtil.toCanonicalPath(root.getPath());
		collectModifiedClasses(root, rootPath, rootPath + "/", modifiedClasses, progress, timeStamp);
	}

	return modifiedClasses;
}
 

import com.intellij.openapi.roots.OrderEnumerator; //导入依赖的package包/类
public void configureByModule(final Module module, @MagicConstant(valuesFromClass = OwnJavaParameters.class) int classPathType, @Nullable Sdk jdk) throws CantRunException
{
	if((classPathType & JDK_ONLY) != 0)
	{
		if(jdk == null)
		{
			throw CantRunException.noJdkConfigured();
		}
		setJdk(jdk);
	}

	if((classPathType & CLASSES_ONLY) == 0)
	{
		return;
	}

	setDefaultCharset(module.getProject());
	configureEnumerator(OrderEnumerator.orderEntries(module).recursively(), classPathType, jdk).collectPaths(getClassPath());
	configureJavaLibraryPath(OrderEnumerator.orderEntries(module).recursively());
}
 

import com.intellij.openapi.roots.OrderEnumerator; //导入依赖的package包/类
private void configureJavaLibraryPath(OrderEnumerator enumerator)
{
	PathsList pathsList = new PathsList();
	enumerator.runtimeOnly().withoutSdk().roots(NativeLibraryOrderRootType.getInstance()).collectPaths(pathsList);
	if(!pathsList.getPathList().isEmpty())
	{
		ParametersList vmParameters = getVMParametersList();
		if(vmParameters.hasProperty(JAVA_LIBRARY_PATH_PROPERTY))
		{
			LOG.info(JAVA_LIBRARY_PATH_PROPERTY + " property is already specified, " + "native library paths from dependencies (" + pathsList.getPathsString() + ") won't be added");
		}
		else
		{
			vmParameters.addProperty(JAVA_LIBRARY_PATH_PROPERTY, pathsList.getPathsString());
		}
	}
}