Unnamed: 0
int64 0
305k
| body
stringlengths 7
52.9k
| name
stringlengths 1
185
|
|---|---|---|
2,700 |
List<String> () { return Collections.emptyList(); }
|
getCompilableFileExtensions
|
2,701 |
InputStream (String internalClassName) { final BinaryContent content = outputConsumer.lookupClassBytes(internalClassName.replace("/", ".")); if (content != null) { return new ByteArrayInputStream(content.getBuffer(), content.getOffset(), content.getLength()); } return null; }
|
lookupClassBeforeClasspath
|
2,702 |
ExitCode (CompileContext context, ModuleChunk chunk, InstrumentationClassFinder finder, OutputConsumer outputConsumer) { ExitCode exitCode = ExitCode.NOTHING_DONE; for (CompiledClass compiledClass : outputConsumer.getCompiledClasses().values()) { if (Utils.IS_TEST_MODE || LOG.isDebugEnabled()) { LOG.debug("checking " + compiledClass + " by " + getClass()); } final BinaryContent originalContent = compiledClass.getContent(); final ClassReader reader = new FailSafeClassReader(originalContent.getBuffer(), originalContent.getOffset(), originalContent.getLength()); final int version = InstrumenterClassWriter.getClassFileVersion(reader); if (IS_INSTRUMENTED_KEY.get(compiledClass, Boolean.FALSE) || !canInstrument(compiledClass, version)) { // do not instrument the same content twice continue; } final ClassWriter writer = new InstrumenterClassWriter(reader, InstrumenterClassWriter.getAsmClassWriterFlags(version), finder); try { if (Utils.IS_TEST_MODE || LOG.isDebugEnabled()) { LOG.debug("instrumenting " + compiledClass + " by " + getClass()); } final BinaryContent instrumented = instrument(context, compiledClass, reader, writer, finder); if (instrumented != null) { compiledClass.setContent(instrumented); String className = compiledClass.getClassName(); assert className != null : compiledClass; finder.cleanCachedData(className); IS_INSTRUMENTED_KEY.set(compiledClass, Boolean.TRUE); exitCode = ExitCode.OK; } } catch (Throwable e) { LOG.info(e); final String message = e.getMessage(); if (message != null) { String sourcePath = ContainerUtil.getFirstItem(compiledClass.getSourceFilesPaths()); context.processMessage(new CompilerMessage(getPresentableName(), BuildMessage.Kind.ERROR, message, sourcePath)); } else { context.processMessage(CompilerMessage.createInternalCompilationError(getPresentableName(), e)); } } } return exitCode; }
|
performBuild
|
2,703 |
List<T> (@NotNull JpsModel model) { Collection<JpsArtifact> artifacts = JpsBuilderArtifactService.getInstance().getArtifacts(model, true); List<T> targets = new ArrayList<>(artifacts.size()); for (JpsArtifact artifact : artifacts) { if (!StringUtil.isEmpty(artifact.getOutputPath())) { targets.add(createArtifactBasedTarget(artifact)); } } return targets; }
|
computeAllTargets
|
2,704 |
BuildTargetLoader<T> (@NotNull JpsModel model) { return new Loader(model); }
|
createLoader
|
2,705 |
File (@NotNull String fullPath) { final int i = fullPath.indexOf(JAR_SEPARATOR); String filePath = i == -1 ? fullPath : fullPath.substring(0, i); return new File(FileUtil.toSystemDependentName(filePath)); }
|
getLocalFile
|
2,706 |
String () { return myArtifact.getName(); }
|
getId
|
2,707 |
JpsArtifact () { return myArtifact; }
|
getArtifact
|
2,708 |
boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; return myArtifact.equals(((ArtifactBasedBuildTarget)o).myArtifact); }
|
equals
|
2,709 |
int () { return myArtifact.hashCode(); }
|
hashCode
|
2,710 |
String (@NotNull String path) { return myRelativizer.toRelative(path); }
|
normalizePath
|
2,711 |
List<SourcePathAndRootIndex> (@NotNull List<SourcePathAndRootIndex> state) { List<SourcePathAndRootIndex> normalizePathList = new SmartList<>(); state.forEach(it -> normalizePathList.add(new SourcePathAndRootIndex(normalizePath(it.myPath), it.myRootIndex))); return normalizePathList; }
|
normalizePaths
|
2,712 |
String () { return myPath; }
|
getPath
|
2,713 |
int () { return myRootIndex; }
|
getRootIndex
|
2,714 |
JpsBuilderArtifactService () { return ourInstance; }
|
getInstance
|
2,715 |
ArtifactBuildTarget (JpsArtifact artifact) { return new ArtifactBuildTarget(artifact); }
|
createArtifactBasedTarget
|
2,716 |
String () { return getBuilderName(); }
|
getPresentableName
|
2,717 |
boolean () { String outputFilePath = artifact.getOutputFilePath(); if (StringUtil.isEmpty(outputFilePath)) { context.processMessage(new CompilerMessage(getBuilderName(), BuildMessage.Kind.ERROR, JpsBuildBundle.message("build.message.cannot.build.0.artifact.output.path.is.not.specified", artifact.getName()))); return false; } final ArtifactSorter sorter = new ArtifactSorter(pd.getModel()); final Map<JpsArtifact, JpsArtifact> selfIncludingNameMap = sorter.getArtifactToSelfIncludingNameMap(); final JpsArtifact selfIncluding = selfIncludingNameMap.get(artifact); if (selfIncluding != null) { context.processMessage(new CompilerMessage(getBuilderName(), BuildMessage.Kind.ERROR, JpsBuildBundle.message("build.message.cannot.build.0.artifact.it.includes.itself", artifact.getName(), selfIncluding.getName(), selfIncluding.equals(artifact) ? 0 : 1))); return false; } String messageText = JpsBuildBundle.message("progress.message.building.artifact.0", artifact.getName()); context.processMessage(new ProgressMessage(messageText)); LOG.debug(messageText); return true; }
|
startBuild
|
2,718 |
List<BuildTask> (ArtifactBuildTaskProvider.ArtifactBuildPhase phase) { List<BuildTask> result = new ArrayList<>(); for (ArtifactBuildTaskProvider provider : JpsServiceManager.getInstance().getExtensions(ArtifactBuildTaskProvider.class)) { result.addAll(provider.createArtifactBuildTasks(artifact, phase)); } return result; }
|
createArtifactTasks
|
2,719 |
void (final int rootIndex, final String path, Collection<String> deletedFiles) { if (deletedFiles.contains(path)) { return; } Set<String> paths = filesToProcess.get(rootIndex); if (paths == null) { paths = CollectionFactory.createFilePathSet(); filesToProcess.put(rootIndex, paths); } paths.add(path); }
|
addFileToProcess
|
2,720 |
void (@NotNull ProjectDescriptor pd, @NotNull PrintWriter out) { final PathRelativizerService relativizer = pd.dataManager.getRelativizer(); String outputPath = getArtifact().getOutputPath(); out.println(StringUtil.isNotEmpty(outputPath) ? relativizer.toRelative(outputPath) : ""); final BuildRootIndex rootIndex = pd.getBuildRootIndex(); for (ArtifactRootDescriptor descriptor : rootIndex.getTargetRoots(this, null)) { descriptor.writeConfiguration(out, relativizer); } }
|
writeConfiguration
|
2,721 |
List<ArtifactRootDescriptor> (@NotNull JpsModel model, @NotNull ModuleExcludeIndex index, @NotNull IgnoredFileIndex ignoredFileIndex, @NotNull BuildDataPaths dataPaths) { ArtifactInstructionsBuilderImpl builder = new ArtifactInstructionsBuilderImpl(index, ignoredFileIndex, this, model, dataPaths); ArtifactInstructionsBuilderContext context = new ArtifactInstructionsBuilderContextImpl(model, dataPaths); final JpsArtifact artifact = getArtifact(); String outputPath = StringUtil.notNullize(artifact.getOutputPath()); final CopyToDirectoryInstructionCreator instructionCreator = new CopyToDirectoryInstructionCreator(builder, outputPath); LayoutElementBuildersRegistry.getInstance().generateInstructions(artifact, instructionCreator, context); return builder.getDescriptors(); }
|
computeRootDescriptors
|
2,722 |
ArtifactRootDescriptor (@NotNull String rootId, @NotNull BuildRootIndex rootIndex) { return rootIndex.getTargetRoots(this, null).get(Integer.parseInt(rootId)); }
|
findRootDescriptor
|
2,723 |
String () { return "Artifact '" + getArtifact().getName() + "'"; }
|
getPresentableName
|
2,724 |
Collection<File> (@NotNull CompileContext context) { String outputFilePath = getArtifact().getOutputFilePath(); return outputFilePath != null && !StringUtil.isEmpty(outputFilePath) ? Collections.singleton(new File(FileUtil.toSystemDependentName(outputFilePath))) : Collections.emptyList(); }
|
getOutputRoots
|
2,725 |
Class<E> () { return myElementClass; }
|
getElementClass
|
2,726 |
LayoutElementBuildersRegistry () { return InstanceHolder.ourInstance; }
|
getInstance
|
2,727 |
void (JpsArtifact artifact, CopyToDirectoryInstructionCreator creator, ArtifactInstructionsBuilderContext context) { context.enterArtifact(artifact); generateInstructions(artifact.getRootElement(), creator, context); }
|
generateInstructions
|
2,728 |
void (JpsPackagingElement layoutElement, ArtifactCompilerInstructionCreator instructionCreator, ArtifactInstructionsBuilderContext builderContext) { final LayoutElementBuilderService builder = getElementBuilder(layoutElement); if (builder != null) { //noinspection unchecked builder.generateInstructions(layoutElement, instructionCreator, builderContext); } }
|
generateInstructions
|
2,729 |
void (JpsCompositePackagingElement element, ArtifactCompilerInstructionCreator instructionCreator, ArtifactInstructionsBuilderContext builderContext) { generateInstructions(element.getChildren(), instructionCreator, builderContext); }
|
generateChildrenInstructions
|
2,730 |
void (JpsComplexPackagingElement element, ArtifactCompilerInstructionCreator instructionCreator, ArtifactInstructionsBuilderContext builderContext) { final List<JpsPackagingElement> substitution = element.getSubstitution(); if (substitution != null) { generateInstructions(substitution, instructionCreator, builderContext); } }
|
generateSubstitutionInstructions
|
2,731 |
void (final List<JpsPackagingElement> elements, ArtifactCompilerInstructionCreator instructionCreator, ArtifactInstructionsBuilderContext builderContext) { for (JpsPackagingElement child : elements) { generateInstructions(child, instructionCreator, builderContext); } }
|
generateInstructions
|
2,732 |
void (@NotNull List<JpsModuleSourceRoot> roots, @NotNull ArtifactCompilerInstructionCreator creator, @NotNull JpsPackagingElement contextElement) { for (JpsModuleSourceRoot root : roots) { File source = root.getFile(); ArtifactCompilerInstructionCreator target; JavaSourceRootProperties javaProperties = root.getProperties(JavaModuleSourceRootTypes.SOURCES); if (javaProperties != null) { String prefix = javaProperties.getPackagePrefix().replace('.', '/'); target = creator.subFolderByRelativePath(prefix); } else { target = creator; } target.addDirectoryCopyInstructions(source, null, target.getInstructionsBuilder().createCopyingHandler(source, contextElement, target)); } }
|
generateModuleSourceInstructions
|
2,733 |
void (@Nullable String outputUrl, @NotNull ArtifactCompilerInstructionCreator creator, @NotNull JpsPackagingElement contextElement) { if (outputUrl != null) { File directory = JpsPathUtil.urlToFile(outputUrl); creator.addDirectoryCopyInstructions(directory, null, creator.getInstructionsBuilder().createCopyingHandler(directory, contextElement, creator)); } }
|
generateModuleOutputInstructions
|
2,734 |
void (JpsArtifactRootElement element, ArtifactCompilerInstructionCreator instructionCreator, ArtifactInstructionsBuilderContext builderContext) { generateChildrenInstructions(element, instructionCreator, builderContext); }
|
generateInstructions
|
2,735 |
void (JpsDirectoryPackagingElement element, ArtifactCompilerInstructionCreator instructionCreator, ArtifactInstructionsBuilderContext builderContext) { generateChildrenInstructions(element, instructionCreator.subFolder(element.getDirectoryName()), builderContext); }
|
generateInstructions
|
2,736 |
void (JpsArchivePackagingElement element, ArtifactCompilerInstructionCreator instructionCreator, ArtifactInstructionsBuilderContext builderContext) { generateChildrenInstructions(element, instructionCreator.archive(element.getArchiveName()), builderContext); }
|
generateInstructions
|
2,737 |
void (JpsDirectoryCopyPackagingElement element, ArtifactCompilerInstructionCreator instructionCreator, ArtifactInstructionsBuilderContext builderContext) { final String dirPath = element.getDirectoryPath(); if (dirPath != null) { final File directory = new File(dirPath); instructionCreator.addDirectoryCopyInstructions(directory, null, instructionCreator.getInstructionsBuilder().createCopyingHandler(directory, element, instructionCreator)); } }
|
generateInstructions
|
2,738 |
void (JpsFileCopyPackagingElement element, ArtifactCompilerInstructionCreator instructionCreator, ArtifactInstructionsBuilderContext builderContext) { final String filePath = element.getFilePath(); if (filePath != null) { final File file = new File(filePath); final String fileName = element.getRenamedOutputFileName(); String outputFileName = fileName != null ? fileName : file.getName(); instructionCreator.addFileCopyInstruction(file, outputFileName, instructionCreator.getInstructionsBuilder().createCopyingHandler(file, element, instructionCreator)); } }
|
generateInstructions
|
2,739 |
void (JpsExtractedDirectoryPackagingElement element, ArtifactCompilerInstructionCreator instructionCreator, ArtifactInstructionsBuilderContext builderContext) { final String jarPath = element.getFilePath(); final String pathInJar = element.getPathInJar(); instructionCreator.addExtractDirectoryInstruction(new File(jarPath), pathInJar); }
|
generateInstructions
|
2,740 |
void (JpsProductionModuleOutputPackagingElement element, ArtifactCompilerInstructionCreator instructionCreator, ArtifactInstructionsBuilderContext builderContext) { generateModuleOutputInstructions(element.getOutputUrl(), instructionCreator, element); }
|
generateInstructions
|
2,741 |
void (JpsProductionModuleSourcePackagingElement element, ArtifactCompilerInstructionCreator instructionCreator, ArtifactInstructionsBuilderContext builderContext) { JpsModule module = element.getModuleReference().resolve(); if (module != null) { List<JpsModuleSourceRoot> productionSources = ContainerUtil.filter(module.getSourceRoots(), root -> JavaModuleSourceRootTypes.PRODUCTION.contains(root.getRootType())); generateModuleSourceInstructions(productionSources, instructionCreator, element); } }
|
generateInstructions
|
2,742 |
void (JpsTestModuleOutputPackagingElement element, ArtifactCompilerInstructionCreator instructionCreator, ArtifactInstructionsBuilderContext builderContext) { generateModuleOutputInstructions(element.getOutputUrl(), instructionCreator, element); }
|
generateInstructions
|
2,743 |
void (JpsComplexPackagingElement element, ArtifactCompilerInstructionCreator instructionCreator, ArtifactInstructionsBuilderContext builderContext) { generateSubstitutionInstructions(element, instructionCreator, builderContext); }
|
generateInstructions
|
2,744 |
void (JpsArtifactOutputPackagingElement element, ArtifactCompilerInstructionCreator instructionCreator, ArtifactInstructionsBuilderContext builderContext) { final JpsArtifact artifact = element.getArtifactReference().resolve(); if (artifact == null) return; Set<JpsArtifact> parentArtifacts = builderContext.getParentArtifacts(); List<JpsPackagingElement> customLayout = getCustomArtifactLayout(artifact, parentArtifacts); final String outputPath = artifact.getOutputPath(); if (StringUtil.isEmpty(outputPath) || customLayout != null) { try { if (builderContext.enterArtifact(artifact)) { if (customLayout != null) { LayoutElementBuildersRegistry.this.generateInstructions(customLayout, instructionCreator, builderContext); } else { generateSubstitutionInstructions(element, instructionCreator, builderContext); } } } finally { builderContext.leaveArtifact(artifact); } return; } final JpsPackagingElement rootElement = artifact.getRootElement(); final File outputDir = new File(outputPath); if (rootElement instanceof JpsArchivePackagingElement) { final String fileName = ((JpsArchivePackagingElement)rootElement).getArchiveName(); instructionCreator.addFileCopyInstruction(new File(outputDir, fileName), fileName); } else { instructionCreator.addDirectoryCopyInstructions(outputDir); } }
|
generateInstructions
|
2,745 |
String (String outputPath, String pathInJar) { LOG.assertTrue(outputPath.length() > 0 && outputPath.charAt(outputPath.length() - 1) != '/'); return outputPath + "!/" + pathInJar; }
|
appendPathInJar
|
2,746 |
String () { return myPathInJar; }
|
getPathInJar
|
2,747 |
JarInfo () { return myJarInfo; }
|
getJarInfo
|
2,748 |
String () { return myPathInJar + "(" + getOutputPath() + ")"; }
|
toString
|
2,749 |
String () { return myOutputPath; }
|
getOutputPath
|
2,750 |
String () { return myOutputFilePath; }
|
getOutputFilePath
|
2,751 |
JarDestinationInfo (@NotNull String pathInJar) { return new JarDestinationInfo(childPathInJar(pathInJar), myJarInfo, myJarDestination); }
|
createFileDestination
|
2,752 |
void (ArtifactRootDescriptor descriptor) { myJarInfo.addContent(StringUtil.trimStart(((JarDestinationInfo)descriptor.getDestinationInfo()).getPathInJar(), "/"), descriptor); }
|
onAdded
|
2,753 |
String (String fileName) { return myPathInJar.length() == 0 ? fileName : myPathInJar + "/" + fileName; }
|
childPathInJar
|
2,754 |
PackIntoArchiveInstructionCreator (@NotNull String directoryName) { return new PackIntoArchiveInstructionCreator(myInstructionsBuilder, myJarInfo, childPathInJar(directoryName), myJarDestination); }
|
subFolder
|
2,755 |
ArtifactCompilerInstructionCreator (@NotNull String archiveFileName) { final JarDestinationInfo destination = createFileDestination(archiveFileName); final JarInfo jarInfo = new JarInfo(destination); final String outputPath = myJarDestination.getOutputPath() + "/" + archiveFileName; if (!myInstructionsBuilder.registerJarFile(jarInfo, outputPath)) { return new SkipAllInstructionCreator(myInstructionsBuilder); } myJarInfo.addJar(destination.getPathInJar(), jarInfo); return new PackIntoArchiveInstructionCreator(myInstructionsBuilder, jarInfo, "", destination); }
|
archive
|
2,756 |
IgnoredFileIndex () { return myIgnoredFileIndex; }
|
getIgnoredFileIndex
|
2,757 |
boolean (@NotNull ArtifactRootDescriptor descriptor) { myDescriptors.add(descriptor); return true; }
|
addDestination
|
2,758 |
ModuleExcludeIndex () { return myRootsIndex; }
|
getRootsIndex
|
2,759 |
boolean (@NotNull JarInfo jarInfo, @NotNull String outputPath) { if (myJarByPath.containsKey(outputPath)) { return false; } myJarByPath.put(outputPath, jarInfo); return true; }
|
registerJarFile
|
2,760 |
List<ArtifactRootDescriptor> () { return myDescriptors; }
|
getDescriptors
|
2,761 |
FileBasedArtifactRootDescriptor (@NotNull File file, @NotNull SourceFileFilter filter, final @NotNull DestinationInfo destinationInfo, FileCopyingHandler handler) { return new FileBasedArtifactRootDescriptor(file, filter, myRootIndex++, myBuildTarget, destinationInfo, handler); }
|
createFileBasedRoot
|
2,762 |
FileCopyingHandler (@NotNull File file, @NotNull JpsPackagingElement contextElement, @NotNull ArtifactCompilerInstructionCreator instructionCreator) { File targetDirectory = instructionCreator.getTargetDirectory(); if (targetDirectory != null) { for (ArtifactRootCopyingHandlerProvider provider : myCopyingHandlerProviders) { FileCopyingHandler handler = provider.createCustomHandler(myBuildTarget.getArtifact(), file, targetDirectory, contextElement, myModel, myBuildDataPaths); if (handler != null) { return handler; } } } return FilterCopyHandler.DEFAULT; }
|
createCopyingHandler
|
2,763 |
JarBasedArtifactRootDescriptor (@NotNull File jarFile, @NotNull String pathInJar, @NotNull SourceFileFilter filter, @NotNull DestinationInfo destinationInfo, @NotNull Condition<? super String> pathInJarFilter) { return new JarBasedArtifactRootDescriptor(jarFile, pathInJar, filter, myRootIndex++, myBuildTarget, destinationInfo, pathInJarFilter); }
|
createJarBasedRoot
|
2,764 |
String () { return myRoot.getPath() + JarPathUtil.JAR_SEPARATOR + myPathInJar; }
|
getFullPath
|
2,765 |
DestinationInfo (@NotNull String outputFileName) { return null; }
|
createFileDestination
|
2,766 |
void (ArtifactRootDescriptor descriptor) { }
|
onAdded
|
2,767 |
DestinationInfo () { return null; }
|
createDirectoryDestination
|
2,768 |
SkipAllInstructionCreator (@NotNull String directoryName) { return this; }
|
subFolder
|
2,769 |
SkipAllInstructionCreator (@NotNull String archiveFileName) { return this; }
|
archive
|
2,770 |
File () { return null; }
|
getTargetDirectory
|
2,771 |
DestinationInfo (@NotNull String outputFileName) { return new ExplodedDestinationInfo(myOutputPath + "/" + outputFileName); }
|
createFileDestination
|
2,772 |
ExplodedDestinationInfo () { return new ExplodedDestinationInfo(myOutputPath); }
|
createDirectoryDestination
|
2,773 |
void (ArtifactRootDescriptor descriptor) { }
|
onAdded
|
2,774 |
CopyToDirectoryInstructionCreator (@NotNull String directoryName) { return new CopyToDirectoryInstructionCreator(myInstructionsBuilder, myOutputPath + "/" + directoryName); }
|
subFolder
|
2,775 |
ArtifactCompilerInstructionCreator (@NotNull String archiveFileName) { String jarOutputPath = myOutputPath + "/" + archiveFileName; final ExplodedDestinationInfo destination = new ExplodedDestinationInfo(jarOutputPath); final JarInfo jarInfo = new JarInfo(destination); if (!myInstructionsBuilder.registerJarFile(jarInfo, jarOutputPath)) { return new SkipAllInstructionCreator(myInstructionsBuilder); } return new PackIntoArchiveInstructionCreator(myInstructionsBuilder, jarInfo, "", destination); }
|
archive
|
2,776 |
void (@NotNull File directoryUrl) { addDirectoryCopyInstructions(directoryUrl, null); }
|
addDirectoryCopyInstructions
|
2,777 |
void (@NotNull File directory, @Nullable SourceFileFilter filter) { addDirectoryCopyInstructions(directory, filter, FilterCopyHandler.DEFAULT); }
|
addDirectoryCopyInstructions
|
2,778 |
void (@NotNull File directory, @Nullable SourceFileFilter filter, @NotNull FileCopyingHandler copyingHandler) { final boolean copyExcluded = myInstructionsBuilder.getRootsIndex().isExcluded(directory); SourceFileFilter fileFilter = new SourceFileFilterImpl(filter, myInstructionsBuilder.getRootsIndex(), myInstructionsBuilder.getIgnoredFileIndex(), copyExcluded); DestinationInfo destination = createDirectoryDestination(); if (destination != null) { ArtifactRootDescriptor descriptor = myInstructionsBuilder.createFileBasedRoot(directory, fileFilter, destination, copyingHandler); if (myInstructionsBuilder.addDestination(descriptor)) { onAdded(descriptor); } } }
|
addDirectoryCopyInstructions
|
2,779 |
void (@NotNull File jarFile, @NotNull String pathInJar) { addExtractDirectoryInstruction(jarFile, pathInJar, Conditions.alwaysTrue()); }
|
addExtractDirectoryInstruction
|
2,780 |
void (@NotNull File jarFile, @NotNull String pathInJar, @NotNull Condition<? super String> pathInJarFilter) { //an entry of a jar file is excluded if and only if the jar file itself is excluded. In that case we should unpack entries to the artifact //because the jar itself is explicitly added to the artifact layout. final SourceFileFilterImpl filter = new SourceFileFilterImpl(null, myInstructionsBuilder.getRootsIndex(), myInstructionsBuilder.getIgnoredFileIndex(), true); DestinationInfo destination = createDirectoryDestination(); if (destination != null) { ArtifactRootDescriptor descriptor = myInstructionsBuilder.createJarBasedRoot(jarFile, pathInJar, filter, destination, pathInJarFilter); if (myInstructionsBuilder.addDestination(descriptor)) { onAdded(descriptor); } } }
|
addExtractDirectoryInstruction
|
2,781 |
ArtifactCompilerInstructionCreator (@NotNull String relativeDirectoryPath) { final List<String> folders = StringUtil.split(relativeDirectoryPath, "/"); ArtifactCompilerInstructionCreator current = this; for (String folder : folders) { current = current.subFolder(folder); } return current; }
|
subFolderByRelativePath
|
2,782 |
void (@NotNull File file, @NotNull String outputFileName) { addFileCopyInstruction(file, outputFileName, FilterCopyHandler.DEFAULT); }
|
addFileCopyInstruction
|
2,783 |
void (@NotNull File file, @NotNull String outputFileName, @NotNull FileCopyingHandler copyingHandler) { DestinationInfo destination = createFileDestination(outputFileName); if (destination != null) { FileBasedArtifactRootDescriptor root = myInstructionsBuilder.createFileBasedRoot(file, SourceFileFilter.ALL, destination, copyingHandler); if (myInstructionsBuilder.addDestination(root)) { onAdded(root); } } }
|
addFileCopyInstruction
|
2,784 |
ArtifactInstructionsBuilder () { return myInstructionsBuilder; }
|
getInstructionsBuilder
|
2,785 |
boolean (@NotNull String fullFilePath) { if (myBaseFilter != null && !myBaseFilter.accept(fullFilePath)) return false; if (myIgnoredFileIndex.isIgnored(PathUtilRt.getFileName(fullFilePath))) { return false; } if (!myIncludeExcluded) { final File file = JarPathUtil.getLocalFile(fullFilePath); if (myRootsIndex.isExcluded(file)) { return false; } } return true; }
|
accept
|
2,786 |
JpsModel () { return myModel; }
|
getModel
|
2,787 |
BuildDataPaths () { return myDataPaths; }
|
getDataPaths
|
2,788 |
boolean (JpsArtifact artifact) { return myParentArtifacts.add(artifact); }
|
enterArtifact
|
2,789 |
Set<JpsArtifact> () { return myParentArtifacts; }
|
getParentArtifacts
|
2,790 |
void (JpsArtifact artifact) { myParentArtifacts.remove(artifact); }
|
leaveArtifact
|
2,791 |
void (@NotNull PrintWriter out) { }
|
writeConfiguration
|
2,792 |
FileFilter () { return myFilter; }
|
createFileFilter
|
2,793 |
boolean (@NotNull String fullFilePath) { return true; }
|
accept
|
2,794 |
boolean (@NotNull String fullFilePath, ProjectDescriptor projectDescriptor) { return true; }
|
shouldBeCopied
|
2,795 |
String () { return getFullPath(); }
|
toString
|
2,796 |
void (PrintWriter out, PathRelativizerService relativizer) { out.println(relativizer.toRelative(getFullPath())); out.println("->" + relativizer.toRelative(myDestinationInfo.getOutputPath())); }
|
writeConfiguration
|
2,797 |
ArtifactBuildTarget () { return myTarget; }
|
getTarget
|
2,798 |
FileFilter () { return file -> myFilter.accept(file.getAbsolutePath()); }
|
createFileFilter
|
2,799 |
File () { return myRoot; }
|
getRootFile
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.