plugins/org.eclipse.sphinx.emf.editors/src/org/eclipse/sphinx/emf/editors/ModelEditorInputSynchronizer.java - sphinx/org.eclipse.sphinx - Git at Google

 /**
  * <copyright>
  *
  * Copyright (c) 2015-2016 itemis and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
  *
  * Contributors:
  *     itemis - Initial API and implementation
  *     itemis - [501112] Temporary model loading form editor page sometimes happens to remain in place forever even when underlying model has been loaded

  * </copyright>
  */
 package org.eclipse.sphinx.emf.editors;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;

 import org.eclipse.core.runtime.Assert;
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EcorePackage;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.emf.ecore.resource.ResourceSet;
 import org.eclipse.emf.edit.provider.IDisposable;
 import org.eclipse.emf.transaction.NotificationFilter;
 import org.eclipse.emf.transaction.ResourceSetChangeEvent;
 import org.eclipse.emf.transaction.ResourceSetListener;
 import org.eclipse.emf.transaction.ResourceSetListenerImpl;
 import org.eclipse.emf.transaction.TransactionalEditingDomain;
 import org.eclipse.ui.IEditorInput;

 public class ModelEditorInputSynchronizer implements IDisposable {

 	private ResourceSetListener resourceLoadedListener;
 	private ResourceSetListener resourceMovedListener;
 	private ResourceSetListener resourceRemovedListener;
 	private ResourceSetListener objectChangedListener;

 	protected IEditorInput editorInput;
 	protected TransactionalEditingDomain editingDomain;
 	protected IModelEditorInputChangeAnalyzer editorInputChangeAnalyzer;
 	protected IModelEditorInputChangeHandler editorInputChangeHandler;

 	public ModelEditorInputSynchronizer(IEditorInput editorInput, TransactionalEditingDomain editingDomain,
 			IModelEditorInputChangeAnalyzer editorInputChangeAnalyzer, IModelEditorInputChangeHandler editorInputChangeHandler) {
 		Assert.isNotNull(editorInput);
 		Assert.isNotNull(editingDomain);
 		Assert.isNotNull(editorInputChangeAnalyzer);
 		Assert.isNotNull(editorInputChangeHandler);

 		this.editorInput = editorInput;
 		this.editingDomain = editingDomain;
 		this.editorInputChangeAnalyzer = editorInputChangeAnalyzer;
 		this.editorInputChangeHandler = editorInputChangeHandler;

 		installModelChangeListeners();
 	}

 	protected void installModelChangeListeners() {
 		// Create and register listener that detects loaded resources
 		resourceLoadedListener = createResourceLoadedListener();
 		Assert.isNotNull(resourceLoadedListener);
 		editingDomain.addResourceSetListener(resourceLoadedListener);

 		// Create and register listener that detects renamed or moved resources
 		resourceMovedListener = createResourceMovedListener();
 		Assert.isNotNull(resourceMovedListener);
 		editingDomain.addResourceSetListener(resourceMovedListener);

 		// Create and register listener that detects removed resources
 		resourceRemovedListener = createResourceRemovedListener();
 		Assert.isNotNull(resourceRemovedListener);
 		editingDomain.addResourceSetListener(resourceRemovedListener);

 		// Create and register listener that detects changed objects
 		objectChangedListener = createObjectChangedListener();
 		Assert.isNotNull(objectChangedListener);
 		editingDomain.addResourceSetListener(objectChangedListener);
 	}

 	protected void uninstallModelChangeListeners() {
 		editingDomain.removeResourceSetListener(resourceLoadedListener);
 		editingDomain.removeResourceSetListener(resourceMovedListener);
 		editingDomain.removeResourceSetListener(resourceRemovedListener);
 		editingDomain.removeResourceSetListener(objectChangedListener);
 	}

 	protected ResourceSetListener createResourceLoadedListener() {
 		return new ResourceSetListenerImpl(
 				NotificationFilter.createFeatureFilter(EcorePackage.eINSTANCE.getEResource(), Resource.RESOURCE__IS_LOADED)) {
 			@Override
 			public void resourceSetChanged(ResourceSetChangeEvent event) {
 				// Retrieve loaded resources from notification
 				List<?> notifications = event.getNotifications();
 				for (Object object : notifications) {
 					if (object instanceof Notification) {
 						Notification notification = (Notification) object;
 						if (notification.getNewBooleanValue()) {
 							Resource loadedResource = (Resource) notification.getNotifier();
 							// Is loaded resource containing editor input object?
 							if (editorInputChangeAnalyzer.containsEditorInputResourceURI(editorInput,
 									Collections.singleton(loadedResource.getURI()))) {
 								// Has loaded resource not been unloaded again subsequently?
 								if (loadedResource.isLoaded()) {
 									// Handle (re-)loaded editor input resource
 									editorInputChangeHandler.handleEditorInputResourceLoaded(editorInput);
 									break;
 								} else {
 									editorInputChangeHandler.handleEditorInputResourceUnloaded(editorInput);
 									break;
 								}
 							}
 						}
 					}
 				}
 			}

 			@Override
 			public boolean isPostcommitOnly() {
 				return true;
 			}
 		};
 	}

 	protected ResourceSetListener createResourceMovedListener() {
 		return new ResourceSetListenerImpl(NotificationFilter.createFeatureFilter(EcorePackage.eINSTANCE.getEResource(), Resource.RESOURCE__URI)) {
 			@Override
 			public void resourceSetChanged(ResourceSetChangeEvent event) {
 				// Retrieve moved resources from notification
 				List<?> notifications = event.getNotifications();
 				for (Object object : notifications) {
 					if (object instanceof Notification) {
 						Notification notification = (Notification) object;
 						// Is moved resource the resource containing editor input object?
 						if (notification.getOldValue() instanceof URI) {
 							URI oldResourceURI = (URI) notification.getOldValue();
 							if (oldResourceURI != null) {
 								if (editorInputChangeAnalyzer.containsEditorInputResourceURI(editorInput, Collections.singleton(oldResourceURI))) {
 									// Handle moved editor input resource
 									editorInputChangeHandler.handleEditorInputResourceMoved(editorInput, oldResourceURI,
 											(URI) notification.getNewValue());
 									break;
 								}
 							}
 						}
 					}
 				}
 			}

 			@Override
 			public boolean isPostcommitOnly() {
 				return true;
 			}
 		};
 	}

 	protected ResourceSetListener createResourceRemovedListener() {
 		return new ResourceSetListenerImpl(NotificationFilter.createFeatureFilter(EcorePackage.eINSTANCE.getEResource(), Resource.RESOURCE__IS_LOADED)
 				.or(NotificationFilter.createFeatureFilter(EcorePackage.eINSTANCE.getEResourceSet(), ResourceSet.RESOURCE_SET__RESOURCES))) {
 			@Override
 			public void resourceSetChanged(ResourceSetChangeEvent event) {
 				// Retrieve removed and added resources from notification
 				Set<Resource> removedResources = new HashSet<Resource>();
 				Set<Resource> addedResources = new HashSet<Resource>();

 				// Analyze notifications for changed resources; record only added and removed resources which have not
 				// got removed/added again later on
 				List<?> notifications = event.getNotifications();
 				for (Object object : notifications) {
 					if (object instanceof Notification) {
 						Notification notification = (Notification) object;
 						Object notifier = notification.getNotifier();
 						if (notifier instanceof ResourceSet) {
 							if (notification.getEventType() == Notification.ADD || notification.getEventType() == Notification.ADD_MANY) {
 								List<Resource> newResources = new ArrayList<Resource>();
 								Object newValue = notification.getNewValue();
 								if (newValue instanceof List<?>) {
 									@SuppressWarnings("unchecked")
 									List<Resource> newResourcesValue = (List<Resource>) newValue;
 									newResources.addAll(newResourcesValue);
 								} else if (newValue instanceof Resource) {
 									newResources.add((Resource) newValue);
 								}

 								for (Resource newResource : newResources) {
 									Resource removedResource = findEquivalentResource(removedResources, newResource);
 									// If the newResource has been removed, then remove the equivalent resource from
 									// removedResource, otherwise add it to addedResources
 									if (removedResource != null) {
 										removedResources.remove(removedResource);
 									} else {
 										addedResources.add(newResource);
 									}
 								}
 							} else if (notification.getEventType() == Notification.REMOVE
 									|| notification.getEventType() == Notification.REMOVE_MANY) {
 								List<Resource> oldResources = new ArrayList<Resource>();
 								Object oldValue = notification.getOldValue();
 								if (oldValue instanceof List<?>) {
 									@SuppressWarnings("unchecked")
 									List<Resource> oldResourcesValue = (List<Resource>) oldValue;
 									oldResources.addAll(oldResourcesValue);
 								} else if (oldValue instanceof Resource) {
 									oldResources.add((Resource) oldValue);
 								}

 								for (Resource oldResource : oldResources) {
 									Resource oldAddedResource = findEquivalentResource(addedResources, oldResource);
 									// If the oldResource has been added, then remove the equivalent resource from
 									// addedResources, otherwise add it to removedResources
 									if (oldAddedResource != null) {
 										addedResources.remove(oldAddedResource);
 									} else {
 										removedResources.add(oldResource);
 									}
 								}
 							}
 						}
 					}
 				}

 				// Include removed resources the resource containing editor input object?
 				if (!removedResources.isEmpty()) {
 					Set<URI> removedResourceURIs = new HashSet<URI>(removedResources.size());
 					for (Resource removedResource : removedResources) {
 						removedResourceURIs.add(removedResource.getURI());
 					}
 					if (editorInputChangeAnalyzer.containsEditorInputResourceURI(editorInput, removedResourceURIs)) {
 						// Handle removed editor input resource
 						editorInputChangeHandler.handleEditorInputResourceRemoved(editorInput);
 					}
 				}
 			}

 			/**
 			 * Returns a resource from the given set of resources that is "equal to" the indicated one. The "equals"
 			 * method detects an URI equivalence relation on non-null resources: if the resource URI equals to the URI
 			 * of the specified resource, then the resource is returned.
 			 */
 			protected Resource findEquivalentResource(Set<Resource> resources, Resource resource) {
 				URI uri = resource.getURI();
 				for (Resource equivalentResourceCandidate : resources) {
 					if (equivalentResourceCandidate.getURI().equals(uri)) {
 						return equivalentResourceCandidate;
 					}
 				}
 				return null;
 			}

 			@Override
 			public boolean isPostcommitOnly() {
 				return true;
 			}
 		};
 	}

 	protected ResourceSetListener createObjectChangedListener() {
 		return new ResourceSetListenerImpl(NotificationFilter.createFeatureFilter(EcorePackage.eINSTANCE.getEResource(), Resource.RESOURCE__CONTENTS)
 				.or(NotificationFilter.createNotifierTypeFilter(EObject.class))) {
 			@Override
 			public void resourceSetChanged(ResourceSetChangeEvent event) {
 				Set<EObject> addedObjects = new HashSet<EObject>();
 				Set<EObject> removedObjects = new HashSet<EObject>();
 				Set<EObject> movedObjects = new HashSet<EObject>();
 				Set<EObject> changedObjects = new HashSet<EObject>();

 				// Analyze notifications for changed objects; record only set/added and unset/removed objects which have
 				// not got unset/removed or set/added again later on
 				for (Notification notification : event.getNotifications()) {
 					if (notification.getEventType() == Notification.SET || notification.getEventType() == Notification.ADD
 							|| notification.getEventType() == Notification.ADD_MANY) {
 						List<EObject> newValues = new ArrayList<EObject>();
 						Object newValue = notification.getNewValue();
 						if (newValue instanceof List<?>) {
 							@SuppressWarnings("unchecked")
 							List<EObject> newValueList = (List<EObject>) newValue;
 							newValues.addAll(newValueList);
 						} else if (newValue instanceof EObject) {
 							newValues.add((EObject) newValue);
 						}

 						for (EObject value : newValues) {
 							changedObjects.add(value);
 							if (removedObjects.contains(value)) {
 								movedObjects.add(value);
 								removedObjects.remove(value);
 							} else {
 								addedObjects.add(value);
 							}
 						}
 					} else if (notification.getEventType() == Notification.UNSET || notification.getEventType() == Notification.REMOVE
 							|| notification.getEventType() == Notification.REMOVE_MANY) {
 						List<EObject> oldValues = new ArrayList<EObject>();
 						Object oldValue = notification.getOldValue();
 						if (oldValue instanceof List<?>) {
 							@SuppressWarnings("unchecked")
 							List<EObject> oldValueList = (List<EObject>) oldValue;
 							oldValues.addAll(oldValueList);
 						} else if (oldValue instanceof EObject) {
 							oldValues.add((EObject) oldValue);
 						}

 						for (EObject value : oldValues) {
 							changedObjects.add(value);
 							if (addedObjects.contains(value)) {
 								movedObjects.add(value);
 								addedObjects.remove(value);
 							} else {
 								removedObjects.add(value);
 							}
 						}
 					}
 				}

 				// Is editor input object part of the added objects or contained by one or them?
 				if (!addedObjects.isEmpty()) {
 					if (editorInputChangeAnalyzer.containsEditorInputObject(editorInput, addedObjects)) {
 						// Handle added editor input object
 						editorInputChangeHandler.handleEditorInputObjectAdded(editorInput, addedObjects);
 					}
 				}

 				// Is editor input object part of the removed objects or contained by one or them?
 				if (!removedObjects.isEmpty()) {
 					if (editorInputChangeAnalyzer.containsEditorInputObject(editorInput, removedObjects)) {
 						// Handle removed editor input object
 						editorInputChangeHandler.handleEditorInputObjectRemoved(editorInput, removedObjects);
 					}
 				}

 				// Is editor input object part of the moved objects or contained by one or them?
 				if (!movedObjects.isEmpty()) {
 					if (editorInputChangeAnalyzer.containsEditorInputObject(editorInput, movedObjects)) {
 						// Handle moved editor input object
 						editorInputChangeHandler.handleEditorInputObjectMoved(editorInput, movedObjects);
 					}
 				}

 				// Is editor input object part of the changed objects or contained by one or them?
 				if (!changedObjects.isEmpty()) {
 					if (editorInputChangeAnalyzer.containsEditorInputObject(editorInput, changedObjects)) {
 						// Handle changed editor input object
 						editorInputChangeHandler.handleEditorInputObjectChanged(editorInput, changedObjects);
 					}
 				}
 			}

 			@Override
 			public boolean isPostcommitOnly() {
 				return true;
 			}
 		};
 	}

 	/*
 	 * @see org.eclipse.emf.edit.provider.IDisposable#dispose()
 	 */
 	@Override
 	public void dispose() {
 		uninstallModelChangeListeners();
 	}
 }
	/**
	* <copyright>
	*
	* Copyright (c) 2015-2016 itemis and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
	*
	* Contributors:
	* itemis - Initial API and implementation
	* itemis - [501112] Temporary model loading form editor page sometimes happens to remain in place forever even when underlying model has been loaded

	* </copyright>
	*/
	package org.eclipse.sphinx.emf.editors;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Set;

	import org.eclipse.core.runtime.Assert;
	import org.eclipse.emf.common.notify.Notification;
	import org.eclipse.emf.common.util.URI;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.EcorePackage;
	import org.eclipse.emf.ecore.resource.Resource;
	import org.eclipse.emf.ecore.resource.ResourceSet;
	import org.eclipse.emf.edit.provider.IDisposable;
	import org.eclipse.emf.transaction.NotificationFilter;
	import org.eclipse.emf.transaction.ResourceSetChangeEvent;
	import org.eclipse.emf.transaction.ResourceSetListener;
	import org.eclipse.emf.transaction.ResourceSetListenerImpl;
	import org.eclipse.emf.transaction.TransactionalEditingDomain;
	import org.eclipse.ui.IEditorInput;

	public class ModelEditorInputSynchronizer implements IDisposable {

	private ResourceSetListener resourceLoadedListener;
	private ResourceSetListener resourceMovedListener;
	private ResourceSetListener resourceRemovedListener;
	private ResourceSetListener objectChangedListener;

	protected IEditorInput editorInput;
	protected TransactionalEditingDomain editingDomain;
	protected IModelEditorInputChangeAnalyzer editorInputChangeAnalyzer;
	protected IModelEditorInputChangeHandler editorInputChangeHandler;

	public ModelEditorInputSynchronizer(IEditorInput editorInput, TransactionalEditingDomain editingDomain,
	IModelEditorInputChangeAnalyzer editorInputChangeAnalyzer, IModelEditorInputChangeHandler editorInputChangeHandler) {
	Assert.isNotNull(editorInput);
	Assert.isNotNull(editingDomain);
	Assert.isNotNull(editorInputChangeAnalyzer);
	Assert.isNotNull(editorInputChangeHandler);

	this.editorInput = editorInput;
	this.editingDomain = editingDomain;
	this.editorInputChangeAnalyzer = editorInputChangeAnalyzer;
	this.editorInputChangeHandler = editorInputChangeHandler;

	installModelChangeListeners();
	}

	protected void installModelChangeListeners() {
	// Create and register listener that detects loaded resources
	resourceLoadedListener = createResourceLoadedListener();
	Assert.isNotNull(resourceLoadedListener);
	editingDomain.addResourceSetListener(resourceLoadedListener);

	// Create and register listener that detects renamed or moved resources
	resourceMovedListener = createResourceMovedListener();
	Assert.isNotNull(resourceMovedListener);
	editingDomain.addResourceSetListener(resourceMovedListener);

	// Create and register listener that detects removed resources
	resourceRemovedListener = createResourceRemovedListener();
	Assert.isNotNull(resourceRemovedListener);
	editingDomain.addResourceSetListener(resourceRemovedListener);

	// Create and register listener that detects changed objects
	objectChangedListener = createObjectChangedListener();
	Assert.isNotNull(objectChangedListener);
	editingDomain.addResourceSetListener(objectChangedListener);
	}

	protected void uninstallModelChangeListeners() {
	editingDomain.removeResourceSetListener(resourceLoadedListener);
	editingDomain.removeResourceSetListener(resourceMovedListener);
	editingDomain.removeResourceSetListener(resourceRemovedListener);
	editingDomain.removeResourceSetListener(objectChangedListener);
	}

	protected ResourceSetListener createResourceLoadedListener() {
	return new ResourceSetListenerImpl(
	NotificationFilter.createFeatureFilter(EcorePackage.eINSTANCE.getEResource(), Resource.RESOURCE__IS_LOADED)) {
	@Override
	public void resourceSetChanged(ResourceSetChangeEvent event) {
	// Retrieve loaded resources from notification
	List<?> notifications = event.getNotifications();
	for (Object object : notifications) {
	if (object instanceof Notification) {
	Notification notification = (Notification) object;
	if (notification.getNewBooleanValue()) {
	Resource loadedResource = (Resource) notification.getNotifier();
	// Is loaded resource containing editor input object?
	if (editorInputChangeAnalyzer.containsEditorInputResourceURI(editorInput,
	Collections.singleton(loadedResource.getURI()))) {
	// Has loaded resource not been unloaded again subsequently?
	if (loadedResource.isLoaded()) {
	// Handle (re-)loaded editor input resource
	editorInputChangeHandler.handleEditorInputResourceLoaded(editorInput);
	break;
	} else {
	editorInputChangeHandler.handleEditorInputResourceUnloaded(editorInput);
	break;
	}
	}
	}
	}
	}
	}

	@Override
	public boolean isPostcommitOnly() {
	return true;
	}
	};
	}

	protected ResourceSetListener createResourceMovedListener() {
	return new ResourceSetListenerImpl(NotificationFilter.createFeatureFilter(EcorePackage.eINSTANCE.getEResource(), Resource.RESOURCE__URI)) {
	@Override
	public void resourceSetChanged(ResourceSetChangeEvent event) {
	// Retrieve moved resources from notification
	List<?> notifications = event.getNotifications();
	for (Object object : notifications) {
	if (object instanceof Notification) {
	Notification notification = (Notification) object;
	// Is moved resource the resource containing editor input object?
	if (notification.getOldValue() instanceof URI) {
	URI oldResourceURI = (URI) notification.getOldValue();
	if (oldResourceURI != null) {
	if (editorInputChangeAnalyzer.containsEditorInputResourceURI(editorInput, Collections.singleton(oldResourceURI))) {
	// Handle moved editor input resource
	editorInputChangeHandler.handleEditorInputResourceMoved(editorInput, oldResourceURI,
	(URI) notification.getNewValue());
	break;
	}
	}
	}
	}
	}
	}

	@Override
	public boolean isPostcommitOnly() {
	return true;
	}
	};
	}

	protected ResourceSetListener createResourceRemovedListener() {
	return new ResourceSetListenerImpl(NotificationFilter.createFeatureFilter(EcorePackage.eINSTANCE.getEResource(), Resource.RESOURCE__IS_LOADED)
	.or(NotificationFilter.createFeatureFilter(EcorePackage.eINSTANCE.getEResourceSet(), ResourceSet.RESOURCE_SET__RESOURCES))) {
	@Override
	public void resourceSetChanged(ResourceSetChangeEvent event) {
	// Retrieve removed and added resources from notification
	Set<Resource> removedResources = new HashSet<Resource>();
	Set<Resource> addedResources = new HashSet<Resource>();

	// Analyze notifications for changed resources; record only added and removed resources which have not
	// got removed/added again later on
	List<?> notifications = event.getNotifications();
	for (Object object : notifications) {
	if (object instanceof Notification) {
	Notification notification = (Notification) object;
	Object notifier = notification.getNotifier();
	if (notifier instanceof ResourceSet) {
	if (notification.getEventType() == Notification.ADD \|\| notification.getEventType() == Notification.ADD_MANY) {
	List<Resource> newResources = new ArrayList<Resource>();
	Object newValue = notification.getNewValue();
	if (newValue instanceof List<?>) {
	@SuppressWarnings("unchecked")
	List<Resource> newResourcesValue = (List<Resource>) newValue;
	newResources.addAll(newResourcesValue);
	} else if (newValue instanceof Resource) {
	newResources.add((Resource) newValue);
	}

	for (Resource newResource : newResources) {
	Resource removedResource = findEquivalentResource(removedResources, newResource);
	// If the newResource has been removed, then remove the equivalent resource from
	// removedResource, otherwise add it to addedResources
	if (removedResource != null) {
	removedResources.remove(removedResource);
	} else {
	addedResources.add(newResource);
	}
	}
	} else if (notification.getEventType() == Notification.REMOVE
	\|\| notification.getEventType() == Notification.REMOVE_MANY) {
	List<Resource> oldResources = new ArrayList<Resource>();
	Object oldValue = notification.getOldValue();
	if (oldValue instanceof List<?>) {
	@SuppressWarnings("unchecked")
	List<Resource> oldResourcesValue = (List<Resource>) oldValue;
	oldResources.addAll(oldResourcesValue);
	} else if (oldValue instanceof Resource) {
	oldResources.add((Resource) oldValue);
	}

	for (Resource oldResource : oldResources) {
	Resource oldAddedResource = findEquivalentResource(addedResources, oldResource);
	// If the oldResource has been added, then remove the equivalent resource from
	// addedResources, otherwise add it to removedResources
	if (oldAddedResource != null) {
	addedResources.remove(oldAddedResource);
	} else {
	removedResources.add(oldResource);
	}
	}
	}
	}
	}
	}

	// Include removed resources the resource containing editor input object?
	if (!removedResources.isEmpty()) {
	Set<URI> removedResourceURIs = new HashSet<URI>(removedResources.size());
	for (Resource removedResource : removedResources) {
	removedResourceURIs.add(removedResource.getURI());
	}
	if (editorInputChangeAnalyzer.containsEditorInputResourceURI(editorInput, removedResourceURIs)) {
	// Handle removed editor input resource
	editorInputChangeHandler.handleEditorInputResourceRemoved(editorInput);
	}
	}
	}

	/**
	* Returns a resource from the given set of resources that is "equal to" the indicated one. The "equals"
	* method detects an URI equivalence relation on non-null resources: if the resource URI equals to the URI
	* of the specified resource, then the resource is returned.
	*/
	protected Resource findEquivalentResource(Set<Resource> resources, Resource resource) {
	URI uri = resource.getURI();
	for (Resource equivalentResourceCandidate : resources) {
	if (equivalentResourceCandidate.getURI().equals(uri)) {
	return equivalentResourceCandidate;
	}
	}
	return null;
	}

	@Override
	public boolean isPostcommitOnly() {
	return true;
	}
	};
	}

	protected ResourceSetListener createObjectChangedListener() {
	return new ResourceSetListenerImpl(NotificationFilter.createFeatureFilter(EcorePackage.eINSTANCE.getEResource(), Resource.RESOURCE__CONTENTS)
	.or(NotificationFilter.createNotifierTypeFilter(EObject.class))) {
	@Override
	public void resourceSetChanged(ResourceSetChangeEvent event) {
	Set<EObject> addedObjects = new HashSet<EObject>();
	Set<EObject> removedObjects = new HashSet<EObject>();
	Set<EObject> movedObjects = new HashSet<EObject>();
	Set<EObject> changedObjects = new HashSet<EObject>();

	// Analyze notifications for changed objects; record only set/added and unset/removed objects which have
	// not got unset/removed or set/added again later on
	for (Notification notification : event.getNotifications()) {
	if (notification.getEventType() == Notification.SET \|\| notification.getEventType() == Notification.ADD
	\|\| notification.getEventType() == Notification.ADD_MANY) {
	List<EObject> newValues = new ArrayList<EObject>();
	Object newValue = notification.getNewValue();
	if (newValue instanceof List<?>) {
	@SuppressWarnings("unchecked")
	List<EObject> newValueList = (List<EObject>) newValue;
	newValues.addAll(newValueList);
	} else if (newValue instanceof EObject) {
	newValues.add((EObject) newValue);
	}

	for (EObject value : newValues) {
	changedObjects.add(value);
	if (removedObjects.contains(value)) {
	movedObjects.add(value);
	removedObjects.remove(value);
	} else {
	addedObjects.add(value);
	}
	}
	} else if (notification.getEventType() == Notification.UNSET \|\| notification.getEventType() == Notification.REMOVE
	\|\| notification.getEventType() == Notification.REMOVE_MANY) {
	List<EObject> oldValues = new ArrayList<EObject>();
	Object oldValue = notification.getOldValue();
	if (oldValue instanceof List<?>) {
	@SuppressWarnings("unchecked")
	List<EObject> oldValueList = (List<EObject>) oldValue;
	oldValues.addAll(oldValueList);
	} else if (oldValue instanceof EObject) {
	oldValues.add((EObject) oldValue);
	}

	for (EObject value : oldValues) {
	changedObjects.add(value);
	if (addedObjects.contains(value)) {
	movedObjects.add(value);
	addedObjects.remove(value);
	} else {
	removedObjects.add(value);
	}
	}
	}
	}

	// Is editor input object part of the added objects or contained by one or them?
	if (!addedObjects.isEmpty()) {
	if (editorInputChangeAnalyzer.containsEditorInputObject(editorInput, addedObjects)) {
	// Handle added editor input object
	editorInputChangeHandler.handleEditorInputObjectAdded(editorInput, addedObjects);
	}
	}

	// Is editor input object part of the removed objects or contained by one or them?
	if (!removedObjects.isEmpty()) {
	if (editorInputChangeAnalyzer.containsEditorInputObject(editorInput, removedObjects)) {
	// Handle removed editor input object
	editorInputChangeHandler.handleEditorInputObjectRemoved(editorInput, removedObjects);
	}
	}

	// Is editor input object part of the moved objects or contained by one or them?
	if (!movedObjects.isEmpty()) {
	if (editorInputChangeAnalyzer.containsEditorInputObject(editorInput, movedObjects)) {
	// Handle moved editor input object
	editorInputChangeHandler.handleEditorInputObjectMoved(editorInput, movedObjects);
	}
	}

	// Is editor input object part of the changed objects or contained by one or them?
	if (!changedObjects.isEmpty()) {
	if (editorInputChangeAnalyzer.containsEditorInputObject(editorInput, changedObjects)) {
	// Handle changed editor input object
	editorInputChangeHandler.handleEditorInputObjectChanged(editorInput, changedObjects);
	}
	}
	}

	@Override
	public boolean isPostcommitOnly() {
	return true;
	}
	};
	}

	/*
	* @see org.eclipse.emf.edit.provider.IDisposable#dispose()
	*/
	@Override
	public void dispose() {
	uninstallModelChangeListeners();
	}
	}