Datasets:

Mlxa

/

java_methods

like 0

JpsLibraryCollection () { return myLibraryCollection; }

getLibraryCollection

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

getProject

JpsModuleType<P> () { return myModuleType; }

getModuleType

String () { return "JpsModuleImpl: "+getName(); }

toString

Collection<String> () { Set<String> urls = new LinkedHashSet<>(); processUrls(new CollectConsumer<>(urls)); return urls; }

getUrls

Collection<File> () { Set<File> files = new LinkedHashSet<>(); processUrls(url -> { if (!JpsPathUtil.isJrtUrl(url)) { files.add(JpsPathUtil.urlToFile(url)); } }); return files; }

getRoots

void (final Consumer<? super String> urlConsumer) { myDependenciesEnumerator.processDependencies(dependencyElement -> { if (dependencyElement instanceof JpsModuleSourceDependency) { processModuleRootUrls(dependencyElement.getContainingModule(), dependencyElement, urlConsumer); } else if (dependencyElement instanceof JpsModuleDependency) { JpsModule dep = ((JpsModuleDependency)dependencyElement).getModule(); if (dep != null) { processModuleRootUrls(dep, dependencyElement, urlConsumer); } } else if (dependencyElement instanceof JpsLibraryDependency) { JpsLibrary lib = ((JpsLibraryDependency)dependencyElement).getLibrary(); if (lib != null) { processLibraryRootUrls(lib, urlConsumer); } } else if (dependencyElement instanceof JpsSdkDependency) { JpsLibrary lib = ((JpsSdkDependency)dependencyElement).resolveSdk(); if (lib != null) { processLibraryRootUrls(lib, urlConsumer); } } return true; }); }

processUrls

boolean (JpsLibrary library, Consumer<? super String> urlConsumer) { for (String url : library.getRootUrls(myRootType)) { urlConsumer.accept(url); } return true; }

processLibraryRootUrls

List<JpsArtifact> (@NotNull JpsProject project) { JpsElementCollection<JpsArtifact> collection = project.getContainer().getChild(JpsArtifactRole.ARTIFACT_COLLECTION_ROLE); return collection != null ? collection.getElements() : Collections.emptyList(); }

getArtifacts

List<JpsArtifact> (@NotNull JpsProject project) { List<JpsArtifact> artifacts = new ArrayList<>(getArtifacts(project)); artifacts.sort((o1, o2) -> o1.getName().compareToIgnoreCase(o2.getName())); return artifacts; }

getSortedArtifacts

JpsArtifactReference (@NotNull String artifactName) { return new JpsArtifactReferenceImpl(artifactName); }

createReference

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

createCopy

String () { return myElementName; }

getArtifactName

JpsArtifactReferenceImpl (@NotNull JpsModel model) { model.registerExternalReference(this); return this; }

asExternal

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

createCopy

String () { return myOutputPath; }

getOutputPath

void (@Nullable String outputPath) { if (!Objects.equals(myOutputPath, outputPath)) { myOutputPath = outputPath; fireElementChanged(); } }

setOutputPath

String () { if (StringUtil.isEmpty(myOutputPath)) return null; JpsCompositePackagingElement root = getRootElement(); return root instanceof JpsArchivePackagingElement ? myOutputPath + "/" + ((JpsArchivePackagingElement)root).getArchiveName() : myOutputPath; }

getOutputFilePath

JpsArtifactType<P> () { return myArtifactType; }

getArtifactType

JpsArtifactReferenceImpl () { return new JpsArtifactReferenceImpl(getName()); }

createReference

JpsCompositePackagingElement () { return myContainer.getChild(ROOT_ELEMENT_CHILD_ROLE); }

getRootElement

void (@NotNull JpsCompositePackagingElement rootElement) { myContainer.setChild(ROOT_ELEMENT_CHILD_ROLE, rootElement); }

setRootElement

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

getProperties

boolean () { return myBuildOnMake; }

isBuildOnMake

void (boolean buildOnMake) { if (myBuildOnMake != buildOnMake) { myBuildOnMake = buildOnMake; fireElementChanged(); } }

setBuildOnMake

JpsArtifactRootElementImpl () { return new JpsArtifactRootElementImpl(); }

createCopy

void (@NotNull Self modified) { setFilePath(modified.myFilePath); }

applyChanges

String () { return myFilePath; }

getFilePath

void (String filePath) { if (!Objects.equals(myFilePath, filePath)) { myFilePath = filePath; fireElementChanged(); } }

setFilePath

JpsFileCopyPackagingElementImpl () { return new JpsFileCopyPackagingElementImpl(myFilePath, myRenamedOutputFileName); }

createCopy

void (@NotNull JpsFileCopyPackagingElementImpl modified) { super.applyChanges(modified); setRenamedOutputFileName(modified.myRenamedOutputFileName); }

applyChanges

String () { return myRenamedOutputFileName; }

getRenamedOutputFileName

void (String renamedOutputFileName) { if (!Objects.equals(myRenamedOutputFileName, renamedOutputFileName)) { myRenamedOutputFileName = renamedOutputFileName; fireElementChanged(); } }

setRenamedOutputFileName

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

getModuleReference

String () { JpsModule module = getModuleReference().resolve(); if (module == null) return null; return getOutputUrl(module); }

getOutputUrl

JpsExtractedDirectoryPackagingElementImpl () { return new JpsExtractedDirectoryPackagingElementImpl(myFilePath, myPathInJar); }

createCopy

void (@NotNull JpsExtractedDirectoryPackagingElementImpl modified) { super.applyChanges(modified); setPathInJar(modified.myPathInJar); }

applyChanges

String () { return myPathInJar; }

getPathInJar

void (String pathInJar) { if (!Objects.equals(myPathInJar, pathInJar)) { myPathInJar = pathInJar; fireElementChanged(); } }

setPathInJar

List<JpsPackagingElement> () { return myContainer.getChild(CHILDREN_ROLE).getElements(); }

getChildren

void (@NotNull JpsPackagingElement child) { myContainer.getChild(CHILDREN_ROLE).removeChild(child); }

removeChild

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

createCopy

String () { return myDirectoryName; }

getDirectoryName

void (String directoryName) { if (!myDirectoryName.equals(directoryName)) { myDirectoryName = directoryName; fireElementChanged(); } }

setDirectoryName

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

createCopy

JpsArtifactReference () { return myContainer.getChild(ARTIFACT_REFERENCE_CHILD_ROLE); }

getArtifactReference

List<JpsPackagingElement> () { JpsArtifact artifact = getArtifactReference().resolve(); if (artifact == null) return Collections.emptyList(); JpsCompositePackagingElement rootElement = artifact.getRootElement(); if (rootElement instanceof JpsArtifactRootElement) { return new ArrayList<>(rootElement.getChildren()); } else { return Collections.singletonList(rootElement); } }

getSubstitution

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

createCopy

JpsLibraryReference () { return myContainer.getChild(LIBRARY_REFERENCE_CHILD_ROLE); }

getLibraryReference

List<JpsPackagingElement> () { JpsLibrary library = getLibraryReference().resolve(); if (library == null) return Collections.emptyList(); List<JpsPackagingElement> result = new ArrayList<>(); for (File file : library.getFiles(JpsOrderRootType.COMPILED)) { String path = FileUtil.toSystemIndependentName(file.getAbsolutePath()); if (file.isDirectory()) { result.add(JpsPackagingElementFactory.getInstance().createDirectoryCopy(path)); } else { result.add(JpsPackagingElementFactory.getInstance().createFileCopy(path, null)); } } return result; }

getSubstitution

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

createCopy

String () { return myArchiveName; }

getArchiveName

void (String directoryName) { if (!myArchiveName.equals(directoryName)) { myArchiveName = directoryName; fireElementChanged(); } }

setArchiveName

JpsDirectoryCopyPackagingElement (@NotNull String directoryPath) { return new JpsDirectoryCopyPackagingElementImpl(directoryPath); }

createDirectoryCopy

JpsPackagingElement (String relativeOutputPath, JpsPackagingElement element) { relativeOutputPath = StringUtil.trimStart(relativeOutputPath, "/"); if (relativeOutputPath.length() == 0) { return element; } int slash = relativeOutputPath.indexOf('/'); if (slash == -1) slash = relativeOutputPath.length(); String rootName = relativeOutputPath.substring(0, slash); String pathTail = relativeOutputPath.substring(slash); final JpsDirectoryPackagingElement root = createDirectory(rootName); final JpsCompositePackagingElement last = getOrCreateDirectoryOrArchive(root, pathTail, true); last.addChild(element); return root; }

createParentDirectories

JpsCompositePackagingElement (@NotNull JpsCompositePackagingElement root, @NotNull String path) { return getOrCreateDirectoryOrArchive(root, path, true); }

getOrCreateDirectory

JpsCompositePackagingElement (@NotNull JpsCompositePackagingElement root, @NotNull String path) { return getOrCreateDirectoryOrArchive(root, path, false); }

getOrCreateArchive

JpsCompositePackagingElement (@NotNull JpsCompositePackagingElement root, @NotNull @NonNls String path, final boolean directory) { path = StringUtil.trimStart(StringUtil.trimEnd(path, "/"), "/"); if (path.length() == 0) { return root; } int index = path.lastIndexOf('/'); String lastName = path.substring(index + 1); String parentPath = index != -1 ? path.substring(0, index) : ""; final JpsCompositePackagingElement parent = getOrCreateDirectoryOrArchive(root, parentPath, true); final JpsCompositePackagingElement last = directory ? createDirectory(lastName) : createArchive(lastName); return parent.addChild(last); }

getOrCreateDirectoryOrArchive

JpsFileCopyPackagingElement (@NotNull String filePath, @Nullable String outputFileName) { return new JpsFileCopyPackagingElementImpl(filePath, outputFileName); }

createFileCopy

JpsExtractedDirectoryPackagingElement (@NotNull String jarPath, @NotNull String pathInJar) { return new JpsExtractedDirectoryPackagingElementImpl(jarPath, pathInJar); }

createExtractedDirectory

JpsDirectoryPackagingElement (@NotNull String directoryName) { return new JpsDirectoryPackagingElementImpl(directoryName); }

createDirectory

JpsArchivePackagingElement (@NotNull String archiveName) { return new JpsArchivePackagingElementImpl(archiveName); }

createArchive

JpsArtifactRootElement () { return new JpsArtifactRootElementImpl(); }

createArtifactRoot

JpsLibraryFilesPackagingElement (@NotNull JpsLibraryReference reference) { return new JpsLibraryFilesPackagingElementImpl(reference); }

createLibraryElement

JpsArtifactOutputPackagingElement (@NotNull JpsArtifactReference reference) { return new JpsArtifactOutputPackagingElementImpl(reference); }

createArtifactOutput

JpsDirectoryCopyPackagingElementImpl () { return new JpsDirectoryCopyPackagingElementImpl(myFilePath); }

createCopy

String () { return getFilePath(); }

getDirectoryPath

void (String path) { setFilePath(path); }

setDirectoryPath

FileNameMatcher (@NotNull String pattern) { if (pattern.startsWith("*.") && pattern.indexOf('*', 2) < 0 && pattern.indexOf('.', 2) < 0 && pattern.indexOf('?', 2) < 0) { return new ExtensionFileNameMatcher(StringUtil.toLowerCase(pattern.substring(2))); } if (pattern.contains("*") || pattern.contains("?")) { return new WildcardFileNameMatcher(pattern); } return new ExactFileNameMatcher(pattern); }

createMatcher

JpsRemoteRepositoriesConfiguration (@NotNull JpsProject project) { return project.getContainer().getChild(JpsRemoteRepositoriesConfigurationImpl.ROLE); }

getRemoteRepositoriesConfiguration

JpsRemoteRepositoriesConfigurationImpl () { return new JpsRemoteRepositoriesConfigurationImpl(repositories); }

createCopy

void (@NotNull JpsRemoteRepositoriesConfigurationImpl modified) { setRepositories(modified.getRepositories()); }

applyChanges

List<JpsRemoteRepositoryDescription> () { return Collections.unmodifiableList(repositories); }

getRepositories

void (List<? extends JpsRemoteRepositoryDescription> repositories) { this.repositories.clear(); this.repositories.addAll(repositories); }

setRepositories

String () { return myBaseDirUrl; }

getBaseDirUrl

String () { return myPattern; }

getPattern

JpsExcludePatternImpl () { return new JpsExcludePatternImpl(myBaseDirUrl, myPattern); }

createCopy

void (@NotNull JpsExcludePatternImpl modified) { }

applyChanges

JpsModel () { return myModel; }

getModel

E () { throw new UnsupportedOperationException("'createCopy' not implemented in " + getClass().getName()); }

createCopy

D () { return myData; }

getData

void (@NotNull D data) { if (!myData.equals(data)) { myData = data; fireElementChanged(); } }

setData

JpsSimpleElementImpl<D> () { return new JpsSimpleElementImpl<>(this); }

createCopy

void (@NotNull JpsSimpleElementImpl<D> modified) { setData(modified.getData()); }

applyChanges

JpsProjectImpl () { return myProject; }

getProject

JpsGlobalImpl () { return myGlobal; }

getGlobal

void (@NotNull JpsElementReference<?> reference) { myProject.addExternalReference(reference); }

registerExternalReference

void () { myOriginalModel.applyChanges(this); }

commit

void (@NotNull JpsModelImpl modifiedCopy) { myProject.applyChanges(modifiedCopy.myProject); myGlobal.applyChanges(modifiedCopy.myGlobal); }

applyChanges

T () { final JpsCompositeElement parent = getParentReference().resolve(); if (parent == null) return null; JpsElementCollection<? extends S> collection = getCollection(parent); if (collection == null) return null; final List<? extends S> elements = collection.getElements(); for (S element : elements) { if (element.getName().equals(myElementName)) { T resolved = resolve(element); if (resolved != null) { return resolved; } } } return null; }

resolve

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

asExternal

JpsLibraryCollection () { return myLibraryCollection; }

getLibraryCollection

JpsFileTypesConfiguration () { return myContainer.getChild(JpsFileTypesConfigurationImpl.ROLE); }

getFileTypesConfiguration

JpsPathMapper () { return myPathMapper; }

getPathMapper

void (@NotNull JpsPathMapper pathMapper) { myPathMapper = pathMapper; }

setPathMapper

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

createReference

String (@NotNull File file) { if (isXmlFile(file)) { try { String encoding = XmlCharsetDetector.extractXmlEncodingFromProlog(FileUtil.loadFileBytes(file)); if (encoding != null) { return encoding; } } catch (IOException e) { LOG.info("Cannot detect encoding for xml file " + file.getAbsolutePath(), e); } } if (!myUrlToEncoding.isEmpty()) { File current = file; while (current != null) { String encoding = myUrlToEncoding.get(JpsPathUtil.pathToUrl(FileUtilRt.toSystemIndependentName(current.getPath()))); if (encoding != null) { return encoding; } current = FileUtilRt.getParentFile(current); } } if (myProjectEncoding != null) { return myProjectEncoding; } final JpsModel model = getModel(); assert model != null; return JpsEncodingConfigurationService.getInstance().getGlobalEncoding(model.getGlobal()); }

getEncoding

boolean (File file) { String fileName = file.getName(); return SystemInfo.isFileSystemCaseSensitive ? fileName.endsWith(XML_NAME_SUFFIX) : StringUtil.endsWithIgnoreCase(fileName, XML_NAME_SUFFIX); }

isXmlFile

String () { return myProjectEncoding; }

getProjectEncoding

JpsEncodingProjectConfigurationImpl () { return new JpsEncodingProjectConfigurationImpl(myUrlToEncoding, myProjectEncoding); }

createCopy