Datasets:

Mlxa

/

java_methods

like 0

void (@NotNull JpsEncodingProjectConfigurationImpl modified) { }

applyChanges

String (@NotNull JpsGlobal global) { JpsSimpleElement<String> encoding = global.getContainer().getChild(ENCODING_ROLE); return encoding != null ? encoding.getData() : null; }

getGlobalEncoding

void (@NotNull JpsGlobal global, @Nullable String encoding) { if (encoding != null) { global.getContainer().setChild(ENCODING_ROLE, JpsElementFactory.getInstance().createSimpleElement(encoding)); } else { global.getContainer().removeChild(ENCODING_ROLE); } }

setGlobalEncoding

String (@NotNull JpsModel model) { JpsEncodingProjectConfiguration configuration = getEncodingConfiguration(model.getProject()); if (configuration != null) { String projectEncoding = configuration.getProjectEncoding(); if (projectEncoding != null) { return projectEncoding; } } return getGlobalEncoding(model.getGlobal()); }

getProjectEncoding

JpsEncodingProjectConfiguration (@NotNull JpsProject project) { return project.getContainer().getChild(JpsEncodingProjectConfigurationImpl.ROLE); }

getEncodingConfiguration

JpsEncodingProjectConfiguration (@NotNull JpsProject project, @Nullable String projectEncoding, @NotNull Map<String, String> urlToEncoding) { JpsEncodingProjectConfigurationImpl configuration = new JpsEncodingProjectConfigurationImpl(urlToEncoding, projectEncoding); return project.getContainer().setChild(JpsEncodingProjectConfigurationImpl.ROLE, configuration); }

setEncodingConfiguration

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

createCopy

List<String> () { return myUrls; }

getUrls

void (@NotNull String url) { myUrls.add(url); fireElementChanged(); }

addUrl

void (@NotNull String url) { myUrls.remove(url); fireElementChanged(); }

removeUrl

void (@NotNull JpsUrlListImpl modified) { if (!myUrls.equals(modified.myUrls)) { myUrls.clear(); myUrls.addAll(modified.myUrls); fireElementChanged(); } }

applyChanges

JpsElementContainerEx (@NotNull JpsCompositeElementBase<?> parent) { return new JpsElementContainerImpl(parent); }

createContainer

JpsElementContainerEx (@NotNull JpsElementContainerEx original, @NotNull JpsCompositeElementBase<?> parent) { return new JpsElementContainerImpl(original, parent); }

createContainerCopy

JpsUrlList () { return new JpsUrlListImpl(); }

create

JpsFileTypesConfigurationImpl () { return new JpsFileTypesConfigurationImpl(myIgnoredPatternString); }

createCopy

String () { return myIgnoredPatternString; }

getIgnoredPatternString

void (@NotNull String ignoredPatternString) { if (!myIgnoredPatternString.equals(ignoredPatternString)) { myIgnoredPatternString = ignoredPatternString; fireElementChanged(); } }

setIgnoredPatternString

void (@NotNull JpsFileTypesConfigurationImpl modified) { setIgnoredPatternString(modified.myIgnoredPatternString); }

applyChanges

JpsModel () { return new JpsModelImpl(); }

createModel

JpsModuleReference (@NotNull String moduleName) { return new JpsModuleReferenceImpl(moduleName); }

createModuleReference

JpsLibraryReference (@NotNull String libraryName, @NotNull JpsElementReference<? extends JpsCompositeElement> parentReference) { return new JpsLibraryReferenceImpl(libraryName, parentReference); }

createLibraryReference

JpsElementReference<JpsProject> () { return new JpsProjectElementReference(); }

createProjectReference

JpsElementReference<JpsGlobal> () { return new JpsGlobalElementReference(); }

createGlobalReference

JpsDummyElement () { return new JpsDummyElementImpl(); }

createDummyElement

JpsProject () { final JpsModel model = getModel(); return model != null ? model.getProject() : null; }

resolve

JpsProjectElementReference () { return new JpsProjectElementReference(); }

createCopy

void (@NotNull JpsProjectElementReference modified) { }

applyChanges

String () { return "project ref"; }

toString

JpsGlobal () { final JpsModel model = getModel(); return model != null ? model.getGlobal() : null; }

resolve

JpsGlobalElementReference () { return new JpsGlobalElementReference(); }

createCopy

void (@NotNull JpsGlobalElementReference modified) { }

applyChanges

String () { return "global ref"; }

toString

T (T element) { return element; }

resolve

String () { return myName; }

getName

void (@NotNull String name) { if (!Objects.equals(myName, name)) { myName = name; fireElementChanged(); } }

setName

void (@NotNull JpsElementReference<?> reference) { myContainer.getChild(EXTERNAL_REFERENCES_COLLECTION_ROLE).addChild(reference); }

addExternalReference

List<JpsModule> () { return myContainer.getChild(JpsModuleRole.MODULE_COLLECTION_ROLE).getElements(); }

getModules

void (@NotNull JpsModule module) { myContainer.getChild(JpsModuleRole.MODULE_COLLECTION_ROLE).addChild(module); }

addModule

void (@NotNull JpsModule module) { myContainer.getChild(JpsModuleRole.MODULE_COLLECTION_ROLE).removeChild(module); }

removeModule

JpsLibraryCollection () { return myLibraryCollection; }

getLibraryCollection

JpsSdkReferencesTable () { return myContainer.getChild(JpsSdkReferencesTableImpl.ROLE); }

getSdkReferencesTable

List<JpsRunConfiguration> () { return getRunConfigurationsCollection().getElements(); }

getRunConfigurations

JpsElementCollection<JpsRunConfiguration> () { return myContainer.getChild(RUN_CONFIGURATIONS_ROLE); }

getRunConfigurationsCollection

JpsElementReference<JpsProject> () { return new JpsProjectElementReference(); }

createReference

JpsDummyElementImpl () { return new JpsDummyElementImpl(); }

createCopy

void (@NotNull JpsDummyElementImpl modified) { }

applyChanges

List<E> () { return myElements; }

getElements

E (@NotNull JpsElementCreator<E> creator) { return addChild(creator.create()); }

addChild

void (@NotNull E element) { final boolean removed = myElements.remove(element); if (removed) { setParent(element, null); } }

removeChild

void () { List<E> elements = new ArrayList<>(myElements); for (E element : elements) { removeChild(element); } }

removeAllChildren

JpsElementCollectionImpl<E> () { return new JpsElementCollectionImpl<>(this); }

createCopy

void (@NotNull JpsElementCollectionImpl<E> modified) { Set<E> toRemove = new LinkedHashSet<>(myElements); List<E> toAdd = new ArrayList<>(); final Map<E, E> copyToOriginal = modified.myCopyToOriginal; for (E element : modified.myElements) { final E original = copyToOriginal != null ? copyToOriginal.get(element) : null; if (original != null) { //noinspection unchecked ((BulkModificationSupport<E>)original.getBulkModificationSupport()).applyChanges(element); toRemove.remove(original); } else { //noinspection unchecked final E copy = (E)element.getBulkModificationSupport().createCopy(); toAdd.add(copy); } } for (E e : toRemove) { removeChild(e); } for (E e : toAdd) { addChild(e); } }

applyChanges

Iterator<X> () { //noinspection unchecked Iterator<JpsTypedElement<?>> iterator = (Iterator<JpsTypedElement<?>>)myElements.iterator(); return new FilteringIterator<>(iterator, e -> e.getType().equals(myType)); }

iterator

JpsRunConfigurationImpl<P> () { return new JpsRunConfigurationImpl<>(this); }

createCopy

P () { return myContainer.getChild(myType.getPropertiesRole()); }

getProperties

JpsRunConfigurationType<P> () { return myType; }

getType

void (@NotNull Runnable command) { myService.execute(command); }

execute

void () { myService.shutdown(); }

shutdown

List<Runnable> () { return myService.shutdownNow(); }

shutdownNow

boolean () { return myService.isShutdown(); }

isShutdown

boolean () { return myService.isTerminated(); }

isTerminated

boolean () { synchronized (myExtensions) { JpsPluginManager manager = myPluginManager; if (manager != null) { int stamp = manager.getModificationStamp(); if (myModificationStamp.getAndSet(stamp) != stamp) { myExtensions.clear(); return true; } } return false; } }

cleanupExtensionCache

boolean () { return true; }

isFullyLoaded

int () { return 0; }

getModificationStamp

JpsTypedLibrary<JpsSdk<JpsDummyElement>> (final String mockJdkVersion) { final String mockJdkDir = "mockJDK-" + mockJdkVersion; File home = PathManagerEx.findFileUnderCommunityHome("java/" + mockJdkDir); JpsTypedLibrary<JpsSdk<JpsDummyElement>> jdk = myModel.getGlobal().addSdk(mockJdkVersion, home.getAbsolutePath(), mockJdkVersion, JpsJavaSdkType.INSTANCE); jdk.addRoot(getRtJar(mockJdkDir), JpsOrderRootType.COMPILED); return jdk; }

addJdk

void () { JpsModuleRootModificationUtil.addDependency(myModule, createJDomLibrary()); assertClassRoots(dependencies(myModule), getRtJarJdk17(), getFastUtilJar()); assertClassRoots(dependencies(myModule).withoutSdk(), getFastUtilJar()); assertClassRoots(dependencies(myModule).withoutSdk().productionOnly().runtimeOnly(), getFastUtilJar()); assertClassRoots(dependencies(myModule).withoutLibraries(), getRtJarJdk17()); assertSourceRoots(dependencies(myModule), getFastUtilSources()); }

testLibrary

String () { return IntelliJProjectConfiguration.getProjectLibrary("fastutil-min").getSourcesUrls().get(0); }

getFastUtilSources

String () { return getJarUrlFromProjectLib("fastutil-min"); }

getFastUtilJar

String () { return getJarUrlFromProjectLib("ASM"); }

getAsmJar

String (final String libraryName) { return assertOneElement(IntelliJProjectConfiguration.getProjectLibraryClassesRootUrls(libraryName)); }

getJarUrlFromProjectLib

String () { return getRtJar("mockJDK-1.7"); }

getRtJarJdk17

String () { return getRtJar("mockJDK-1.8"); }

getRtJarJdk18

String (final String mockJdkDir) { return JpsPathUtil.getLibraryRootUrl(PathManagerEx.findFileUnderCommunityHome("java/" + mockJdkDir + "/jre/lib/rt.jar")); }

getRtJar

JpsLibrary () { JpsLibrary library = addLibrary("jdom"); library.addRoot(getFastUtilJar(), JpsOrderRootType.COMPILED); library.addRoot(getFastUtilSources(), JpsOrderRootType.SOURCES); return library; }

createJDomLibrary

JpsLibrary () { JpsLibrary library = addLibrary("asm"); library.addRoot(getAsmJar(), JpsOrderRootType.COMPILED); return library; }

createAsmLibrary

void () { final String srcRoot = addSourceRoot(myModule, false); final String testRoot = addSourceRoot(myModule, true); final String output = setModuleOutput(myModule, false); final String testOutput = setModuleOutput(myModule, true); assertClassRoots(dependencies(myModule).withoutSdk(), testOutput, output); assertClassRoots(dependencies(myModule).withoutSdk().productionOnly(), output); assertSourceRoots(dependencies(myModule), srcRoot, testRoot); assertSourceRoots(dependencies(myModule).productionOnly(), srcRoot); assertEnumeratorRoots(dependencies(myModule).withoutSdk().classes().withoutSelfModuleOutput(), output); assertEnumeratorRoots(dependencies(myModule).withoutSdk().productionOnly().classes().withoutSelfModuleOutput()); }

testModuleSources

void () { JpsLibraryDependency dependency = myModule.getDependenciesList().addLibraryDependency(createJDomLibrary()); getJavaService().getOrCreateDependencyExtension(dependency).setScope(JpsJavaDependencyScope.RUNTIME); JpsModuleRootModificationUtil.addDependency(myModule, createJDomLibrary(), JpsJavaDependencyScope.RUNTIME, false); assertClassRoots(dependencies(myModule).withoutSdk(), getFastUtilJar()); assertClassRoots(dependencies(myModule).withoutSdk().exportedOnly()); assertClassRoots(dependencies(myModule).withoutSdk().compileOnly()); }

testLibraryScope

void () { final JpsModule dep = addModule("dep"); final String depSrcRoot = addSourceRoot(dep, false); final String depTestRoot = addSourceRoot(dep, true); final String depOutput = setModuleOutput(dep, false); final String depTestOutput = setModuleOutput(dep, true); JpsModuleRootModificationUtil.addDependency(dep, createJDomLibrary(), JpsJavaDependencyScope.COMPILE, true); JpsModuleRootModificationUtil.addDependency(myModule, dep, JpsJavaDependencyScope.COMPILE, true); final String srcRoot = addSourceRoot(myModule, false); final String testRoot = addSourceRoot(myModule, true); final String output = setModuleOutput(myModule, false); final String testOutput = setModuleOutput(myModule, true); assertClassRoots(dependencies(myModule).withoutSdk(), testOutput, output, depTestOutput, depOutput); assertClassRoots(dependencies(myModule).withoutSdk().recursively(), testOutput, output, depTestOutput, depOutput, getFastUtilJar()); assertSourceRoots(dependencies(myModule), srcRoot, testRoot, depSrcRoot, depTestRoot); assertSourceRoots(dependencies(myModule).recursively(), srcRoot, testRoot, depSrcRoot, depTestRoot, getFastUtilSources()); assertClassRoots(dependencies(myModule).withoutSdk().withoutModuleSourceEntries().recursively(), getFastUtilJar()); assertSourceRoots(dependencies(myModule).withoutSdk().withoutModuleSourceEntries().recursively(), getFastUtilSources()); assertEnumeratorRoots(dependencies(myModule).withoutSdk().withoutModuleSourceEntries().recursively().classes(), getFastUtilJar()); assertEnumeratorRoots(dependencies(myModule).withoutSdk().withoutModuleSourceEntries().recursively().sources(), getFastUtilSources()); assertEnumeratorRoots(dependencies(myModule).withoutSdk().recursively().classes().withoutSelfModuleOutput(), output, depTestOutput, depOutput, getFastUtilJar()); assertEnumeratorRoots(dependencies(myModule).productionOnly().withoutSdk().recursively().classes().withoutSelfModuleOutput(), depOutput, getFastUtilJar()); assertClassRoots(dependencies(myModule).withoutSdk().withoutDepModules().withoutModuleSourceEntries().recursively(), getFastUtilJar()); assertEnumeratorRoots( dependencies(myModule).productionOnly().withoutSdk().withoutDepModules().withoutModuleSourceEntries().recursively().classes(), getFastUtilJar()); assertClassRoots(dependencies(myModule).withoutSdk().withoutDepModules().withoutModuleSourceEntries()); assertEnumeratorRoots(dependencies(myModule).productionOnly().withoutModuleSourceEntries().withoutSdk().withoutDepModules().classes()); }

testModuleDependency

void () { final JpsModule dep = addModule("dep"); JpsModuleRootModificationUtil.addDependency(dep, createJDomLibrary(), JpsJavaDependencyScope.COMPILE, true); JpsModuleRootModificationUtil.addDependency(myModule, dep, JpsJavaDependencyScope.TEST, true); assertClassRoots(dependencies(myModule).withoutSdk()); assertClassRoots(dependencies(myModule).withoutSdk().recursively(), getFastUtilJar()); assertClassRoots(dependencies(myModule).withoutSdk().exportedOnly().recursively(), getFastUtilJar()); assertClassRoots(dependencies(myModule).withoutSdk().productionOnly().recursively()); assertClassRoots(dependencies(myProject).withoutSdk(), getFastUtilJar()); assertClassRoots(dependencies(myProject).withoutSdk().productionOnly(), getFastUtilJar()); }

testModuleJpsJavaDependencyScope

void () { final JpsModule dep = addModule("dep"); JpsModuleRootModificationUtil.addDependency(dep, createJDomLibrary(), JpsJavaDependencyScope.COMPILE, false); JpsModuleRootModificationUtil.addDependency(myModule, createAsmLibrary(), JpsJavaDependencyScope.COMPILE, false); JpsModuleRootModificationUtil.addDependency(myModule, dep, JpsJavaDependencyScope.COMPILE, false); assertClassRoots(dependencies(myModule).withoutSdk(), getAsmJar()); assertClassRoots(dependencies(myModule).withoutSdk().recursively(), getAsmJar(), getFastUtilJar()); assertClassRoots(dependencies(myModule).withoutSdk().recursivelyExportedOnly(), getAsmJar()); assertClassRoots(dependencies(myModule).withoutSdk().exportedOnly().recursively()); }

testNotExportedLibrary

void () { JpsLibrary library = addLibrary(); String libraryUrl = "temp:///library"; library.addRoot(libraryUrl, JpsAnnotationRootType.INSTANCE); JpsModuleRootModificationUtil.addDependency(myModule, library); assertEnumeratorRoots(dependencies(myModule).annotations(), libraryUrl); String moduleUrl = "temp://module"; JpsJavaExtensionService.getInstance().getOrCreateModuleExtension(myModule).getAnnotationRoots().addUrl(moduleUrl); assertEnumeratorRoots(dependencies(myModule).annotations(), moduleUrl, libraryUrl); }

testAnnotations

void () { assertClassRoots(dependencies(myModule).exportedOnly()); }

testJdkIsNotExported

void () { JpsModule dep = addModule("dep"); JpsTypedLibrary<JpsSdk<JpsDummyElement>> jdk8 = addJdk("1.8"); JpsModuleRootModificationUtil.addDependency(myModule, dep); JpsModuleRootModificationUtil.setModuleSdk(dep, jdk8.getProperties()); assertClassRoots(dependencies(myModule).recursively(), getRtJarJdk17()); assertClassRoots(dependencies(dep).recursively(), getRtJarJdk18()); }

testDoNotAddJdkRootsFromModuleDependency

void () { JpsModuleRootModificationUtil.addDependency(myModule, createJDomLibrary()); final String srcRoot = addSourceRoot(myModule, false); final String testRoot = addSourceRoot(myModule, true); final String output = setModuleOutput(myModule, false); final String testOutput = setModuleOutput(myModule, true); assertClassRoots(dependencies(myProject).withoutSdk(), testOutput, output, getFastUtilJar()); assertSourceRoots(dependencies(myProject).withoutSdk(), srcRoot, testRoot, getFastUtilSources()); }

testProject

void () { JpsModuleRootModificationUtil.addDependency(myModule, createJDomLibrary()); final String srcRoot = addSourceRoot(myModule, false); final String testRoot = addSourceRoot(myModule, true); final String output = setModuleOutput(myModule, false); final String testOutput = setModuleOutput(myModule, true); assertClassRoots(getJavaService().enumerateDependencies(Collections.singletonList(myModule)).withoutSdk(), testOutput, output, getFastUtilJar()); assertSourceRoots(getJavaService().enumerateDependencies(Collections.singletonList(myModule)).withoutSdk(), srcRoot, testRoot, getFastUtilSources()); }

testModules

String (JpsModule module, boolean tests) { try { File file = FileUtil.createTempDirectory(module.getName(), tests ? "testSrc" : "src"); JpsJavaModuleExtension extension = getJavaService().getOrCreateModuleExtension(module); String url = JpsPathUtil.getLibraryRootUrl(file); if (tests) { extension.setTestOutputUrl(url); } else { extension.setOutputUrl(url); } return url; } catch (IOException e) { throw new RuntimeException(e); } }

setModuleOutput

String (JpsModule module, boolean tests) { try { File file = FileUtil.createTempDirectory(module.getName(), tests ? "testSrc" : "src"); return module.addSourceRoot(JpsPathUtil.getLibraryRootUrl(file), tests ? JavaSourceRootType.TEST_SOURCE : JavaSourceRootType.SOURCE).getUrl(); } catch (IOException e) { throw new RuntimeException(e); } }

addSourceRoot

void (final JpsJavaDependenciesEnumerator enumerator, String... urls) { assertEnumeratorRoots(enumerator.classes(), urls); }

assertClassRoots

void (final JpsJavaDependenciesEnumerator enumerator, String... urls) { assertEnumeratorRoots(enumerator.sources(), urls); }

assertSourceRoots

void (JpsJavaDependenciesRootsEnumerator rootsEnumerator, String... urls) { assertOrderedEquals(rootsEnumerator.getUrls(), urls); }

assertEnumeratorRoots

void (JpsModule module, JpsLibrary library) { addDependency(module, library, JpsJavaDependencyScope.COMPILE, false); }

addDependency

void (JpsModule module, JpsLibrary library, final JpsJavaDependencyScope scope, final boolean exported) { setDependencyProperties(module.getDependenciesList().addLibraryDependency(library), scope, exported); }

addDependency

void (JpsDependencyElement dependency, JpsJavaDependencyScope scope, boolean exported) { JpsJavaDependencyExtension extension = JpsJavaExtensionService.getInstance().getOrCreateDependencyExtension(dependency); extension.setExported(exported); extension.setScope(scope); }

setDependencyProperties

void (JpsModule module, @Nullable JpsSdk<JpsDummyElement> sdk) { module.getSdkReferencesTable().setSdkReference(JpsJavaSdkType.INSTANCE, sdk != null ? sdk.createReference() : null); addSdkDependencyIfNeeded(module); }

setModuleSdk

void (JpsModule module) { for (JpsDependencyElement element : module.getDependenciesList().getDependencies()) { if (element instanceof JpsSdkDependency) return; } module.getDependenciesList().addSdkDependency(JpsJavaSdkType.INSTANCE); }

addSdkDependencyIfNeeded

void (JpsModule module) { module.getSdkReferencesTable().setSdkReference(JpsJavaSdkType.INSTANCE, null); }

setSdkInherited

void (final JpsModule from, final JpsModule to) { addDependency(from, to, JpsJavaDependencyScope.COMPILE, false); }

addDependency

void (final JpsModule from, final JpsModule to, final JpsJavaDependencyScope scope, final boolean exported) { setDependencyProperties(from.getDependenciesList().addModuleDependency(to), scope, exported); }

addDependency

void () { JpsLibrary a = myProject.addLibrary("a", JpsJavaLibraryType.INSTANCE); JpsLibraryCollection collection = myProject.getLibraryCollection(); assertSameElements(collection.getLibraries(), a); assertSameElements(ContainerUtil.newArrayList(collection.getLibraries(JpsJavaLibraryType.INSTANCE)), a); assertEmpty(ContainerUtil.newArrayList(collection.getLibraries(JpsJavaSdkType.INSTANCE))); }

testAddLibrary

void () { final JpsLibrary library = myProject.addLibrary("a", JpsJavaLibraryType.INSTANCE); library.addRoot("file://my-url", JpsOrderRootType.COMPILED); assertEquals("file://my-url", assertOneElement(library.getRoots(JpsOrderRootType.COMPILED)).getUrl()); }

testAddRoot