Datasets:

Mlxa

/

java_methods

like 0

JpsJavaDependenciesRootsEnumerator () { myWithoutSelfModuleOutput = true; return this; }

withoutSelfModuleOutput

boolean (JpsModule module, JpsDependencyElement dependencyElement, Consumer<? super String> urlConsumer) { boolean includeProduction, includeTests; if (dependencyElement instanceof JpsModuleDependency) { boolean productionOnTests = myDependenciesEnumerator.isProductionOnTests(dependencyElement); includeProduction = !productionOnTests; includeTests = !myDependenciesEnumerator.isProductionOnly() && myDependenciesEnumerator.shouldIncludeTestsFromDependentModulesToTestClasspath() || productionOnTests; } else { includeProduction = true; includeTests = !myDependenciesEnumerator.isProductionOnly(); } if (myRootType == JpsOrderRootType.SOURCES) { for (JpsModuleSourceRoot root : module.getSourceRoots()) { JpsModuleSourceRootType<?> type = root.getRootType(); if (type.equals(JavaSourceRootType.SOURCE) && includeProduction || type.equals(JavaSourceRootType.TEST_SOURCE) && includeTests) { urlConsumer.accept(root.getUrl()); } } } else if (myRootType == JpsOrderRootType.COMPILED) { JpsJavaExtensionService extensionService = JpsJavaExtensionService.getInstance(); if (myWithoutSelfModuleOutput && myDependenciesEnumerator.isEnumerationRootModule(module)) { if (includeProduction && includeTests) { String url = extensionService.getOutputUrl(module, false); if (url != null) { urlConsumer.accept(url); } } } else { String outputUrl = extensionService.getOutputUrl(module, false); if (includeTests) { String testsOutputUrl = extensionService.getOutputUrl(module, true); if (testsOutputUrl != null && !testsOutputUrl.equals(outputUrl)) { urlConsumer.accept(testsOutputUrl); } } if (includeProduction && outputUrl != null) { urlConsumer.accept(outputUrl); } } } else if (myRootType == JpsAnnotationRootType.INSTANCE) { JpsJavaModuleExtension extension = JpsJavaExtensionService.getInstance().getModuleExtension(module); if (extension != null) { for (String url : extension.getAnnotationRoots().getUrls()) { urlConsumer.accept(url); } } } return true; }

processModuleRootUrls

JpsTestModuleOutputPackagingElementImpl () { return new JpsTestModuleOutputPackagingElementImpl(this); }

createCopy

String (@NotNull JpsModule module) { return JpsJavaExtensionService.getInstance().getOutputUrl(module, true); }

getOutputUrl

JpsJavaModuleExtensionImpl () { return new JpsJavaModuleExtensionImpl(this); }

createCopy

JpsUrlList () { return myContainer.getChild(ANNOTATIONS_ROOTS_ROLE); }

getAnnotationRoots

JpsUrlList () { return myContainer.getChild(JAVADOC_ROOTS_ROLE); }

getJavadocRoots

String () { return myOutputUrl; }

getOutputUrl

void (String outputUrl) { if (!Objects.equals(myOutputUrl, outputUrl)) { myOutputUrl = outputUrl; fireElementChanged(); } }

setOutputUrl

String () { return myTestOutputUrl; }

getTestOutputUrl

void (String testOutputUrl) { if (!Objects.equals(myTestOutputUrl, testOutputUrl)) { myTestOutputUrl = testOutputUrl; fireElementChanged(); } }

setTestOutputUrl

LanguageLevel () { return myLanguageLevel; }

getLanguageLevel

void (LanguageLevel languageLevel) { if (!Comparing.equal(myLanguageLevel, languageLevel)) { myLanguageLevel = languageLevel; fireElementChanged(); } }

setLanguageLevel

void (@NotNull JpsJavaModuleExtensionImpl modified) { setLanguageLevel(modified.myLanguageLevel); setInheritOutput(modified.myInheritOutput); setExcludeOutput(modified.myExcludeOutput); setOutputUrl(modified.myOutputUrl); setTestOutputUrl(modified.myTestOutputUrl); }

applyChanges

boolean () { return myInheritOutput; }

isInheritOutput

void (boolean inheritOutput) { if (myInheritOutput != inheritOutput) { myInheritOutput = inheritOutput; fireElementChanged(); } }

setInheritOutput

boolean () { return myExcludeOutput; }

isExcludeOutput

void (boolean excludeOutput) { if (myExcludeOutput != excludeOutput) { myExcludeOutput = excludeOutput; fireElementChanged(); } }

setExcludeOutput

JpsJavaProjectExtension () { return new JpsJavaProjectExtensionImpl(); }

create

JpsJavaDependenciesEnumerator () { myProductionOnly = true; return this; }

productionOnly

JpsJavaDependenciesEnumerator () { myCompileOnly = true; return this; }

compileOnly

JpsJavaDependenciesEnumerator () { myRuntimeOnly = true; return this; }

runtimeOnly

JpsJavaDependenciesEnumerator () { if (myRecursively) { myRecursivelyExportedOnly = true; } else { myExportedOnly = true; } return this; }

exportedOnly

JpsJavaDependenciesEnumerator () { return recursively().exportedOnly(); }

recursivelyExportedOnly

JpsJavaDependenciesEnumerator (@NotNull JpsJavaClasspathKind classpathKind) { myClasspathKind = classpathKind; return this; }

includedIn

JpsJavaDependenciesRootsEnumerator () { return new JpsJavaDependenciesRootsEnumeratorImpl(this, JpsOrderRootType.COMPILED); }

classes

JpsJavaDependenciesRootsEnumerator () { return new JpsJavaDependenciesRootsEnumeratorImpl(this, JpsOrderRootType.SOURCES); }

sources

JpsJavaDependenciesRootsEnumerator () { return new JpsJavaDependenciesRootsEnumeratorImpl(this, JpsAnnotationRootType.INSTANCE); }

annotations

JpsJavaDependenciesEnumeratorImpl () { return this; }

self

boolean () { return JpsJavaDependenciesEnumerationHandler.shouldProcessDependenciesRecursively(myHandlers); }

shouldProcessDependenciesRecursively

boolean (JpsModule module, JpsDependencyElement element) { boolean exported = !(element instanceof JpsSdkDependency); JpsJavaDependencyExtension extension = JpsJavaExtensionService.getInstance().getDependencyExtension(element); if (extension != null) { exported = extension.isExported(); JpsJavaDependencyScope scope = extension.getScope(); boolean forTestCompile = scope.isIncludedIn(JpsJavaClasspathKind.TEST_COMPILE) || scope == JpsJavaDependencyScope.RUNTIME && shouldAddRuntimeDependenciesToTestCompilationClasspath(); if (myCompileOnly && !scope.isIncludedIn(JpsJavaClasspathKind.PRODUCTION_COMPILE) && !forTestCompile || myRuntimeOnly && !scope.isIncludedIn(JpsJavaClasspathKind.PRODUCTION_RUNTIME) && !scope.isIncludedIn(JpsJavaClasspathKind.TEST_RUNTIME) || myClasspathKind != null && !scope.isIncludedIn(myClasspathKind) && !(myClasspathKind == JpsJavaClasspathKind.TEST_COMPILE && forTestCompile)) { return false; } if (myProductionOnly) { if (!scope.isIncludedIn(JpsJavaClasspathKind.PRODUCTION_COMPILE) && !scope.isIncludedIn(JpsJavaClasspathKind.PRODUCTION_RUNTIME) || myCompileOnly && !scope.isIncludedIn(JpsJavaClasspathKind.PRODUCTION_COMPILE) || myRuntimeOnly && !scope.isIncludedIn(JpsJavaClasspathKind.PRODUCTION_RUNTIME)) { return false; } } } if (!exported) { if (myExportedOnly) return false; if ((myRecursivelyExportedOnly || element instanceof JpsSdkDependency) && !isEnumerationRootModule(module)) return false; } return true; }

shouldProcess

boolean () { return myProductionOnly || myClasspathKind == JpsJavaClasspathKind.PRODUCTION_RUNTIME || myClasspathKind == JpsJavaClasspathKind.PRODUCTION_COMPILE; }

isProductionOnly

boolean (JpsDependencyElement element) { for (JpsJavaDependenciesEnumerationHandler handler : myHandlers) { if (handler.isProductionOnTestsDependency(element)) { return true; } } return false; }

isProductionOnTests

boolean () { for (JpsJavaDependenciesEnumerationHandler handler : myHandlers) { if (!handler.shouldIncludeTestsFromDependentModulesToTestClasspath()) { return false; } } return true; }

shouldIncludeTestsFromDependentModulesToTestClasspath

boolean () { for (JpsJavaDependenciesEnumerationHandler handler : myHandlers) { if (handler.shouldAddRuntimeDependenciesToTestCompilationClasspath()) { return true; } } return false; }

shouldAddRuntimeDependenciesToTestCompilationClasspath

List<Path> (@NotNull Path home, boolean isJre) { Path[] jarDirs; Path fileName = home.getFileName(); if (fileName != null && "Home".equals(fileName.toString()) && Files.exists(home.resolve("../Classes/classes.jar"))) { Path libDir = home.resolve("lib"); Path classesDir = home.resolveSibling("Classes"); Path libExtDir = libDir.resolve("ext"); Path libEndorsedDir = libDir.resolve("endorsed"); jarDirs = new Path[]{libEndorsedDir, libDir, classesDir, libExtDir}; } else if (Files.exists(home.resolve("lib/jrt-fs.jar"))) { jarDirs = new Path[0]; } else { Path libDir = home.resolve(isJre ? "lib" : "jre/lib"); Path libExtDir = libDir.resolve("ext"); Path libEndorsedDir = libDir.resolve("endorsed"); jarDirs = new Path[]{libEndorsedDir, libDir, libExtDir}; } List<Path> rootFiles = new ArrayList<>(); if (Registry.is("project.structure.add.tools.jar.to.new.jdk", false)) { @SuppressWarnings("IdentifierGrammar") Path toolsJar = home.resolve("lib/tools.jar"); if (Files.isRegularFile(toolsJar)) { rootFiles.add(toolsJar); } } Set<String> pathFilter = CollectionFactory.createFilePathSet(); for (Path jarDir : jarDirs) { if (jarDir != null && Files.isDirectory(jarDir)) { try (DirectoryStream<Path> stream = Files.newDirectoryStream(jarDir, "*.jar")) { for (Path jarFile : stream) { String jarFileName = jarFile.getFileName().toString(); if (jarFileName.equals("alt-rt.jar") || jarFileName.equals("alt-string.jar")) { continue; // filter out alternative implementations } String canonicalPath = getCanonicalPath(jarFile); if (canonicalPath == null || !pathFilter.add(canonicalPath)) { continue; // filter out duplicate (symbolically linked) .jar files commonly found in OS X JDK distributions } rootFiles.add(jarFile); } } catch (IOException ignored) { } } } if (ContainerUtil.exists(rootFiles, path -> path.getFileName().toString().startsWith("ibm"))) { // ancient IBM JDKs split JRE classes between `rt.jar` and `vm.jar`, and the latter might be anywhere try (var paths = Files.walk(isJre ? home : home.resolve("jre"))) { paths.filter(path -> path.getFileName().toString().equals("vm.jar")) .findFirst() .ifPresent(rootFiles::add); } catch (IOException ignored) { } } Path classesZip = home.resolve("lib/classes.zip"); if (Files.isRegularFile(classesZip)) { rootFiles.add(classesZip); } if (rootFiles.isEmpty()) { Path classesDir = home.resolve("classes"); if (Files.isDirectory(classesDir)) { rootFiles.add(classesDir); } } return rootFiles; }

getJdkClassesRoots

JpsWrappedJavaSdkReferenceImpl () { return new JpsWrappedJavaSdkReferenceImpl(this); }

createCopy

String () { JpsTypedLibrary<JpsSdk<JpsDummyElement>> sdk = resolve(); return sdk != null ? sdk.getName() : "<unknown>"; }

getSdkName

JpsTypedLibrary<JpsSdk<JpsDummyElement>> () { JpsTypedLibrary<? extends JpsSdk<? extends JpsElement>> wrapper = myContainer.getChild(WRAPPER_ROLE).resolve(); if (wrapper == null) return null; JpsModel model = getModel(); if (model == null) return null; String sdkName = mySdkType.getJavaSdkName(wrapper.getProperties().getSdkProperties()); if (sdkName == null) return null; JpsLibrary library = model.getGlobal().getLibraryCollection().findLibrary(sdkName); return library != null ? library.asTyped(JpsJavaSdkType.INSTANCE) : null; }

resolve

JpsElementReference<JpsTypedLibrary<JpsSdk<JpsDummyElement>>> (@NotNull JpsModel model) { model.registerExternalReference(this); return this; }

asExternal

JpsJavaProjectExtension (@NotNull JpsProject project) { return project.getContainer().getOrSetChild(JavaProjectExtensionRole.INSTANCE); }

getOrCreateProjectExtension

JpsJavaProjectExtension (@NotNull JpsProject project) { return project.getContainer().getChild(JavaProjectExtensionRole.INSTANCE); }

getProjectExtension

JpsJavaModuleExtension (@NotNull JpsModule module) { return module.getContainer().getOrSetChild(JavaModuleExtensionRole.INSTANCE); }

getOrCreateModuleExtension

JpsJavaDependencyExtension (@NotNull JpsDependencyElement dependency) { return dependency.getContainer().getOrSetChild(JpsJavaDependencyExtensionRole.INSTANCE); }

getOrCreateDependencyExtension

JpsJavaDependencyExtension (@NotNull JpsDependencyElement dependency) { return dependency.getContainer().getChild(JpsJavaDependencyExtensionRole.INSTANCE); }

getDependencyExtension

JpsJavaModuleExtension (@NotNull JpsModule module) { return module.getContainer().getChild(JavaModuleExtensionRole.INSTANCE); }

getModuleExtension

ExplodedDirectoryModuleExtension (@NotNull JpsModule module) { return module.getContainer().getOrSetChild(ExplodedDirectoryModuleExtensionImpl.ExplodedDirectoryModuleExtensionRole.INSTANCE); }

getOrCreateExplodedDirectoryExtension

ExplodedDirectoryModuleExtension (@NotNull JpsModule module) { return module.getContainer().getChild(ExplodedDirectoryModuleExtensionImpl.ExplodedDirectoryModuleExtensionRole.INSTANCE); }

getExplodedDirectoryExtension

List<JpsDependencyElement> (JpsModule module, JpsJavaClasspathKind classpathKind, boolean exportedOnly) { final List<JpsDependencyElement> result = new ArrayList<>(); for (JpsDependencyElement dependencyElement : module.getDependenciesList().getDependencies()) { final JpsJavaDependencyExtension extension = getDependencyExtension(dependencyElement); if (extension == null || extension.getScope().isIncludedIn(classpathKind) && (!exportedOnly || extension.isExported())) { result.add(dependencyElement); } } return result; }

getDependencies

LanguageLevel (JpsModule module) { final JpsJavaModuleExtension moduleExtension = getModuleExtension(module); if (moduleExtension == null) return null; final LanguageLevel languageLevel = moduleExtension.getLanguageLevel(); if (languageLevel != null) return languageLevel; final JpsJavaProjectExtension projectExtension = getProjectExtension(module.getProject()); return projectExtension != null ? projectExtension.getLanguageLevel() : null; }

getLanguageLevel

String (JpsModule module, boolean forTests) { final JpsJavaModuleExtension extension = getModuleExtension(module); if (extension == null) return null; if (extension.isInheritOutput()) { JpsJavaProjectExtension projectExtension = getProjectExtension(module.getProject()); if (projectExtension == null) return null; final String url = projectExtension.getOutputUrl(); if (url == null) return null; return url + "/" + (forTests ? "test" : "production") + "/" + module.getName(); } return forTests ? extension.getTestOutputUrl() : extension.getOutputUrl(); }

getOutputUrl

File (JpsModule module, boolean forTests) { String url = getOutputUrl(module, forTests); return url != null ? JpsPathUtil.urlToFile(url) : null; }

getOutputDirectory

JpsTypedLibrary<JpsSdk<JpsDummyElement>> (@NotNull JpsGlobal global, @NotNull String name, @NotNull String homePath) { JdkVersionDetector.JdkVersionInfo jdkInfo = JdkVersionDetector.getInstance().detectJdkVersionInfo(homePath); assert jdkInfo != null : homePath; String version = JdkVersionDetector.formatVersionString(jdkInfo.version); JpsTypedLibrary<JpsSdk<JpsDummyElement>> sdk = global.addSdk(name, homePath, version, JpsJavaSdkType.INSTANCE); List<Path> roots = JavaSdkUtil.getJdkClassesRoots(Paths.get(homePath), false); for (Path root : roots) { sdk.addRoot(root.toFile(), JpsOrderRootType.COMPILED); } return sdk; }

addJavaSdk

JpsJavaCompilerConfiguration (@NotNull JpsProject project) { return project.getContainer().getOrSetChild(JpsJavaCompilerConfigurationImpl.ROLE); }

getCompilerConfiguration

JpsTestModuleProperties (@NotNull JpsModule module) { return module.getContainer().getChild(JpsTestModulePropertiesImpl.ROLE); }

getTestModuleProperties

void (@NotNull JpsModule module, @NotNull JpsModuleReference productionModuleReference) { module.getContainer().setChild(JpsTestModulePropertiesImpl.ROLE, new JpsTestModulePropertiesImpl(productionModuleReference)); }

setTestModuleProperties

JpsSdkReference<JpsDummyElement> (@NotNull JpsJavaSdkTypeWrapper sdkType, @NotNull JpsSdkReference<?> wrapperReference) { return new JpsWrappedJavaSdkReferenceImpl(sdkType, wrapperReference); }

createWrappedJavaSdkReference

JpsApplicationRunConfigurationProperties (JpsApplicationRunConfigurationState state) { return new JpsApplicationRunConfigurationPropertiesImpl(state); }

createRunConfigurationProperties

JavaSourceRootProperties (@NotNull String packagePrefix, boolean isGenerated) { return new JavaSourceRootProperties(packagePrefix, isGenerated); }

createSourceRootProperties

JavaSourceRootProperties (@NotNull String packagePrefix) { return createSourceRootProperties(packagePrefix, false); }

createSourceRootProperties

JavaResourceRootProperties (@NotNull String relativeOutputPath, boolean forGeneratedResource) { return new JavaResourceRootProperties(relativeOutputPath, forGeneratedResource); }

createResourceRootProperties

JpsProductionModuleOutputPackagingElement (@NotNull JpsModuleReference moduleReference) { return new JpsProductionModuleOutputPackagingElementImpl(moduleReference); }

createProductionModuleOutput

JpsProductionModuleSourcePackagingElement (@NotNull JpsModuleReference moduleReference) { return new JpsProductionModuleSourcePackagingElementImpl(moduleReference); }

createProductionModuleSource

JpsTestModuleOutputPackagingElement (@NotNull JpsModuleReference moduleReference) { return new JpsTestModuleOutputPackagingElementImpl(moduleReference); }

createTestModuleOutput

JpsJavaDependenciesEnumerator (Collection<JpsModule> modules) { return new JpsJavaDependenciesEnumeratorImpl(modules); }

enumerateDependencies

JpsJavaDependenciesEnumerator (JpsProject project) { return new JpsJavaDependenciesEnumeratorImpl(project.getModules()); }

enumerateDependencies

JpsJavaDependenciesEnumerator (JpsModule module) { return new JpsJavaDependenciesEnumeratorImpl(Collections.singleton(module)); }

enumerateDependencies

JavaModuleIndex (@NotNull JpsProject project) { return project.getContainer().getOrSetChild(JavaModuleIndexRole.INSTANCE, () -> getCompilerConfiguration(project).getCompilerExcludes()); }

getJavaModuleIndex

JpsModuleReference () { return myContainer.getChild(MODULE_REFERENCE_CHILD_ROLE); }

getModuleReference

JpsProductionModuleSourcePackagingElementImpl () { return new JpsProductionModuleSourcePackagingElementImpl(this); }

createCopy

String () { return myExplodedUrl; }

getExplodedUrl

void (String explodedUrl) { if (!Objects.equals(myExplodedUrl, explodedUrl)) { myExplodedUrl = explodedUrl; fireElementChanged(); } }

setExplodedUrl

boolean () { return myExcludeExploded; }

isExcludeExploded

void (boolean excludeExploded) { if (myExcludeExploded != excludeExploded) { myExcludeExploded = excludeExploded; fireElementChanged(); } }

setExcludeExploded

ExplodedDirectoryModuleExtensionImpl () { return new ExplodedDirectoryModuleExtensionImpl(this); }

createCopy

void (@NotNull ExplodedDirectoryModuleExtensionImpl modified) { setExcludeExploded(modified.myExcludeExploded); setExplodedUrl(modified.myExplodedUrl); }

applyChanges

ExplodedDirectoryModuleExtension () { return new ExplodedDirectoryModuleExtensionImpl(); }

create

JavaModuleIndexImpl () { JavaModuleIndexImpl copy = new JavaModuleIndexImpl(myExcludes); copy.myMapping.putAll(myMapping); return copy; }

createCopy

void (@NotNull JavaModuleIndexImpl modified) { // not supported }

applyChanges

File (@NotNull JpsModule module, boolean forTests) { String key = module.getName() + (forTests ? TEST_SUFFIX : SOURCE_SUFFIX); if (myMapping.containsKey(key)) { return myMapping.get(key); } File file = findModuleInfoFile(module, forTests ? JavaSourceRootType.TEST_SOURCE : JavaSourceRootType.SOURCE); myMapping.put(key, file); return file; }

getModuleInfoFile

File (JpsModule module, JavaSourceRootType rootType) { for (JpsModuleSourceRoot root : module.getSourceRoots()) { if (rootType.equals(root.getRootType())) { File file = new File(JpsPathUtil.urlToOsPath(root.getUrl()), MODULE_INFO_FILE); if (file.isFile() && !myExcludes.isExcluded(file)) { return file; } } } return null; }

findModuleInfoFile

void () { myMapping.clear(); }

dropCache

List<JpsJavaDependenciesEnumerationHandler> (Collection<JpsModule> rootModules) { List<JpsJavaDependenciesEnumerationHandler> handlers = null; for (Factory factory : JpsServiceManager.getInstance().getExtensions(Factory.class)) { JpsJavaDependenciesEnumerationHandler handler = factory.createHandler(rootModules); if (handler != null) { if (handlers == null) { handlers = new SmartList<>(); } handlers.add(handler); } } return handlers; }

createHandlers

boolean (final List<? extends JpsJavaDependenciesEnumerationHandler> handlers) { if (handlers != null) { for (JpsJavaDependenciesEnumerationHandler handler : handlers) { if (!handler.shouldProcessDependenciesRecursively()) { return false; } } } return true; }

shouldProcessDependenciesRecursively

boolean () { return false; }

shouldAddRuntimeDependenciesToTestCompilationClasspath

boolean (JpsDependencyElement element) { return false; }

isProductionOnTestsDependency

boolean () { return true; }

shouldIncludeTestsFromDependentModulesToTestClasspath

boolean () { return true; }

shouldProcessDependenciesRecursively

JpsProductionModuleOutputPackagingElementImpl () { return new JpsProductionModuleOutputPackagingElementImpl(this); }

createCopy

String (@NotNull JpsModule module) { return JpsJavaExtensionService.getInstance().getOutputUrl(module, false); }

getOutputUrl

JpsJavaDependencyExtensionImpl () { return new JpsJavaDependencyExtensionImpl(false, JpsJavaDependencyScope.COMPILE); }

create

JpsJavaModuleExtensionImpl () { return new JpsJavaModuleExtensionImpl(); }

create

void (@NotNull String text) { myLines.add(text); LOG.trace("text: " + text); }

onTextAvailable

boolean () { return myValidateOnBuild; }

isValidateOnBuild

boolean (String validatorId) { return !myDisabledValidators.contains(validatorId); }

isValidatorEnabled

void (String url) { addExcludedFile(JpsPathUtil.urlToFile(url)); }

addExcludedFile

void (String url, boolean recursively) { addExcludedDirectory(JpsPathUtil.urlToFile(url), recursively); }

addExcludedDirectory

void (File file) { myFiles.add(file); }

addExcludedFile

void (File dir, boolean recursively) { (recursively ? myRecursivelyExcludedDirectories : myDirectories).add(dir); }

addExcludedDirectory

boolean (File file) { if (myFiles.contains(file)) { return true; } if (!myDirectories.isEmpty() || !myRecursivelyExcludedDirectories.isEmpty()) { // optimization File parent = FileUtilRt.getParentFile(file); if (myDirectories.contains(parent)) { return true; } while (parent != null) { if (myRecursivelyExcludedDirectories.contains(parent)) { return true; } parent = FileUtilRt.getParentFile(parent); } } return false; }

isExcluded