Datasets:

Mlxa

/

java_methods

like 0

void (File d) { if (d.isDirectory()) { for (File file : d.listFiles()) { deleteRecursively(file); } } if (!d.delete()) { throw new BuildException("Unable to delete file " + d.getAbsolutePath()); } }

deleteRecursively

void (FileSet set) { children.add(new FileSetContainer(set)); }

addFileset

void (ZipFileSet set) { children.add(new FileSetContainer(set)); }

addZipfileset

void (DirContainer container) { children.add(container); }

addDir

void (JarContainer container) { children.add(container); }

addJar

void (ZipContainer container) { children.add(container); }

addZip

void (RenamedFileContainer container) { children.add(container); }

addRenamedFile

void (ExtractedDirContent content) { children.add(content); }

addExtractedDir

void (Container container) { children.add(container); }

addContainer

void (Content content) { children.add(content); }

addContent

void (IdeaModule module) { children.add(new FileSetContainer(module)); }

addModule

void (IdeaModuleTests module) { children.add(new FileSetContainer(module)); }

addModuleTests

List<Content> () { return children; }

getChildren

void (String excludes) { this.excludes = excludes; }

setExcludes

void (String includes) { this.includes = includes; }

setIncludes

List<LayoutFileSet> (TempFileFactory temp) { Set<LayoutFileSet> result = new LinkedHashSet<>(); for (Content child : children) { for (LayoutFileSet set : child.build(temp)) { result.add(createCopy(set)); } } ArrayList<LayoutFileSet> list = new ArrayList<>(result); for (LayoutFileSet set : list) { if (includes != null) { set.setIncludes(includes); } if (excludes != null) { set.setExcludes(excludes); } } return list; }

build

LayoutFileSet (FileSet set) { if (set instanceof IdeaModule) { return new IdeaModule((IdeaModule) set); } if (set instanceof IdeaModuleTests) { return new IdeaModuleTests((IdeaModuleTests) set); } if (set instanceof ZipFileSet) { return new LayoutFileSet((ZipFileSet) set.clone()); } else { return new LayoutFileSet((FileSet) set.clone()); } }

createCopy

Zip () { String version = Main.getAntVersion(); Jar task; if (version != null && (version.contains("1.8.0") || version.contains("1.8.1"))) { task = new PatchedJar(); } else { task = new Jar(); } task.setTaskName("jar"); task.setWhenmanifestonly((Zip.WhenEmpty)EnumeratedAttribute.getInstance(Zip.WhenEmpty.class, "skip")); return task; }

createTask

void (boolean flag) { ((Jar) task).setIndex(flag); }

setIndex

void (String manifestEncoding) { ((Jar) task).setManifestEncoding(manifestEncoding); }

setManifestEncoding

void (File manifestFile) { ((Jar) task).setManifest(manifestFile); }

setManifest

void (Jar.FilesetManifestConfig config) { ((Jar) task).setFilesetmanifest(config); }

setFilesetmanifest

void (Zip.WhenEmpty we) { ((Jar)task).setWhenmanifestonly(we); }

setWhenmanifestonly

void (ZipFileSet fs) { ((Jar) task).addMetainf(fs); }

addMetainf

String () { return "module." + getName() + ".output.test"; }

getOutputDirProperty

String () { return "test"; }

getKind

String () { return "production"; }

getKind

String () { return "module." + getName() + ".output.main"; }

getOutputDirProperty

String () { return name; }

getName

void (String name) { this.name = name; setDir(getOutputDir()); }

setName

File () { String adhoc = getProject().getProperty(getOutputDirProperty()); return adhoc != null ? new File(adhoc) : null; }

getOutputDir

boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; IdeaModule that = (IdeaModule) o; return getDir(getProject()).equals(that.getDir(getProject())); }

equals

int () { return getDir(getProject()).hashCode(); }

hashCode

void (String filePath) { this.filePath = filePath; }

setFilePath

void (String newName) { this.newName = newName; }

setNewName

List<LayoutFileSet> (TempFileFactory temp) { final LayoutFileSet fileSet = new LayoutFileSet(); final File destFile = temp.allocateTempFile(newName); copyTask.setProject(getProject()); copyTask.setFile(new File(filePath.replace('/', File.separatorChar))); copyTask.setTofile(destFile); copyTask.perform(); fileSet.setFile(destFile); return Collections.singletonList(fileSet); }

build

void (String jarPath) { this.jarPath = jarPath; }

setJarPath

void (String pathInJar) { this.pathInJar = pathInJar; }

setPathInJar

List<LayoutFileSet> (TempFileFactory temp) { final File outputDir = temp.allocateTempFile("extractedDir"); expandTask.setProject(getProject()); expandTask.setSrc(new File(jarPath.replace('/', File.separatorChar))); File target = outputDir; if (!pathInJar.endsWith("/")) { pathInJar += "/"; } if (pathInJar.startsWith("/")) { pathInJar = pathInJar.substring(1); } if (pathInJar.length() > 0) { final PatternSet patternSet = new PatternSet(); patternSet.createInclude().setName(pathInJar + "**"); expandTask.addPatternset(patternSet); target = new File(outputDir, pathInJar.replace('/', File.separatorChar)); } expandTask.setDest(outputDir); expandTask.perform(); final LayoutFileSet fileSet = new LayoutFileSet(); fileSet.setDir(target); return Collections.singletonList(fileSet); }

build

String () { return name; }

getName

void (String name) { this.name = name; }

setName

List<LayoutFileSet> (TempFileFactory temp) { List<LayoutFileSet> built = super.build(temp); File dest = temp.allocateTempFile(name); task.setProject(getProject()); task.setDestFile(dest); for (LayoutFileSet set : built) { task.addZipfileset(set); } LayoutFileSet result = new LayoutFileSet(); result.setFile(dest); task.perform(); return Collections.singletonList(result); }

build

Zip () { Zip task = new Zip(); task.setTaskName("zip"); return task; }

createTask

void (boolean compress) { task.setCompress(compress); }

setCompress

void (boolean f) { task.setFilesonly(f); }

setFilesonly

void (Zip.Duplicate df) { task.setDuplicate(df); }

setDuplicate

void (String encoding) { task.setEncoding(encoding); }

setEncoding

void (File baseDir) { task.setBasedir(baseDir); }

setBasedir

List<LayoutFileSet> (TempFileFactory temp) { List<LayoutFileSet> built = super.build(temp); for (LayoutFileSet set : built) { copySet(set); } return Collections.emptyList(); }

build

void (LayoutFileSet set) { Copy task = new Copy(); task.setTaskName("copy"); task.setProject(getProject()); String prefix = set.getPrefix(getProject()); File target = prefix.length() > 0 ? new File(destDirectory, prefix + "/") : destDirectory; target.mkdirs(); task.setTodir(target); LayoutFileSet unprefixed = (LayoutFileSet) set.clone(); unprefixed.setPrefix(""); task.addFileset(unprefixed); task.perform(); }

copySet

List<LayoutFileSet> (TempFileFactory temp) { return Collections.singletonList(Container.createCopy(fileSet)); }

build

void (String name) { dirName = name; }

setName

List<LayoutFileSet> (TempFileFactory temp) { List<LayoutFileSet> unprefixed = super.build(temp); List<LayoutFileSet> prefixed = new ArrayList<>(); for (LayoutFileSet set : unprefixed) { LayoutFileSet copy = createCopy(set); copy.setPrefix(dirName + "/" + set.getPrefix(getProject())); prefixed.add(copy); } return prefixed; }

build

Resource[][] (ResourceCollection[] rcs) { Resource[][] manifests = new Resource[rcs.length][]; for (int i = 0; i < rcs.length; i++) { Resource[][] resources = null; if (rcs[i] instanceof FileSet) { resources = grabResources(new FileSet[] {(FileSet) rcs[i]}); } else { resources = grabNonFileSetResources(new ResourceCollection[] { rcs[i] }); } for (int j = 0; j < resources[0].length; j++) { String name = resources[0][j].getName().replace('\\', '/'); if (rcs[i] instanceof ArchiveFileSet) { ArchiveFileSet afs = (ArchiveFileSet) rcs[i]; if (!"".equals(afs.getFullpath(getProject()))) { name = afs.getFullpath(getProject()); } else if (!"".equals(afs.getPrefix(getProject()))) { String prefix = afs.getPrefix(getProject()); if (!prefix.endsWith("/") && !prefix.endsWith("\\")) { prefix += "/"; } name = prefix + name; } } if (name.equalsIgnoreCase(MANIFEST_NAME)) { manifests[i] = new Resource[] {resources[0][j]}; break; } } if (manifests[i] == null) { manifests[i] = new Resource[0]; } } return manifests; }

grabManifests

boolean (final @NotNull CharSequence filename) { synchronized (myMatcher) { myMatcher.reset(filename); return myMatcher.matches(); } }

matches

boolean (final @NotNull CharSequence filename) { return Strings.endsWith(filename, mySuffix); }

matches

boolean (final @NotNull CharSequence filename) { return Strings.startsWith(filename, 0, myPrefix); }

matches

boolean (final @NotNull CharSequence filename) { return Strings.contains(filename, myInfix); }

matches

MaskMatcher (final @NotNull String pattern) { int len = pattern.length(); if (len > 1 && pattern.indexOf('?') < 0) { if (pattern.charAt(0) == '*' && pattern.indexOf('*', 1) < 0) { return new SuffixMatcher(pattern.substring(1)); } if (pattern.indexOf('*') == len - 1) { return new PrefixMatcher(pattern.substring(0, len - 1)); } if (len > 2 && pattern.charAt(0) == '*' && pattern.indexOf('*', 1) == len - 1) { return new InfixMatcher(pattern.substring(1, len - 1)); } } return new RegexpMatcher(pattern); }

createMatcher

boolean (@NotNull CharSequence fileName) { return myMatcher.matches(fileName); }

acceptsCharSequence

String () { return myPattern; }

getPresentableString

boolean (final Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; final WildcardFileNameMatcher that = (WildcardFileNameMatcher)o; return myPattern.equals(that.myPattern); }

equals

int () { return myPattern.hashCode(); }

hashCode

String () { return myPattern; }

getPattern

String () { return myPattern; }

toString

Set<String> () { return Collections.unmodifiableSet(masks); }

getIgnoreMasks

void (@NotNull String list) { clearPatterns(); StringTokenizer tokenizer = new StringTokenizer(list, ";"); while (tokenizer.hasMoreTokens()) { addIgnoreMask(tokenizer.nextToken()); } }

setIgnoreMasks

boolean (@NotNull CharSequence fileName) { if (ignorePatterns.findAssociatedFileType(fileName) == Boolean.TRUE) { return true; } //Quite a hack, but still we need to have some name, which //won't be caught by VFS for sure. return StringUtilRt.endsWith(fileName, FileUtil.ASYNC_DELETE_EXTENSION); }

isIgnored

T (@NotNull FileNameMatcher matcher, @NotNull T type) { if (matcher instanceof ExtensionFileNameMatcher) { String extension = ((ExtensionFileNameMatcher)matcher).getExtension(); return myExtensionMappings.put(extension, type); } if (matcher instanceof ExactFileNameMatcher) { ExactFileNameMatcher exactFileNameMatcher = (ExactFileNameMatcher)matcher; Map<CharSequence, T> mapToUse = exactFileNameMatcher.isIgnoreCase() ? myExactFileNameAnyCaseMappings : myExactFileNameMappings; return mapToUse.put(exactFileNameMatcher.getFileName(), type); } int i = ContainerUtil.indexOf(myMatchingMappings, p -> p.first.equals(matcher)); if (i == -1) { myMatchingMappings.add(Pair.create(matcher, type)); return null; } Pair<FileNameMatcher, T> old = myMatchingMappings.get(i); myMatchingMappings.set(i, Pair.create(matcher, type)); return Pair.getSecond(old); }

addAssociation

T (@NotNull @NonNls CharSequence fileName) { if (!myExactFileNameMappings.isEmpty()) { T t = myExactFileNameMappings.get(fileName); if (t != null) return t; } if (!myExactFileNameAnyCaseMappings.isEmpty()) { // even hash lookup with case-insensitive hasher is costly for isIgnored checks during compile T t = myExactFileNameAnyCaseMappings.get(fileName); if (t != null) return t; } for (Pair<FileNameMatcher, T> mapping : myMatchingMappings) { if (mapping.getFirst().acceptsCharSequence(fileName)) return mapping.getSecond(); } return findByExtension(FileUtilRt.getExtension(fileName)); }

findAssociatedFileType

FileTypeAssocTable<T> () { return new FileTypeAssocTable<>( myExtensionMappings, myExactFileNameMappings, myExactFileNameAnyCaseMappings, myConcurrentCharSequenceMapBuilder, myHashBangMap, myMatchingMappings ); }

copy

List<FileNameMatcher> (@NotNull T type) { List<FileNameMatcher> result = new ArrayList<>(); for (Pair<FileNameMatcher, T> mapping : myMatchingMappings) { if (type.equals(mapping.getSecond())) { result.add(mapping.getFirst()); } } for (Map.Entry<CharSequence, T> entry : myExactFileNameMappings.entrySet()) { if (type.equals(entry.getValue())) { result.add(new ExactFileNameMatcher(entry.getKey().toString(), false)); } } for (Map.Entry<CharSequence, T> entry : myExactFileNameAnyCaseMappings.entrySet()) { if (type.equals(entry.getValue())) { result.add(new ExactFileNameMatcher(entry.getKey().toString(), true)); } } for (Map.Entry<CharSequence, T> entry : myExtensionMappings.entrySet()) { if (type.equals(entry.getValue())) { result.add(new ExtensionFileNameMatcher(entry.getKey().toString())); } } return result; }

getAssociations

List<String> (@NotNull T type) { return myHashBangMap.entrySet().stream() .filter(e -> e.getValue().equals(type)) .map(e -> e.getKey()) .collect(Collectors.toList()); }

getHashBangPatterns

boolean (Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } FileTypeAssocTable<?> that = (FileTypeAssocTable<?>)o; return myExtensionMappings.equals(that.myExtensionMappings) && myMatchingMappings.equals(that.myMatchingMappings) && myExactFileNameMappings.equals(that.myExactFileNameMappings) && myHashBangMap.equals(that.myHashBangMap) && myExactFileNameAnyCaseMappings.equals(that.myExactFileNameAnyCaseMappings); }

equals

int () { int result = myExtensionMappings.hashCode(); result = 31 * result + myMatchingMappings.hashCode(); result = 31 * result + myHashBangMap.hashCode(); result = 31 * result + myExactFileNameMappings.hashCode(); result = 31 * result + myExactFileNameAnyCaseMappings.hashCode(); return result; }

hashCode

String () { return "FileTypeAssocTable. myExtensionMappings="+myExtensionMappings+";\n" +"myExactFileNameMappings="+myExactFileNameMappings+";\n" +"myExactFileNameAnyCaseMappings="+myExactFileNameAnyCaseMappings+";\n" +"myMatchingMappings="+myMatchingMappings+";\n" +"myHashBangMap="+myHashBangMap+";"; }

toString

void () { myHashBangMap.clear(); myMatchingMappings.clear(); myExtensionMappings.clear(); myExactFileNameMappings.clear(); myExactFileNameAnyCaseMappings.clear(); }

clear

boolean () { return checksumVerificationEnabled; }

isSha256ChecksumVerificationEnabled

boolean () { return bindRepositoryEnabled; }

isBindRepositoryEnabled

void (boolean value) { checksumVerificationEnabled = value; }

setSha256ChecksumVerificationEnabled

void (boolean value) { bindRepositoryEnabled = value; }

setBindRepositoryEnabled

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

createCopy

void (@NotNull JpsDependencyResolverConfigurationImpl modified) { this.checksumVerificationEnabled = modified.checksumVerificationEnabled; this.bindRepositoryEnabled = modified.bindRepositoryEnabled; }

applyChanges

JpsDependencyResolverConfiguration (@NotNull JpsProject project) { JpsDependencyResolverConfiguration config = getDependencyResolverConfiguration(project); if (config == null) { config = project.getContainer().setChild(JpsDependencyResolverConfigurationImpl.ROLE, new JpsDependencyResolverConfigurationImpl()); } return config; }

getOrCreateDependencyResolverConfiguration

JpsPluginManager () { return JpsServiceManager.getInstance().getService(JpsPluginManager.class); }

getInstance

Object () { return myDataLock; }

getDataLock

void (@NotNull JpsElementContainerEx modified) { final Collection<JpsElementChildRole<?>> roles = new ArrayList<>(); synchronized (myDataLock) { roles.addAll(myElements.keySet()); } for (JpsElementChildRole<?> role : roles) { applyChanges(role, modified); } roles.clear(); synchronized (modified.getDataLock()) { roles.addAll(modified.getElementsMap().keySet()); } synchronized (myDataLock) { roles.removeAll(myElements.keySet()); } for (JpsElementChildRole<?> role : roles) { applyChanges(role, modified); } }

applyChanges

JavaModuleIndex (@NotNull JpsCompilerExcludes excludes) { return new JavaModuleIndexImpl(excludes); }

create

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

createCopy

String () { return myOutputUrl; }

getOutputUrl

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

setOutputUrl

LanguageLevel () { return myLanguageLevel; }

getLanguageLevel

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

setLanguageLevel

void (@NotNull JpsJavaProjectExtensionImpl modified) { setLanguageLevel(modified.myLanguageLevel); setOutputUrl(modified.myOutputUrl); }

applyChanges

boolean () { return myExported; }

isExported

void (boolean exported) { if (myExported != exported) { myExported = exported; fireElementChanged(); } }

setExported

JpsJavaDependencyScope () { return myScope; }

getScope

void (@NotNull JpsJavaDependencyScope scope) { if (!scope.equals(myScope)) { myScope = scope; fireElementChanged(); } }

setScope

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

createCopy

void (@NotNull JpsJavaDependencyExtensionImpl modified) { setExported(modified.myExported); setScope(modified.myScope); }

applyChanges