Datasets:
Mlxa
/
java_methods

Dataset card Data Studio Files
xet
Community
1
Unnamed: 0
int64
0
305k
body
stringlengths
7
52.9k
name
stringlengths
1
185
2,200
boolean (K key) { try { return myMap.containsMapping(key); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }
containsKey
2,201
C (K key) { try { C col = myMap.get(key); return col != null? col : myEmptyCollection; } catch (IOException e) { throw new BuildDataCorruptedException(e); } }
get
2,202
void (K key, @NotNull Iterable<? extends V> values) { try { //noinspection unchecked C data = ensureCollection(values); if (data.isEmpty()) { myMap.remove(key); } else { myMap.put(key, data); } } catch (IOException e) { throw new BuildDataCorruptedException(e); } }
put
2,203
C (Iterable<? extends V> seq) { if (myEmptyCollection instanceof Set && seq instanceof Set) { return (C)seq; } if (myEmptyCollection instanceof List && seq instanceof List) { return (C)seq; } return Iterators.collect(seq, myCollectionFactory.get()); }
ensureCollection
2,204
void (K key) { try { myMap.remove(key); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }
remove
2,205
void (K key, V value) { appendValues(key, Collections.singleton(value)); }
appendValue
2,206
void (K key, @NotNull Iterable<? extends V> values) { try { myMap.appendData(key, new AppendablePersistentMap.ValueDataAppender() { @Override public void append(@NotNull DataOutput out) throws IOException { for (V v : values) { myValuesExternalizer.save(out, v); } } }); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }
appendValues
2,207
void (K key, V value) { removeValues(key, Collections.singleton(value)); }
removeValue
2,208
void (K key, @NotNull Iterable<? extends V> values) { try { C collection = get(key); if (!collection.isEmpty()) { boolean changes = false; for (V value : values) { changes |= collection.remove(value); } if (changes) { if (collection.isEmpty()) { myMap.remove(key); } else { myMap.put(key, collection); } } } } catch (IOException e) { throw new BuildDataCorruptedException(e); } }
removeValues
2,209
Iterable<K> () { try { return myMap.getAllKeysWithExistingMapping(); } catch (IOException e) { throw new RuntimeException(e); } }
getKeys
2,210
void () { try { myMap.close(); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }
close
2,211
Set<NodeSource> () { return myBaseSources; }
getBaseSources
2,212
Set<NodeSource> () { return myDeletedSources; }
getDeletedSources
2,213
void (@NotNull Node<?, ?> node, @NotNull Iterable<NodeSource> sources) { ReferenceID nodeID = node.getReferenceID(); for (NodeSource src : sources) { myNodeToSourcesMap.appendValue(nodeID, src); mySourceToNodesMap.appendValue(src, node); } // deduce dependencies for (BackDependencyIndex index : getIndices()) { index.indexNode(node); } }
associate
2,214
boolean (K key) { return myMap.containsKey(key); }
containsKey
2,215
void (K key, V value) { myMap.put(key, value); }
put
2,216
void (K key) { myMap.remove(key); }
remove
2,217
Iterable<K> () { return myMap.keySet(); }
getKeys
2,218
void () { myMap.clear(); }
close
2,219
Path () { return myPath; }
getPath
2,220
boolean (Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final FileSource that = (FileSource)o; if (!myPath.equals(that.myPath)) { return false; } return true; }
equals
2,221
int () { return myPath.hashCode(); }
hashCode
2,222
String () { return "NodeSource {" + myPath + "}"; }
toString
2,223
Iterable<ReferenceID> (Node<?, ?> node) { ReferenceID nodeID = node.getReferenceID(); return Iterators.unique(Iterators.map(Iterators.filter(node.getUsages(), u -> !nodeID.equals(u.getElementOwner())), u -> u.getElementOwner())); }
getIndexedDependencies
2,224
DifferentiateResult (Delta delta, DifferentiateParameters params) { Iterable<NodeSource> deltaSources = delta.getSources(); Set<NodeSource> allProcessedSources = Iterators.collect(Iterators.flat(Arrays.asList(delta.getBaseSources(), deltaSources, delta.getDeletedSources())), new HashSet<>()); Set<Node<?, ?>> nodesBefore = Iterators.collect(Iterators.flat(Iterators.map(allProcessedSources, s -> getNodes(s))), Containers.createCustomPolicySet(DiffCapable::isSame, DiffCapable::diffHashCode)); Set<Node<?, ?>> nodesAfter = Iterators.collect(Iterators.flat(Iterators.map(deltaSources, s -> delta.getNodes(s))), Containers.createCustomPolicySet(DiffCapable::isSame, DiffCapable::diffHashCode)); // do not process 'removed' per-source file. This works when a class comes from exactly one source, but might not work, if a class can be associated with several sources // better make a node-diff over all compiled sources => the sets of removed, added, deleted _nodes_ will be more accurate and reflecting reality List<Node<?, ?>> deletedNodes = Iterators.collect(Iterators.filter(nodesBefore, n -> !nodesAfter.contains(n)), new ArrayList<>()); if (!params.isCalculateAffected()) { return new DifferentiateResult() { @Override public Delta getDelta() { return delta; } @Override public Iterable<Node<?, ?>> getDeletedNodes() { return deletedNodes; } @Override public Iterable<NodeSource> getAffectedSources() { return Collections.emptyList(); } }; } var diffContext = new DifferentiateContext() { private final Predicate<Node<?, ?>> ANY_CONSTRAINT = node -> true; final Set<NodeSource> compiledSources = deltaSources instanceof Set? (Set<NodeSource>)deltaSources : Iterators.collect(deltaSources, new HashSet<>()); final Map<Usage, Predicate<Node<?, ?>>> affectedUsages = new HashMap<>(); final Set<BiPredicate<Node<?, ?>, Usage>> usageQueries = new HashSet<>(); final Set<NodeSource> affectedSources = new HashSet<>(); @Override public DifferentiateParameters getParams() { return params; } @Override public @NotNull Graph getGraph() { return DependencyGraphImpl.this; } @Override public @NotNull Delta getDelta() { return delta; } @Override public boolean isCompiled(NodeSource src) { return compiledSources.contains(src); } @Override public void affectUsage(@NotNull Usage usage) { affectedUsages.put(usage, ANY_CONSTRAINT); } @Override public void affectUsage(@NotNull Usage usage, @NotNull Predicate<Node<?, ?>> constraint) { Predicate<Node<?, ?>> prevConstraint = affectedUsages.put(usage, constraint); if (prevConstraint != null) { affectedUsages.put(usage, prevConstraint == ANY_CONSTRAINT? ANY_CONSTRAINT : prevConstraint.or(constraint)); } } @Override public void affectUsage(@NotNull BiPredicate<Node<?, ?>, Usage> usageQuery) { usageQueries.add(usageQuery); } @Override public void affectNodeSource(@NotNull NodeSource source) { affectedSources.add(source); } boolean isNodeAffected(Node<?, ?> node) { for (Usage usage : node.getUsages()) { Predicate<Node<?, ?>> constraint = affectedUsages.get(usage); if (constraint != null && constraint.test(node)) { return true; } for (BiPredicate<Node<?, ?>, Usage> query : usageQueries) { if (query.test(node, usage)) { return true; } } } return false; } }; boolean incremental = true; for (DifferentiateStrategy diffStrategy : ourDifferentiateStrategies) { if (!diffStrategy.differentiate(diffContext, nodesBefore, nodesAfter)) { incremental = false; break; } } if (!incremental) { return DifferentiateResult.createNonIncremental(delta, deletedNodes); } Set<NodeSource> affectedSources = new HashSet<>(); Set<ReferenceID> dependingOnDeleted = Iterators.collect(Iterators.flat(Iterators.map(deletedNodes, n -> getDependingNodes(n.getReferenceID()))), new HashSet<>()); for (ReferenceID dep : dependingOnDeleted) { for (NodeSource src : getSources(dep)) { affectedSources.add(src); } } Iterable<ReferenceID> changedScopeNodes = Iterators.unique(Iterators.flat(Iterators.map(nodesAfter, n -> n.getReferenceID()), Iterators.map(diffContext.affectedUsages.keySet(), u -> u.getElementOwner()))); for (ReferenceID dependent : Iterators.unique(Iterators.filter(Iterators.flat(Iterators.map(changedScopeNodes, id -> getDependingNodes(id))), id -> !dependingOnDeleted.contains(id)))) { for (NodeSource depSrc : getSources(dependent)) { if (!affectedSources.contains(depSrc)) { boolean affectSource = false; for (var depNode : getNodes(depSrc)) { if (diffContext.isNodeAffected(depNode)) { affectSource = true; for (DifferentiateStrategy strategy : ourDifferentiateStrategies) { if (!strategy.isIncremental(diffContext, depNode)) { return DifferentiateResult.createNonIncremental(delta, deletedNodes); } } } } if (affectSource) { affectedSources.add(depSrc); } } } } // do not include sources that were already compiled affectedSources.removeAll(allProcessedSources); // ensure sources explicitly marked by strategies are affected, even if these sources were compiled initially affectedSources.addAll(diffContext.affectedSources); return new DifferentiateResult() { @Override public Delta getDelta() { return delta; } @Override public Iterable<Node<?, ?>> getDeletedNodes() { return deletedNodes; } @Override public Iterable<NodeSource> getAffectedSources() { return affectedSources; } }; }
differentiate
2,225
Delta () { return delta; }
getDelta
2,226
Iterable<NodeSource> () { return Collections.emptyList(); }
getAffectedSources
2,227
DifferentiateParameters () { return params; }
getParams
2,228
Graph () { return DependencyGraphImpl.this; }
getGraph
2,229
Delta () { return delta; }
getDelta
2,230
boolean (NodeSource src) { return compiledSources.contains(src); }
isCompiled
2,231
void (@NotNull Usage usage) { affectedUsages.put(usage, ANY_CONSTRAINT); }
affectUsage
2,232
void (@NotNull Usage usage, @NotNull Predicate<Node<?, ?>> constraint) { Predicate<Node<?, ?>> prevConstraint = affectedUsages.put(usage, constraint); if (prevConstraint != null) { affectedUsages.put(usage, prevConstraint == ANY_CONSTRAINT? ANY_CONSTRAINT : prevConstraint.or(constraint)); } }
affectUsage
2,233
void (@NotNull BiPredicate<Node<?, ?>, Usage> usageQuery) { usageQueries.add(usageQuery); }
affectUsage
2,234
void (@NotNull NodeSource source) { affectedSources.add(source); }
affectNodeSource
2,235
Delta () { return delta; }
getDelta
2,236
Iterable<NodeSource> () { return affectedSources; }
getAffectedSources
2,237
void (@NotNull DifferentiateResult diffResult) { final Delta delta = diffResult.getDelta(); // handle deleted nodes and sources if (!Iterators.isEmpty(diffResult.getDeletedNodes())) { Set<NodeSource> differentiatedSources = Iterators.collect(Iterators.flat(List.of(delta.getBaseSources(), delta.getSources(), delta.getDeletedSources())), new HashSet<>()); for (var deletedNode : diffResult.getDeletedNodes()) { // the set of deleted nodes includes ones corresponding to deleted sources Set<NodeSource> nodeSources = Iterators.collect(myNodeToSourcesMap.get(deletedNode.getReferenceID()), new HashSet<>()); nodeSources.removeAll(differentiatedSources); if (nodeSources.isEmpty()) { myNodeToSourcesMap.remove(deletedNode.getReferenceID()); } else { myNodeToSourcesMap.put(deletedNode.getReferenceID(), nodeSources); } } } for (NodeSource deletedSource : delta.getDeletedSources()) { mySourceToNodesMap.remove(deletedSource); } var updatedNodes = Iterators.collect(Iterators.flat(Iterators.map(delta.getSources(), s -> getNodes(s))), new HashSet<>()); for (BackDependencyIndex index : getIndices()) { BackDependencyIndex deltaIndex = delta.getIndex(index.getName()); assert deltaIndex != null; index.integrate(diffResult.getDeletedNodes(), updatedNodes, deltaIndex); } var deltaNodes = Iterators.unique(Iterators.map(Iterators.flat(Iterators.map(delta.getSources(), s -> delta.getNodes(s))), node -> node.getReferenceID())); for (ReferenceID nodeID : deltaNodes) { Set<NodeSource> sources = Iterators.collect(myNodeToSourcesMap.get(nodeID), new HashSet<>()); sources.removeAll(delta.getBaseSources()); Iterators.collect(delta.getSources(nodeID), sources); myNodeToSourcesMap.put(nodeID, sources); } for (NodeSource src : delta.getSources()) { mySourceToNodesMap.put(src, delta.getNodes(src)); } }
integrate
2,238
Set<NodeSource> (Iterable<NodeSource> sources, Iterable<NodeSource> deletedSources) { // ensure initial sources are in the result Set<NodeSource> result = Iterators.collect(sources, new HashSet<>()); // todo: check if a special hashing-policy set is required here Set<NodeSource> deleted = Iterators.collect(deletedSources, new HashSet<>()); Set<Node<?, ?>> affectedNodes = Iterators.collect(Iterators.flat(Iterators.map(Iterators.flat(result, deleted), s -> getNodes(s))), new HashSet<>()); for (var node : affectedNodes) { Iterators.collect(Iterators.filter(getSources(node.getReferenceID()), s -> !result.contains(s) && !deleted.contains(s) && Iterators.filter(getNodes(s).iterator(), affectedNodes::contains).hasNext()), result); } return result; }
completeSourceSet
2,239
boolean (K key) { return myDelegate.containsKey(key); }
containsKey
2,240
Iterable<V> (K key) { return myCache.get(key); }
get
2,241
void (K key, @NotNull Iterable<? extends V> values) { myCache.invalidate(key); myDelegate.put(key, values); }
put
2,242
void (K key) { myCache.invalidate(key); myDelegate.remove(key); }
remove
2,243
void (K key, V value) { appendValues(key, Collections.singleton(value)); }
appendValue
2,244
void (K key, @NotNull Iterable<? extends V> values) { if (!Iterators.isEmpty(values)) { myCache.invalidate(key); myDelegate.appendValues(key, values); } }
appendValues
2,245
void (K key, V value) { removeValues(key, Collections.singleton(value)); }
removeValue
2,246
void (K key, @NotNull Iterable<? extends V> values) { if (Iterators.isEmpty(values)) { return; } Iterable<V> currentData = myCache.get(key); Collection<V> collection = currentData instanceof Collection? (Collection<V>)currentData : Iterators.collect(currentData, new SmartList<>()); if (!collection.isEmpty()) { boolean changes = false; for (V value : values) { changes |= collection.remove(value); } if (changes) { myCache.invalidate(key); if (collection.isEmpty()) { myDelegate.remove(key); } else { myDelegate.put(key, collection); } } } }
removeValues
2,247
Iterable<K> () { return myDelegate.getKeys(); }
getKeys
2,248
DataInput (DataInput in) { return new GraphDataInput(in); }
wrap
2,249
DataInput (DataInput in, StringEnumerator enumerator) { return new GraphDataInput(in) { @Override public @NotNull String readUTF() throws IOException { return enumerator.toString(readInt()); } }; }
wrap
2,250
boolean (K key) { try { return myMap.containsMapping(key); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }
containsKey
2,251
void (K key, V value) { try { if (value == null) { myMap.remove(key); } else { myMap.put(key, value); } } catch (IOException e) { throw new BuildDataCorruptedException(e); } }
put
2,252
void (K key) { try { myMap.remove(key); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }
remove
2,253
Iterable<K> () { try { return myMap.getAllKeysWithExistingMapping(); } catch (IOException e) { throw new RuntimeException(e); } }
getKeys
2,254
void (BackDependencyIndex index) { myIndices.add(index); }
addIndex
2,255
Iterable<ReferenceID> (@NotNull ReferenceID id) { return myDependencyIndex.getDependencies(id); }
getDependingNodes
2,256
Iterable<BackDependencyIndex> () { return myIndices; }
getIndices
2,257
Iterable<NodeSource> (@NotNull ReferenceID id) { return myNodeToSourcesMap.get(id); }
getSources
2,258
Iterable<ReferenceID> () { return myNodeToSourcesMap.getKeys(); }
getRegisteredNodes
2,259
Iterable<NodeSource> () { return mySourceToNodesMap.getKeys(); }
getSources
2,260
void (@NotNull FileGeneratedEvent event) { final ProjectDescriptor pd = myContext.getProjectDescriptor(); final BuildFSState fsState = pd.fsState; for (Pair<String, String> pair : event.getPaths()) { final String relativePath = pair.getSecond(); final File file = relativePath.equals(".") ? new File(pair.getFirst()) : new File(pair.getFirst(), relativePath); for (BuildRootDescriptor desc : pd.getBuildRootIndex().findAllParentDescriptors(file, myContext)) { if (!event.getSourceTarget().equals(desc.getTarget())) { // do not mark files belonging to the target that originated the event // It is assumed that those files will be explicitly marked dirty by particular builder, if needed. try { fsState.markDirty(myContext, file, desc, pd.getProjectStamps().getStampStorage(), false); } catch (IOException ignored) { } } } } }
filesGenerated
2,261
void (@NotNull FileDeletedEvent event) { final BuildFSState state = myContext.getProjectDescriptor().fsState; final BuildRootIndex rootsIndex = myContext.getProjectDescriptor().getBuildRootIndex(); for (String path : event.getFilePaths()) { final File file = new File(FileUtil.toSystemDependentName(path)); for (BuildRootDescriptor desc : rootsIndex.findAllParentDescriptors(file, myContext)) { state.registerDeleted(myContext, desc.getTarget(), file); } } }
filesDeleted
2,262
ProfilingMode () { String profilingModeString = System.getProperty(PROFILING_MODE_PROPERTY, "false"); switch (profilingModeString) { case "false": return ProfilingMode.NONE; case "true": return ProfilingMode.YOURKIT_SAMPLING; case "tracing": return ProfilingMode.YOURKIT_TRACING; default: throw new IllegalArgumentException("Invalid value of '" + PROFILING_MODE_PROPERTY + "' system property (accepting only 'false', 'true', 'tracing'): " + profilingModeString); } }
getProfilingMode
2,263
File () { return ourSystemRoot; }
getSystemRoot
2,264
void (@NotNull File systemRoot) { ourSystemRoot = systemRoot; }
setSystemRoot
2,265
File (@NotNull String projectPath) { return getDataStorageRoot(ourSystemRoot, projectPath); }
getDataStorageRoot
2,266
File (@NotNull File systemRoot, @NotNull String projectPath) { return getDataStorageRoot(systemRoot, projectPath, s -> s.hashCode()); }
getDataStorageRoot
2,267
File (@NotNull File systemRoot, @NotNull String projectPath, @NotNull Function<? super String, Integer> hashFunction) { projectPath = FileUtil.toCanonicalPath(projectPath); String name; final int locationHash; final Path rootFile = Paths.get(projectPath); if (!Files.isDirectory(rootFile) && projectPath.endsWith(".ipr")) { name = StringUtil.trimEnd(rootFile.getFileName().toString(), ".ipr"); locationHash = hashFunction.apply(projectPath); } else { Path directoryBased; if (rootFile.endsWith(PathMacroUtil.DIRECTORY_STORE_NAME)) { directoryBased = rootFile; } else { directoryBased = rootFile.resolve(PathMacroUtil.DIRECTORY_STORE_NAME); } name = PathUtilRt.suggestFileName(JpsProjectLoader.getDirectoryBaseProjectName(directoryBased)); locationHash = hashFunction.apply(directoryBased.toString()); } return new File(systemRoot, StringUtil.toLowerCase(name) + "_" + Integer.toHexString(locationHash)); }
getDataStorageRoot
2,268
boolean (CompileContext context) { return ERRORS_DETECTED_KEY.get(context, Boolean.FALSE); }
errorsDetected
2,269
String (long duration) { return StringUtil.formatDuration(duration); }
formatDuration
2,270
int () { //final JpsProject project = context.getProjectDescriptor().getProject(); //final JpsJavaCompilerConfiguration config = JpsJavaExtensionService.getInstance().getOrCreateCompilerConfiguration(project); //final JpsJavaCompilerOptions options = config.getCurrentCompilerOptions(); //return options.MAXIMUM_HEAP_SIZE; if (FORKED_JAVAC_HEAP_SIZE_MB > 0) { return FORKED_JAVAC_HEAP_SIZE_MB; } final int maxMbytes = (int)(Runtime.getRuntime().maxMemory() / 1048576L); if (maxMbytes < 0 || maxMbytes > 1500) { return -1; // in the size is too big for older VMs or int overflow, return -1 to let VM choose the heap size } return Math.max(maxMbytes, 256); // per-forked process: minimum 256 Mb }
suggestForkedCompilerHeapSize
2,271
Runnable (int count, Runnable operation) { return new Runnable() { private final AtomicInteger myCounter = new AtomicInteger(count); @Override public void run() { int currentVal = myCounter.decrementAndGet(); if (currentVal % count == 0) { try { operation.run(); } finally { while (currentVal <= 0 && !myCounter.compareAndSet(currentVal, count + (currentVal % count))) { // restore the counter currentVal = myCounter.get(); } } } } }; }
asCountedRunnable
2,272
void () { int currentVal = myCounter.decrementAndGet(); if (currentVal % count == 0) { try { operation.run(); } finally { while (currentVal <= 0 && !myCounter.compareAndSet(currentVal, count + (currentVal % count))) { // restore the counter currentVal = myCounter.get(); } } } }
run
2,273
boolean (Iterable<? extends JavaBuilderExtension> builders, File file) { for (JavaBuilderExtension extension : builders) { if (extension.shouldHonorFileEncodingForCompilation(file)) { return true; } } return false; }
shouldHonorEncodingForCompilation
2,274
String (JpsModule module) { final Set<String> encodings = getModuleCharsetMap().get(module); return ContainerUtil.getFirstItem(encodings, null); }
getPreferredModuleEncoding
2,275
Set<String> (@NotNull ModuleChunk moduleChunk) { final Map<JpsModule, Set<String>> map = getModuleCharsetMap(); Set<String> encodings = new HashSet<>(); for (JpsModule module : moduleChunk.getModules()) { final Set<String> moduleEncodings = map.get(module); if (moduleEncodings != null) { encodings.addAll(moduleEncodings); } } return encodings; }
getAllModuleChunkEncodings
2,276
boolean (@NotNull BuildTarget<?> target) { return isWholeTargetAffected(target) || myFiles.containsKey(target) || myIndirectlyAffectedFiles.containsKey(target); }
isAffected
2,277
boolean (@NotNull BuildTarget<?> target) { return (myTypes.contains(target.getTargetType()) || myTargets.contains(target) || isAffectedByAssociatedModule(target)) && !myFiles.containsKey(target); }
isWholeTargetAffected
2,278
boolean (@NotNull BuildTargetType<?> type) { return myTypes.contains(type) && myFiles.isEmpty(); }
isAllTargetsOfTypeAffected
2,279
boolean (@NotNull BuildTarget<?> target) { return myFiles.isEmpty() && myTypesToForceBuild.contains(target.getTargetType()) && isWholeTargetAffected(target); }
isBuildForced
2,280
boolean (@NotNull BuildTargetType<?> targetType) { return myTypesToForceBuild.contains(targetType) && isAllTargetsOfTypeAffected(targetType); }
isBuildForcedForAllTargets
2,281
boolean (@NotNull BuildTargetType<?> targetType) { return !myTypesToForceBuild.contains(targetType); }
isBuildIncrementally
2,282
boolean (BuildTarget<?> target, @NotNull File file) { final Set<File> files = myFiles.isEmpty()? null : myFiles.get(target); if (files == null) { return isWholeTargetAffected(target) || isIndirectlyAffected(target, file); } return files.contains(file) || isIndirectlyAffected(target, file); }
isAffected
2,283
boolean (BuildTarget<?> target, @NotNull File file) { synchronized (myIndirectlyAffectedFiles) { final Set<File> indirect = myIndirectlyAffectedFiles.get(target); return indirect != null && indirect.contains(file); } }
isIndirectlyAffected
2,284
void (BuildTarget<?> target, @NotNull File file) { synchronized (myIndirectlyAffectedFiles) { Set<File> files = myIndirectlyAffectedFiles.get(target); if (files == null) { files = new HashSet<>(); myIndirectlyAffectedFiles.put(target, files); } files.add(file); } }
markIndirectlyAffected
2,285
boolean (BuildTarget<?> target) { if (target instanceof ModuleBasedTarget) { final JpsModule module = ((ModuleBasedTarget<?>)target).getModule(); // this target is associated with module JavaModuleBuildTargetType targetType = JavaModuleBuildTargetType.getInstance(((ModuleBasedTarget<?>)target).isTests()); if (myTypes.contains(targetType) || myTargets.contains(new ModuleBuildTarget(module, targetType))) { return true; } } return false; }
isAffectedByAssociatedModule
2,286
File () { return myOutputFile; }
getOutputFile
2,287
Collection<File> () { return mySourceFiles; }
getSourceFiles
2,288
List<String> () { return ContainerUtil.map(mySourceFiles, file -> file.getPath()); }
getSourceFilesPaths
2,289
BinaryContent () { return myContent; }
getContent
2,290
void (@NotNull BinaryContent content) { myContent = content; myIsDirty = true; }
setContent
2,291
boolean () { return myIsDirty; }
isDirty
2,292
boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; CompiledClass aClass = (CompiledClass)o; if (!FileUtil.filesEqual(myOutputFile, aClass.myOutputFile)) return false; return true; }
equals
2,293
int () { return FileUtil.fileHashCode(myOutputFile); }
hashCode
2,294
String () { return "CompiledClass{" + "myOutputFile=" + myOutputFile + ", mySourceFiles=" + mySourceFiles + ", myIsDirty=" + myIsDirty + '}'; }
toString
2,295
String () { return getModule().getName(); }
getId
2,296
Set<File> (File root, ModuleExcludeIndex index) { final Collection<File> moduleExcludes = index.getModuleExcludes(getModule()); if (moduleExcludes.isEmpty()) { return Collections.emptySet(); } final Set<File> excludes = FileCollectionFactory.createCanonicalFileSet(); for (File excluded : moduleExcludes) { if (FileUtil.isAncestor(root, excluded, true)) { excludes.add(excluded); } } return excludes; }
computeRootExcludes
2,297
R (@NotNull String rootId, @NotNull BuildRootIndex rootIndex) { final List<R> descriptors = rootIndex.getRootDescriptors( new File(rootId), Collections.singletonList((BuildTargetType<? extends JVMModuleBuildTarget<R>>)getTargetType()), null ); return ContainerUtil.getFirstItem(descriptors); }
findRootDescriptor
2,298
void (BuildMessage msg) { }
processMessage
2,299
boolean (@NotNull String path, @NotNull Collection<? super String> deletedPaths, @Nullable Set<? super File> parentDirs) { File file = new File(path); boolean deleted = deleteRecursively(file, deletedPaths); if (deleted && parentDirs != null) { File parent = file.getParentFile(); if (parent != null) { parentDirs.add(parent); } } return deleted; }
deleteRecursively