Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
240,900 | void (@NotNull String line, @NotNull Key outputType) { if (outputType == ProcessOutputTypes.STDERR) { LOG.warn(line); } if (outputType != ProcessOutputTypes.STDOUT || myIsShuttingDown) { return; } if (LOG.isTraceEnabled()) LOG.trace(">> " + line); if (myLastOp == null) { WatcherOp watcherOp; try { watcherOp = WatcherOp... | notifyTextAvailable |
240,901 | void () { Set<Pair<String, String>> pairs = new HashSet<>(); for (int i = 0; i < myLines.size() - 1; i += 2) { pairs.add(Pair.create(myLines.get(i), myLines.get(i + 1))); } myNotificationSink.notifyMapping(pairs); } | processRemap |
240,902 | void () { myIgnoredRoots.addAll(myLines); myNotificationSink.notifyManualWatchRoots(NativeFileWatcherImpl.this, myLines); } | processUnwatchable |
240,903 | void (String path, WatcherOp op) { if (SystemInfo.isWindows && op == WatcherOp.RECDIRTY) { myNotificationSink.notifyReset(path); return; } if ((op == WatcherOp.CHANGE || op == WatcherOp.STATS) && isRepetition(path)) { if (LOG.isTraceEnabled()) LOG.trace("repetition: " + path); return; } if (SystemInfo.isMac) { path = N... | processChange |
240,904 | boolean (String path) { // debouncing subsequent notifications (happen e.g. on copying of large files); this reduces path checks at least 20% on Windows synchronized (myLastChangedPaths) { for (int i = 0; i < myLastChangedPaths.length; ++i) { int last = myLastChangedPathIndex - i - 1; if (last < 0) last += myLastChange... | isRepetition |
240,905 | void (boolean isRestart) { myShuttingDown = true; } | appWillBeClosed |
240,906 | void () { myFileWatcherExecutor.shutdown(); Future<?> lastTask = myLastTask.get(); if (lastTask != null) { lastTask.cancel(false); } try { myFileWatcherExecutor.awaitTermination(1, TimeUnit.HOURS); } catch (InterruptedException e) { LOG.error(e); } PluggableFileWatcher.EP_NAME.forEachExtensionSafe(watcher -> watcher.di... | dispose |
240,907 | boolean () { for (PluggableFileWatcher watcher : PluggableFileWatcher.EP_NAME.getIterable()) { if (watcher.isOperational()) return true; } return false; } | isOperational |
240,908 | boolean () { Future<?> lastTask = myLastTask.get(); // a new task may come after the read, but this seems to be an acceptable race if (lastTask != null && !lastTask.isDone()) { return true; } for (PluggableFileWatcher watcher : PluggableFileWatcher.EP_NAME.getIterable()) { if (watcher.isSettingRoots()) return true; } r... | isSettingRoots |
240,909 | DirtyPaths () { return myNotificationSink.getDirtyPaths(); } | getDirtyPaths |
240,910 | void (@NotNull @NlsContexts.NotificationContent String cause, @Nullable NotificationListener listener) { LOG.warn(cause); String title = IdeCoreBundle.message("watcher.slow.sync"); Notification notification = new Notification("File Watcher Messages", title, cause, NotificationType.WARNING) .setSuggestionType(true); if ... | notifyOnFailure |
240,911 | DirtyPaths () { DirtyPaths dirtyPaths = DirtyPaths.EMPTY; synchronized (myLock) { if (!myDirtyPaths.isEmpty()) { dirtyPaths = myDirtyPaths; myDirtyPaths = new DirtyPaths(); } } PluggableFileWatcher.EP_NAME.forEachExtensionSafe(watcher -> watcher.resetChangedPaths()); return dirtyPaths; } | getDirtyPaths |
240,912 | void (@NotNull PluggableFileWatcher watcher, @NotNull Collection<String> roots) { Set<String> rootSet = myManualWatchRoots.computeIfAbsent(watcher, k -> new HashSet<>()); synchronized (rootSet) { rootSet.addAll(roots); } notifyOnEvent(OTHER); } | notifyManualWatchRoots |
240,913 | void (@NotNull Collection<? extends Pair<String, String>> mapping) { if (!mapping.isEmpty()) { myPathMap.addMapping(mapping); } notifyOnEvent(OTHER); } | notifyMapping |
240,914 | void (@NotNull String path) { Collection<String> paths = myPathMap.mapToOriginalWatchRoots(path, true); if (!paths.isEmpty()) { synchronized (myLock) { for (String eachPath : paths) { myDirtyPaths.addDirtyPath(eachPath); } } } notifyOnEvent(path); } | notifyDirtyPath |
240,915 | void (@NotNull String path) { Collection<String> paths = myPathMap.mapToOriginalWatchRoots(path, true); if (!paths.isEmpty()) { synchronized (myLock) { for (String p : paths) { myDirtyPaths.addDirtyPathRecursive(p); String parentPath = new File(p).getParent(); if (parentPath != null) { myDirtyPaths.addDirtyPath(parentP... | notifyPathCreatedOrDeleted |
240,916 | void (@NotNull String path) { Collection<String> paths = myPathMap.mapToOriginalWatchRoots(path, false); if (!paths.isEmpty()) { synchronized (myLock) { myDirtyPaths.dirtyDirectories.addAll(paths); } } notifyOnEvent(path); } | notifyDirtyDirectory |
240,917 | void (@NotNull String path) { Collection<String> paths = myPathMap.mapToOriginalWatchRoots(path, false); if (!paths.isEmpty()) { synchronized (myLock) { for (String each : paths) { myDirtyPaths.addDirtyPathRecursive(each); } } } notifyOnEvent(path); } | notifyDirtyPathRecursive |
240,918 | void (@Nullable String path) { if (path != null) { synchronized (myLock) { myDirtyPaths.addDirtyPathRecursive(path); } } else { VirtualFile[] roots = myManagingFS.getLocalRoots(); synchronized (myLock) { for (VirtualFile root : roots) { myDirtyPaths.addDirtyPathRecursive(root.getPresentableUrl()); } } } notifyOnEvent(R... | notifyReset |
240,919 | void (@NotNull @NlsContexts.NotificationContent String cause, @Nullable NotificationListener listener) { notifyOnFailure(cause, listener); } | notifyUserOnFailure |
240,920 | void (String path) { Consumer<? super String> notifier = myTestNotifier; if (notifier != null) notifier.accept(path); } | notifyOnEvent |
240,921 | void (@NotNull AnActionEvent e) { String pathToFile = Messages.showInputDialog("Path to file: ", "Virtual File Info", Messages.getQuestionIcon()); if (pathToFile == null) return; VirtualFile virtualFile = LocalFileSystem.getInstance().findFileByIoFile(new File(pathToFile)); if (virtualFile == null){ Messages.showErrorD... | actionPerformed |
240,922 | ActionUpdateThread () { return ActionUpdateThread.BGT; } | getActionUpdateThread |
240,923 | CanonicalPathMap () { return new CanonicalPathMap(Collections.emptyNavigableSet(), Collections.emptyNavigableSet(), Collections.emptyNavigableSet()); } | empty |
240,924 | void () { var lastMapping = ""; var lastCollection = (Collection<String>)null; for (var mapping: myInitialPathMappings) { var currentMapping = mapping.first; // If mappings are sorted, the below check should improve performance by avoiding unnecessary gets from the concurrent multi-map. if (!currentMapping.equals(lastM... | initializeMappings |
240,925 | Collection<String> (@NotNull String reportedPath, boolean isExact) { if (myOptimizedFlatWatchRoots.isEmpty() && myOptimizedRecursiveWatchRoots.isEmpty()) return Collections.emptyList(); var affectedPaths = applyMapping(reportedPath); var changedPaths = new HashSet<String>(); for (var affectedPath : affectedPaths) { if ... | mapToOriginalWatchRoots |
240,926 | Collection<String> (String reportedPath) { if (myPathMappings.isEmpty()) { return List.of(reportedPath); } var results = new SmartList<>(reportedPath); WatchRootsUtil.forEachPathSegment(reportedPath, File.separatorChar, path -> { myPathMappings.get(path).forEach(mapped -> results.add(mapped + reportedPath.substring(pat... | applyMapping |
240,927 | void (NavigableSet<String> paths, String prefix, Collection<? super String> result) { var possibleRoot = paths.ceiling(prefix); if (possibleRoot != null && FileUtil.startsWith(possibleRoot, prefix)) { // It's worth going for the set and iterator for (var root : paths.tailSet(prefix, false)) { if (FileUtil.startsWith(ro... | addPrefixedPaths |
240,928 | void (@NotNull List<? extends @NotNull VFileEvent> events) { analyzeEvents(events); } | after |
240,929 | void (@NotNull List<? extends VFileEvent> events) { if (events.isEmpty()) { return; } Set<String> toRefresh = new HashSet<>(); FileWatcher fileWatcher = mySystem.getFileWatcher(); Consumer<String> queuePath = path -> toRefresh.addAll(fileWatcher.mapToAllSymlinks(FileUtil.toSystemDependentName(path))); Consumer<VirtualF... | analyzeEvents |
240,930 | void (Set<String> toRefresh) { synchronized (myLock) { myRefreshQueue.addAll(toRefresh); if (myScheduledFuture == null) { myScheduledFuture = myExecutor.schedule(this::performRefresh, REFRESH_DELAY, TimeUnit.MILLISECONDS); } } } | scheduleRefresh |
240,931 | void () { Set<String> toRefresh; synchronized (myLock) { toRefresh = myRefreshQueue; myRefreshQueue = new HashSet<>(); myScheduledFuture = null; } List<VirtualFile> files = ContainerUtil.mapNotNull(toRefresh, mySystem::findFileByPath); RefreshQueue.getInstance().refresh(false, false, null, files); } | performRefresh |
240,932 | boolean (@NotNull VirtualFile file) { if (((VirtualFileSystemEntry)file).thisOrParentHaveSymlink()) { while (file != null && !file.is(VFileProperty.SYMLINK)) { file = file.getParent(); } return file != null && file.isRecursiveOrCircularSymlink(); } return false; } | isUnderRecursiveOrCircularSymlink |
240,933 | boolean (@NotNull NavigableSet<String> recursiveRoots, @NotNull String path) { String recursiveRoot = recursiveRoots.floor(path); return recursiveRoot != null && OSAgnosticPathUtil.startsWith(path, recursiveRoot); } | isCoveredRecursively |
240,934 | void (@NotNull NavigableSet<String> recursiveRoots, @NotNull String path) { if (!isCoveredRecursively(recursiveRoots, path)) { recursiveRoots.add(path); // Remove any roots covered by newly added String higher; while ((higher = recursiveRoots.higher(path)) != null && OSAgnosticPathUtil.startsWith(higher, path)) { recur... | insertRecursivePath |
240,935 | void (@NotNull String path, char separator, @NotNull Predicate<? super String> consumer) { int position = path.indexOf(separator); int length = path.length(); while (position >= 0 && position < length) { String subPath = path.substring(0, position); if (!consumer.test(subPath)) { return; } position = path.indexOf(separ... | forEachPathSegment |
240,936 | NavigableSet<String> (@NotNull Collection<String> flatRoots, @NotNull NavigableSet<String> recursiveRoots, boolean convertToForwardSlashes) { NavigableSet<String> result = createFileNavigableSet(); if (convertToForwardSlashes) { for (String flatRoot : flatRoots) { flatRoot = flatRoot.replace('/', '\\'); if (!isCoveredR... | optimizeFlatRoots |
240,937 | NavigableSet<String> () { return new TreeSet<>(OSAgnosticPathUtil.COMPARATOR); } | createFileNavigableSet |
240,938 | boolean (@NotNull NavigableSet<String> optimizedRecursiveRoots, @NotNull NavigableMap<String, ?> sourceRecursiveRoots, @NotNull String path) { if (!optimizedRecursiveRoots.remove(path)) { return false; } Ref<String> lastPathRef = new Ref<>(); collectByPrefix(sourceRecursiveRoots, path, entry -> { String lastPath = last... | removeRecursivePath |
240,939 | FileWatcher () { return myWatcher; } | getFileWatcher |
240,940 | void () { myDisposed = true; myWatcher.dispose(); } | dispose |
240,941 | void () { if (myWatcher.isOperational()) { var dirtyPaths = myWatcher.getDirtyPaths(); var marked = markPathsDirty(dirtyPaths.dirtyPaths) | markFlatDirsDirty(dirtyPaths.dirtyDirectories) | markRecursiveDirsDirty(dirtyPaths.dirtyPathsRecursive); if (marked) { statusRefreshed(); } } } | storeRefreshStatusToFiles |
240,942 | void () { } | statusRefreshed |
240,943 | boolean (Iterable<String> dirtyPaths) { var marked = false; for (var dirtyPath : dirtyPaths) { var file = findFileByPathIfCached(dirtyPath); if (file instanceof NewVirtualFile nvf) { nvf.markDirty(); marked = true; } } return marked; } | markPathsDirty |
240,944 | boolean (Iterable<String> dirtyPaths) { var marked = false; for (var dirtyPath : dirtyPaths) { var exactOrParent = VfsImplUtil.findCachedFileByPath(this, dirtyPath); if (exactOrParent.first != null) { exactOrParent.first.markDirty(); for (var child : exactOrParent.first.getCachedChildren()) { ((NewVirtualFile)child).ma... | markFlatDirsDirty |
240,945 | boolean (Iterable<String> dirtyPaths) { var marked = false; for (var dirtyPath : dirtyPaths) { var exactOrParent = VfsImplUtil.findCachedFileByPath(this, dirtyPath); if (exactOrParent.first != null) { exactOrParent.first.markDirtyRecursively(); marked = true; } else if (exactOrParent.second != null) { exactOrParent.sec... | markRecursiveDirsDirty |
240,946 | void (@NotNull List<? extends VirtualFile> files) { storeRefreshStatusToFiles(); if (myWatcher.isOperational()) { for (String root : myWatcher.getManualWatchRoots()) { VirtualFile suspiciousRoot = findFileByPathIfCached(root); if (suspiciousRoot != null) { ((NewVirtualFile)suspiciousRoot).markDirtyRecursively(); } } } ... | markSuspiciousFilesDirty |
240,947 | Set<WatchRequest> (@NotNull Collection<WatchRequest> watchRequestsToRemove, @Nullable Collection<String> recursiveRootsToAdd, @Nullable Collection<String> flatRootsToAdd) { if (myDisposed) return Collections.emptySet(); var nonNullWatchRequestsToRemove = ContainerUtil.skipNulls(watchRequestsToRemove); LOG.assertTrue(no... | replaceWatchedRoots |
240,948 | void (boolean asynchronous) { Runnable heavyRefresh = () -> { for (VirtualFile root : myManagingFS.getRoots(this)) { ((NewVirtualFile)root).markDirtyRecursively(); } refresh(asynchronous); }; if (asynchronous && myWatcher.isOperational()) { RefreshQueue.getInstance().refresh(true, true, heavyRefresh, myManagingFS.getRo... | refreshWithoutFileWatcher |
240,949 | void (int fileId, @Nullable VirtualFile parent, @NotNull CharSequence name, @NotNull String linkPath, @Nullable String linkTarget) { if (linkTarget == null || !isRecursiveOrCircularSymlink(parent, name, linkTarget)) { myWatchRootsManager.updateSymlink(fileId, linkPath, linkTarget); } } | symlinkUpdated |
240,950 | void (int fileId) { myWatchRootsManager.removeSymlink(fileId); } | symlinkRemoved |
240,951 | void () { super.cleanupForNextTest(); myWatchRootsManager.clear(); } | cleanupForNextTest |
240,952 | boolean (@Nullable VirtualFile parent, CharSequence name, String symlinkTarget) { if (startsWith(parent, name, symlinkTarget)) return true; if (!(parent instanceof VirtualFileSystemEntry)) return false; // check if it's circular - any symlink above resolves to my target too for (VirtualFileSystemEntry p = (VirtualFileS... | isRecursiveOrCircularSymlink |
240,953 | boolean (@Nullable VirtualFile parent, CharSequence name, String symlinkTarget) { // parent == null means name is root //noinspection StaticMethodReferencedViaSubclass return parent != null ? VfsUtilCore.isAncestorOrSelf(StringUtil.trimEnd(symlinkTarget, "/" + name), parent) : StringUtil.equal(name, symlinkTarget, Syst... | startsWith |
240,954 | void () { myFileAttributesCache.remove(); } | clearListCache |
240,955 | FileAttributes (@NotNull VirtualFile file) { Pair<VirtualFile, Map<String, FileAttributes>> cache = myFileAttributesCache.get(); if (cache != null) { if (!cache.first.equals(file.getParent())) { LOG.error("unordered access to " + file + " outside " + cache.first); } else { return cache.second.get(file.getName()); } } r... | getAttributes |
240,956 | String () { return "LocalFileSystem"; } | toString |
240,957 | void (@NotNull List<? extends @NotNull VFileEvent> events) { synchronized (myLock) { if (myWatcherRequiresUpdate) { updateFileWatcher(); } } } | after |
240,958 | Set<WatchRequest> (@NotNull Collection<WatchRequest> requestsToRemove, @NotNull Collection<String> recursiveRootsToAdd, @NotNull Collection<String> flatRootsToAdd) { Set<WatchRequest> recursiveRequestsToRemove = new HashSet<>(), flatRequestsToRemove = new HashSet<>(); requestsToRemove.forEach(req -> (req.isToWatchRecur... | replaceWatchedRoots |
240,959 | void () { myFileWatcher.setWatchRoots(() -> { synchronized (myLock) { if (!myWatcherRequiresUpdate) return null; myWatcherRequiresUpdate = false; var convert = File.separatorChar == '\\'; return createCanonicalPathMap(myFlatWatchRoots.navigableKeySet(), myOptimizedRecursiveWatchRoots, myPathMappings, convert); } }); } | updateFileWatcher |
240,960 | CanonicalPathMap (@NotNull Set<String> flatWatchRoots, @NotNull Set<String> optimizedRecursiveWatchRoots, @NotNull Collection<Pair<String, String>> pathMappings, boolean convertToForwardSlashes) { NavigableSet<@SystemDependent String> optimizedRecursiveWatchRootsCopy = WatchRootsUtil.createFileNavigableSet(); List<Pair... | createCanonicalPathMap |
240,961 | void (@NotNull Collection<String> rootsToAdd, @NotNull Set<WatchRequest> requestsToRemove, @NotNull Set<WatchRequest> result, @NotNull Map<String, List<WatchRequest>> roots, boolean recursiveWatchRoots) { List<WatchSymlinkRequest> watchSymlinkRequestsToAdd = new SmartList<>(); for (String root : rootsToAdd) { String wa... | updateWatchRoots |
240,962 | void (@NotNull WatchRequest request) { String watchRoot = request.getRootPath(); Map<String, List<WatchRequest>> roots = request.isToWatchRecursively() ? myRecursiveWatchRoots : myFlatWatchRoots; List<WatchRequest> requests = roots.get(watchRoot); if (requests != null) { requests.remove(request); if (requests.isEmpty()... | removeWatchRequest |
240,963 | void (@NotNull List<WatchSymlinkRequest> watchSymlinkRequestsToAdd) { for (WatchSymlinkRequest request : watchSymlinkRequestsToAdd) { if (!request.getRootPath().isEmpty() && !request.isRegistered()) { addWatchSymlinkRequest(request); } } } | addWatchSymlinkRequests |
240,964 | void (@NotNull WatchSymlinkRequest request) { String watchRoot = request.getRootPath(); Map<String, List<WatchRequest>> roots = request.isToWatchRecursively() ? myRecursiveWatchRoots : myFlatWatchRoots; List<WatchRequest> requests = roots.computeIfAbsent(watchRoot, __ -> new SmartList<>()); requests.add(request); if (r... | addWatchSymlinkRequest |
240,965 | void (@NotNull List<WatchSymlinkRequest> watchSymlinkRequestsToRemove) { for (WatchSymlinkRequest request : watchSymlinkRequestsToRemove) { Ref<Boolean> remove = new Ref<>(true); WatchRootsUtil.forEachPathSegment(request.getOriginalPath(), '/', path -> { List<WatchRequest> requests = myRecursiveWatchRoots.get(path); if... | removeWatchSymlinkRequests |
240,966 | void (@NotNull WatchSymlinkRequest request) { if (!request.isRegistered()) { return; } removeWatchRequest(request); if (request.setRegistered(false)) { myPathMappings.remove(new Pair<>(request.getRootPath(), request.getOriginalPath())); myWatcherRequiresUpdate = true; } } | removeWatchSymlinkRequest |
240,967 | void (@NotNull WatchRequestImpl newRequest, @NotNull Collection<WatchSymlinkRequest> watchSymlinkRequestsToAdd) { assert newRequest.isToWatchRecursively() : newRequest; WatchRootsUtil.collectByPrefix(mySymlinksByPath, newRequest.getRootPath(), e -> { if (e.getValue().hasValidTarget()) { watchSymlinkRequestsToAdd.add(e.... | collectSymlinkRequests |
240,968 | boolean () { return myWatchRecursively; } | isToWatchRecursively |
240,969 | String () { return getRootPath(); } | toString |
240,970 | boolean () { return myWatchRecursively; } | isToWatchRecursively |
240,971 | WatchSymlinkRequest () { assert hasValidTarget(); if (myWatchRequest == null) { myWatchRequest = new WatchSymlinkRequest(this, true); } return myWatchRequest; } | getWatchRequest |
240,972 | String () { return "SymlinkData{" + id + ", " + path + " -> " + target + '}'; } | toString |
240,973 | void (@NotNull String pathInJar) { if (myNoCopyJarPaths == null) return; int index = pathInJar.indexOf(JAR_SEPARATOR); if (index > 0) pathInJar = pathInJar.substring(0, index); myNoCopyJarPaths.add(new File(pathInJar).getPath()); } | setNoCopyJarForPath |
240,974 | boolean (@NotNull File originalJar) { return !(myNoCopyJarPaths == null || myNoCopyJarPaths.contains(originalJar.getPath()) || originalJar.toPath().startsWith(myNoCopyJarDir)); } | isMakeCopyOfJar |
240,975 | String () { return PROTOCOL; } | getProtocol |
240,976 | String (@NotNull String path) { return super.extractPresentableUrl(StringUtil.trimEnd(path, JAR_SEPARATOR)); } | extractPresentableUrl |
240,977 | String (@NotNull String normalizedPath) { int separatorIndex = normalizedPath.indexOf(JAR_SEPARATOR); return separatorIndex > 0 ? normalizedPath.substring(0, separatorIndex + JAR_SEPARATOR.length()) : ""; } | extractRootPath |
240,978 | String (@NotNull String rootPath) { return StringUtil.trimEnd(rootPath, JAR_SEPARATOR); } | extractLocalPath |
240,979 | String (@NotNull String localPath) { return localPath + JAR_SEPARATOR; } | composeRootPath |
240,980 | ArchiveHandler (@NotNull VirtualFile entryFile) { return VfsImplUtil.getHandler(this, entryFile, myNoCopyJarPaths == null ? ZipHandler::new : TimedZipHandler::new); } | getHandler |
240,981 | void (@NotNull VirtualFile file) { // clear caches in ArchiveHandler so that refresh will actually refresh something getHandler(file).clearCaches(); VfsUtil.markDirtyAndRefresh(false, true, true, file); } | markDirtyAndRefreshVirtualFileDeepInsideJarForTest |
240,982 | VirtualFile (@NotNull String path) { return isValid(path) ? VfsImplUtil.findFileByPath(this, path) : null; } | findFileByPath |
240,983 | VirtualFile (@NotNull String path) { return isValid(path) ? VfsImplUtil.findFileByPathIfCached(this, path) : null; } | findFileByPathIfCached |
240,984 | VirtualFile (@NotNull String path) { return isValid(path) ? VfsImplUtil.refreshAndFindFileByPath(this, path) : null; } | refreshAndFindFileByPath |
240,985 | boolean (String path) { return path.contains(JAR_SEPARATOR); } | isValid |
240,986 | void (boolean asynchronous) { VfsImplUtil.refresh(this, asynchronous); } | refresh |
240,987 | void () { TimedZipHandler.closeOpenZipReferences(); } | cleanupForNextTest |
240,988 | void () { synchronized (openFileLimitGuard) { for (TimedZipHandler handler : openFileLimitGuard.keySet()) { handler.clearCaches(); } } } | closeOpenZipReferences |
240,989 | void () { super.clearCaches(); myHandle.invalidateZipReference(); } | clearCaches |
240,990 | long () { return myHandle.getFileStamp(); } | getEntryFileStamp |
240,991 | void () { assert myLock.isLocked(); ScheduledFuture<?> invalidationRequest; try { myInvalidationRequest = invalidationRequest = ourScheduledExecutorService.schedule(() -> { invalidateZipReference(); }, myInvalidationTime, TimeUnit.MILLISECONDS); } finally { myLock.unlock(); } synchronized (openFileLimitGuard) { if (ope... | close |
240,992 | ZipFile () { assert myLock.isLocked(); return myFile; } | get |
240,993 | void () { invalidateZipReference(null); } | invalidateZipReference |
240,994 | void (@Nullable ScheduledFuture<?> expectedInvalidationRequest) { myLock.lock(); try { if (myFile == null) return; if (expectedInvalidationRequest != null) { if (doTracing) LOG.trace("Invalidation cache size exceeded"); if (myInvalidationRequest != expectedInvalidationRequest) { return; } } myInvalidationRequest = null... | invalidateZipReference |
240,995 | long () { assert myLock.isLocked(); return myFileStamp; } | getFileStamp |
240,996 | int () { return myFontType; } | getFontType |
240,997 | DocumentListener (@NotNull Project project, @NotNull DocumentListener listener) { //noinspection TestOnlyProblems return ProjectManagerImpl.Companion.isLight(project) ? new ProjectDisposeAwareDocumentListener(project, listener) : listener; } | create |
240,998 | void (@NotNull DocumentEvent event) { if (!project.isDisposed()) { listener.beforeDocumentChange(event); } } | beforeDocumentChange |
240,999 | void (@NotNull DocumentEvent event) { if (!project.isDisposed()) { listener.documentChanged(event); } } | documentChanged |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.