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
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.