/*package*/ void scheduleFullUpdate() {
myQueue.addTask(
new Runnable() {
public void run() {
update(false);
}
});
}
public void dispose() {
synchronized (this) {
if (!(myDisposed)) {
myDisposed = true;
SModelRepository.getInstance().removeModelRepositoryListener(myModelListener);
myEventsCollector.remove(myModelDescriptor);
myEventsCollector.dispose();
myQueue.runTask(
new Runnable() {
public void run() {
myDifference.removeChangeSet();
}
});
}
}
}
private void runUpdateTask(
final _FunctionTypes._void_P0_E0 task, SNode currentNode, final SModelEvent event) {
myEventConsumingMapping.addEvent(event);
final List<SNodeId> ancestors =
ListSequence.fromList(SNodeOperations.getAncestors(currentNode, null, true))
.select(
new ISelector<SNode, SNodeId>() {
public SNodeId select(SNode a) {
return a.getNodeId();
}
})
.toListSequence();
myQueue.runTask(
new Runnable() {
public void run() {
if (myDifference.getChangeSet() == null) {
update(true);
} else {
if (ListSequence.fromList(ancestors)
.any(
new IWhereFilter<SNodeId>() {
public boolean accept(SNodeId a) {
return myAddedNodesToChanges.containsKey(a);
}
})) {
// ignore
} else {
if (myEventConsumingMapping.removeEvent(event)) {
myDifference.getBroadcaster().changeUpdateStarted();
ModelAccess.instance()
.runReadAction(
new Runnable() {
public void run() {
synchronized (ChangesTracking.this) {
if (!(myDisposed)) {
task.invoke();
}
}
}
});
myDifference.getBroadcaster().changeUpdateFinished();
}
}
}
}
});
}
private void update(boolean force) {
final Wrappers._boolean _force = new Wrappers._boolean(force);
myQueue.assertSoftlyIsCommandThread();
if (!(myDifference.isEnabled())) {
return;
}
IFile modelFile = myModelDescriptor.getSource().getFile();
if (!(modelFile.exists())) {
return;
}
VirtualFile modelVFile = VirtualFileUtils.getVirtualFile(modelFile);
if (modelVFile == null
|| ProjectLevelVcsManager.getInstance(myProject).getVcsFor(modelVFile) == null) {
return;
}
FileStatus status = FileStatusManager.getInstance(myProject).getStatus(modelVFile);
if (ConflictsUtil.isModelOrModuleConflicting(myModelDescriptor, myProject)) {
status = FileStatus.MERGED_WITH_CONFLICTS;
}
if (myDifference.getChangeSet() != null) {
ModelAccess.instance()
.runReadAction(
new Runnable() {
public void run() {
if (myDifference.getChangeSet().getNewModel() != myModelDescriptor.getSModel()) {
_force.value = true;
}
}
});
}
if (myStatusOnLastUpdate == status && !(_force.value)) {
return;
}
myDifference.removeChangeSet();
myStatusOnLastUpdate = status;
if (FileStatus.NOT_CHANGED == status && !(_force.value)) {
return;
}
final Wrappers._T<SModel> baseVersionModel = new Wrappers._T<SModel>(null);
if (BaseVersionUtil.isAddedFileStatus(status)
|| ConflictsUtil.isModelOrModuleConflicting(myModelDescriptor, myProject)) {
baseVersionModel.value =
new jetbrains.mps.smodel.SModel(myModelDescriptor.getSModelReference());
} else {
String content = BaseVersionUtil.getBaseVersionContent(modelVFile, myProject);
if (content == null && status != FileStatus.NOT_CHANGED) {
LOG.error("Base version content is null while file status is " + status);
}
if (content == null) {
return;
}
try {
baseVersionModel.value = ModelPersistence.readModel(content, false);
} catch (ModelReadException e) {
LOG.warning("", e);
return;
}
}
ModelAccess.instance()
.runReadAction(
new Runnable() {
public void run() {
synchronized (ChangesTracking.this) {
if (!(myDisposed)) {
ChangeSet changeSet =
ChangeSetBuilder.buildChangeSet(
baseVersionModel.value, myModelDescriptor.getSModel(), true);
myDifference.setChangeSet((ChangeSetImpl) changeSet);
buildCaches();
}
}
}
});
}
