public void putData(String kind, String realm, Object data) {
if (data == null) {
myStorage.remove(kind + "$" + realm);
} else {
myStorage.put(kind + "$" + realm, data);
}
}
@Override
public void removeVcsListener(VcsListener listener) {
final MessageBusConnection connection = myAdapters.remove(listener);
if (connection != null) {
connection.disconnect();
}
}
private void runAfterCommitActions(@NotNull Document document) {
ApplicationManager.getApplication().assertIsDispatchThread();
List<Runnable> list;
synchronized (ACTION_AFTER_COMMIT) {
list = document.getUserData(ACTION_AFTER_COMMIT);
if (list != null) {
list = new ArrayList<Runnable>(list);
document.putUserData(ACTION_AFTER_COMMIT, null);
}
}
if (list != null) {
for (final Runnable runnable : list) {
runnable.run();
}
}
if (!hasUncommitedDocuments() && !actionsWhenAllDocumentsAreCommitted.isEmpty()) {
List<Object> keys = new ArrayList<Object>(actionsWhenAllDocumentsAreCommitted.keySet());
for (Object key : keys) {
try {
Runnable action = actionsWhenAllDocumentsAreCommitted.remove(key);
myDocumentCommitProcessor.log(
"Running after commit runnable: ", null, false, key, action);
action.run();
} catch (Throwable e) {
LOG.error(e);
}
}
}
}
public void removeEntryPoint(RefElement anEntryPoint) {
if (anEntryPoint instanceof RefClass) {
RefClass refClass = (RefClass) anEntryPoint;
if (!refClass.isInterface()) {
anEntryPoint = refClass.getDefaultConstructor();
}
}
if (anEntryPoint == null) return;
myTemporaryEntryPoints.remove(anEntryPoint);
Set<Map.Entry<String, SmartRefElementPointer>> set = myPersistentEntryPoints.entrySet();
String key = null;
for (Map.Entry<String, SmartRefElementPointer> entry : set) {
SmartRefElementPointer value = entry.getValue();
if (value.getRefElement() == anEntryPoint) {
key = entry.getKey();
break;
}
}
if (key != null) {
myPersistentEntryPoints.remove(key);
((RefElementImpl) anEntryPoint).setEntry(false);
}
if (anEntryPoint.isPermanentEntry() && anEntryPoint.isValid()) {
final Project project = anEntryPoint.getElement().getProject();
final EntryPointsManagerImpl entryPointsManager = getInstance(project);
if (this != entryPointsManager) {
entryPointsManager.removeEntryPoint(anEntryPoint);
}
}
}
void removeNode(@NotNull FilePointerPartNode node, VirtualFilePointerListener listener) {
boolean rootNodeEmpty = node.remove();
if (rootNodeEmpty) {
myPointers.remove(listener);
} else {
myPointers.get(listener).checkConsistency();
}
}
private ProgressIndicatorEx removeFromMaps(@NotNull InlineProgressIndicator progress) {
final ProgressIndicatorEx original = myInline2Original.get(progress);
myInline2Original.remove(progress);
myOriginal2Inlines.remove(original, progress);
if (myOriginal2Inlines.get(original) == null) {
final int originalIndex = myOriginals.indexOf(original);
myOriginals.remove(originalIndex);
myInfos.remove(originalIndex);
}
return original;
}
@Override
public void dispose() {
synchronized (ourInstances) {
ourInstances.remove(myParent);
for (Object o : myCounts.keys()) {
VirtualFilePointerImpl pointer = (VirtualFilePointerImpl) o;
int disposeCount = myCounts.get(pointer);
int after = pointer.myNode.incrementUsageCount(-disposeCount + 1);
LOG.assertTrue(after > 0, after);
pointer.dispose();
}
}
}
private synchronized void onBreakpointRemoved(@Nullable final XBreakpoint xBreakpoint) {
ApplicationManager.getApplication().assertIsDispatchThread();
if (xBreakpoint == null) {
return;
}
Breakpoint breakpoint = myBreakpoints.remove(xBreakpoint);
if (breakpoint != null) {
// updateBreakpointRules(breakpoint);
myBreakpointsListForIteration = null;
// we delete breakpoints inside release, so gutter will not fire events to deleted breakpoints
breakpoint.delete();
RequestManagerImpl.deleteRequests(breakpoint);
myDispatcher.getMulticaster().breakpointsChanged();
}
}
private void restoreCopy(VirtualFile file) {
try {
if (file == null) return; // Externally deleted actually.
if (!file.isWritable()) return; // IDEA was unable to save it as well. So no need to restore.
final byte[] bytes = mySavedCopies.get(file);
if (bytes != null) {
try {
file.setBinaryContent(bytes, -1, mySavedTimestamps.get(file));
} catch (IOException e) {
Messages.showWarningDialog(
ProjectBundle.message("project.reload.write.failed", file.getPresentableUrl()),
ProjectBundle.message("project.reload.write.failed.title"));
}
}
} finally {
mySavedCopies.remove(file);
mySavedTimestamps.remove(file);
}
}
private void validateEntryPoints() {
long count = PsiManager.getInstance(myProject).getModificationTracker().getModificationCount();
if (count != myLastModificationCount) {
myLastModificationCount = count;
Collection<SmartRefElementPointer> collection = myPersistentEntryPoints.values();
SmartRefElementPointer[] entries =
collection.toArray(new SmartRefElementPointer[collection.size()]);
for (SmartRefElementPointer entry : entries) {
RefElement refElement = (RefElement) entry.getRefElement();
if (refElement != null && !refElement.isValid()) {
myPersistentEntryPoints.remove(entry.getFQName());
}
}
final Iterator<RefElement> it = myTemporaryEntryPoints.iterator();
while (it.hasNext()) {
RefElement refElement = it.next();
if (!refElement.isValid()) {
it.remove();
}
}
}
}
public void unregisterAdditionalIndentOptions(FileType fileType) {
myAdditionalIndentOptions.remove(fileType);
}
