org.eclipse.gmf.runtime.emf.clipboard.core/src/org/eclipse/gmf/runtime/emf/clipboard/core/internal/SavingEMFResource.java - gmf-runtime/org.eclipse.gmf-runtime - Git at Google

 /******************************************************************************
  * Copyright (c) 2002, 2011 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *    IBM Corporation - initial API and implementation
  ****************************************************************************/

 package org.eclipse.gmf.runtime.emf.clipboard.core.internal;

 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.common.util.TreeIterator;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.EAnnotation;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.emf.ecore.EcoreFactory;
 import org.eclipse.emf.ecore.InternalEObject;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.emf.ecore.resource.impl.ResourceImpl;
 import org.eclipse.emf.ecore.util.EcoreEList;
 import org.eclipse.emf.ecore.util.InternalEList;
 import org.eclipse.emf.ecore.xmi.XMLResource;
 import org.eclipse.emf.ecore.xmi.XMLSave;
 import org.eclipse.emf.ecore.xmi.impl.XMISaveImpl;
 import org.eclipse.gmf.runtime.emf.clipboard.core.CopyObjects;
 import org.eclipse.gmf.runtime.emf.clipboard.core.IClipboardSupport;

 /**
  * @author Yasser Lulu
  */
 public class SavingEMFResource
 	extends SerializationEMFResource {

 	private Map copy2ObjectMap;

 	private EList contentList;

 	private Set contentSet;

 	private CopyObjects copyObjects;

 	private Collection excludedObjects;

 	public SavingEMFResource(URI uri, String encoding, Map defaultSaveOptions,
 		Map copy2ObjectMap, CopyObjects copyObjects,
 		IClipboardSupport clipboardOperationHelper) {
 		super(encoding, uri, clipboardOperationHelper);
 		this.defaultSaveOptions = defaultSaveOptions;
 		this.eObjectToIDMap = new HashMap();
 		this.idToEObjectMap = new HashMap();
 		this.copy2ObjectMap = copy2ObjectMap;
 		this.contentSet = new LinkedHashSet(copyObjects.totalCopyObjects);
 		this.copyObjects = copyObjects;
 		this.excludedObjects = clipboardOperationHelper
 			.getExcludedCopyObjects(copyObjects.totalCopyObjects);
 		//we must ensure that every EObject in the contentSet has a resource,
 		//becuase the serialization process needs that. Those who don't, will
 		// be added to us.
 		setMissingResource();
 		//set containment refs.
 		setContainmentFeatures();
 		//needed to allow calls to unload() to proceed
 		setLoaded(true);
 		if (copyObjects.sortTotalCopyObjects) {
 			sortContentSetOnOriginalStorageOrder();
 		}
 	}

 	private void sortContentSetOnOriginalStorageOrder() {
 		Map parentObjectMap = new HashMap();
 		List roots = new ArrayList();
 		Iterator it = contentSet.iterator();
 		while (it.hasNext()) {
 			EObject eObj = (EObject) it.next();
 			EObject eParent = eObj.eContainer();
 			if (eParent == null) {
 				roots.add(eObj);
 			} else {
 				List children = (List) parentObjectMap.get(eParent);
 				if (children == null) {
 					children = new ArrayList();
 					parentObjectMap.put(eParent, children);
 				}
 				children.add(eObj);
 			}
 		}//while

 		List list = new ArrayList(roots);
 		Iterator entryIt = parentObjectMap.entrySet().iterator();
 		while (entryIt.hasNext()) {
 			Map.Entry entry = (Map.Entry) entryIt.next();

 			// get the basic list view of the contents list to avoid resolving
 			//    cross-resource containment proxies
 			Collections.sort((List) entry.getValue(), new ListIndexComparator(
 				((InternalEList) ((EObject) entry.getKey()).eContents()).basicList()));
 			list.addAll((List) entry.getValue());
 		}
 		contentSet = new LinkedHashSet(list);
 	}

 	private void setContainmentFeatures() {
 		EAnnotation containmentAnnotations = EcoreFactory.eINSTANCE
 			.createEAnnotation();
 		EAnnotation eAnnotation = EcoreFactory.eINSTANCE.createEAnnotation();
 		eAnnotation.setSource(SERIALIZATION_ANNOTATIONS);
 		containmentAnnotations.getEAnnotations().add(eAnnotation);
 		Set set = new HashSet(contentSet);
 		set.addAll(copyObjects.originalObjects);
 		Iterator it = set.iterator();
 		while (it.hasNext()) {
 			EObject eObj = (EObject) it.next();
 			addToSerializationAnnotation(eAnnotation, eObj);

 			// OK to resolve containment proxies because we must load the
 			//    entire model sub-tree in order to copy it
 			TreeIterator contentIt = eObj.eAllContents();
 			while (contentIt.hasNext()) {
 				EObject childEObj = (EObject) contentIt.next();
 				if (getClipboardOperationHelper().shouldSaveContainmentFeature(
 					childEObj) == false) {
 					contentIt.prune();
 					continue;
 				}
 				addToSerializationAnnotation(eAnnotation, childEObj);
 			}
 		}
 		super.getContents().add(containmentAnnotations);
 		contentSet.add(containmentAnnotations);
 	}

 	private void addToSerializationAnnotation(EAnnotation eAnnotation,
 		EObject eObj) {
 		EObject eObjectWithValidContainer = (eObj.eContainer() == null) ? getOriginalEObject(eObj)
 			: eObj;
 		EAnnotation ref_obj_Annotation = EcoreFactory.eINSTANCE
 			.createEAnnotation();
 		ref_obj_Annotation.getReferences().add(eObj);
 		if (eObjectWithValidContainer != null) {
 			ref_obj_Annotation.getReferences().add(
 				eObjectWithValidContainer.eContainmentFeature());
 		} else {
 			// If there is no containment feature, which is the case when copying a
 			// root element, then an unattached EReference is added to the annotation.
 			// This EReference ensures that that the annotation references
 			// are serialized using CROSS_DOC.
 			// A better fix would be to add some intelligence to the sameDocMany(..) method
 			// of the XMISameImpl class created in method createXMLSave().
 			ref_obj_Annotation.getReferences().add(EcoreFactory.eINSTANCE.createEReference());
 		}
 		eAnnotation.getEAnnotations().add(ref_obj_Annotation);
 	}

 	private void setMissingResource() {
 		Iterator it = contentSet.iterator();
 		EObject eObject = null;
 		while (it.hasNext()) {
 			eObject = (EObject) it.next();
 			if (eObject.eResource() == null) {
 				//no resource (detached view-element), therefore add the
 				// top-most
 				//parent to the us so that a newer call to getResource will
 				// succeed.
 				// don't add the element itself, since adding the element to a
 				//resource will set its container to null,and we want to
 				// preserve
 				//the container of the original detached element. This means
 				// that
 				//if the element itself has no container (top-most
 				// copyAlwaysCopy),
 				//then we'll add it regardless since its parent is already
 				// null.
 				//therefore add the container of the detached original element
 				// so
 				//that the container's container will be set to null
 				while (eObject.eContainer() != null) {
 					eObject = eObject.eContainer();
 				}
 				super.getContents().add(eObject);
 			}
 		}

 		//let's make sure that things went OK, for if they didn't, the
 		//paste process or even the serialization process will fail
 		it = contentSet.iterator();
 		while (it.hasNext()) {
 			eObject = (EObject) it.next();
 			if (eObject.eResource() == null) {

 				RuntimeException e = new IllegalArgumentException();

 				ClipboardPlugin.throwing(getClass(),
 					"setMissingResource", e); //$NON-NLS-1$

 				throw e;
 			}
 		}
 	}

 	public void doLoad(InputStream inputStream, Map options) throws IOException {
 		throwUnsupportedOperationException("doLoad", //$NON-NLS-1$
 			new UnsupportedOperationException(
 				"Can't call load on serializing resource"));//$NON-NLS-1$
 	}

 	protected XMLSave createXMLSave() {
 		return new XMISaveImpl(createXMLHelper()) {

 			protected void saveElement(InternalEObject o, EStructuralFeature f) {
 				// do not save cross-resource-contained objects as hrefs, because
 				//    the clipboard resource must actually duplicate all of the
 				//    original data
 				saveElement((EObject) o, f);
 			}

 			protected void saveElement(EObject o, EStructuralFeature f) {
 				if (excludedObjects.contains(o)) {
 					return;
 				}
 				super.saveElement(o, f);
 			}

 			/**
 			 * @see org.eclipse.emf.ecore.xmi.impl.XMLSaveImpl#sameDocMany(org.eclipse.emf.ecore.EObject,
 			 *      org.eclipse.emf.ecore.EStructuralFeature)
 			 */
 			protected int sameDocMany(EObject o, EStructuralFeature f) {
 				InternalEList values = (InternalEList) helper.getValue(o, f);
 				if (values.isEmpty()) {
 					return SKIP;
 				}

 				for (Iterator i = values.basicIterator(); i.hasNext();) {
 					InternalEObject value = (InternalEObject) i.next();
 					if (value.eIsProxy()
 						|| (isInSavingResource(value) == false)) {
 						return CROSS_DOC;
 					}
 				}

 				return SAME_DOC;
 			}

 			/**
 			 * @see org.eclipse.emf.ecore.xmi.impl.XMLSaveImpl#sameDocSingle(org.eclipse.emf.ecore.EObject,
 			 *      org.eclipse.emf.ecore.EStructuralFeature)
 			 */
 			protected int sameDocSingle(EObject o, EStructuralFeature f) {
 				InternalEObject value = (InternalEObject) helper.getValue(o, f);
 				if (value == null) {
 					return SKIP;
 				} else if (value.eIsProxy()) {
 					return CROSS_DOC;
 				} else {
 					return (isInSavingResource(value)) ? SAME_DOC : CROSS_DOC;
 				}
 			}

 		};
 	}

 	boolean isInSavingResource(EObject eObject) {
 		if (eObject.eResource() == this) {
 			return true;
 		} else if ((copyObjects.originalObjects.contains(eObject))
 			|| (copyObjects.copyParent2CopyMap.values().contains(eObject))
 			|| (copyObjects.combinedCopyAlwaysSet.contains(eObject))) {
 			return true;
 		}
 		EObject eContainer = eObject.eContainer();
 		while (eContainer != null) {
 			if ((copyObjects.originalObjects.contains(eContainer))
 				|| (copyObjects.copyParent2CopyMap.values().contains(eContainer))
 				|| (copyObjects.combinedCopyAlwaysSet.contains(eContainer))) {
 				return true;
 			}
 			eContainer = eContainer.eContainer();
 		}
 		return false;
 	}

 	EObject getOriginalEObject(EObject copiedEObject) {
 		return (EObject) copy2ObjectMap.get(copiedEObject);
 	}

 	private String getOriginalID(EObject eObject) {
 		Resource res = eObject.eResource();

 		if (res != this) {
 			if (res instanceof XMLResource) {
 				return ((XMLResource) res).getID(eObject);
 			} else if (res instanceof ResourceImpl) {
 				Map<String, EObject> map = ((ResourceImpl)res).getIntrinsicIDToEObjectMap();
 				if (map != null) {
 					for (Map.Entry<String, EObject> mapEntry : map.entrySet()) {
 						if (eObject.equals(mapEntry.getValue())) {
 							return mapEntry.getKey();
 						}
 					}
 				}
 			}
 		}
 		return null;
 	}

 	/**
 	 * @see org.eclipse.emf.ecore.xmi.XMLResource#getID(org.eclipse.emf.ecore.EObject)
 	 */
 	public String getID(EObject eObject) {

 		//is this an original object?
 		String id = getOriginalID(eObject);
 		if (id == null) {
 			//no, then, is it a copied object?
 			EObject original = (EObject) copy2ObjectMap.get(eObject);
 			if (original != null) {
 				id = getOriginalID(original);
 			} else {
 				Resource res = eObject.eResource();

 				if (res != null) {
 					//we'll use our own assigned ids, (detached view-elements bug)
 					assert eObject.eResource() == this: "eObject.eResource not same as self"; //$NON-NLS-1$
 					id = super.getID(eObject);
 				}
 			}
 		}
 		return id;
 	}

 	/**
 	 * @see org.eclipse.emf.ecore.resource.impl.ResourceImpl#getContents()
 	 */

 	private static class ContentBasicEList
 		extends EcoreEList.UnmodifiableEList
 		implements InternalEList {

 		private static final long serialVersionUID = -2551747854798104709L;

 		ContentBasicEList(Set contentSet) {
 			super(null, null, contentSet.size(), contentSet.toArray());
 		}
 	}

 	public EList getContents() {
 		if (contentList == null) {
 			contentList = new ContentBasicEList(contentSet);
 		}
 		return contentList;
 	}

 	/**
 	 * @see org.eclipse.emf.ecore.resource.impl.ResourceImpl#doUnload()
 	 */
 	protected void doUnload() {
 		//unset resource for those whom we've actually added to ourselves -in the setMissingResource() above
 		//be carefull that the super.getContents() list is a ContentsEList and therefore calling clear on it
 		//it will end up calling eInverseRemove on the EObjects it holds and they in turn would end up
 		//calling the getResource().getContents() to remove themselves, but as we know that our own getContents()
 		// list is unmodifiable and this will throw an exception, therefore replace our own getContents() list
 		//with our parent's super.getContents() list before we clear it
 		contentList = super.getContents();
 		super.getContents().clear();

 	}
 }
	/******************************************************************************
	* Copyright (c) 2002, 2011 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	****************************************************************************/

	package org.eclipse.gmf.runtime.emf.clipboard.core.internal;

	import java.io.IOException;
	import java.io.InputStream;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.LinkedHashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	import org.eclipse.emf.common.util.EList;
	import org.eclipse.emf.common.util.TreeIterator;
	import org.eclipse.emf.common.util.URI;
	import org.eclipse.emf.ecore.EAnnotation;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.EStructuralFeature;
	import org.eclipse.emf.ecore.EcoreFactory;
	import org.eclipse.emf.ecore.InternalEObject;
	import org.eclipse.emf.ecore.resource.Resource;
	import org.eclipse.emf.ecore.resource.impl.ResourceImpl;
	import org.eclipse.emf.ecore.util.EcoreEList;
	import org.eclipse.emf.ecore.util.InternalEList;
	import org.eclipse.emf.ecore.xmi.XMLResource;
	import org.eclipse.emf.ecore.xmi.XMLSave;
	import org.eclipse.emf.ecore.xmi.impl.XMISaveImpl;
	import org.eclipse.gmf.runtime.emf.clipboard.core.CopyObjects;
	import org.eclipse.gmf.runtime.emf.clipboard.core.IClipboardSupport;

	/**
	* @author Yasser Lulu
	*/
	public class SavingEMFResource
	extends SerializationEMFResource {

	private Map copy2ObjectMap;

	private EList contentList;

	private Set contentSet;

	private CopyObjects copyObjects;

	private Collection excludedObjects;

	public SavingEMFResource(URI uri, String encoding, Map defaultSaveOptions,
	Map copy2ObjectMap, CopyObjects copyObjects,
	IClipboardSupport clipboardOperationHelper) {
	super(encoding, uri, clipboardOperationHelper);
	this.defaultSaveOptions = defaultSaveOptions;
	this.eObjectToIDMap = new HashMap();
	this.idToEObjectMap = new HashMap();
	this.copy2ObjectMap = copy2ObjectMap;
	this.contentSet = new LinkedHashSet(copyObjects.totalCopyObjects);
	this.copyObjects = copyObjects;
	this.excludedObjects = clipboardOperationHelper
	.getExcludedCopyObjects(copyObjects.totalCopyObjects);
	//we must ensure that every EObject in the contentSet has a resource,
	//becuase the serialization process needs that. Those who don't, will
	// be added to us.
	setMissingResource();
	//set containment refs.
	setContainmentFeatures();
	//needed to allow calls to unload() to proceed
	setLoaded(true);
	if (copyObjects.sortTotalCopyObjects) {
	sortContentSetOnOriginalStorageOrder();
	}
	}

	private void sortContentSetOnOriginalStorageOrder() {
	Map parentObjectMap = new HashMap();
	List roots = new ArrayList();
	Iterator it = contentSet.iterator();
	while (it.hasNext()) {
	EObject eObj = (EObject) it.next();
	EObject eParent = eObj.eContainer();
	if (eParent == null) {
	roots.add(eObj);
	} else {
	List children = (List) parentObjectMap.get(eParent);
	if (children == null) {
	children = new ArrayList();
	parentObjectMap.put(eParent, children);
	}
	children.add(eObj);
	}
	}//while

	List list = new ArrayList(roots);
	Iterator entryIt = parentObjectMap.entrySet().iterator();
	while (entryIt.hasNext()) {
	Map.Entry entry = (Map.Entry) entryIt.next();

	// get the basic list view of the contents list to avoid resolving
	// cross-resource containment proxies
	Collections.sort((List) entry.getValue(), new ListIndexComparator(
	((InternalEList) ((EObject) entry.getKey()).eContents()).basicList()));
	list.addAll((List) entry.getValue());
	}
	contentSet = new LinkedHashSet(list);
	}

	private void setContainmentFeatures() {
	EAnnotation containmentAnnotations = EcoreFactory.eINSTANCE
	.createEAnnotation();
	EAnnotation eAnnotation = EcoreFactory.eINSTANCE.createEAnnotation();
	eAnnotation.setSource(SERIALIZATION_ANNOTATIONS);
	containmentAnnotations.getEAnnotations().add(eAnnotation);
	Set set = new HashSet(contentSet);
	set.addAll(copyObjects.originalObjects);
	Iterator it = set.iterator();
	while (it.hasNext()) {
	EObject eObj = (EObject) it.next();
	addToSerializationAnnotation(eAnnotation, eObj);

	// OK to resolve containment proxies because we must load the
	// entire model sub-tree in order to copy it
	TreeIterator contentIt = eObj.eAllContents();
	while (contentIt.hasNext()) {
	EObject childEObj = (EObject) contentIt.next();
	if (getClipboardOperationHelper().shouldSaveContainmentFeature(
	childEObj) == false) {
	contentIt.prune();
	continue;
	}
	addToSerializationAnnotation(eAnnotation, childEObj);
	}
	}
	super.getContents().add(containmentAnnotations);
	contentSet.add(containmentAnnotations);
	}

	private void addToSerializationAnnotation(EAnnotation eAnnotation,
	EObject eObj) {
	EObject eObjectWithValidContainer = (eObj.eContainer() == null) ? getOriginalEObject(eObj)
	: eObj;
	EAnnotation ref_obj_Annotation = EcoreFactory.eINSTANCE
	.createEAnnotation();
	ref_obj_Annotation.getReferences().add(eObj);
	if (eObjectWithValidContainer != null) {
	ref_obj_Annotation.getReferences().add(
	eObjectWithValidContainer.eContainmentFeature());
	} else {
	// If there is no containment feature, which is the case when copying a
	// root element, then an unattached EReference is added to the annotation.
	// This EReference ensures that that the annotation references
	// are serialized using CROSS_DOC.
	// A better fix would be to add some intelligence to the sameDocMany(..) method
	// of the XMISameImpl class created in method createXMLSave().
	ref_obj_Annotation.getReferences().add(EcoreFactory.eINSTANCE.createEReference());
	}
	eAnnotation.getEAnnotations().add(ref_obj_Annotation);
	}

	private void setMissingResource() {
	Iterator it = contentSet.iterator();
	EObject eObject = null;
	while (it.hasNext()) {
	eObject = (EObject) it.next();
	if (eObject.eResource() == null) {
	//no resource (detached view-element), therefore add the
	// top-most
	//parent to the us so that a newer call to getResource will
	// succeed.
	// don't add the element itself, since adding the element to a
	//resource will set its container to null,and we want to
	// preserve
	//the container of the original detached element. This means
	// that
	//if the element itself has no container (top-most
	// copyAlwaysCopy),
	//then we'll add it regardless since its parent is already
	// null.
	//therefore add the container of the detached original element
	// so
	//that the container's container will be set to null
	while (eObject.eContainer() != null) {
	eObject = eObject.eContainer();
	}
	super.getContents().add(eObject);
	}
	}

	//let's make sure that things went OK, for if they didn't, the
	//paste process or even the serialization process will fail
	it = contentSet.iterator();
	while (it.hasNext()) {
	eObject = (EObject) it.next();
	if (eObject.eResource() == null) {

	RuntimeException e = new IllegalArgumentException();

	ClipboardPlugin.throwing(getClass(),
	"setMissingResource", e); //$NON-NLS-1$

	throw e;
	}
	}
	}

	public void doLoad(InputStream inputStream, Map options) throws IOException {
	throwUnsupportedOperationException("doLoad", //$NON-NLS-1$
	new UnsupportedOperationException(
	"Can't call load on serializing resource"));//$NON-NLS-1$
	}

	protected XMLSave createXMLSave() {
	return new XMISaveImpl(createXMLHelper()) {

	protected void saveElement(InternalEObject o, EStructuralFeature f) {
	// do not save cross-resource-contained objects as hrefs, because
	// the clipboard resource must actually duplicate all of the
	// original data
	saveElement((EObject) o, f);
	}

	protected void saveElement(EObject o, EStructuralFeature f) {
	if (excludedObjects.contains(o)) {
	return;
	}
	super.saveElement(o, f);
	}

	/**
	* @see org.eclipse.emf.ecore.xmi.impl.XMLSaveImpl#sameDocMany(org.eclipse.emf.ecore.EObject,
	* org.eclipse.emf.ecore.EStructuralFeature)
	*/
	protected int sameDocMany(EObject o, EStructuralFeature f) {
	InternalEList values = (InternalEList) helper.getValue(o, f);
	if (values.isEmpty()) {
	return SKIP;
	}

	for (Iterator i = values.basicIterator(); i.hasNext();) {
	InternalEObject value = (InternalEObject) i.next();
	if (value.eIsProxy()
	\|\| (isInSavingResource(value) == false)) {
	return CROSS_DOC;
	}
	}

	return SAME_DOC;
	}

	/**
	* @see org.eclipse.emf.ecore.xmi.impl.XMLSaveImpl#sameDocSingle(org.eclipse.emf.ecore.EObject,
	* org.eclipse.emf.ecore.EStructuralFeature)
	*/
	protected int sameDocSingle(EObject o, EStructuralFeature f) {
	InternalEObject value = (InternalEObject) helper.getValue(o, f);
	if (value == null) {
	return SKIP;
	} else if (value.eIsProxy()) {
	return CROSS_DOC;
	} else {
	return (isInSavingResource(value)) ? SAME_DOC : CROSS_DOC;
	}
	}

	};
	}

	boolean isInSavingResource(EObject eObject) {
	if (eObject.eResource() == this) {
	return true;
	} else if ((copyObjects.originalObjects.contains(eObject))
	\|\| (copyObjects.copyParent2CopyMap.values().contains(eObject))
	\|\| (copyObjects.combinedCopyAlwaysSet.contains(eObject))) {
	return true;
	}
	EObject eContainer = eObject.eContainer();
	while (eContainer != null) {
	if ((copyObjects.originalObjects.contains(eContainer))
	\|\| (copyObjects.copyParent2CopyMap.values().contains(eContainer))
	\|\| (copyObjects.combinedCopyAlwaysSet.contains(eContainer))) {
	return true;
	}
	eContainer = eContainer.eContainer();
	}
	return false;
	}

	EObject getOriginalEObject(EObject copiedEObject) {
	return (EObject) copy2ObjectMap.get(copiedEObject);
	}

	private String getOriginalID(EObject eObject) {
	Resource res = eObject.eResource();

	if (res != this) {
	if (res instanceof XMLResource) {
	return ((XMLResource) res).getID(eObject);
	} else if (res instanceof ResourceImpl) {
	Map<String, EObject> map = ((ResourceImpl)res).getIntrinsicIDToEObjectMap();
	if (map != null) {
	for (Map.Entry<String, EObject> mapEntry : map.entrySet()) {
	if (eObject.equals(mapEntry.getValue())) {
	return mapEntry.getKey();
	}
	}
	}
	}
	}
	return null;
	}

	/**
	* @see org.eclipse.emf.ecore.xmi.XMLResource#getID(org.eclipse.emf.ecore.EObject)
	*/
	public String getID(EObject eObject) {

	//is this an original object?
	String id = getOriginalID(eObject);
	if (id == null) {
	//no, then, is it a copied object?
	EObject original = (EObject) copy2ObjectMap.get(eObject);
	if (original != null) {
	id = getOriginalID(original);
	} else {
	Resource res = eObject.eResource();

	if (res != null) {
	//we'll use our own assigned ids, (detached view-elements bug)
	assert eObject.eResource() == this: "eObject.eResource not same as self"; //$NON-NLS-1$
	id = super.getID(eObject);
	}
	}
	}
	return id;
	}

	/**
	* @see org.eclipse.emf.ecore.resource.impl.ResourceImpl#getContents()
	*/

	private static class ContentBasicEList
	extends EcoreEList.UnmodifiableEList
	implements InternalEList {

	private static final long serialVersionUID = -2551747854798104709L;

	ContentBasicEList(Set contentSet) {
	super(null, null, contentSet.size(), contentSet.toArray());
	}
	}

	public EList getContents() {
	if (contentList == null) {
	contentList = new ContentBasicEList(contentSet);
	}
	return contentList;
	}

	/**
	* @see org.eclipse.emf.ecore.resource.impl.ResourceImpl#doUnload()
	*/
	protected void doUnload() {
	//unset resource for those whom we've actually added to ourselves -in the setMissingResource() above
	//be carefull that the super.getContents() list is a ContentsEList and therefore calling clear on it
	//it will end up calling eInverseRemove on the EObjects it holds and they in turn would end up
	//calling the getResource().getContents() to remove themselves, but as we know that our own getContents()
	// list is unmodifiable and this will throw an exception, therefore replace our own getContents() list
	//with our parent's super.getContents() list before we clear it
	contentList = super.getContents();
	super.getContents().clear();

	}
	}