Attachment #32208 for bug #113863




import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.xmi.XMLResource;
import org.eclipse.emf.ecore.xmi.impl.XMIHelperImpl;
import org.eclipse.gmf.runtime.emf.core.internal.util.MSLConstants;
import org.eclipse.gmf.runtime.emf.core.internal.util.MSLUtil;
import org.eclipse.gmf.runtime.emf.core.util.EObjectUtil;

 * @author rafikj
 */
public class MSLHelper
	extends XMIHelperImpl {

	/**
	 * Constructor.
	 */
	public MSLHelper(XMLResource resource) {
		super(resource);
	}





import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.xmi.XMLHelper;
import org.eclipse.emf.ecore.xmi.XMLResource;
import org.eclipse.emf.ecore.xmi.impl.XMISaveImpl;
import org.eclipse.emf.ecore.xmi.impl.XMLSaveImpl;

import org.eclipse.gmf.runtime.emf.core.internal.util.MSLConstants;

 * @author rafikj
 */
public class MSLSave
	extends XMISaveImpl {

	/**
	 * Discards control characters 0x00 - 0x1F except for TAB, CR, and LF, which

	public Object writeTopObjects(List contents) {

		writeCCToken();
		writeArtifactVersionToken();
		return super.writeTopObjects(contents);
	}





/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resources;

import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.xmi.impl.XMIHelperImpl;


public class LogicalHelper
	extends XMIHelperImpl {

	private final LogicalResource logicalResource;
	private final LogicalResourceUnit unit;
	private boolean urisRelativeToRoot = true;
	
	public LogicalHelper(LogicalResourceUnit resource) {
		super(resource);
		
		logicalResource = resource.getLogicalResource();
		unit = resource;
	}
	
	LogicalResource getLogicalResource() {
		return logicalResource;
	}
	
	LogicalResourceUnit getUnit() {
		return unit;
	}
	
	boolean urisRelativeToRoot() {
		return urisRelativeToRoot;
	}
	
	void setUrisRelativeToRoot(boolean b) {
		urisRelativeToRoot = b;
	}

	protected URI getHREF(Resource otherResource, EObject obj) {
		if (otherResource instanceof LogicalResource) {
			LogicalResource otherLogical = (LogicalResource) otherResource;
			URI uri;
			
			if (urisRelativeToRoot()) {
				uri = otherLogical.getURI();
			} else {
				uri = otherLogical.getUnit(obj).getURI();
			}
			
			return uri.appendFragment(otherResource.getURIFragment(obj));
		}
		
		return super.getHREF(otherResource, obj);
	}
	
	/**
	 * Extends the superclass implementation to ensure that proxies for elements
	 * in unloaded resources are not discarded.
	 */
	protected URI handleDanglingHREF(EObject object) {
		URI result;
		
		URI proxyUri = EcoreUtil.getURI(object);
		if ((proxyUri != null)
				&& proxyUri.trimFragment().equals(getLogicalResource().getURI())) {
			// do not discard unresolved references to unloaded units
			//   of the logical resource
			result = proxyUri;
		} else {
			result = super.handleDanglingHREF(object);
		}
		
		return result;
	}
}




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resources;

import org.eclipse.emf.ecore.xmi.XMLHelper;
import org.eclipse.emf.ecore.xmi.impl.SAXWrapper;
import org.eclipse.emf.ecore.xmi.impl.XMILoadImpl;
import org.xml.sax.helpers.DefaultHandler;


/**
 * Loader implementation for logical resources.  This implementation ensures
 * that XML namespace EPackages are loaded in the same resource set as the
 * logical resource, not its internal resource set for the physical resources.
 *
 * @author Christian W. Damus (cdamus)
 */
public class LogicalLoad
	extends XMILoadImpl {

	/**
	 * Initializes me with my helper helper.
	 * 
	 * @param helper my helper
	 */
	public LogicalLoad(XMLHelper helper) {
		super(helper);
	}
	
	/**
	 * Creates a {@link LogicalHandler}.
	 */
	protected DefaultHandler makeDefaultHandler() {
		return new SAXWrapper(
			new LogicalHandler((LogicalResourceUnit) resource, helper, options));
	}

}




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resources;

import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EFactory;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.gmf.runtime.common.core.util.Log;
import org.eclipse.gmf.runtime.emf.core.internal.l10n.EMFCoreMessages;
import org.eclipse.gmf.runtime.emf.core.internal.plugin.MSLDebugOptions;
import org.eclipse.gmf.runtime.emf.core.internal.plugin.MSLPlugin;
import org.eclipse.gmf.runtime.emf.core.internal.plugin.MSLStatusCodes;
import org.eclipse.gmf.runtime.emf.core.internal.util.Trace;
import org.eclipse.gmf.runtime.emf.core.resources.AbstractLogicalResourcePolicy;
import org.eclipse.gmf.runtime.emf.core.resources.CannotAbsorbException;
import org.eclipse.gmf.runtime.emf.core.resources.CannotSeparateException;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResourcePolicy;
import org.eclipse.osgi.util.NLS;


/**
 * Manager of {@link ILogicalResourcePolicy} implementations registered on the
 * <tt>org.eclipse.gmf.runtime.emf.core.resourcePolicies</tt> extension point.
 *
 * @author Christian W. Damus (cdamus)
 */
public class LogicalResourcePolicyManager implements ILogicalResourcePolicy {
	private static final String EXT_POINT = "resourcePolicies"; //$NON-NLS-1$
	private static final String E_POLICY = "policy"; //$NON-NLS-1$
	private static final String E_EPACKAGE = "epackage"; //$NON-NLS-1$
	private static final String E_EFACTORY = "efactory"; //$NON-NLS-1$
	private static final String A_NSURI = "nsURI"; //$NON-NLS-1$
	private static final String A_CLASS = "class"; //$NON-NLS-1$
	
	private static final LogicalResourcePolicyManager INSTANCE =
		new LogicalResourcePolicyManager();
	
	private static final ILogicalResourcePolicy[] EMPTY_ARRAY =
		new ILogicalResourcePolicy[0];
	
	private final Map policyMap = new java.util.HashMap();
	private final Map factoryMap = new java.util.HashMap();
	
	/**
	 * Not instantiable by clients.
	 */
	private LogicalResourcePolicyManager() {
		super();
		initializePolicyExtensions();
	}

	/**
	 * Obtains the singleton policy manager instance.
	 * 
	 * @return the policy manager
	 */
	public static LogicalResourcePolicyManager getInstance() {
		return INSTANCE;
	}
	
	/**
	 * Initializes me from the extension point.
	 */
	private void initializePolicyExtensions() {
		IConfigurationElement[] elements =
			Platform.getExtensionRegistry().getConfigurationElementsFor(
			MSLPlugin.getPluginId(), EXT_POINT);
		
		for (int i = 0; i < elements.length; i++) {
			if (E_POLICY.equals(elements[i].getName())) {
				initializePolicy(elements[i]);
			} else if (E_EFACTORY.equals(elements[i].getName())) {
				initializeFactory(elements[i]);
			} else {
				Log.log(
					MSLPlugin.getDefault(),
					IStatus.WARNING,
					MSLStatusCodes.LOGICAL_INVALID_POLICY_ELEMENT,
					NLS.bind(EMFCoreMessages.resourcePolicy_element_WARN_,
						new Object[] {
							elements[i].getName(),
							elements[i].getNamespace()}),
					null);
			}
		}
		
		// convert the policy map's lists to arrays
		for (Iterator iter = policyMap.entrySet().iterator(); iter.hasNext();) {
			Map.Entry next = (Map.Entry) iter.next();
			List list = (List) next.getValue();
			
			next.setValue(list.toArray(new ILogicalResourcePolicy[list.size()]));
		}
	}
	
	private void initializePolicy(IConfigurationElement element) {
		PolicyDescriptor descriptor = new PolicyDescriptor(element);
		
		List nsUris = descriptor.getNamespaceUris();
		
		if (nsUris.isEmpty()) {
			Log.warning(
				MSLPlugin.getDefault(),
				MSLStatusCodes.LOGICAL_INVALID_POLICY_ELEMENT,
				NLS.bind(EMFCoreMessages.resourcePolicy_nsUris_WARN_, element.getNamespace())
			);
		} else {
			for (Iterator iter = nsUris.iterator(); iter.hasNext();) {
				String nsUri = (String) iter.next();
				
				List list = (List) policyMap.get(nsUri);
				if (list == null) {
					list = new java.util.ArrayList();
					policyMap.put(nsUri, list);
				}
				
				list.add(descriptor);
			}
		}
	}
	
	private void initializeFactory(IConfigurationElement element) {
		FactoryDescriptor descriptor = new FactoryDescriptor(element);
		factoryMap.put(descriptor.getNamespaceUri(), descriptor);
	}
	
	/**
	 * Gets the policies pertaining to the specified model element.
	 * 
	 * @param eObject an element
	 * @return the policies or an empty array if none (never <code>null</code>)
	 */
	ILogicalResourcePolicy[] getPolicies(EObject eObject) {
		return getPolicies(eObject.eClass().getEPackage().getNsURI());
	}
	
	/**
	 * Gets the policies pertaining to the specified metamodel.
	 * 
	 * @param nsUri a metamodel namespace URI
	 * @return the policies or an empty array if none (never <code>null</code>)
	 */
	ILogicalResourcePolicy[] getPolicies(String nsUri) {
		ILogicalResourcePolicy[] result =
			(ILogicalResourcePolicy[]) policyMap.get(nsUri);
		
		if (result == null) {
			result = EMPTY_ARRAY;
			policyMap.put(nsUri, result);
		}
		
		return result;
	}

	public boolean canSeparate(ILogicalResource resource, EObject eObject) {
		boolean result = true;
		ILogicalResourcePolicy[] policies = getPolicies(eObject);
		
		for (int i = 0; result && (i < policies.length); i++) {
			try {
				if (Trace.isEnabled(MSLDebugOptions.RESOURCES)) {
					Trace.trace(
						MSLDebugOptions.RESOURCES,
						"Invoking canSeparate() on policy: " + policies[i]); //$NON-NLS-1$
				}
				
				result = policies[i].canSeparate(resource, eObject);
			} catch (RuntimeException e) {
				Trace.catching(getClass(), "canSeparate", e); //$NON-NLS-1$
				Log.warning(
					MSLPlugin.getDefault(),
					MSLStatusCodes.LOGICAL_POLICY_FAILED,
					EMFCoreMessages.resource_policy_EXC_,
					e);
			}
		}
		
		return result;
	}

	public URI preSeparate(ILogicalResource resource, EObject eObject, URI uri)
		throws CannotSeparateException {
		
		URI result = uri;
		ILogicalResourcePolicy[] policies = getPolicies(eObject);
		
		for (int i = 0; i < policies.length; i++) {
			try {
				if (Trace.isEnabled(MSLDebugOptions.RESOURCES)) {
					Trace.trace(
						MSLDebugOptions.RESOURCES,
						"Invoking preSeparate() on policy: " + policies[i]); //$NON-NLS-1$
				}
				
				URI suggestion = policies[i].preSeparate(resource, eObject, uri);
				
				if (result == null) {
					result = suggestion;
				}
			} catch (RuntimeException e) {
				Trace.catching(getClass(), "preSeparate", e); //$NON-NLS-1$
				Log.warning(
					MSLPlugin.getDefault(),
					MSLStatusCodes.LOGICAL_POLICY_FAILED,
					EMFCoreMessages.resource_policy_EXC_,
					e);
			}
		}
		
		return result;
	}

	public void postSeparate(ILogicalResource resource, EObject eObject, URI uri) {
		ILogicalResourcePolicy[] policies = getPolicies(eObject);
		
		for (int i = 0; i < policies.length; i++) {
			try {
				if (Trace.isEnabled(MSLDebugOptions.RESOURCES)) {
					Trace.trace(
						MSLDebugOptions.RESOURCES,
						"Invoking postSeparate() on policy: " + policies[i]); //$NON-NLS-1$
				}
				
				policies[i].postSeparate(resource, eObject, uri);
			} catch (RuntimeException e) {
				Trace.catching(getClass(), "postSeparate", e); //$NON-NLS-1$
				Log.warning(
					MSLPlugin.getDefault(),
					MSLStatusCodes.LOGICAL_POLICY_FAILED,
					EMFCoreMessages.resource_policy_EXC_,
					e);
			}
		}
	}

	public void preAbsorb(ILogicalResource resource, EObject eObject)
		throws CannotAbsorbException {
		
		ILogicalResourcePolicy[] policies = getPolicies(eObject);
		
		for (int i = 0; i < policies.length; i++) {
			try {
				if (Trace.isEnabled(MSLDebugOptions.RESOURCES)) {
					Trace.trace(
						MSLDebugOptions.RESOURCES,
						"Invoking preAbsorb() on policy: " + policies[i]); //$NON-NLS-1$
				}
				
				policies[i].preAbsorb(resource, eObject);
			} catch (RuntimeException e) {
				Trace.catching(getClass(), "preAbsorb", e); //$NON-NLS-1$
				Log.warning(
					MSLPlugin.getDefault(),
					MSLStatusCodes.LOGICAL_POLICY_FAILED,
					EMFCoreMessages.resource_policy_EXC_,
					e);
			}
		}
	}

	public void postAbsorb(ILogicalResource resource, EObject eObject) {
		ILogicalResourcePolicy[] policies = getPolicies(eObject);
		
		for (int i = 0; i < policies.length; i++) {
			try {
				if (Trace.isEnabled(MSLDebugOptions.RESOURCES)) {
					Trace.trace(
						MSLDebugOptions.RESOURCES,
						"Invoking postAbsorb() on policy: " + policies[i]); //$NON-NLS-1$
				}
				
				policies[i].postAbsorb(resource, eObject);
			} catch (RuntimeException e) {
				Trace.catching(getClass(), "postAbsorb", e); //$NON-NLS-1$
				Log.warning(
					MSLPlugin.getDefault(),
					MSLStatusCodes.LOGICAL_POLICY_FAILED,
					EMFCoreMessages.resource_policy_EXC_,
					e);
			}
		}
	}
	
	/**
	 * Instantiates the specified <code>EClass</code> in order to create an
	 * unloaded element.  This method will use a factory registered on the
	 * extension point for this purpose, if any.  Otherwise, it will use the
	 * package's default factory.
	 * 
	 * @param eClass the <code>EClass</code> to create
	 * @return a new instance of it
	 */
	public EObject create(EClass eClass) {
		EFactory factory = getEFactory(eClass.getEPackage());
		return factory.create(eClass);
	}
	
	/**
	 * Gets the most appropriate factory for the specified package.  This might
	 * be one that is registered on the extension point, or it might not.
	 * 
	 * @param epackage the <code>EPackage</code> to get a factory for
	 * @return the corresponding factory
	 */
	public EFactory getEFactory(EPackage epackage) {
		EFactory result;
		FactoryDescriptor descriptor = (FactoryDescriptor) factoryMap.get(
			epackage.getNsURI());
		
		if (descriptor == null) {
			result = epackage.getEFactoryInstance();
		} else {
			result = descriptor.instantiate();
		}
		
		return result;
	}
	
	/**
	 * Extension descriptor that lazily initializes the delegate policy instance
	 * when required.  It replaces itself by the delegate for efficiency.
	 *
	 * @author Christian W. Damus (cdamus)
	 */
	private class PolicyDescriptor implements ILogicalResourcePolicy {
		private IConfigurationElement config;
		private List namespaceUris = new java.util.ArrayList();
		private ILogicalResourcePolicy delegate;
		
		PolicyDescriptor(IConfigurationElement config) {
			this.config = config;
			
			IConfigurationElement[] elements = config.getChildren();
			for (int i = 0; i < elements.length; i++) {
				if (E_EPACKAGE.equals(elements[i].getName())) {
					String nsUri = elements[i].getAttribute(A_NSURI);
					
					if ((nsUri != null) && (nsUri.length() > 0)) {
						namespaceUris.add(nsUri);
					}
				} else {
					Log.log(
						MSLPlugin.getDefault(),
						IStatus.WARNING,
						MSLStatusCodes.LOGICAL_INVALID_POLICY_ELEMENT,
						NLS.bind(EMFCoreMessages.resourcePolicy_element_WARN_,
							new Object[] {
								elements[i].getName(),
								elements[i].getNamespace()}),
						null);
				}
			}
		}
		
		List getNamespaceUris() {
			return namespaceUris;
		}
		
		/**
		 * Ensures that my delegate is instantiated and replaces me in the
		 * manager's map.
		 * 
		 * @return the actual policy, or a null implementation if the real one
		 *     failed to initialize
		 */
		ILogicalResourcePolicy instantiate() {
			if (delegate == null) {
				try {
					delegate = (ILogicalResourcePolicy) config.createExecutableExtension(A_CLASS);
				} catch (CoreException e) {
					Trace.catching(getClass(), "instantiate", e); //$NON-NLS-1$
					
					Log.log(MSLPlugin.getDefault(), e.getStatus());
					
					delegate = new NullPolicy();
				}
				
				for (Iterator iter = getNamespaceUris().iterator(); iter.hasNext();) {
					String nsUri = (String) iter.next();
					
					ILogicalResourcePolicy[] policies = getPolicies(nsUri);
					for (int i = 0; i < policies.length; i++) {
						if (policies[i] == this) {
							policies[i] = delegate;
						}
					}
				}
			}
			
			return delegate;
		}

		public boolean canSeparate(ILogicalResource resource, EObject eObject) {
			instantiate();
			
			return delegate.canSeparate(resource, eObject);
		}

		public URI preSeparate(ILogicalResource resource, EObject eObject, URI uri)
			throws CannotSeparateException {
			
			instantiate();
			
			return delegate.preSeparate(resource, eObject, uri);
		}

		public void postSeparate(ILogicalResource resource, EObject eObject, URI uri) {
			instantiate();
			
			delegate.postSeparate(resource, eObject, uri);
		}

		public void preAbsorb(ILogicalResource resource, EObject eObject)
			throws CannotAbsorbException {
			
			instantiate();
			
			delegate.preAbsorb(resource, eObject);
		}

		public void postAbsorb(ILogicalResource resource, EObject eObject) {
			instantiate();
			
			delegate.postAbsorb(resource, eObject);
		}
		
		public String toString() {
			instantiate();
			
			return delegate.toString();
		}
	}
	
	/**
	 * Extension descriptor that lazily initializes the delegate factory instance
	 * when required.
	 *
	 * @author Christian W. Damus (cdamus)
	 */
	private class FactoryDescriptor {
		private IConfigurationElement config;
		private String namespaceUri;
		private EFactory factory;
		
		FactoryDescriptor(IConfigurationElement config) {
			this.config = config;
			namespaceUri = config.getAttribute(A_NSURI);
		}
		
		String getNamespaceUri() {
			return namespaceUri;
		}
		
		/**
		 * Ensures that my delegate is instantiated and replaces me in the
		 * manager's map.
		 * 
		 * @return the actual factory, or the default implementation if the
		 *     configured one failed to initialize
		 */
		EFactory instantiate() {
			if (factory == null) {
				try {
					factory = (EFactory) config.createExecutableExtension(A_CLASS);
				} catch (CoreException e) {
					Trace.catching(getClass(), "instantiate", e); //$NON-NLS-1$
					
					Log.log(MSLPlugin.getDefault(), e.getStatus());
					
					factory = EPackage.Registry.INSTANCE.getEPackage(
						getNamespaceUri()).getEFactoryInstance();
				}
			}
			
			return factory;
		}
	}
	
	/**
	 * Placeholder for policy extensions that could not be instantiated.
	 *
	 * @author Christian W. Damus (cdamus)
	 */
	private static final class NullPolicy extends AbstractLogicalResourcePolicy {
		NullPolicy() {
			super();
		}
	}
}




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resources;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.util.ECollections;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.URIConverter;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.ecore.util.EContentAdapter;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.gmf.runtime.common.core.util.Log;
import org.eclipse.gmf.runtime.emf.core.internal.l10n.EMFCoreMessages;
import org.eclipse.gmf.runtime.emf.core.internal.plugin.MSLDebugOptions;
import org.eclipse.gmf.runtime.emf.core.internal.plugin.MSLPlugin;
import org.eclipse.gmf.runtime.emf.core.internal.plugin.MSLStatusCodes;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage;
import org.eclipse.gmf.runtime.emf.core.internal.util.Trace;
import org.eclipse.gmf.runtime.emf.core.resources.AbstractLogicalResource;
import org.eclipse.gmf.runtime.emf.core.resources.CannotAbsorbException;
import org.eclipse.gmf.runtime.emf.core.resources.CannotSeparateException;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;
import org.eclipse.gmf.runtime.emf.core.resources.MResourceFactory;
import org.eclipse.osgi.util.NLS;

/**
 * Implementation of the {@linkplain ILogicalResource logical resource} API.
 * <p>
 * <b>Note</b> that subclasses are encouraged to define also a companion unit
 * class extending {@link LogicalResourceUnit}, in case they have any need to
 * customize the serialization of their physical resources.  If a custom unit
 * class is implemented, then the logical resource class must override the
 * {@link #createUnit(URI)} method to create instances of the appropriate unit
 * class.
 * </p>
 * <p>
 * For example:
 * </p><pre>
 *     public class MyResource extends LogicalResource {
 *         // ... fields and stuff ...
 *         
 *         public MyResource(URI uri) {
 *             super(root, uri);
 *             
 *             // ... other initialization ...
 *         }
 *         
 *         protected LogicalResourceUnit createUnit(URI uri) {
 *             return new MyResourceUnit(uri, this);
 *         }
 *         
 *         // ... other methods and stuff ...
 *     }
 *     
 *     public class MyResourceUnit extends LogicalResourceUnit {
 *         public MyResourceUnit(URI uri, MyResource logical) {
 *             super(uri, logical);
 *         }
 *         
 *         // ... other stuff here ...
 *     }
 * </pre>
 *
 * @see LogicalResourceUnit
 * @see #createUnit(URI)
 * 
 * @author Christian W. Damus (cdamus)
 */
public class LogicalResource
	extends AbstractLogicalResource
	implements ILogicalResource {

	private DirtyAdapter dirtyAdapter;
	
	// stores the individual sub-unit resources.  All resources share one copy
	//    so that they can resolve x-refs to the same physical resource
	private final ResourceSet subunitResourceSet;
	
	private boolean autoLoadEnabled = true;
	
	/**
	 * Initializes me with my URI.
	 * 
	 * @param uri my URI
	 */
	protected LogicalResource(URI uri) {
		super(uri);
		
		dirtyAdapter = new DirtyAdapter();
		eAdapters().add(dirtyAdapter);
		subunitResourceSet = new SubunitResourceSet();
		contents = new LogicalContentsList();
	}

	protected boolean useUUIDs() {
		return true;
	}
	
	/**
	 * Creates a new unit of this logical resource.  Subclasses must override
	 * to create an instance of their companion unit class.
	 * 
	 * @param uri the URI of the new unit
	 * @return the new unit
	 */
	protected LogicalResourceUnit createUnit(URI unitUri) {
		return new LogicalResourceUnit(unitUri, this);
	}
	
	public boolean isSeparate(EObject eObject) {
		return LogicalResourceUtil.isSeparate(this, eObject);
	}
	
	protected void doSeparate(EObject eObject, URI physUri) throws CannotSeparateException {
		LogicalResourceUtil.separate(this, eObject, physUri);
	}
	
	protected void doAbsorb(EObject eObject) throws CannotAbsorbException {
		LogicalResourceUtil.absorb(this, eObject);
	}
	
	public boolean isLoaded(EObject eObject) {
		return LogicalResourceUtil.isLoaded(this, eObject);
	}
	
	protected void doLoad(EObject eObject) throws IOException {
		LogicalResourceUtil.load(this, eObject);
		
		LogicalResourceUnit unit = getUnit(eObject);
		
		// Propagate content adapters to the now-loaded object.
		//    Make sure that the adapters' propagation, if they encounter any
		//    more unloaded objects, doesn't cause the rest of the tree
		//    to load prematurely
		try {
			unit.disableAutoLoad();
			eObject.eAdapters().addAll(
				0,
				getContentAdapters(eObject.eContainer()));
		} finally {
			unit.enableAutoLoad();
		}
	}
	
	// overridden to make it visible in this package
	protected void addMappedResource(EObject object, Resource subunit) {
		super.addMappedResource(object, subunit);
	}

	// overridden to make it visible in this package
	protected void removeMappedResource(EObject object) {
		super.removeMappedResource(object);
	}
	
	// overridden to make it visible in this package
	protected Map getResourceMap() {
		return super.getResourceMap();
	}
	
	protected Resource getPhysicalResource(URI physUri) {
		Resource result = getSubunitResourceSet().getResource(physUri, false);
		
		if (result != null) {
			result = UnmodifiableResourceView.get(result);
		}
		
		return result;
	}
	
	/**
	 * Extends the inherited method to revert the logical resource to a single,
	 * monolithic logical resource on the new URI.  This ensures that saving the
	 * resource under a new URI does not leave the former root resource
	 * disconnected from its sub-units (as they would be subordinate to the
	 * new URI).  It also ensures that there will be no need to check out all of
	 * the sub-units in an SCM environment.
	 */
	public void setURI(URI uri) {
		super.setURI(uri);
		
		// load any as-yet-unloaded sub-units
		try {
			LogicalResourceUtil.loadAllUnloadedUnits(this);
		} catch (IOException e) {
			Trace.catching(getClass(), "setURI(URI)", e); //$NON-NLS-1$
			
			Log.error(
				MSLPlugin.getDefault(),
				MSLStatusCodes.LOGICAL_SETURI_UNLOADED_FAILED,					
				NLS.bind(EMFCoreMessages.setUri_unloaded_failed_EXC_, uri),
				e);
		}
		
		// forget all of my sub-units
		clearMappedResources();
		getSubunitResourceSet().getResources().clear();
		
		// create my new physical root
		LogicalResourceUnit phys = getRootUnit();
		phys.setDirty();
		
		// all of my roots are in the new physical root
		phys.getContents().addAll(getContents());
	}
	
	public Object getAdapter(Class adapter) {
		if (adapter == ResourceSet.class) {
			// I do represent a resource set, in a sense
			return getSubunitResourceSet();
		} else {
			return Platform.getAdapterManager().getAdapter(this, adapter);
		}
	}
	
	/**
	 * Finds and, if necessary, creates the physical resource corresponding
	 * to the logical resource URI.  This is the "root" of the physical resource
	 * structure.
	 * 
	 * @return the root physical resource
	 */
	LogicalResourceUnit getRootUnit() {
		LogicalResourceUnit result =
			(LogicalResourceUnit) getSubunitResourceSet().getResource(
				getURI(),
				false);
		
		if (result == null) {
			result = (LogicalResourceUnit) getSubunitResourceSet().createResource(
				getURI());
		}
		
		return result;
	}
	
	/**
	 * Obtains the resource set that maintains my physical resources.
	 * 
	 * @return my physical resource set
	 */
	ResourceSet getSubunitResourceSet() {
		return subunitResourceSet;
	}
	
	/**
	 * Ensures that the specified element has all of the content adapters
	 * attached to it that its container has.
	 * 
	 * @param eObject the element
	 */
	void propagateContentAdapters(EObject eObject) {
		eObject.eAdapters().addAll(getContentAdapters(eObject.eContainer()));
	}
	
	/**
	 * Ensures that the specified element does not have my dirty adapter
	 * attached to it.
	 * 
	 * @param eObject the element
	 */
	void removeContentAdapters(EObject eObject) {
		eObject.eAdapters().removeAll(getContentAdapters(eObject));
	}
	
	/**
	 * Gets those of the adapters attached to an element that are content
	 * adapters.  If the element is <code>null</code>, then the adapters on the
	 * logical resource are returned, for convenience when an element's
	 * container (which normally would propagate) is <code>null</code>.
	 * 
	 * @param eObject an element, or <code>null</code> to get the adapters on
	 *      the logical resource
	 * @return the content adapters (and not other kinds of adapters)
	 */
	List getContentAdapters(EObject eObject) {
		Collection adapters;
		if (eObject == null) {
			adapters = eAdapters();
		} else {
			adapters = eObject.eAdapters();
		}
		
		List result = new java.util.ArrayList(adapters.size());
		for (Iterator iter = adapters.iterator(); iter.hasNext();) {
			Object next = iter.next();
			
			if (next instanceof EContentAdapter) {
				result.add(next);
			}
		}
		
		return result;
	}
	
	private void initCustomLoadOptions(Map options) {
		if (!options.containsKey(OPTION_LOAD_AS_LOGICAL)) {
			options.put(OPTION_LOAD_AS_LOGICAL, Boolean.TRUE);
		}
		
		if (!Boolean.TRUE.equals(options.get(OPTION_LOAD_AS_LOGICAL))) {
			// don't load any sub-units
			options.put(OPTION_LOAD_ALL_UNITS, Boolean.FALSE);
			options.put(OPTION_AUTO_LOAD_UNITS, Boolean.FALSE);
		} else {
			if (!options.containsKey(OPTION_LOAD_ALL_UNITS)) {
				options.put(OPTION_LOAD_ALL_UNITS, Boolean.FALSE);
			}
			
			if (!options.containsKey(OPTION_AUTO_LOAD_UNITS)) {
				options.put(OPTION_AUTO_LOAD_UNITS, Boolean.TRUE);
			}
		}
		
		// propagate to demand-loaded sub-units
		((SubunitResourceSet) getSubunitResourceSet()).clearLoadOptions();
		getSubunitResourceSet().getLoadOptions().putAll(options);
	}
	
	public void doLoad(InputStream inputStream, Map options)
		throws IOException {
		
		try {
			disableAutoLoad();
			dirtyAdapter.disable();
			
			initCustomLoadOptions(options);
			
			final boolean loadAsLogical = Boolean.TRUE.equals(
				options.get(OPTION_LOAD_AS_LOGICAL));
			
			// do the loading
			
			LogicalResourceUnit physicalRoot = getRootUnit();
			
			LogicalResourceUtil.loadUnit(physicalRoot, inputStream);
			
			if (loadAsLogical && (physicalRoot.getResourceIndex() != null)) {
				// if we're loading ourselves as a logical resource, then
				//    check whether we are opening the root resource
				ResourceMap rootIndex = physicalRoot.getResourceIndex().getRootMap();
				
				if ((rootIndex != null) && (rootIndex != physicalRoot.getResourceIndex())) {
					
					// I am not the root of the logical resource.  I need to
					//   load it and become it.  Be sure to load the whole
					//   containment chain up to the root
					
					// This handles the case where rootIndex is a proxy
					URI rootUri = EcoreUtil.getURI(rootIndex).trimFragment();
					
					// Be careful not to set the URI of the physical resource
					//    that I have already loaded
					super.setURI(rootUri);
					
					physicalRoot = getRootUnit();
					
					if (!physicalRoot.isLoaded()) {
						// this shouldn't happen, because we should have
						//    resolved the rootIndex reference by loading
						//    the root resource already!
						LogicalResourceUtil.loadUnit(physicalRoot);
					}
				}
			} else if (!loadAsLogical && getContents().isEmpty()) {
				// we didn't get any of the logical roots, yet, from the true
				//    root unit, so we should fake it
				EList actualRoots = physicalRoot.getContents();
				int offset = 1 + actualRoots.indexOf(
					physicalRoot.getResourceIndex());
				
				getContents().addAll(actualRoots.subList(
					offset, actualRoots.size()));
			}
		} finally {
			dirtyAdapter.enable();
		}
		
		if (Trace.isEnabled(MSLDebugOptions.RESOURCES)) {
			Trace.trace(
				MSLDebugOptions.RESOURCES,
				"Loaded logical resource: " + getURI()); //$NON-NLS-1$
		}
	}
	
	public void save(Map options)
		throws IOException {
		
		if (getRootUnit().isDirty() || isMonolithic()) {
			// for compatibility with the defaultXMI resource implementation,
			//   we will force the save even when we are not dirty, if we
			//   are monolithic
			super.save(options);
		} else {
			// we're not dirty, so we don't need an output stream to write to,
			//    but we probably have sub-units that need saving
			doSave((OutputStream)null, options);
			setModified(false);
		}
	}
	
	public void doSave(OutputStream outputStream, Map options)
		throws IOException {
		
		try {
			dirtyAdapter.disable();
			
			cleanupResourceIndices();
			
			LogicalResourceUnit phys = getRootUnit();
			
			if (phys.isDirty() ||(outputStream != null)) {
				// use this output stream to save my physical root resource
				phys.save(outputStream, options);
			}
			
			saveSubunits(options, getSubunitResourceSet());
			
			if (Trace.isEnabled(MSLDebugOptions.RESOURCES)) {
				Trace.trace(
					MSLDebugOptions.RESOURCES,
					"Saved logical resource: " + getURI()); //$NON-NLS-1$
			}
		} finally {
			dirtyAdapter.enable();
			
			if (errors != null) {
				// look for an IOException that indicates a save problem, and
				//    throw it
				for (Iterator iter = errors.iterator(); iter.hasNext();) {
					Object next = iter.next();
					
					if (next instanceof IOException) {
						IOException e = (IOException) next;
						Trace.throwing(getClass(), "doSave(OutputStream, Map)", e); //$NON-NLS-1$
						throw e;
					}
				}
			}
		}
	}
	
	/**
	 * Queries whether auto-loading of sub-units is enabled.
	 * 
	 * @return <code>true</code> if auto-loading of sub-units is enabled;
	 *     <code>false</code>, otherwise
	 */
	boolean isAutoLoadEnabled() {
		return autoLoadEnabled;
	}
	
	/**
	 * Turns off auto-loading of unloaded sub-units.
	 */
	void disableAutoLoad() {
		autoLoadEnabled = false;
	}
	
	/**
	 * Turns on auto-loading of unloaded sub-units.  This should only be
	 * invoked either by the root resource when it first becomes unmodified
	 * after loading.
	 */
	void enableAutoLoad() {
		autoLoadEnabled = true;
	}
	
	/**
	 * Used by the root of the logical resource to save all of its sub-unit
	 * resources that are dirty.
	 * 
	 * @param options the current save options (all units saved with the same
	 *    options
	 * @param rset the resource set containing the sub-unit resources
	 * @throws IOException if anything goes wrong in saving a resource
	 */
	private void saveSubunits(Map options, ResourceSet rset) {
		for (Iterator iter = rset.getResources().iterator(); iter.hasNext();) {
			LogicalResourceUnit next = (LogicalResourceUnit) iter.next();
			
			if (next.isDirty()) {
				try {
					next.save(options);
				} catch (IOException e) {
					Trace.catching(getClass(), "saveSubunits(Map, ResourceSet)", e); //$NON-NLS-1$
					error(e);
				}
			}
		}
	}
	
	/**
	 * Adds a throwable to my list of error-severity exceptions.
	 * 
	 * @param t a throwable to add to my errors
	 */
	protected void error(Throwable t) {
		getErrors().add(t);
	}
	
	protected void doUnload() {
		super.doUnload();
		
		clearMappedResources();
		
		ResourceSet rset = getSubunitResourceSet();
		List toUnload = new java.util.ArrayList(rset.getResources());
		
		for (Iterator iter = toUnload.iterator(); iter.hasNext();) {
			((Resource) iter.next()).unload();
		}
		
		rset.getResources().clear();
	}
	
	/**
	 * Queries whether I am a monolithic logical resource, comprising only a
	 * single physical resource.
	 * 
	 * @return whether I do not comprise more than one physical resource
	 */
	boolean isMonolithic() {
		return getSubunitResourceSet().getResources().size() < 2;
	}
	
	/**
	 * Cleans up my resource indices to ensure that they are up-to-date when we
	 * save.  This should only be invoked on the root resource.
	 */
	private void cleanupResourceIndices() {
		Set resources = new java.util.HashSet(
			getSubunitResourceSet().getResources());
		
		// let each resource recompute its resource index if it is dirty.
		//   This may even involve moving sub-units between parent units
		for (Iterator iter = resources.iterator(); iter.hasNext();) {
			LogicalResourceUnit subunit = (LogicalResourceUnit) iter.next();
		
			if (subunit.isDirty()) {
				subunit.cleanupResourceIndex();
			} else {
				iter.remove(); // don't process in the next loop
			}
		}
		
		// now, we must sort the sub-unit entries for each parent object
		//    by position, so that we will not try to insert them out of
		//    sequence on next loading (which would access invalid indices).
		//    Do this in a separate loop once all resources know their
		//    sub-units
		Comparator comp = new Comparator() {
			public int compare(Object o1, Object o2) {
				return ((ResourceEntry) o1).getChildPosition()
					- ((ResourceEntry) o2).getChildPosition();
			}};
			
		for (Iterator iter = resources.iterator(); iter.hasNext();) {
			LogicalResourceUnit subunit = (LogicalResourceUnit) iter.next();
			ResourceMap index = subunit.getResourceIndex();
			
			if (index != null) {
				List toSort = index.getParentEntries();
				
				for (Iterator jter = toSort.iterator(); jter.hasNext();) {
					ParentEntry next = (ParentEntry) jter.next();
					ECollections.sort(next.getResourceEntries(), comp);
				}
			}
		}
	}
	
	/**
	 * Ensures that I know (and that adapters listening know) that I am loaded.
	 */
	void loaded() {
		if (!isLoaded()) {
			Notification notification = setLoaded(true);
			if (notification != null) {
				eNotify(notification);
			}
		}
	}
	
	public void setModified(boolean isModified) {
		super.setModified(isModified);
		
		if (!isModified) {
			// NOTE: Must do this only after firing the notification (in the
			// super method) because that is when the MSL's indexer traverses
			// the content tree, and it would force all of my sub-units to load
			enableAutoLoad();
		}
	}
	
	/**
	 * Finds and returns the physical resource that stores the specified
	 * element.
	 * 
	 * @param eObject an element in the logical resource
	 * @return the corresponding physical resource
	 * 
	 * @throws IllegalArgumentException if the <code>eObject</code> is not
	 *     in the logical resource
	 */
	public LogicalResourceUnit getUnit(EObject eObject) {
		return LogicalResourceUtil.getUnitFor(this, eObject);
	}
	
	/**
	 * Listens for changes in the contents of the logical resource, to set the
	 * dirty flag on the appropriate physical resource and to keep the physical
	 * mapping metadata up to date.
	 *
	 * @author Christian W. Damus (cdamus)
	 */
	private class DirtyAdapter extends EContentAdapter {
		private boolean enabled;
		
		public boolean isAdapterForType(Object type) {
			return type == DirtyAdapter.class;
		}
		
		/**
		 * Extends the inherited method to mark sub-units (physical resources)
		 * as dirty when their logical contents change, but only when dirty
		 * tracking is enabled.
		 */
		public void notifyChanged(Notification notification) {
			super.notifyChanged(notification);
			
			if (isEnabled() && !notification.isTouch()) {
				Object feature = notification.getFeature();
				if (feature instanceof EStructuralFeature &&
						((EStructuralFeature) feature).isTransient()) {
					// don't respond to transient features
					return;
				}
				
				Object notifier = notification.getNotifier();
				
				if (notifier instanceof EObject) {
					EObject eObject = (EObject) notifier;
					
					if ((eObject.eResource() != null)
							&& (eObject.eClass().getEPackage() != ResourceMapPackage.eINSTANCE)) {
						LogicalResourceUnit dirtyUnit = getUnit((EObject) notifier);
						dirtyUnit.setDirty();
					}
				} else if (notifier instanceof LogicalResource) {
					if (notification.getFeatureID(Resource.class) == Resource.RESOURCE__CONTENTS) {
						// any change in the contents list means that either the
						//    root unit's contents list is changed or its resource
						//    map is changed
						getRootUnit().setDirty();
					}
				}
			}
		}

		/**
		 * Extends the inherited method to update the resource index metadata
		 * whenever a separate element is removed from or added to the logical
		 * content tree.
		 */
		protected void handleContainment(Notification notification) {
			super.handleContainment(notification);
			
			if (isEnabled()) {
				Object notifier = notification.getNotifier();
				Object feature = notification.getFeature();
				
				switch (notification.getEventType()) {
					case Notification.SET:
					case Notification.UNSET: {
						Object value = notification.getOldValue();
						if (value != null) {
							removeFromResourceIndex(notifier, feature, value);
						}
						value = notification.getNewValue();
						if (value != null) {
							addToResourceIndex(value);
						}
						break;
					}
					case Notification.ADD: {
						addToResourceIndex(notification.getNewValue());
						break;
					}
					case Notification.MOVE: {
						updateResourceIndex(
							notification.getNewValue(),
							notification.getPosition());
						break;
					}
					case Notification.ADD_MANY: {
						Collection c = (Collection) notification.getNewValue();
						for (Iterator iter = c.iterator(); iter.hasNext(); ) {
							Object next = iter.next();
							addToResourceIndex(next);
						}
						break;
					}
					case Notification.REMOVE: {
						removeFromResourceIndex(
							notifier, feature, notification.getOldValue());
						break;
					}
					case Notification.REMOVE_MANY: {
						Collection c = (Collection) notification.getOldValue();
						for (Iterator iter = c.iterator(); iter.hasNext(); ) {
							Object next = iter.next();
							removeFromResourceIndex(notifier, feature, next);
						}
						break;
					}
				}
			}
		}
		
		/**
		 * Updates the resource index metadata when an element that was
		 * separate is added back into the content tree.  This recomputes the
		 * index in reparenting scenarios.
		 * 
		 * @param object an object added to the logical content tree
		 */
		private void addToResourceIndex(Object object) {
			if (object instanceof EObject) {
				EObject eObject = (EObject) object;
				EObject parent = eObject.eContainer();
				
				// is this a separate element that we are being added to?  If so,
				//    then we need to update the resource map for it
				addMappedResource(eObject, null);
				
				LogicalResourceUnit subunit =
					(LogicalResourceUnit) getResourceMap().get(eObject);
				
				if ((subunit != null) && !subunit.isRoot()) {
					subunit.getContents().add(eObject);
					
					LogicalResourceUnit parentUnit = getUnit(parent);
					if (parentUnit != null) {
						parentUnit.setDirty();
						updateChildPositions(parentUnit, parent, eObject.eContainmentFeature());
					}
				}
			}
		}
		
		/**
		 * Updates the resource index metadata when an element that was
		 * separate is removed from the content tree.  This recomputes the
		 * index in reparenting scenarios.
		 * 
		 * @param notifier the notifier from which an object was removed
		 * @param feature the containment feature from which an object was removed
		 * @param object an object removed from the logical content tree
		 */
		private void removeFromResourceIndex(Object notifier, Object feature, Object object) {
			if (object instanceof EObject) {
				EObject eObject = (EObject) object;
				EObject parent = null;
				EReference containment = null;
				
				if (notifier instanceof EObject) {
					parent = (EObject) notifier;
					containment = (EReference) feature;
				} // else the notifier is a resource, so the parent is null
				 
				// is this a separate element that we are being removed from?  If so,
				//    then we need to update the resource map for it
				LogicalResourceUnit subunit =
					(LogicalResourceUnit) getResourceMap().get(eObject);
				
				if ((subunit != null) && !subunit.isRoot()) {
					subunit.getContents().remove(eObject);
					
					// the adapter will afterwards find the new unit and dirty it
					subunit.setDirty();
					
					removeMappedResource(eObject);
					
					LogicalResourceUnit parentUnit = getUnit(parent);
					
					if (parentUnit != null) {
						parentUnit.setDirty();
						updateChildPositions(parentUnit, parent, containment);
					}
				}
			}
		}
		
		/**
		 * Updates the resource index metadata when an element is moved within
		 * a containment collection.  This recomputes the child position.
		 * 
		 * @param object an object moved in a containment collection
		 * @param position the new child position
		 */
		private void updateResourceIndex(Object object, int position) {
			if (object instanceof EObject) {
				EObject eObject = (EObject) object;
					
				// is this a separate element that we are being added to?  If so,
				//    then we need to update the resource map for it
				LogicalResourceUnit subunit =
					(LogicalResourceUnit) getResourceMap().get(eObject);
				
				if ((subunit != null) && !subunit.isRoot()) {
					LogicalResourceUnit parentUnit = getUnit(eObject.eContainer());
					ResourceEntry entry = parentUnit.getResourceIndex().getResourceEntry(
						eObject);
					
					if (entry != null) {
						entry.setChildPosition(position);
					}
				}
			}
		}
		
		/**
		 * Updates the positions in the physical resource map of the separate
		 * children in a containment reference in which an element has been
		 * added or removed.
		 * 
		 * @param unit the unit that owns <code>parent</code> element
		 * @param parent an element that had a child added or removed
		 * @param containment the containment reference
		 */
		private void updateChildPositions(
				LogicalResourceUnit unit,
				EObject parent,
				EReference containment) {
			
			if (unit != null) {
				// must update the positions of all other separate
				//    elements in the same container and feature, because
				//    they have been moved (though no MOVE event occurs)
				ResourceMap index = unit.getResourceIndex();
				if (index != null) {
					ParentEntry entry = index.getParentEntry(
						parent,
						containment);
					
					if (entry != null) {
						LogicalResourceUtil.updateChildPositions(unit, entry);
					}
				}
			}
		}
		
		final boolean isEnabled() {
			return enabled;
		}
		
		void enable() {
			enabled = true;
		}
		
		void disable() {
			enabled = false;
		}
	}
	
	/**
	 * Special resource set implementation to manage the physical resources
	 * comprising a logical resource.  This resource set delegates several
	 * features to the logical resource's containing resource set:
	 * <ul>
	 *   <li>URI converter:  to get the uri mappings (such as pathmaps)</li>
	 *   <li>load options:  for consistent deserialization characteristics</li>
	 *   <li>package registry:  for consistent resolution of demand-loaded
	 *       packages (such as for XML namespaces)</li>
	 *   <li>resource factory registry:  just in case, though a sub-unit
	 *       resource set will always create resources of the same actual type
	 *       as the logical resource</li>
	 * </ul>
	 *
	 * @author Christian W. Damus (cdamus)
	 */
	private class SubunitResourceSet extends ResourceSetImpl {
		private Map options;
		
		SubunitResourceSet() {
			super();
		}
		
		public URIConverter getURIConverter() {
			// we need to use the same URI converter as the logical resource's
			//    resource set in order to access path maps
			return LogicalResource.this.getURIConverter();
		}
		
		public Map getLoadOptions() {
			if (options == null) {
				options = new java.util.HashMap();
				
				// get default load options from the outer resource set
				ResourceSet rset = LogicalResource.this.getResourceSet();
				
				if (rset != null) {
					options.putAll(rset.getLoadOptions());
				} else {
					options.putAll(MResourceFactory.getDefaultLoadOptions());
				}
			}
			
			return options;
		}
		
		void clearLoadOptions() {
			options = null;
		}
		
		public EPackage.Registry getPackageRegistry() {
			EPackage.Registry result;
			
			// delegate package registry to the outer resource set
			ResourceSet rset = LogicalResource.this.getResourceSet();
			
			if (rset != null) {
				result = rset.getPackageRegistry();
			} else {
				result = super.getPackageRegistry();
			}
			
			return result;
		}
		
		public Resource.Factory.Registry getResourceFactoryRegistry() {
			Resource.Factory.Registry result;
			
			// delegate resource factory registry to the outer resource set
			ResourceSet rset = LogicalResource.this.getResourceSet();
			
			if (rset != null) {
				result = rset.getResourceFactoryRegistry();
			} else {
				result = Resource.Factory.Registry.INSTANCE;
			}
			
			return result;
		}
		
		protected void demandLoad(Resource resource)
			throws IOException {
			
			if (resource instanceof LogicalResourceUnit) {
				// we always want to load sub-units using the method that
				//   correctly links their roots into the content tree (where
				//   the parent unit is already loaded)
				LogicalResourceUtil.loadUnit((LogicalResourceUnit) resource);
			} else {
				// shouldn't happen, but just in case ...
				super.demandLoad(resource);
			}
		}
		
		public Resource createResource(URI newUri) {
			LogicalResourceUnit result = createUnit(newUri);
			
			getResources().add(result);
			
			return result;
		}
	}
	
	/**
	 * Contents list for the logical resource.  This list does have an inverse,
	 * according to the usual EMF resource contents.  Thus, the contents of
	 * a logical resource really do consider the logical resource to be their
	 * ultimate container.
	 *
	 * @author Christian W. Damus (cdamus)
	 */
	private class LogicalContentsList extends ContentsEList {
		private static final long serialVersionUID = 1L;
		
		protected void didAdd(int index, Object object) {
			super.didAdd(index, object);
			didAddImpl(index, object);
		}
		
		private void didAddImpl(int index, Object object) {
			if (!getResourceMap().containsKey(object)) {
				// do not put a separate logical root into the root unit
				
				LogicalResourceUnit phys = getRootUnit();
				EList actualRoots = phys.getContents();
				
				if (!phys.getContents().contains(object)) {
					int offset = 1 + actualRoots.indexOf(
						phys.getResourceIndex());
					
					phys.getContents().add(offset + index, object);
				}
			}
		}
		
		protected void didRemove(int index, Object object) {
			super.didRemove(index, object);
			didRemoveImpl(index, object);
		}
		
		private void didRemoveImpl(int index, Object object) {
			getRootUnit().getContents().remove(object);
		}
		
		protected void didSet(int index, Object newObject, Object oldObject) {
			super.didSet(index, newObject, oldObject);
			didRemoveImpl(index, oldObject);
			didAddImpl(index, newObject);
		}
	}
}




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

import java.io.IOException;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;

import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;



 * @author Christian W. Damus (cdamus)
 * 
 * @see #canSeparate(EObject)
 * 
 * @deprecated Use the cross-resource containment support provided by EMF,
 *     instead, by defining containment features that are capable of storing
 *     proxies.
 */
public class LogicalResourceWrapper
	extends AbstractResourceWrapper

			return new LogicalResourceWrapper(resource);
		}};
	
	private Map resourceMap;
	
	/**
	 * Initializes me with the delegate that I wrap.
	 * 

	}

	public Map getMappedResources() {
		return Collections.EMPTY_MAP;
			resourceMap = new java.util.HashMap() {
				{
					eAdapters().add(new AdapterImpl() {
						public void notifyChanged(Notification msg) {
							if (msg.getFeatureID(null) == RESOURCE__CONTENTS) {
								switch (msg.getEventType()) {
								case Notification.ADD:
									add(msg.getNewValue());
									break;
								case Notification.ADD_MANY:
									addAll((Collection) msg.getNewValue());
									break;
								case Notification.REMOVE:
									remove(msg.getOldValue());
									break;
								case Notification.REMOVE_MANY:
									removeAll((Collection) msg.getOldValue());
									break;
								case Notification.SET:
									remove(msg.getOldValue());
									add(msg.getNewValue());
								}
							}
						}});
					
					addAll(getContents());
				}
				
				void add(Object o) {
					put(o, UnmodifiableResourceView.get(getWrappedResource()));
				}
				
				void addAll(Collection c) {
					for (Iterator iter = c.iterator(); iter.hasNext();) {
						add(iter.next());
					}
				}
				
				void removeAll(Collection c) {
					for (Iterator iter = c.iterator(); iter.hasNext();) {
						remove(c);
					}
				}};
			
			resourceMap = Collections.unmodifiableMap(resourceMap);
		}
		
		return resourceMap;
	}

	public Object getAdapter(Class adapter) {




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resources;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.NotificationChain;
import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.util.InternalEList;
import org.eclipse.emf.ecore.xmi.XMLHelper;
import org.eclipse.emf.ecore.xmi.XMLLoad;
import org.eclipse.emf.ecore.xmi.XMLSave;
import org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl;

import org.eclipse.gmf.runtime.emf.core.internal.plugin.MSLDebugOptions;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapFactory;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage;
import org.eclipse.gmf.runtime.emf.core.internal.util.MSLUtil;
import org.eclipse.gmf.runtime.emf.core.internal.util.Trace;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;
import org.eclipse.gmf.runtime.emf.core.util.EObjectUtil;

/**
 * Implementation of a physical unit of a {@link LogicalResource}.  Units are
 * serialized as XMI.  It is recommended (though not required) that subclasses
 * of the logical resource provide companion unit classes extending this one.
 * See the <code>LogicalResource</code> documentation for details.
 * 
 * @see LogicalResource
 *
 * @author Christian W. Damus (cdamus)
 */
public class LogicalResourceUnit
	extends XMIResourceImpl {

	private final LogicalResource logical;
	private boolean dirty = false;
	
	private boolean autoLoadEnabled = true;
	
	// this list has no inverse references
	private EList roots = new ContentsList();
	
	private ResourceMap resourceIndex;
	
	/**
	 * Initializes me with as a child of the specified <code>logical</code>
	 * resource.
	 * 
	 * @param uri my URI
	 * @param logical my logical resource
	 */
	protected LogicalResourceUnit(URI uri, LogicalResource logical) {
		super(uri);
		
		this.logical = logical;
	}

	protected boolean useUUIDs() {
		return true;
	}
	
	/**
	 * Gets the logical resource that owns me.
	 * 
	 * @return my logical resource
	 */
	LogicalResource getLogicalResource() {
		return logical;
	}
	
	/**
	 * Queries whether I am the root unit.
	 * 
	 * @return whether I am the root unit
	 */
	boolean isRoot() {
		ResourceMap index = getResourceIndex();
		
		// don't resolve the proxy, because we want to avoid loading this
		//    resource if possible (in case of loading as physical)
		return (index == null) ||
			(index.eGet(ResourceMapPackage.eINSTANCE.getResourceMap_RootMap(), false) == null);
	}
	
	public void doLoad(InputStream inputStream, Map options)
		throws IOException {
		
		try {
			disableAutoLoad();
			Map idMap = LogicalResourceUtil.getUnloadedElements(this);
			
			super.doLoad(inputStream, options);
			
			// must reconcile my roots with any unloaded "proxies" in parent
			//   units before loading my sub-units, otherwise I will
			//     - try to splice sub-units into the wrong indices in empty
			//       collections in the unloaded elements
			//     - if the previous worked, I will lose the sub-units when
			//       replacing the proxy's collections with my own
			LogicalResourceUtil.reconcileUnloadedUnits(this, idMap);
			
			if (getResourceIndex() != null) {
				loadParentUnits(getResourceIndex(), options);
				loadSubunits(getResourceIndex(), options);
			}
		} finally {
			// We will finally propagate any errors or warnings to
			//  the parent logical resource so that it obeys the regular
			//  EMF resource contract by providing all errors and warnings
			//  that occurred during a load.
			getLogicalResource().getErrors().addAll(getErrors());
			getLogicalResource().getWarnings().addAll(getWarnings());
			setClean();
			enableAutoLoad();
		}
		
		if (Trace.isEnabled(MSLDebugOptions.RESOURCES)) {
			URI base = getLogicalResource().getURI();
			String relative = getURI().deresolve(base).toString();
			
			if (relative.length() == 0) {
				relative = "(root)"; //$NON-NLS-1$
			}
			
			Trace.trace(
				MSLDebugOptions.RESOURCES,
				"Loaded unit: " + relative + " of: " + base); //$NON-NLS-1$ //$NON-NLS-2$
		}
	}
	
	public void doSave(OutputStream outputStream, Map options)
		throws IOException {
		
		try {
			if (isDirty() || (outputStream != null)) {
				// don't try to write if I don't need it, unless somebody has
				//   already created an output stream, in which case we would
				//   erase the contents of our file if we didn't proceed
				super.doSave(outputStream, options);
				
				if (Trace.isEnabled(MSLDebugOptions.RESOURCES)) {
					URI base = getLogicalResource().getURI();
					String relative = getURI().deresolve(base).toString();
					
					if (relative.length() == 0) {
						relative = "(root)"; //$NON-NLS-1$
					}
					
					Trace.trace(
						MSLDebugOptions.RESOURCES,
						"Saved unit: " + relative + " of: " + base); //$NON-NLS-1$ //$NON-NLS-2$
				}
			}
		} finally {
			setClean();
		}
	}
	
	/**
	 * Queries whether auto-loading of sub-units is enabled.
	 * 
	 * @return <code>true</code> if auto-loading of sub-units is enabled;
	 *     <code>false</code>, otherwise
	 */
	boolean isAutoLoadEnabled() {
		return autoLoadEnabled && getLogicalResource().isAutoLoadEnabled();
	}
	
	/**
	 * Turns off auto-loading of unloaded sub-units.
	 */
	void disableAutoLoad() {
		autoLoadEnabled = false;
	}
	
	/**
	 * Turns on auto-loading of unloaded sub-units.  After the resource has
	 * finished loading (this distinguishes this flag from the
	 * <code>isLoaded</code> state).
	 */
	void enableAutoLoad() {
		autoLoadEnabled = true;
	}
	
	/**
	 * If we are loading as a logical resource, ensures that the parent units
	 * of my roots are loaded.
	 * 
	 * @param index my physical resource map
	 * @param options my load options
	 */
	private void loadParentUnits(ResourceMap index, Map options) {
		final boolean loadUnits = Boolean.TRUE.equals(
			options.get(ILogicalResource.OPTION_LOAD_AS_LOGICAL));
		
		for (Iterator iter = index.getChildEntries().iterator(); iter.hasNext();) {
			ChildEntry childEntry = (ChildEntry) iter.next();
			
			// be sure to resolve this reference
			childEntry.getChildObject();
			
			if (loadUnits) {
				// dereference parent resource map to force parent unit to load,
				//    if that load option is enabled
				childEntry.getParentMap();
			}
		}
	}
	
	/**
	 * Loads separate elements from sub-units according to the load options.
	 * At a minimum, unloaded "proxies" are created that will be filled in
	 * later.
	 * <p>
	 * <b>Note</b> that, as a special case, logical roots that are separate
	 * elements are always loaded because we must have all logical roots
	 * (at least) accounted for.
	 * </p>
	 * 
	 * @param index my physical resource map
	 * @param options my load options
	 */
	private void loadSubunits(ResourceMap index, Map options) {
		final boolean loadUnits = Boolean.TRUE.equals(
			options.get(ILogicalResource.OPTION_LOAD_ALL_UNITS));
		
		for (Iterator iter = index.getParentEntries().iterator(); iter.hasNext();) {
			ParentEntry parentEntry = (ParentEntry) iter.next();
			
			EObject parent = parentEntry.getParentObject();
			EReference slot = parentEntry.getChildSlot();
			
			if ((parent != null) && parent.eIsProxy()) {
				// this should not happen, because the parent must be in me
				parent = EcoreUtil.resolve(parent, getResourceSet());
			}
			
			for (Iterator iter2 = parentEntry.getResourceEntries().iterator(); iter2.hasNext();) {
				ResourceEntry subunit = (ResourceEntry) iter2.next();
				
				int pos = subunit.getChildPosition();
				
				EObject child;
				if (loadUnits || (parent == null)) {
					// may result in proxy if unit not found
					child = subunit.getChildObject();
				} else {
					// just get the proxy without resolving it
					child = (EObject) subunit.eGet(
						ResourceMapPackage.eINSTANCE.getResourceEntry_ChildObject(),
						false);
				}
				
				if (child.eIsProxy()) {
					// we may have loaded this unit already, by reaching
					//   another of its roots
					URI physUri = EcoreUtil.getURI(child).trimFragment();
					Resource res = getResourceSet().getResource(
						physUri, false);
					if (res == null) {
						res = getResourceSet().createResource(physUri);
					}
					subunit.setResource(res);
					
					if (res.isLoaded()) {
						// try to resolve the reference to the sub-unit in the
						//   dedicated resource set
						child = EcoreUtil.resolve(child, getResourceSet());
					} else {
						// create a stand-in for the child element
						//   but do not load its resource
						getLogicalResource().addMappedResource(child, res);
						
						// grab the object's ID while it is still a proxy
						String id = MSLUtil.getProxyID(child);
						String name = MSLUtil.getProxyName(child);
						
						// this object will do nicely for the time being, so
						// de-proxyize it now that we know the resource
						((InternalEObject) child).eSetProxyURI(null);
						addToParent(parent, slot, pos, child);
						
						// remove the dirty adapter because we don't care about
						//    changes in the "proxy" object
						getLogicalResource().removeContentAdapters(child);

						if (id != null) {
							setID(child, id);
						}
						if (name != null) {
							EObjectUtil.setName(child, name);
						}
					}
				}
				
				if (!child.eIsProxy() && (child.eContainer() == null)) {
					// we resolved to the root of a sub-unit resource (and
					//    didn't create an unloaded element, because it has
					//    a container).
					// Don't ask for eResource() because the child doesn't
					//    know it
					LogicalResourceUnit res = getLogicalResource().getUnit(child);
					
					subunit.setResource(res);
					addToParent(parent, slot, pos, child);
					
					if (res.getContents().get(0) instanceof ResourceMap) {
						// load its sub-units, recursively
						res.loadSubunits(
							(ResourceMap) res.getContents().get(0),
							options);
					}
					
					res.setClean();
				}
			}
		}
	}
	
	/**
	 * Inserts the specified <code>child</code> object (loaded from a sub-unit)
	 * into the correct <code>pos</code>ition in the correct <code>slot</code>
	 * of its <code>parent</code> element.
	 * 
	 * @param parent the parent element to insert the <code>child</code> into,
	 *    or <code>null</code> to insert as a logical root
	 * @param slot the containment reference to hold the <code>child</code>,
	 *    or <code>null</code> to insert into the logical resource contents
	 * @param pos the position in the reference, if it is a list
	 * @param child the child object to insert into the content tree
	 */
	private void addToParent(EObject parent, EReference slot, int pos, EObject child) {
		LogicalResource res = getLogicalResource();
		
		try {
			if (parent != null) {
				parent.eSetDeliver(false);
			} else {
				res.eSetDeliver(false);
			}
			child.eSetDeliver(false);
			
			if (slot == null) {
				// this is a logical root element
				res.getContents().add(pos, child);
			} else if (slot.isMany()) {
				EList values = (EList) parent.eGet(slot);
				
				if (!values.contains(child)) {
					values.add(pos, child);
				}
			} else {
				parent.eSet(slot, child);
			}
		} finally {
			child.eSetDeliver(true);
			if (parent != null) {
				parent.eSetDeliver(true);
			} else {
				res.eSetDeliver(true);
			}
			
			// manually propagate content adapters because we didn't deliver
			//    notifications
			res.propagateContentAdapters(child);
		}
	}
	
	/**
	 * Retrieves the index map of my physical resource structure.  This is
	 * either the map that I deserialized when I was loaded, or it is lazily
	 * created (only if there are multiple physical resources in the logical
	 * resource).  The resource map is an index of the locations in each
	 * parent where separate children belong.
	 * 
	 * @return my physical resource map
	 */
	ResourceMap getResourceIndex() {
		if (resourceIndex == null) {
			if (!getContents().isEmpty() && (getContents().get(0) instanceof ResourceMap)) {
				resourceIndex = (ResourceMap) getContents().get(0);
			} else if (!getLogicalResource().isMonolithic()) { // don't create one for a monolithic resource
				resourceIndex = ResourceMapFactory.eINSTANCE.createResourceMap();
				getContents().add(0, resourceIndex); // add as first root
				ResourceMap rootIndex = getLogicalResource().getRootUnit().getResourceIndex();
				if (rootIndex != resourceIndex) {
					resourceIndex.setRootMap(rootIndex);
				}
			}
		}
		
		return resourceIndex;
	}
	
	/**
	 * Cleans out of my resource index any separate elements that 
	 * are no longer attached to the logical content tree.  Note that we should
	 * only do this when we save, because otherwise, some operation might be
	 * about to reattach a temporarily detached sub-unit.
	 */
	void cleanupResourceIndex() {
		ResourceMap index = getResourceIndex();
		
		if (index != null) {
			// take this opportunity to hook the index up to its root resource
			//   index, if any
			ResourceMap rootIndex = getLogicalResource().getRootUnit()
				.getResourceIndex();
			
			if ((rootIndex != null) && (rootIndex != getResourceIndex())) {
				index.setRootMap(rootIndex);
			}
			
			// clean up the parent entries
			for (Iterator iter = index.getParentEntries().iterator(); iter.hasNext();) {
				ParentEntry parentEntry = (ParentEntry) iter.next();
				
				for (Iterator jter = parentEntry.getResourceEntries().iterator(); jter.hasNext();) {
					ResourceEntry subunitEntry = (ResourceEntry) jter.next();
					
					EObject child = subunitEntry.getChildObject();
					if (child.eResource() != getLogicalResource()) {
						// child has been disconnected.  Forget about its sub-unit
						jter.remove();  // remove the sub-unit resource entry
						
						LogicalResourceUnit subunit = getLogicalResource().getUnit(child);
						if ((subunit != null) && !subunit.isDirty()) {
							// ensure that it is cleaned up
							subunit.cleanupResourceIndex();
						}
					}
				}
				
				if (parentEntry.getResourceEntries().isEmpty()) {
					iter.remove();  // no need for a parent entry without sub-units
				}
			}
			
			// clean up the child entries.  This works in reverse:  we look for
			//    roots that have no corresponding child entries, and delete them
			if (this != getLogicalResource().getRootUnit()) {
				for (Iterator iter = getContents().iterator(); iter.hasNext();) {
					EObject next = (EObject) iter.next();
					
					if (next != index) {
						ChildEntry childEntry = index.getChildEntry(next);
						
						if (childEntry == null) {
							// child has been disconnected.  Remove it
							iter.remove();
						}
					}
				}
			}
		}
	}
	
	/**
	 * Queries whether I need to be saved.
	 * 
	 * @return <code>true</code> if I have changes that need to be saved;
	 *    <code>false</code>, otherwise
	 */
	boolean isDirty() {
		return dirty && isLoaded();  // unloaded resources cannot be dirty
	}
	
	/**
	 * Sets me as needing to be saved.
	 */
	void setDirty() {
		super.setModified(true); // do not propagate to logical resource
		dirty = true;
	}
	
	/**
	 * Sets me as not needing to be saved; I have no pending changes.
	 */
	void setClean() {
		super.setModified(false); // do not propagate to logical resource
		dirty = false;
	}
	
	/**
	 * Ensures that I know (and that adapters listening know) that I am loaded.
	 */
	void loaded() {
		if (!isLoaded()) {
			Notification notification = setLoaded(true);
			if (notification != null) {
				eNotify(notification);
			}
		}
	}
	
	public void setModified(boolean isModified) {
		super.setModified(isModified);
		
		if (isModified && getLogicalResource().isTrackingModification()) {
			// propagate modified state to the root
			getLogicalResource().setModified(isModified);
		}
	}
	
	protected XMLHelper createXMLHelper() {
		return new LogicalHelper(this);
	}
	
	protected XMLLoad createXMLLoad() {
		return new LogicalLoad(createXMLHelper());
	}
	
	protected XMLSave createXMLSave() {
		return new LogicalSave(createXMLHelper());
	}
	
	public EObject getEObject(String uriFragment) {
		return getLogicalResource().getEObject(uriFragment);
	}
	
	public String getID(EObject eObject) {
		return getLogicalResource().getID(eObject);
	}
	
	public void setID(EObject eObject, String id) {
		getLogicalResource().setID(eObject, id);
	}
	
	public String getEncoding() {
		return getLogicalResource().getEncoding();
	}
	
	public Map getIDToEObjectMap() {
		return getLogicalResource().getIDToEObjectMap();
	}
	
	public Map getEObjectToIDMap() {
		return getLogicalResource().getEObjectToIDMap();
	}
	
	public EList getContents() {
		return roots;
	}
	
	/**
	 * <p>
	 * A contents list for the physical resources in a logical resource.
	 * This list does not maintain an inverse relationship:  the roots of a
	 * physical resource do not know what physical resource they are in, but
	 * only the logical resource.
	 * </p><p>
	 * This contents list is also responsible for synchronizing the logical
	 * resource's {@linkplain LogicalResource#getResourceMap() resource map}.
	 * </p>
	 *
	 * @author Christian W. Damus (cdamus)
	 */
	private class ContentsList extends BasicEList implements InternalEList {
		private static final long serialVersionUID = 1L;
		
		protected boolean isUnique() {
			return true;
		}
		
		protected void didAdd(int index, Object object) {
			super.didAdd(index, object);
			didAddImpl(index, object);
		}

		private void didAddImpl(int index, Object object) {
			loaded();  // ensure that we know that we're loaded
			
			if (object instanceof ResourceMap) {
				InternalEObject eObject = (InternalEObject) object;
				
				// the resource map is properly contained by me
				eObject.eSetResource(LogicalResourceUnit.this, null);
				attached(eObject);
			} else {
				EObject eObject = (EObject) object;
				
				getLogicalResource().addMappedResource(
					eObject,
					LogicalResourceUnit.this);
				
				// don't create sub-unit entries in the root unit, and
				//   also don't do it while we are deserializing ourselves
				if (!isRoot() && isAutoLoadEnabled()) {
					EObject parent = eObject.eContainer();
					
					LogicalResourceUnit parentUnit =
						getLogicalResource().getUnit(parent);
					
					LogicalResourceUtil.createSubunitEntry(
						eObject, parentUnit, LogicalResourceUnit.this);
				} else if (isRoot() && !getLogicalResource().getContents().contains(eObject)) {
					// this is a logical root element.  Add it
					getLogicalResource().getContents().add(eObject);
				}
			}
		}
		
		protected void didRemove(int index, Object object) {
			super.didRemove(index, object);
			didRemoveImpl(index, object);
		}
		
		private void didRemoveImpl(int index, Object object) {
			if (object instanceof ResourceMap) {
				InternalEObject eObject = (InternalEObject) object;
				
				// the resource map was properly contained by me
				eObject.eSetResource(null, null);
				detached(eObject);
			} else {
				EObject eObject = (EObject) object;
				
				getLogicalResource().removeMappedResource(eObject);
				
				// don't remove child entries in the root unit, and
				//   also don't do it while we are deserializing ourselves
				if (!isRoot() && isAutoLoadEnabled()) {
					LogicalResourceUtil.removeChildEntry(
						LogicalResourceUnit.this,
						eObject);
				}
			}
		}
		
		protected void didSet(int index, Object newObject, Object oldObject) {
			super.didSet(index, newObject, oldObject);
			didRemoveImpl(index, oldObject);
			didAddImpl(index, newObject);
		}

		//
		// Delegate the internal interface to the inherited implementations.
		//
		
		public NotificationChain basicRemove(Object object, NotificationChain notifications) {
			remove(object);
			return notifications;
		}

		public NotificationChain basicAdd(Object object, NotificationChain notifications) {
			add(object);
			return notifications;
		}
		
		public List basicList() {
			return super.basicList();
		}
		
		public Iterator basicIterator() {
			return super.basicIterator();
		}
		
		public ListIterator basicListIterator() {
			return super.basicListIterator();
		}
		
		public ListIterator basicListIterator(int index) {
			return super.basicListIterator(index);
		}
	}
}




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resources;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Map;

import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.ECollections;
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.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EcoreUtil;

import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap;


/**
 * An unmodifiable view of a resource, used for presenting sub-units safely
 * to clients of the logical resource API.  This class maintains a canonical
 * mapping of unmodifiable views to resources, accessed by the
 * {@link #get(Resource)} method.
 *
 * @author Christian W. Damus (cdamus)
 */
public class UnmodifiableResourceView
	extends AbstractResourceWrapper
	implements Resource {

	private static final CanonicalMap instances = new CanonicalMap() {
		protected AbstractResourceWrapper createWrapper(Resource resource) {
			return new UnmodifiableResourceView(resource);
		}};
	
	/**
	 * Initializes me with the resource that I wrap.
	 * 
	 * @param resource the wrapped resource
	 */
	private UnmodifiableResourceView(Resource resource) {
		super(resource);
	}
	
	/**
	 * Gets the canonical unmodifiable view of the specified
	 * <code>resource</code>.  Note that, if the <code>resource</code>
	 * argument is already an unmodifiable resource, then it is returned as is.
	 * 
	 * @param resource the resource to get an unmodifiable view of
	 * @return its unmodifiable view
	 */
	public static Resource get(Resource resource) {
		Resource result = null;
		
		if (resource instanceof UnmodifiableResourceView) {
			result = resource;
		} else {
			result = instances.get(resource);
		}
		
		return result;
	}
	
	/**
	 * No access to the resource set is provided.
	 * 
	 * @return <code>null</code>, always
	 */
	public ResourceSet getResourceSet() {
		return null;
	}

	/**
	 * Not allowed.
	 * 
	 * @throws UnsupportedOperationException, always
	 */
	public void setURI(URI uri) {
		throw new UnsupportedOperationException("setURI(URI)"); //$NON-NLS-1$
	}

	/**
	 * Returns an unmodifiable view of the wrapped resource's contents, excluding
	 * the first root (which is the resource map).
	 */
	public EList getContents() {
		EList contents = super.getContents();
		EList result;
		
		if (!contents.isEmpty() && (contents.get(0) instanceof ResourceMap)) {
			// too bad ELists don't support sub-lists as ELists
			result = new BasicEList(contents.size() - 1);
			ECollections.setEList(result, contents.subList(1, contents.size()));
		} else {
			result = contents;
		}
		
		return ECollections.unmodifiableEList(result);
	}

	public TreeIterator getAllContents() {
		return EcoreUtil.getAllContents(getContents());
	}

	/**
	 * Not allowed.
	 * 
	 * @throws UnsupportedOperationException, always
	 */
	public void save(Map options)
		throws IOException {
		throw new UnsupportedOperationException("save(Map)"); //$NON-NLS-1$
	}

	/**
	 * Not allowed.
	 * 
	 * @throws UnsupportedOperationException, always
	 */
	public void load(Map options)
		throws IOException {
		throw new UnsupportedOperationException("load(Map)"); //$NON-NLS-1$
	}

	/**
	 * Not allowed.
	 * 
	 * @throws UnsupportedOperationException, always
	 */
	public void save(OutputStream outputStream, Map options)
		throws IOException {
		throw new UnsupportedOperationException("save(OutputStream, Map)"); //$NON-NLS-1$
	}

	/**
	 * Not allowed.
	 * 
	 * @throws UnsupportedOperationException, always
	 */
	public void load(InputStream inputStream, Map options)
		throws IOException {
		throw new UnsupportedOperationException("load(InputStream, Map)"); //$NON-NLS-1$
	}

	/**
	 * Not allowed.
	 * 
	 * @throws UnsupportedOperationException, always
	 */
	public void setTrackingModification(boolean isTrackingModification) {
		throw new UnsupportedOperationException("setTrackingModification(boolean)"); //$NON-NLS-1$
	}

	/**
	 * Not allowed.
	 * 
	 * @throws UnsupportedOperationException, always
	 */
	public void setModified(boolean isModified) {
		throw new UnsupportedOperationException("setModified(boolean)"); //$NON-NLS-1$
	}

	/**
	 * Not allowed.
	 * 
	 * @throws UnsupportedOperationException, always
	 */
	public void unload() {
		throw new UnsupportedOperationException("unload()"); //$NON-NLS-1$
	}

	/**
	 * Returns an unmodifiable view of the wrapped resource's errors.
	 */
	public EList getErrors() {
		return ECollections.unmodifiableEList(super.getErrors());
	}

	/**
	 * Returns an unmodifiable view of the wrapped resource's warnings.
	 */
	public EList getWarnings() {
		return ECollections.unmodifiableEList(super.getWarnings());
	}
	
	public String toString() {
		return "Unmodifiable(" + getWrappedResource().toString() + ')'; //$NON-NLS-1$
	}
}




/******************************************************************************
 * Copyright (c) 2004 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.core.internal.resources;

import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.xmi.XMLHelper;
import org.eclipse.emf.ecore.xmi.XMLLoad;
import org.eclipse.emf.ecore.xmi.XMLSave;

import org.eclipse.gmf.runtime.emf.core.edit.MEditingDomain;

/**
 * Companion sub-unit class for the MSL resource implementation.
 *
 * @author Christian W. Damus (cdamus)
 */
public class MSLResourceUnit
	extends LogicalResourceUnit {

	private MSLResource logicalMslResource;
	
	/**
	 * Initializes me.
	 */
	public MSLResourceUnit(URI uri, LogicalResource logicalResource) {
		super(MEditingDomain.INSTANCE.convertURI(uri), logicalResource);
		
		logicalMslResource = (MSLResource) logicalResource;
	}

	protected boolean useIDAttributes() {
		return logicalMslResource.useIDAttributes();
	}

	protected boolean useUUIDs() {
		return logicalMslResource.useUUIDs();
	}

	protected XMLHelper createXMLHelper() {
		return new MSLHelper(this);
	}

	protected XMLLoad createXMLLoad() {
		return new MSLLoad(createXMLHelper());
	}

	protected XMLSave createXMLSave() {
		return new MSLSave(createXMLHelper());
	}

	public void setURI(URI uri) {

		MEditingDomain domain = MEditingDomain.getEditingDomain(this);

		if (domain == null)
			domain = MEditingDomain.INSTANCE;

		setRawURI(domain.convertURI(uri));
	}

	/**
	 * Set the URI of the resource without processing it.
	 */
	public void setRawURI(URI uri) {

		URI oldURI = getURI();

		if ((uri == oldURI) || ((uri != null) && (uri.equals(oldURI))))
			return;

		super.setURI(uri);
	}
}




import org.eclipse.emf.ecore.xmi.XMLHelper;
import org.eclipse.emf.ecore.xmi.XMLResource;
import org.eclipse.emf.ecore.xmi.impl.SAXWrapper;
import org.eclipse.emf.ecore.xmi.impl.XMILoadImpl;
import org.xml.sax.helpers.DefaultHandler;

/**

 * @author rafikj
 */
public class MSLLoad
	extends XMILoadImpl {

	/**
	 * Constructor.

	 * @see org.eclipse.emf.ecore.xmi.impl.XMLLoadImpl#makeDefaultHandler()
	 */
	protected DefaultHandler makeDefaultHandler() {
		return new SAXWrapper(new MSLHandler(resource, helper, options));
	}
}

Lines 11-24 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/internal/resources/MSLResource.java (-4 / +74 lines)
11		11
12	package org.eclipse.gmf.runtime.emf.core.internal.resources;	12	package org.eclipse.gmf.runtime.emf.core.internal.resources;
13		13
		14	import java.io.IOException;
		15	import java.util.Collections;
		16	import java.util.Map;
		17
		18	import org.eclipse.core.runtime.Platform;
14	import org.eclipse.emf.common.notify.Adapter;	19	import org.eclipse.emf.common.notify.Adapter;
15	import org.eclipse.emf.common.notify.Notification;	20	import org.eclipse.emf.common.notify.Notification;
16	import org.eclipse.emf.common.util.URI;	21	import org.eclipse.emf.common.util.URI;
17	import org.eclipse.emf.ecore.EObject;	22	import org.eclipse.emf.ecore.EObject;
18	import org.eclipse.emf.ecore.EStructuralFeature;	23	import org.eclipse.emf.ecore.EStructuralFeature;
19		24	import org.eclipse.emf.ecore.xmi.XMLHelper;
		25	import org.eclipse.emf.ecore.xmi.XMLLoad;
		26	import org.eclipse.emf.ecore.xmi.XMLSave;
		27	import org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl;
20	import org.eclipse.gmf.runtime.emf.core.edit.MEditingDomain;	28	import org.eclipse.gmf.runtime.emf.core.edit.MEditingDomain;
21	import org.eclipse.gmf.runtime.emf.core.internal.util.MSLConstants;	29	import org.eclipse.gmf.runtime.emf.core.internal.util.MSLConstants;
		30	import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;
22		31
23	/**	32	/**
24	* Custom implementation of an XMIResource.	33	* Custom implementation of an XMIResource.
Lines 26-32 Link Here
26	* @author rafikj	35	* @author rafikj
27	*/	36	*/
28	public class MSLResource	37	public class MSLResource
29	extends LogicalResource {	38	extends XMIResourceImpl
		39	implements ILogicalResource {
30		40
31	private boolean useIDAttributes = false;	41	private boolean useIDAttributes = false;
32		42
Lines 40-47 Link Here
40	setTrackingModification(true);	50	setTrackingModification(true);
41	}	51	}
42		52
43	protected LogicalResourceUnit createUnit(URI unitUri) {	53	protected boolean useUUIDs() {
44	return new MSLResourceUnit(unitUri, this);	54	return true;
45	}	55	}
46		56
47	/**	57	/**
Lines 58-63 Link Here
58	return useIDAttributes;	68	return useIDAttributes;
59	}	69	}
60		70
		71	protected XMLHelper createXMLHelper() {
		72	return new MSLHelper(this);
		73	}
		74
		75	protected XMLLoad createXMLLoad() {
		76	return new MSLLoad(createXMLHelper());
		77	}
		78
		79	protected XMLSave createXMLSave() {
		80	return new MSLSave(createXMLHelper());
		81	}
		82
61	/**	83	/**
62	* @see org.eclipse.emf.ecore.resource.Resource#getEObject(java.lang.String)	84	* @see org.eclipse.emf.ecore.resource.Resource#getEObject(java.lang.String)
63	*/	85	*/
Lines 163-166 Link Here
163	return false;	185	return false;
164	}};	186	}};
165	}	187	}
		188
		189	//
		190	// ILogicalResource methods
		191	//
		192
		193	/**
		194	* I cannot separate any elements.
		195	*
		196	* @return <code>false</code>, always
		197	*/
		198	public boolean canSeparate(EObject eObject) {
		199	return false;
		200	}
		201
		202	/**
		203	* I cannot separate any elements.
		204	*
		205	* @return <code>false</code>, always
		206	*/
		207	public boolean isSeparate(EObject eObject) {
		208	return false;
		209	}
		210
		211	public void separate(EObject eObject, URI uri) {
		212	throw new IllegalArgumentException("cannot separate eObject"); //$NON-NLS-1$
		213	}
		214
		215	public void absorb(EObject eObject) {
		216	throw new IllegalArgumentException("eObject is not separate"); //$NON-NLS-1$
		217	}
		218
		219	public boolean isLoaded(EObject eObject) {
		220	return true; // no object in a non-logical-resource can be unloaded
		221	}
		222
		223	public void load(EObject eObject)
		224	throws IOException {
		225
		226	throw new IllegalArgumentException("eObject is not separate"); //$NON-NLS-1$
		227	}
		228
		229	public Map getMappedResources() {
		230	return Collections.EMPTY_MAP;
		231	}
		232
		233	public Object getAdapter(Class adapter) {
		234	return Platform.getAdapterManager().getAdapter(this, adapter);
		235	}
166	}	236	}




/******************************************************************************
 * Copyright (c) 2004 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.core.internal.resources;

import java.util.Map;

import org.eclipse.emf.ecore.EFactory;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.xmi.XMLHelper;
import org.eclipse.emf.ecore.xmi.impl.SAXXMIHandler;

import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;

/**
 * The SAX handler for logical resources.  Ensures that XML namespace EPackages
 * are loaded in the same resource set as the logical resource, rather than in
 * the logical resource's internal resource set (for the physical resources).
 * 
 * @author Christian W. Damus (cdamus)
 */
public class LogicalHandler
	extends SAXXMIHandler {
	
	boolean isAutoLoading;
	
	/**
	 * Initializes me.
	 * 
	 * @param resource the logical resource that I am handling
	 * @param helper the <code>resource</code>'s helper
	 * @param options the load options
	 */
	public LogicalHandler(LogicalResourceUnit resource, XMLHelper helper, Map options) {
		
		super(resource, helper, options);
		
		// use the logical resource's resource set for finding and
		//    loading EPackages (for XML namespaces)
		resourceSet = resource.getLogicalResource().getResourceSet();
		
		isAutoLoading =
			Boolean.FALSE.equals(
				options.get(ILogicalResource.OPTION_LOAD_ALL_UNITS))
			&&
			Boolean.TRUE.equals(
				options.get(ILogicalResource.OPTION_AUTO_LOAD_UNITS));
	}

	protected EFactory getFactoryForPrefix(String prefix) {
		EFactory factory = (EFactory) prefixesToFactories.get(prefix);
		
		if (factory == null) {
			factory = super.getFactoryForPrefix(prefix);
			
			if (isAutoLoading && (factory != null)) {
				// substitute with our alternative
				EFactory alt = LogicalResourcePolicyManager.getInstance().getEFactory(
					factory.getEPackage());
				if ((alt != null) && (alt != factory)) {
					prefixesToFactories.put(prefix, alt);
					factory = alt;
				}
			}
		}

		return factory;
	}
	
	protected EObject createObjectFromFactory(EFactory factory, String typeName) {
		if (isAutoLoading && (factory != null)) {
			EFactory alt = LogicalResourcePolicyManager.getInstance().getEFactory(
				factory.getEPackage());
			
			if ((alt != null) && (alt != factory)) {
				factory = alt;
			}
		}
		
		return super.createObjectFromFactory(factory, typeName);
	}
}




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resources;

import java.util.Iterator;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.util.InternalEList;
import org.eclipse.emf.ecore.xmi.XMLHelper;
import org.eclipse.emf.ecore.xmi.impl.XMISaveImpl;
import org.eclipse.emf.ecore.xml.type.AnyType;

import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap;

/**
 * Customization of the XML serialization (saving) for logical resources.
 * Special requirements for logical resources include:
 * <ul>
 *   <li>the determination of what is a cross-doc and what is a same-doc
 *       reference is based on the physical URI rather than the logical URI</li>
 *   <li>elements in the content tree that are stored in other resources are
 *       skipped (not saved in this resource)</li>
 * </ul>
 *
 * @author Christian W. Damus (cdamus)
 */
public class LogicalSave
	extends XMISaveImpl {

	private LogicalHelper logicalHelper;
	private LogicalResource logicalResource;
	private boolean savingResourceMap = false;
	
	public LogicalSave(XMLHelper helper) {
		super(helper);
		
		if (helper instanceof LogicalHelper) {
			logicalHelper = (LogicalHelper) helper;
			logicalResource = logicalHelper.getLogicalResource();
		}
	}

	protected void saveElementID(EObject o) {
		if (o instanceof ResourceMap && logicalHelper != null) {
			// writing the sub-unit map.  It needs to encode child references
			//    using physical URIs.  The rest of the resource
			//    needs to encode intra-logical-model references as relative
			//    to the root resource URI
			savingResourceMap = true;
			logicalHelper.setUrisRelativeToRoot(false);
			super.saveElementID(o);
			logicalHelper.setUrisRelativeToRoot(true);
			savingResourceMap = false;
		} else {
			super.saveElementID(o);
		}
	}

	protected void saveElement(EObject o, EStructuralFeature f) {
		// if we're saving an AnyType, then it is coming from the extended
		//    data (compatibility mode), so we cannot check for separateness
		//    (which it wouldn't be, anyway)
		if (savingResourceMap || logicalResource == null ||
				(o instanceof AnyType) || !logicalResource.isSeparate(o)) {
			super.saveElement(o, f);
		}
	}
	
	protected int sameDocSingle(EObject o, EStructuralFeature f) {
	    EObject value = (EObject) helper.getValue(o, f);
		if (value == null) {
			return SKIP;
		} else if (value.eIsProxy()) {
			return CROSS_DOC;
		} else {
			return isSameDocument(o, value) ? SAME_DOC : CROSS_DOC;
		}
	}
	
	private boolean isSameDocument(EObject source, EObject target) {
		boolean result = false;
		
	      Resource targetRes = target.eResource();
	      if (targetRes instanceof LogicalResource && logicalHelper != null) {
	    	  // can only have same-doc ref if both resources are logical
	    	  LogicalResourceUnit sourceRes = logicalHelper.getUnit();
		      
		      result = sourceRes == ((LogicalResource) targetRes).getUnit(target);
	      } else {
	    	  result = targetRes == helper.getResource();
	      }
		
		return result;
	}
	
	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();) {
			EObject value = (EObject) i.next();
			if (value.eIsProxy()) {
				return CROSS_DOC;
			} else if (!isSameDocument(o, value)) {
				return CROSS_DOC;
			}
		}

		return SAME_DOC;
	}
}




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resources;

import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.resources.IFile;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.gmf.runtime.common.core.util.Log;
import org.eclipse.gmf.runtime.emf.core.EventTypes;
import org.eclipse.gmf.runtime.emf.core.internal.l10n.EMFCoreMessages;
import org.eclipse.gmf.runtime.emf.core.internal.plugin.MSLDebugOptions;
import org.eclipse.gmf.runtime.emf.core.internal.plugin.MSLPlugin;
import org.eclipse.gmf.runtime.emf.core.internal.plugin.MSLStatusCodes;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapFactory;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage;
import org.eclipse.gmf.runtime.emf.core.internal.util.Trace;
import org.eclipse.gmf.runtime.emf.core.resources.CannotSeparateException;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;
import org.eclipse.gmf.runtime.emf.core.util.ResourceUtil;

/**
 * <p>
 * Utilities for working with "logical resources."  Logical resources can
 * comprise multiple separate resources, primarily for the purpose of
 * decomposing files in source control.  Individual physical resources in a
 * logical resource can be separately version-controlled to assist a smooth
 * team development workflow.
 * </p><p>
 * When a logical resource is loaded, it automatically loads its constituent
 * physical resources and combines them into a single in-memory representation.
 * All of the objects in this logical resource are addressed by a single URI.
 * </p><p>
 * Particular EMF metamodels (<code>EPackage</code>s) can restrict which
 * elements are permitted to form the roots of separate resources.  The
 * {@link #canSeparate(EObject)} method is used to determine whether an element
 * is permitted to root a separate resource.
 * </p><p>
 * Given an element that may be separated, the {@link #separate(EObject)} method
 * will create a separate resource for it if none is defined already.  A
 * separate element can be re-incorporated into the resource of its container
 * by the {@link #absorb(EObject)} method.  To determine whether an element
 * currently is separated, use the {@link #isSeparate(EObject)} method.
 * </p>
 * 
 * @author Christian W. Damus (cdamus)
 */
public class LogicalResourceUtil {
	private LogicalResourceUtil() {
		super();
	}
	
	/**
	 * Queries whether the specified <code>eObject</code> is the root of a
	 * separate resource in a larger logical resource.
	 * 
	 * @param res the logical resource
	 * @param eObject a model element in the logical resource
	 * 
	 * @return whether it is the root of a separate resource
	 */
	static boolean isSeparate(LogicalResource res, EObject eObject) {
		assert eObject.eResource() == res : "eObject is not in res" ; //$NON-NLS-1$
		
		LogicalResourceUnit unit = (LogicalResourceUnit) res.getResourceMap().get(eObject);
		
		return (unit != null) && (unit != res.getRootUnit());
	}
	
	/**
	 * Ensures that the specified <code>eObject</code> is the root of a
	 * separate resource, if it is {@linkplain #canSeparate(EObject) allowed}
	 * to be such.
	 * 
	 * @param res the logical resource
	 * @param eObject a model element
	 * @param uri URI for the physical resource to store the
	 *    <code>eObject</code> in, or <code>null</code> for the default
	 * 
	 * @throws CannotSeparateException if something unforeseen goes wrong in
	 *     the separation of the element.  This may be failure to make a
	 *     version-controlled file writeable, failure to meet metamodel-specific
	 *     constraints on separation, etc.
	 * 
	 * @see #canSeparate(LogicalResource, EObject)
	 * @see #absorb(LogicalResource, EObject)
	 */
	static void separate(LogicalResource res, EObject eObject, URI uri) throws CannotSeparateException {
		LogicalResourceUnit oldUnit = getUnitFor(res, eObject);
		LogicalResourceUnit newUnit = initializeUnit(res, eObject, uri);
		
		if (newUnit == oldUnit) {
			// not allowed to separate into current storage unit
			CannotSeparateException e = new CannotSeparateException(
				EMFCoreMessages.separate_sameUnit_ERROR_);
			Trace.throwing(LogicalResourceUtil.class, "separate", e); //$NON-NLS-1$
			throw e;
		}
		
		if (eObject.eContainer() == null) {
			// this was a root of the root unit
			oldUnit.getContents().remove(eObject);
			
			// add back to the map because we just removed it
			res.addMappedResource(eObject, oldUnit);
		}
		newUnit.getContents().add(eObject);
		
		// ensure that both units are dirty
		oldUnit.setDirty();
		newUnit.setDirty();
		
		reparentChildUnits(oldUnit, newUnit, eObject);
	}
	
	/**
	 * Ensures that any separate elements in the containment tree of a
	 * recently-separated or -absorbed element that reference the element's old
	 * unit as their parent now reference the new sub-unit.
	 * 
	 * @param oldUnit a separated or absorbed <code>element</code>'s old unit
	 * @param newUnit a separated or absorbed <code>element</code>'s new unit
	 * @param element the recently-separated/absorbed element
	 */
	private static void reparentChildUnits(
			LogicalResourceUnit oldUnit, LogicalResourceUnit newUnit,
			EObject element) {
		
		// must make a defensive copy to protect against concurrent
		//   modifications in the absorption case
		List parentEntries = new java.util.ArrayList(
			oldUnit.getResourceIndex().getParentEntries());
		
		for (Iterator iter = parentEntries.iterator(); iter.hasNext();) {
			ParentEntry next = (ParentEntry) iter.next();
			EObject parent = next.getParentObject();
			
			if (EcoreUtil.isAncestor(element, parent)) {
				// this parent is in another unit, now
				newUnit.getResourceIndex().getParentEntries().add(next);
				
				// mark the child resources dirty so that they will save
				for (Iterator jter = next.getResourceEntries().iterator(); jter.hasNext();) {
					ResourceEntry re = (ResourceEntry) jter.next();
					
					LogicalResourceUnit child = (LogicalResourceUnit) re.getResource();
					
					// must load it in order to save it, unless we are in
					//    physical mode
					if (child.isLoaded() || !isPhysicalMode(child.getLogicalResource())) {
						// proxy resolution loads the child resource
						EObject childObj = re.getChildObject();
						
						// point the child unit to its new parent unit
						ChildEntry ce = child.getResourceIndex().getChildEntry(childObj);
						ce.setParentMap(newUnit.getResourceIndex());
						child.setDirty();
					}
				}
			}
		}
	}
	
	/**
	 * Queries whether the specified logical resource was loaded in physical
	 * mode.
	 * 
	 * @param res the logical resource
	 * @return <code>true</code> if it was loaded in physical mode;
	 *     <code>false</code>, otherwise
	 */
	static boolean isPhysicalMode(LogicalResource res) {
		return !Boolean.TRUE.equals(
			res.getSubunitResourceSet().getLoadOptions().get(
				ILogicalResource.OPTION_LOAD_AS_LOGICAL));
	}
	
	/**
	 * Queries whether the specified <code>eObject</code> is currently loaded.
	 * If it is not loaded, then it is just a stand-in for the absent sub-tree
	 * of the logical model.
	 * 
	 * @param res a logical resource
	 * @param eObject an element in the logical resource.  It may be a separate
	 *      element (in which case the question of loaded is interesting) or
	 *      it may not.  In the latter case, the element is necessarily
	 *      to be considered as loaded
	 * @return <code>true</code> if the <code>eObject</code> is fully loaded
	 *      from its physical resource; <code>false</code>, otherwise
	 * 
	 * @throws IllegalArgumentException if the <code>eObject</code> is not
	 *     contained within me
	 *     
	 * @see #load(LogicalResource, EObject)
	 */
	static boolean isLoaded(LogicalResource res, EObject eObject) {
		assert eObject.eResource() == res : "eObject is not in res" ; //$NON-NLS-1$
		
		boolean result;
		
		if (!isSeparate(res, eObject)) {
			result = true;
		} else {
			LogicalResourceUnit unit = getUnitFor(res, eObject);
			result = unit.isLoaded() && unit.getContents().contains(eObject);
		}
		
		return result;
	}
	
	/**
	 * Loads the specified eObject from its physical resource.
	 * 
	 * @param res the logical resource
	 * @param eObject a separate element in the logical resource
	 * 
	 * @throws IllegalArgumentException if the <code>eObject</code> is not
	 *     separate or if it is not contained within me
	 * @throws IOException if any exception occurs while loading the
	 *     <code>eObject</code>'s physical resource
	 *     
	 * @see #isLoaded(LogicalResource, EObject)
	 */
	static void load(LogicalResource res, EObject eObject) throws IOException {
		LogicalResourceUnit unit = getUnitFor(res, eObject);
		
		if (!unit.isLoaded()) {
			loadUnit(unit);
		}
	}
	
	/**
	 * Convenience method to load a sub-unit into the logical resource with
	 * the correct load options.
	 * 
	 * @param unit a sub-unit to be loaded
	 * @throws IOException if anything goes wrong in loading it
	 * 
	 * @see #loadUnit(LogicalResourceUnit, InputStream)
	 */
	static void loadUnit(LogicalResourceUnit unit) throws IOException {
		unit.load(unit.getResourceSet().getLoadOptions());
	}
	
	/**
	 * Convenience method to load a sub-unit into the logical resource with
	 * the correct load options.
	 * 
	 * @param unit a sub-unit to be loaded
	 * @param inputStream the input stream to load the unit from
	 * @throws IOException if anything goes wrong in loading it
	 */
	static void loadUnit(LogicalResourceUnit unit, InputStream inputStream) throws IOException {
		unit.load(inputStream, unit.getResourceSet().getLoadOptions());
	}
	
	/**
	 * Gets a mapping of objects as yet unloaded in the logical resource
	 * that resolve to roots of the specified <code>unit</code>.
	 * 
	 * @param unit a unit in a logical resource
	 * @return map of {@link String} ID ==&gt; unloaded {@link EObject}
	 */
	static Map getUnloadedElements(LogicalResourceUnit unit) {
		LogicalResource logical = unit.getLogicalResource();
		Map result = new java.util.HashMap();
		
		for (Iterator iter = logical.getResourceMap().entrySet().iterator();
				iter.hasNext();) {
			
			Map.Entry entry = (Map.Entry) iter.next();
			if (entry.getValue() == unit) {
				// this is an element whose ID we need
				EObject element = (EObject) entry.getKey();
				
				result.put(logical.getID(element), element);
			}
		}
		
		return result;
	}
	
	/**
	 * Reconciles existing unloaded units from the specified map with the roots
	 * of the just-loaded <code>unit</code>.  This merges the features of the
	 * <code>unit</code>'s roots into existing unloaded elements; this
	 * effectively loads these elements.  The original unloaded elements (now
	 * loaded) then replace the <code>unit</code>'s existing roots.
	 * <p>
	 * The ID mapping provided maps IDs of the roots of the <code>unit</code> to
	 * the IDs of the unloaded units that match them, to preserve their IDs
	 * (because loading the <code>unit</code> replaced the existing IDs in the
	 * XML resource's ID-to-element map).
	 * </p>
	 * 
	 * @param unit a logical resource unit that was just loaded
	 * @param idMap mapping of 
	 */
	static void reconcileUnloadedUnits(LogicalResourceUnit unit, Map idMap) {
		LogicalResource logical = unit.getLogicalResource();
		
		EObject[] roots = (EObject[]) unit.getContents().toArray(
			new EObject[unit.getContents().size()]);  // safe copy
		
		for (int i = 0; i < roots.length; i++) {
			// the logical resource now knows the actual sub-unit roots under
			//   the IDs previously retrieved
			String id = logical.getID(roots[i]);
			EObject oldObject = (EObject) idMap.get(id);
			
			// only do replacement if they are not the same object
			if ((oldObject != null) && (oldObject != roots[i])) {
				become(oldObject, roots[i], id, unit);
				fireLoadEvent(oldObject);
			}
		}	
	}

	/**
	 * Auto-loads the specified element of the specified resource, if it is
	 * an unloaded separate element.
	 * 
	 * @param res a resource, which may or may not be a logical resource
	 * @param eObject an element of the resource, which may or may not be
	 *     an unloaded separate element
	 */
	public static void autoload(Resource res, EObject eObject) {
		if (res instanceof ILogicalResource) {
			ILogicalResource logical = (ILogicalResource) res;
			Resource unit = AbstractResourceWrapper.unwrap(
				getPhysicalResource(logical, eObject.eContainer()));
			
			if (isAutoLoadable(unit) && !logical.isLoaded(eObject)) {
				try {
					if (Trace.isEnabled(MSLDebugOptions.RESOURCES)) {
						URI base = logical.getURI();
						URI relative = unit.getURI().deresolve(base);
						
						Trace.trace(
							MSLDebugOptions.RESOURCES,
							"Auto-loading unit: " + relative + " of: " + base); //$NON-NLS-1$ //$NON-NLS-2$
					}
					
					logical.load(eObject);
				} catch (IOException e) {
					Trace.catching(
						LogicalResourceUtil.class,
						"autoload(Resource, EObject)", e); //$NON-NLS-1$
					
					Log.error(
						MSLPlugin.getDefault(),
						MSLStatusCodes.LOGICAL_AUTOLOAD_FAILED,					
						EMFCoreMessages.autoload_failed_EXC_,
						e);
				}
			}
		}
	}
	
	/**
	 * Queries whether the specified <code>unit</code> can be auto-loaded.
	 * Instances of {@link LogicalResourceUnit} have configurable auto-loading
	 * support; other implementations are implicitly auto-loadable.
	 * 
	 * @param unit a unit
	 * @return <code>true</code> if it can be auto-loaded;
	 *     <code>false</code>, otherwise
	 */
	private static boolean isAutoLoadable(Resource unit) {
		boolean result = true;
		
		if (unit instanceof LogicalResourceUnit) {
			result = ((LogicalResourceUnit) unit).isAutoLoadEnabled();
		}
		
		return result;
	}
	
	/**
	 * Quietly loads the specified newly loaded object's features into the
	 * old object, and replaces the loaded object with the old one in the
	 * <code>subunit</code>.
	 * 
	 * @param oldObj the old object that we are loading
	 * @param newObj the newly loaded object that the <code>oldObj</code>
	 *      is to become
	 * @param id the ID object of the object that was loaded
	 * @param subunit the resource from which <code>newObj</code> was loaded
	 */
	private static void become(EObject oldObj, EObject newObj, String id,
			LogicalResourceUnit subunit) {
		// do this quietly
		oldObj.eSetDeliver(false);
		
		boolean wasClean = !subunit.isDirty();
		
		// transfer all features from the new object
		for (Iterator iter = newObj.eClass().getEAllStructuralFeatures().iterator();
				iter.hasNext();) {
			
			EStructuralFeature feature = (EStructuralFeature) iter.next();
			
			if (isTransferableFeature(feature)) {
				if (!feature.isMany()) {
					// simple case.  Just eSet without resolving the value
					oldObj.eSet(feature, newObj.eGet(feature, false));
				} else {
					// must transfer the EList contents without resolving anything
					//   or gathering any notifications.  Must copy the source
					//   list to avoid concurrent modification
					List oldValue = (List) oldObj.eGet(feature, false);
					List newValue = new java.util.ArrayList((List) newObj.eGet(feature, false));
					
					oldValue.clear();
					for (Iterator xfer = newValue.iterator(); xfer.hasNext();) {
						oldValue.add(xfer.next());
					}
				}
			}
		}
		
		// set the old object into the sub-unit resource.  This has the
		//    side-effect of updating the object-to-subunit map
		int pos = subunit.getContents().indexOf(newObj);
		subunit.getContents().set(pos, oldObj);
		
		// update the child entry to point to the right object.  If we can't
		//   find it, then it was already up-to-date
		ChildEntry childEntry = subunit.getResourceIndex().getChildEntry(newObj);
		if (childEntry != null) {
			childEntry.setChildObject(oldObj);
		}
		
		// the old object must re-assume the ID of the new one
		subunit.setID(oldObj, id);
		
		if (wasClean) {
			// the sub-unit should not be considered as dirty by this operation
			subunit.setClean();
		}
		
		oldObj.eSetDeliver(true);
	}
	
	/**
	 * Determines whether the specified feature is transferable from one object
	 * to another.  Transferable features are those that meet the following
	 * criteria:
	 * <ul>
	 *   <li>they are {@link EStructuralFeature#isChangeable() changeable}</li>
	 *   <li>they are not {@link EStructuralFeature#isDerived() derived}</li>
	 *   <li>they are not {@link EReference#isContainer() container} references</li>
	 * </ul>
	 * 
	 * @param feature a structural feature
	 * @return whether it is transferable, according to the criteria, above
	 */
	private static boolean isTransferableFeature(EStructuralFeature feature) {
		boolean result = feature.isChangeable() && !feature.isDerived();

		if (result && (feature instanceof EReference)) {
			result = !((EReference) feature).isContainer();
		}
		
		return result;
	}
	
	/**
	 * Loads all units of a logical resource that are not already loaded.
	 * 
	 * @param res a logical resource
	 * 
	 * @throws IOException if anything goes wrong in loading any unloaded
	 *     units
	 */
	public static void loadAllUnloadedUnits(ILogicalResource res) throws IOException {
		// must always iterate a separate collection to prevent concurrent mods
		Set newElements = new java.util.HashSet(
			res.getMappedResources().keySet());
		int lastCount = newElements.size();
		boolean foundNewElements = true;
		
		while (foundNewElements) {
			Set elements = newElements;
			
			for (Iterator iter = elements.iterator(); iter.hasNext();) {
				EObject next = (EObject) iter.next();
				
				if (!res.isLoaded(next)) {
					res.load(next);
				}
			}
			
			// found any new unloaded elements?
			int newCount = res.getMappedResources().size();
			foundNewElements = newCount > lastCount;
			
			if (foundNewElements) {
				// compute the new elements, and iterate again
				newElements = new java.util.HashSet(
					res.getMappedResources().keySet());
				newElements.removeAll(elements);
				lastCount = newCount;
			}
		}
	}

	/**
	 * Finds the unit within a logical resource that physically contains the
	 * specified element.
	 * 
	 * @param res a logical resource, or a unit in a logical resource
	 * @param eObject an element in the logical resource
	 * @return the unit of the logical resource that contains the element 
	 */
	static LogicalResourceUnit getUnitFor(LogicalResource res, EObject eObject) {
		LogicalResourceUnit result = null;
		
		if (eObject == null) {
			result = res.getRootUnit();
		} else {
			result = (LogicalResourceUnit) AbstractResourceWrapper.unwrap(
				getPhysicalResource(res, eObject));
		}
		
		return result;
	}

	/**
	 * A convenience method for retrieving the physical resource (as an
	 * unmodifiable view) that stores the specified element.
	 * 
	 * @param eObject an element in the logical resource.  It needs not be
	 *     a separate element (i.e., the root of a physical resource)
	 * @return an unmodifiable view of the resource that stores the element
	 */
	public static Resource getPhysicalResource(ILogicalResource res, EObject eObject) {
		Resource result = null;
		Map map = res.getMappedResources();
		
		while ((eObject != null) && (result == null)) {
			if (map.containsKey(eObject)) {
				result = (Resource) map.get(eObject);
			}
			
			eObject = eObject.eContainer();
		}
		
		return result;
	}
	
	/**
	 * Ensures that the specified <code>eObject</code> is not the root of a
	 * separate resource.
	 * 
	 * @param res the logical resource
	 * @param eObject a model element
	 * 
	 * @see #separate(LogicalResource, EObject, URI)
	 */
	static void absorb(LogicalResource res, EObject eObject) {
		LogicalResourceUnit oldUnit = getUnitFor(res, eObject);
		
		// dirty the former unit
		oldUnit.getContents().remove(eObject);
		oldUnit.setDirty();
		
		// must also dirty the new unit
		LogicalResourceUnit newUnit = getUnitFor(res, eObject.eContainer());
		if (eObject.eContainer() == null) {
			// this is now a root of the root unit
			newUnit.getContents().add(eObject);
		}
		newUnit.setDirty();
		
		reparentChildUnits(oldUnit, newUnit, eObject);
	}
	
	/**
	 * Removes the specified element's child entry from the old unit's resource
	 * index.
	 * 
	 * @param oldUnit the element's old unit
	 * @param eObject the element
	 */
	static void removeChildEntry(LogicalResourceUnit oldUnit, EObject eObject) {
		ResourceMap index = oldUnit.getResourceIndex();
		
		if (index != null) {
			ChildEntry childEntry = index.getChildEntry(eObject);
			
			if (childEntry != null) {
				index.getChildEntries().remove(childEntry);
				
				ResourceMap parentIndex = childEntry.getParentMap();
				if (parentIndex != null) {
					ResourceEntry resourceEntry =
						parentIndex.getResourceEntry(eObject);
					
					if (resourceEntry != null) {
						ParentEntry parentEntry = resourceEntry.getParentEntry();
						
						parentEntry.getResourceEntries().remove(
							resourceEntry);
						
						if (parentEntry.getResourceEntries().isEmpty()) {
							// don't need this parent entry any more if it
							//    has no sub-units remaining
							parentEntry.getResourceMap().getParentEntries().remove(
								parentEntry);
						}
					}
				}
			}
		}
	}
	
	/**
	 * Creates a resource entry for the sub-unit storing the specified
	 * <code>eObject</code> in the parent unit's resource <code>index</code>.
	 * This has the side-effect of creating the corresponding child entry
	 * in the sub-unit's own resource index.
	 * 
	 * @param eObject the sub-unit element
	 * @param parentUnit the <code>eObject</code>'s old physical unit
	 * @param subunit the <code>eObject</code>'s new physical unit
	 */
	static void createSubunitEntry(
			EObject eObject,
			LogicalResourceUnit parentUnit,
			LogicalResourceUnit subunit) {
		
		ResourceMap parentIndex = parentUnit.getResourceIndex();
		
		EObject parent = eObject.eContainer();
		EReference containment = eObject.eContainmentFeature();
		
		ParentEntry parentEntry = createParentEntry(parentIndex, parent, containment);
		
		ResourceEntry entry = parentEntry.getResourceEntry(eObject);
		
		if (entry == null) {
			entry = ResourceMapFactory.eINSTANCE.createResourceEntry();
			parentEntry.getResourceEntries().add(entry);
			entry.setChildObject(eObject);
		}
		
		updateChildPosition(subunit, entry);
		
		ResourceMap childIndex = subunit.getResourceIndex();
		if (childIndex != null) {
			// really shouldn't be null!
			ChildEntry childEntry = childIndex.getChildEntry(eObject);
			
			if (childEntry == null) {
				childEntry = ResourceMapFactory.eINSTANCE.createChildEntry();
				childIndex.getChildEntries().add(childEntry);
				childEntry.setChildObject(eObject);
			}
			
			childEntry.setParentMap(parentIndex);
		}
	}
	
	/**
	 * Creates the parent entry in a resource <code>index</code> for the
	 * specified container and reference.  If the <code>parent</code> and
	 * <code>containment</code> reference are both <code>null</code>, then
	 * we are creating an entry for the resource, itself (to separate a root).
	 * 
	 * @param index the resource index to create the entry in
	 * @param parent the container element (may be <code>null</code>)
	 * @param containment the containment reference (may be <code>null</code>)
	 * 
	 * @return the new parent entry, added to the <code>index</code>
	 */
	private static ParentEntry createParentEntry(ResourceMap index, EObject parent, EReference containment) {
		ParentEntry result = index.getParentEntry(parent, containment);
		
		if (result == null) {
			result = ResourceMapFactory.eINSTANCE.createParentEntry();
			result.setParentObject(parent);
			result.setChildSlot(containment);
			index.getParentEntries().add(result);
		}
		
		return result;
	}
	
	/**
	 * Initializes a sub-unit resource to prepare it for adding a new root
	 * element to it.
	 * 
	 * @param res the logical resource
	 * @param eObject the physical resource's new root
	 * @param uri the the physical resource's URI
	 * 
	 * @return the physical resource, ready to receive its new root
	 */
	private static LogicalResourceUnit initializeUnit(LogicalResource res,
			EObject eObject, URI uri) {
		
		ResourceSet rset = res.getSubunitResourceSet();
		LogicalResourceUnit result = (LogicalResourceUnit) rset.getResource(uri, false); 
		if (result == null) {
			result = (LogicalResourceUnit) rset.createResource(uri);
		}
		
		if (!result.isLoaded()) {
			IFile file = ResourceUtil.getFile(result);
			
			if ((file != null) && file.exists()) {
				try {
					loadUnit(result);
				} catch (IOException e) {
					Trace.catching(
						LogicalResourceUtil.class,
						"initResource(LogicalResource, EObject, URI)", e); //$NON-NLS-1$
					
					Log.warning(
						MSLPlugin.getDefault(),
						MSLStatusCodes.LOGICAL_LOAD_FAILED,				
						EMFCoreMessages.load_failed_EXC_,
						e);
				}
			}
		}
		
		return result;
	}
	
	/**
	 * Set the child position of the specified resource <code>entry</code>
	 * from its index in the containment feature (if it is a list).
	 * 
	 * @param subunit the sub-unit that the <code>entry</code> references
	 * @param entry the entry whose child position is to be set
	 */
	static void updateChildPosition(LogicalResourceUnit subunit, ResourceEntry entry) {
		EObject child = entry.getChildObject();
		EReference containment = entry.getParentEntry().getChildSlot();
		
		// ensure that the resource is set
		entry.setResource(subunit);
		
		if (containment == null) {
			Resource res = subunit.getLogicalResource();
			entry.setChildPosition(res.getContents().indexOf(child));
		} else if (containment.isMany()) {
			EList values = (EList) child.eContainer().eGet(containment);
			entry.setChildPosition(values.indexOf(child));
		} else {
			entry.eUnset(ResourceMapPackage.eINSTANCE.getResourceEntry_ChildPosition());
		}
	}
	
	/**
	 * Sets the child positions of the resources in a parent <code>entry</code>
	 * from their indices in the containment feature (if it is a list).  This is
	 * useful when all existing entries need to be recomputed because of the
	 * addition or removal of an element from the list
	 * 
	 * @param unit the unit that owns the parent <code>entry</code>
	 * @param entry the parent entry whose child positions are to be set
	 */
	static void updateChildPositions(LogicalResourceUnit unit, ParentEntry entry) {
		EObject parent = entry.getParentObject();
		EReference containment = entry.getChildSlot();
		
		for (Iterator iter = entry.getResourceEntries().iterator(); iter.hasNext();) {
			ResourceEntry resEntry = (ResourceEntry) iter.next();
			EObject child = resEntry.getChildObject();
			
			if (containment == null) {
				Resource res = unit.getLogicalResource();
				resEntry.setChildPosition(res.getContents().indexOf(child));
			} else if (containment.isMany()) {
				EList values = (EList) parent.eGet(containment);
				resEntry.setChildPosition(values.indexOf(child));
			} else {
				resEntry.eUnset(
					ResourceMapPackage.eINSTANCE.getResourceEntry_ChildPosition());
			}
		}
	}
	
	/**
	 * Computes the index of a <code>child</code> object in its
	 * <code>parent</code>'s <code>containment</code> reference.
	 * 
	 * @param child an element
	 * @param parent its container
	 * @param containment the containment feature of the <code>child</code>
	 * 
	 * @return the index, or -1 if the <code>containment</code> reference is not
	 *     a collection
	 */
	private static int indexOf(EObject child, EObject parent, EReference containment) {
		int result = -1;
		
		if (containment.isMany()) {
			// it's a containment reference, so no worries about proxy resolution
			EList value = (EList) parent.eGet(containment);
			result = value.indexOf(child);
		}
		
		return result;
	}
	
	/**
	 * Fires an artificial {@link EventTypes#SEPARATE} notification for the
	 * separation of the specified object.
	 * 
	 * @param eObject the newly separated object
	 * @param oldResource the object's old resource
	 * @param newResource its new resource
	 */
	public static void fireSeparationEvent(EObject eObject,
			Resource oldResource, Resource newResource) {
		Notification notification = createNotification(
			eObject,
			EventTypes.SEPARATE,
			oldResource,
			newResource);
		
		dispatch(notification);
	}
	
	/**
	 * Fires an artificial {@link EventTypes#ABSORB} notification for the
	 * absorption of the specified object.
	 * 
	 * @param eObject the newly separated object
	 * @param oldResource the object's old resource
	 * @param newResource its new resource
	 */
	public static void fireAbsorptionEvent(EObject eObject,
			Resource oldResource, Resource newResource) {
		Notification notification = createNotification(
			eObject,
			EventTypes.ABSORB,
			oldResource,
			newResource);
		
		dispatch(notification);
	}
	
	/**
	 * Fires an artificial {@link EventTypes#LOADED} notification for the
	 * loading of the specified object.
	 * 
	 * @param eObject the newly loaded object
	 */
	public static void fireLoadEvent(EObject eObject) {
		Notification notification = createNotification(
			eObject,
			EventTypes.LOAD,
			eObject,
			eObject);
		
		dispatch(notification);
	}
	
	/**
	 * Creates a notification of the specified type for the specified element,
	 * with old and new values.
	 * 
	 * @param eObject the element to create the notification for
	 * @param type the notification type
	 * @param oldValue the old value
	 * @param newValue the new value
	 * 
	 * @return the new notification
	 */
	private static Notification createNotification(
			EObject eObject, int type, Object oldValue, Object newValue) {
		
		EObject container = eObject.eContainer();
		EReference containment = eObject.eContainmentFeature();
		
		Notification result;
		int index;
		
		if (containment != null) {
			index = indexOf(eObject, container, containment);
			result = new NotificationImpl(
				(InternalEObject) container,
				type,
				containment,
				oldValue, newValue,
				index);
		} else {
			// it's a logical root
			Resource res = eObject.eResource();
			index = res.getContents().indexOf(eObject);
			result = new ResourceNotificationImpl(
				res,
				type,
				oldValue, newValue,
				index);
		}
		
		return result;
	}
	
	/**
	 * Dispatches the specified <code>notification</code> to adapters.
	 * 
	 * @param notification the notification to dispatch
	 */
	private static void dispatch(Notification notification) {
		Notifier notifier = (Notifier) notification.getNotifier();
		notifier.eNotify(notification);
	}
	
	/**
	 * Notification implementation for notification of changes to the physical
	 * structure of a logical resource.
	 *
	 * @author Christian W. Damus (cdamus)
	 */
	private static class NotificationImpl extends ENotificationImpl {
		NotificationImpl(InternalEObject notifier, int eventType,
			EStructuralFeature feature, Object oldValue, Object newValue,
			int index) {
			
			super(notifier, eventType, feature, oldValue, newValue, index);
		}
		
		public boolean isTouch() {
			// changes in the physical resource structure do not affect the
			//   resource's logical contents
			return true;
		}
	}
	
	private static class ResourceNotificationImpl
		extends org.eclipse.emf.common.notify.impl.NotificationImpl {

		private final Resource notifier;
		
		public ResourceNotificationImpl(Resource notifier,
				int eventType, Object oldValue, Object newValue, int position) {
			// consider the resource contents to be always set
			super(eventType, oldValue, newValue, position, true);
			this.notifier = notifier;
		}
		
		public Object getNotifier() {
			return notifier;
		}
		
		public int getFeatureID(Class expectedClass) {
			return Resource.RESOURCE__CONTENTS;
		}
		
		public boolean isTouch() {
			// changes in the physical resource structure do not affect the
			//   resource's logical contents
			return true;
		}
	}
}

Lines 24-29 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/internal/resources/MSLHandler.java (-2 / +4 lines)
24	import org.eclipse.emf.ecore.resource.Resource;	24	import org.eclipse.emf.ecore.resource.Resource;
25	import org.eclipse.emf.ecore.resource.impl.ResourceImpl;	25	import org.eclipse.emf.ecore.resource.impl.ResourceImpl;
26	import org.eclipse.emf.ecore.xmi.XMLHelper;	26	import org.eclipse.emf.ecore.xmi.XMLHelper;
		27	import org.eclipse.emf.ecore.xmi.XMLResource;
		28	import org.eclipse.emf.ecore.xmi.impl.SAXXMIHandler;
27	import org.eclipse.emf.ecore.xml.type.AnyType;	29	import org.eclipse.emf.ecore.xml.type.AnyType;
28		30
29	/**	31	/**
Lines 33-39 Link Here
33	* @author khussey	35	* @author khussey
34	*/	36	*/
35	public class MSLHandler	37	public class MSLHandler
36	extends LogicalHandler {	38	extends SAXXMIHandler {
37		39
38	protected final Map urisToProxies;	40	protected final Map urisToProxies;
39		41
Lines 48-54 Link Here
48	* @param options	50	* @param options
49	* The load options for the new handler.	51	* The load options for the new handler.
50	*/	52	*/
51	public MSLHandler(MSLResourceUnit xmiResource, XMLHelper helper, Map options) {	53	public MSLHandler(XMLResource xmiResource, XMLHelper helper, Map options) {
52	super(xmiResource, helper, options);	54	super(xmiResource, helper, options);
53		55
54	urisToProxies = new HashMap();	56	urisToProxies = new HashMap();

Lines 371-376 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/edit/MEditingDomain.java (+8 lines)
371	* @return whether the <code>resource</code> is a logical resource	371	* @return whether the <code>resource</code> is a logical resource
372	*	372	*
373	* @see ILogicalResource	373	* @see ILogicalResource
		374	*
		375	* @deprecated Use the cross-resource containment support provided by EMF,
		376	* instead, by defining containment features that are capable of storing
		377	* proxies.
374	*/	378	*/
375	public abstract boolean isLogicalResource(Resource resource);	379	public abstract boolean isLogicalResource(Resource resource);
376		380
Lines 383-388 Link Here
383	*	387	*
384	* @param resource a resource for which we want to obtain a logical view	388	* @param resource a resource for which we want to obtain a logical view
385	* @return the logical view of the resource	389	* @return the logical view of the resource
		390	*
		391	* @deprecated Use the cross-resource containment support provided by EMF,
		392	* instead, by defining containment features that are capable of storing
		393	* proxies.
386	*/	394	*/
387	public abstract ILogicalResource asLogicalResource(Resource resource);	395	public abstract ILogicalResource asLogicalResource(Resource resource);
388		396

Lines 173-178 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/edit/DemuxedMListener.java (+12 lines)
173		173
174	/**	174	/**
175	* Does nothing.	175	* Does nothing.
		176	*
		177	* @deprecated Use the cross-resource containment support provided by EMF,
		178	* instead, by defining containment features that are capable of storing
		179	* proxies.
176	*/	180	*/
177	public void handleElementSeparatedEvent(Notification notification,	181	public void handleElementSeparatedEvent(Notification notification,
178	ILogicalResource resource, EObject eObject, Resource newResource) {	182	ILogicalResource resource, EObject eObject, Resource newResource) {
Lines 181-186 Link Here
181		185
182	/**	186	/**
183	* Does nothing.	187	* Does nothing.
		188	*
		189	* @deprecated Use the cross-resource containment support provided by EMF,
		190	* instead, by defining containment features that are capable of storing
		191	* proxies.
184	*/	192	*/
185	public void handleElementAbsorbedEvent(Notification notification,	193	public void handleElementAbsorbedEvent(Notification notification,
186	ILogicalResource resource, EObject eObject, Resource oldResource) {	194	ILogicalResource resource, EObject eObject, Resource oldResource) {
Lines 189-194 Link Here
189		197
190	/**	198	/**
191	* Does nothing.	199	* Does nothing.
		200	*
		201	* @deprecated Use the cross-resource containment support provided by EMF,
		202	* instead, by defining containment features that are capable of storing
		203	* proxies.
192	*/	204	*/
193	public void handleElementLoadedEvent(Notification notification,	205	public void handleElementLoadedEvent(Notification notification,
194	ILogicalResource resource, EObject eObject) {	206	ILogicalResource resource, EObject eObject) {

Lines 39-44 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/edit/IDemuxedMListener2.java (+12 lines)
39	* separated into a subordinate resource with the specified <code>uri</code>	39	* separated into a subordinate resource with the specified <code>uri</code>
40	* @param newResource the new subordinate resource (within the logical	40	* @param newResource the new subordinate resource (within the logical
41	* <code>resource</code>) that stores the <code>eObject</code>	41	* <code>resource</code>) that stores the <code>eObject</code>
		42	*
		43	* @deprecated Use the cross-resource containment support provided by EMF,
		44	* instead, by defining containment features that are capable of storing
		45	* proxies.
42	*/	46	*/
43	public void handleElementSeparatedEvent(Notification notification,	47	public void handleElementSeparatedEvent(Notification notification,
44	ILogicalResource resource, EObject eObject, Resource newResource);	48	ILogicalResource resource, EObject eObject, Resource newResource);
Lines 53-58 Link Here
53	* absorbed from a subordinate resource with the specified <code>uri</code>	57	* absorbed from a subordinate resource with the specified <code>uri</code>
54	* @param oldResource the subordinate resource (within the logical	58	* @param oldResource the subordinate resource (within the logical
55	* <code>resource</code>) that formerly stored the <code>eObject</code>	59	* <code>resource</code>) that formerly stored the <code>eObject</code>
		60	*
		61	* @deprecated Use the cross-resource containment support provided by EMF,
		62	* instead, by defining containment features that are capable of storing
		63	* proxies.
56	*/	64	*/
57	public void handleElementAbsorbedEvent(Notification notification,	65	public void handleElementAbsorbedEvent(Notification notification,
58	ILogicalResource resource, EObject eObject, Resource oldResource);	66	ILogicalResource resource, EObject eObject, Resource oldResource);
Lines 65-70 Link Here
65	* @param resource the logical resource into which the object was loaded	73	* @param resource the logical resource into which the object was loaded
66	* @param eObject an object in the <code>resource</code>, which is	74	* @param eObject an object in the <code>resource</code>, which is
67	* newly loaded from a previously unloaded physical resource	75	* newly loaded from a previously unloaded physical resource
		76	*
		77	* @deprecated Use the cross-resource containment support provided by EMF,
		78	* instead, by defining containment features that are capable of storing
		79	* proxies.
68	*/	80	*/
69	public void handleElementLoadedEvent(Notification notification,	81	public void handleElementLoadedEvent(Notification notification,
70	ILogicalResource resource, EObject eObject);	82	ILogicalResource resource, EObject eObject);

Lines 48-53 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/edit/MResourceOption.java (+8 lines)
48	* {@linkplain org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource logical resource}.	48	* {@linkplain org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource logical resource}.
49	*	49	*
50	* @see #DONT_AUTO_LOAD_SUBUNITS	50	* @see #DONT_AUTO_LOAD_SUBUNITS
		51	*
		52	* @deprecated Use the cross-resource containment support provided by EMF,
		53	* instead, by defining containment features that are capable of storing
		54	* proxies.
51	*/	55	*/
52	public static final int LOAD_ALL_SUBUNITS = 16;	56	public static final int LOAD_ALL_SUBUNITS = 16;
53		57
Lines 57-62 Link Here
57	* This option is ignored if all units are loaded initially.	61	* This option is ignored if all units are loaded initially.
58	*	62	*
59	* @see #LOAD_ALL_SUBUNITS	63	* @see #LOAD_ALL_SUBUNITS
		64	*
		65	* @deprecated Use the cross-resource containment support provided by EMF,
		66	* instead, by defining containment features that are capable of storing
		67	* proxies.
60	*/	68	*/
61	public static final int DONT_AUTO_LOAD_SUBUNITS = 32;	69	public static final int DONT_AUTO_LOAD_SUBUNITS = 32;
62		70

Lines 129-134 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/edit/MFilter.java (+8 lines)
129		129
130	/**	130	/**
131	* Filter for element separated or absorbed events.	131	* Filter for element separated or absorbed events.
		132	*
		133	* @deprecated Use the cross-resource containment support provided by EMF,
		134	* instead, by defining containment features that are capable of storing
		135	* proxies.
132	*/	136	*/
133	public final static MFilter SEPARATED_ABSORBED_FILTER = new MFilter.Or(	137	public final static MFilter SEPARATED_ABSORBED_FILTER = new MFilter.Or(
134	new MFilter.EventType(EventTypes.SEPARATE), new MFilter.EventType(	138	new MFilter.EventType(EventTypes.SEPARATE), new MFilter.EventType(
Lines 168-173 Link Here
168		172
169	/**	173	/**
170	* Filter for element loaded events.	174	* Filter for element loaded events.
		175	*
		176	* @deprecated Use the cross-resource containment support provided by EMF,
		177	* instead, by defining containment features that are capable of storing
		178	* proxies.
171	*/	179	*/
172	public final static MFilter ELEMENT_LOADED_FILTER =	180	public final static MFilter ELEMENT_LOADED_FILTER =
173	new MFilter.EventType(EventTypes.LOAD);	181	new MFilter.EventType(EventTypes.LOAD);




import java.util.List;

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.resource.Resource;

import org.eclipse.gmf.runtime.emf.core.EventTypes;
import org.eclipse.gmf.runtime.emf.core.internal.notifications.MSLResourceListener;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;
import org.eclipse.gmf.runtime.emf.core.util.ResourceUtil;

/**

					Resource resource = (Resource) notifier;
					eventListener
						.handleResourceExportedEvent(notification, resource);
				} else if (notification.getEventType() == EventTypes.SEPARATE) {
					int featureID = notification.getFeatureID(Resource.class);
					if ((featureID == Resource.RESOURCE__CONTENTS) && (eventListener2 != null)) {
						ILogicalResource res = (ILogicalResource) notifier;
						Resource newRes = (Resource) notification.getNewValue();
						int position = notification.getPosition();
						
						EObject element = (EObject) res.getContents().get(position);
						
						eventListener2.handleElementSeparatedEvent(
							notification, res, element, newRes);
					}
				} else if (notification.getEventType() == EventTypes.ABSORB) {
					int featureID = notification.getFeatureID(Resource.class);
					if ((featureID == Resource.RESOURCE__CONTENTS) && (eventListener2 != null)) {
						ILogicalResource res = (ILogicalResource) notifier;
						Resource oldRes = (Resource) notification.getOldValue();
						int position = notification.getPosition();
						
						EObject element = (EObject) res.getContents().get(position);
						
						eventListener2.handleElementAbsorbedEvent(
							notification, res, element, oldRes);
					}
				} else if (notification.getEventType() == EventTypes.LOAD) {
					int featureID = notification.getFeatureID(Resource.class);
					if ((featureID == Resource.RESOURCE__CONTENTS) && (eventListener2 != null)) {
						EObject element = (EObject) notification.getNewValue();
						ILogicalResource res = (ILogicalResource) notifier;
						
						eventListener2.handleElementLoadedEvent(
							notification, res, element);
					}
				}
			} else if (notifier instanceof EObject) {
				if (notification.getEventType() == EventTypes.ADD) {

					EObject element = (EObject) notifier;
					eventListener.handleElementModifiedEvent(notification,
						element);
				} else if (notification.getEventType() == EventTypes.SEPARATE) {
					if (eventListener2 != null) {
						EObject element = (EObject) notifier;
						ILogicalResource res = (ILogicalResource) element.eResource();
						EReference feature = (EReference) notification.getFeature();
						Resource newRes = (Resource) notification.getNewValue();
						int position = notification.getPosition();
						
						if (position < 0) {
							// scalar reference
							element = (EObject) element.eGet(feature);
						} else {
							element = (EObject) ((EList) element.eGet(feature)).get(position);
						}
						
						eventListener2.handleElementSeparatedEvent(
							notification, res, element, newRes);
					}
				} else if (notification.getEventType() == EventTypes.ABSORB) {
					if (eventListener2 != null) {
						EObject element = (EObject) notifier;
						ILogicalResource res = (ILogicalResource) element.eResource();
						EReference feature = (EReference) notification.getFeature();
						Resource oldRes = (Resource) notification.getOldValue();
						int position = notification.getPosition();
						
						if (position < 0) {
							// scalar reference
							element = (EObject) element.eGet(feature);
						} else {
							element = (EObject) ((EList) element.eGet(feature)).get(position);
						}
						
						eventListener2.handleElementAbsorbedEvent(
							notification, res, element, oldRes);
					}
				} else if (notification.getEventType() == EventTypes.LOAD) {
					if (eventListener2 != null) {
						EObject element = (EObject) notification.getNewValue();
						ILogicalResource res = (ILogicalResource) element.eResource();
						
						eventListener2.handleElementLoadedEvent(
							notification, res, element);
					}
				}
			} else if (notifier instanceof MUndoInterval) {
				MUndoInterval undoInterval = (MUndoInterval) notifier;

Lines 18-26 Link Here

(-)META-INF/MANIFEST.MF (-3 lines)
18	org.eclipse.gmf.runtime.emf.core.internal.l10n,	18	org.eclipse.gmf.runtime.emf.core.internal.l10n,
19	org.eclipse.gmf.runtime.emf.core.internal.notifications,	19	org.eclipse.gmf.runtime.emf.core.internal.notifications,
20	org.eclipse.gmf.runtime.emf.core.internal.plugin,	20	org.eclipse.gmf.runtime.emf.core.internal.plugin,
21	org.eclipse.gmf.runtime.emf.core.internal.resourcemap;x-friends:="org.eclipse.gmf.tests.runtime.emf.core",
22	org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl;x-friends:="org.eclipse.gmf.tests.runtime.emf.core",
23	org.eclipse.gmf.runtime.emf.core.internal.resourcemap.util;x-friends:="org.eclipse.gmf.tests.runtime.emf.core",
24	org.eclipse.gmf.runtime.emf.core.internal.resources,	21	org.eclipse.gmf.runtime.emf.core.internal.resources,
25	org.eclipse.gmf.runtime.emf.core.internal.services.metamodel,	22	org.eclipse.gmf.runtime.emf.core.internal.services.metamodel,
26	org.eclipse.gmf.runtime.emf.core.internal.type,	23	org.eclipse.gmf.runtime.emf.core.internal.type,




<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<head>
<!--

/******************************************************************************
 * Copyright (c) 2004,2005 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 
 ****************************************************************************/





/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resourcemap.util;

import java.util.List;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;

import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage;

/**
 * <!-- begin-user-doc -->
 * The <b>Switch</b> for the logical resource physical mapping metamodel's
 * inheritance hierarchy.
 * It supports the call {@link #doSwitch(EObject) doSwitch(object)}
 * to invoke the <code>caseXXX</code> method for each class of the metamodel,
 * starting with the actual class of the object
 * and proceeding up the inheritance hierarchy
 * until a non-null result is returned,
 * which is the result of the switch.
 * <!-- end-user-doc -->
 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage
 * @generated
 */
public class ResourceMapSwitch {
	/**
	 * The cached model package
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected static ResourceMapPackage modelPackage;

	/**
	 * Creates an instance of the switch.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public ResourceMapSwitch() {
		if (modelPackage == null) {
			modelPackage = ResourceMapPackage.eINSTANCE;
		}
	}

	/**
	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the first non-null result returned by a <code>caseXXX</code> call.
	 * @generated
	 */
	public Object doSwitch(EObject theEObject) {
		return doSwitch(theEObject.eClass(), theEObject);
	}

	/**
	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the first non-null result returned by a <code>caseXXX</code> call.
	 * @generated
	 */
	protected Object doSwitch(EClass theEClass, EObject theEObject) {
		if (theEClass.eContainer() == modelPackage) {
			return doSwitch(theEClass.getClassifierID(), theEObject);
		}
		else {
			List eSuperTypes = theEClass.getESuperTypes();
			return
				eSuperTypes.isEmpty() ?
					defaultCase(theEObject) :
					doSwitch((EClass)eSuperTypes.get(0), theEObject);
		}
	}

	/**
	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the first non-null result returned by a <code>caseXXX</code> call.
	 * @generated
	 */
	protected Object doSwitch(int classifierID, EObject theEObject) {
		switch (classifierID) {
			case ResourceMapPackage.RESOURCE_MAP: {
				ResourceMap resourceMap = (ResourceMap)theEObject;
				Object result = caseResourceMap(resourceMap);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case ResourceMapPackage.RESOURCE_ENTRY: {
				ResourceEntry resourceEntry = (ResourceEntry)theEObject;
				Object result = caseResourceEntry(resourceEntry);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case ResourceMapPackage.PARENT_ENTRY: {
				ParentEntry parentEntry = (ParentEntry)theEObject;
				Object result = caseParentEntry(parentEntry);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case ResourceMapPackage.CHILD_ENTRY: {
				ChildEntry childEntry = (ChildEntry)theEObject;
				Object result = caseChildEntry(childEntry);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			default: return defaultCase(theEObject);
		}
	}

	/**
	 * Returns the result of interpretting the object as an instance of '<em>Resource Map</em>'.
	 * <!-- begin-user-doc -->
	 * This implementation returns null;
	 * returning a non-null result will terminate the switch.
	 * <!-- end-user-doc -->
	 * @param object the target of the switch.
	 * @return the result of interpretting the object as an instance of '<em>Resource Map</em>'.
	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	 * @generated
	 */
	public Object caseResourceMap(ResourceMap object) {
		return null;
	}

	/**
	 * Returns the result of interpretting the object as an instance of '<em>Resource Entry</em>'.
	 * <!-- begin-user-doc -->
	 * This implementation returns null;
	 * returning a non-null result will terminate the switch.
	 * <!-- end-user-doc -->
	 * @param object the target of the switch.
	 * @return the result of interpretting the object as an instance of '<em>Resource Entry</em>'.
	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	 * @generated
	 */
	public Object caseResourceEntry(ResourceEntry object) {
		return null;
	}

	/**
	 * Returns the result of interpretting the object as an instance of '<em>Parent Entry</em>'.
	 * <!-- begin-user-doc -->
	 * This implementation returns null;
	 * returning a non-null result will terminate the switch.
	 * <!-- end-user-doc -->
	 * @param object the target of the switch.
	 * @return the result of interpretting the object as an instance of '<em>Parent Entry</em>'.
	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	 * @generated
	 */
	public Object caseParentEntry(ParentEntry object) {
		return null;
	}

	/**
	 * Returns the result of interpretting the object as an instance of '<em>Child Entry</em>'.
	 * <!-- begin-user-doc -->
	 * This implementation returns null;
	 * returning a non-null result will terminate the switch.
	 * <!-- end-user-doc -->
	 * @param object the target of the switch.
	 * @return the result of interpretting the object as an instance of '<em>Child Entry</em>'.
	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	 * @generated
	 */
	public Object caseChildEntry(ChildEntry object) {
		return null;
	}

	/**
	 * Returns the result of interpretting the object as an instance of '<em>EObject</em>'.
	 * <!-- begin-user-doc -->
	 * This implementation returns null;
	 * returning a non-null result will terminate the switch, but this is the last case anyway.
	 * <!-- end-user-doc -->
	 * @param object the target of the switch.
	 * @return the result of interpretting the object as an instance of '<em>EObject</em>'.
	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
	 * @generated
	 */
	public Object defaultCase(EObject object) {
		return null;
	}

} //ResourceMapSwitch




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resourcemap.util;

import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
import org.eclipse.emf.ecore.EObject;

import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage;

/**
 * <!-- begin-user-doc -->
 * The <b>Adapter Factory</b> for the logical resource physical mapping metamodel.
 * <!-- end-user-doc -->
 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage
 * @generated
 */
public class ResourceMapAdapterFactory extends AdapterFactoryImpl {
	/**
	 * The cached model package.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected static ResourceMapPackage modelPackage;

	/**
	 * Creates an instance of the adapter factory.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public ResourceMapAdapterFactory() {
		if (modelPackage == null) {
			modelPackage = ResourceMapPackage.eINSTANCE;
		}
	}

	/**
	 * Returns whether this factory is applicable for the type of the object.
	 * <!-- begin-user-doc -->
	 * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
	 * <!-- end-user-doc -->
	 * @return whether this factory is applicable for the type of the object.
	 * @generated
	 */
	public boolean isFactoryForType(Object object) {
		if (object == modelPackage) {
			return true;
		}
		if (object instanceof EObject) {
			return ((EObject)object).eClass().getEPackage() == modelPackage;
		}
		return false;
	}

	/**
	 * The switch the delegates to the <code>createXXX</code> methods.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected ResourceMapSwitch modelSwitch =
		new ResourceMapSwitch() {
			public Object caseResourceMap(ResourceMap object) {
				return createResourceMapAdapter();
			}
			public Object caseResourceEntry(ResourceEntry object) {
				return createResourceEntryAdapter();
			}
			public Object caseParentEntry(ParentEntry object) {
				return createParentEntryAdapter();
			}
			public Object caseChildEntry(ChildEntry object) {
				return createChildEntryAdapter();
			}
			public Object defaultCase(EObject object) {
				return createEObjectAdapter();
			}
		};

	/**
	 * Creates an adapter for the <code>target</code>.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param target the object to adapt.
	 * @return the adapter for the <code>target</code>.
	 * @generated
	 */
	public Adapter createAdapter(Notifier target) {
		return (Adapter)modelSwitch.doSwitch((EObject)target);
	}


	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap <em>Resource Map</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap
	 * @generated
	 */
	public Adapter createResourceMapAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry <em>Resource Entry</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry
	 * @generated
	 */
	public Adapter createResourceEntryAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry <em>Parent Entry</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry
	 * @generated
	 */
	public Adapter createParentEntryAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry <em>Child Entry</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry
	 * @generated
	 */
	public Adapter createChildEntryAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for the default case.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @generated
	 */
	public Adapter createEObjectAdapter() {
		return null;
	}

} //ResourceMapAdapterFactory




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resourcemap.impl;

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.ecore.impl.EObjectImpl;

import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage;

/**
 * <!-- begin-user-doc -->
 * An implementation of the model object '<em><b>Child Entry</b></em>'.
 * <!-- end-user-doc -->
 * <p>
 * The following features are implemented:
 * <ul>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ChildEntryImpl#getChildObject <em>Child Object</em>}</li>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ChildEntryImpl#getParentMap <em>Parent Map</em>}</li>
 * </ul>
 * </p>
 *
 * @generated
 */
public class ChildEntryImpl extends EObjectImpl implements ChildEntry {
	/**
	 * The cached value of the '{@link #getChildObject() <em>Child Object</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getChildObject()
	 * @generated
	 * @ordered
	 */
	protected EObject childObject = null;

	/**
	 * The cached value of the '{@link #getParentMap() <em>Parent Map</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getParentMap()
	 * @generated
	 * @ordered
	 */
	protected ResourceMap parentMap = null;

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected ChildEntryImpl() {
		super();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected EClass eStaticClass() {
		return ResourceMapPackage.eINSTANCE.getChildEntry();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EObject getChildObject() {
		if (childObject != null && childObject.eIsProxy()) {
			EObject oldChildObject = childObject;
			childObject = eResolveProxy((InternalEObject)childObject);
			if (childObject != oldChildObject) {
				if (eNotificationRequired())
					eNotify(new ENotificationImpl(this, Notification.RESOLVE, ResourceMapPackage.CHILD_ENTRY__CHILD_OBJECT, oldChildObject, childObject));
			}
		}
		return childObject;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EObject basicGetChildObject() {
		return childObject;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void setChildObject(EObject newChildObject) {
		EObject oldChildObject = childObject;
		childObject = newChildObject;
		if (eNotificationRequired())
			eNotify(new ENotificationImpl(this, Notification.SET, ResourceMapPackage.CHILD_ENTRY__CHILD_OBJECT, oldChildObject, childObject));
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public ResourceMap getParentMap() {
		if (parentMap != null && parentMap.eIsProxy()) {
			ResourceMap oldParentMap = parentMap;
			parentMap = (ResourceMap)eResolveProxy((InternalEObject)parentMap);
			if (parentMap != oldParentMap) {
				if (eNotificationRequired())
					eNotify(new ENotificationImpl(this, Notification.RESOLVE, ResourceMapPackage.CHILD_ENTRY__PARENT_MAP, oldParentMap, parentMap));
			}
		}
		return parentMap;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public ResourceMap basicGetParentMap() {
		return parentMap;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void setParentMap(ResourceMap newParentMap) {
		ResourceMap oldParentMap = parentMap;
		parentMap = newParentMap;
		if (eNotificationRequired())
			eNotify(new ENotificationImpl(this, Notification.SET, ResourceMapPackage.CHILD_ENTRY__PARENT_MAP, oldParentMap, parentMap));
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
		switch (eDerivedStructuralFeatureID(eFeature)) {
			case ResourceMapPackage.CHILD_ENTRY__CHILD_OBJECT:
				if (resolve) return getChildObject();
				return basicGetChildObject();
			case ResourceMapPackage.CHILD_ENTRY__PARENT_MAP:
				if (resolve) return getParentMap();
				return basicGetParentMap();
		}
		return eDynamicGet(eFeature, resolve);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void eSet(EStructuralFeature eFeature, Object newValue) {
		switch (eDerivedStructuralFeatureID(eFeature)) {
			case ResourceMapPackage.CHILD_ENTRY__CHILD_OBJECT:
				setChildObject((EObject)newValue);
				return;
			case ResourceMapPackage.CHILD_ENTRY__PARENT_MAP:
				setParentMap((ResourceMap)newValue);
				return;
		}
		eDynamicSet(eFeature, newValue);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void eUnset(EStructuralFeature eFeature) {
		switch (eDerivedStructuralFeatureID(eFeature)) {
			case ResourceMapPackage.CHILD_ENTRY__CHILD_OBJECT:
				setChildObject((EObject)null);
				return;
			case ResourceMapPackage.CHILD_ENTRY__PARENT_MAP:
				setParentMap((ResourceMap)null);
				return;
		}
		eDynamicUnset(eFeature);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public boolean eIsSet(EStructuralFeature eFeature) {
		switch (eDerivedStructuralFeatureID(eFeature)) {
			case ResourceMapPackage.CHILD_ENTRY__CHILD_OBJECT:
				return childObject != null;
			case ResourceMapPackage.CHILD_ENTRY__PARENT_MAP:
				return parentMap != null;
		}
		return eDynamicIsSet(eFeature);
	}

} //ChildEntryImpl




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resourcemap.impl;

import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EOperation;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.impl.EPackageImpl;

import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapFactory;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage;

/**
 * <!-- begin-user-doc -->
 * An implementation of the model <b>Package</b>.
 * <!-- end-user-doc -->
 * @generated
 */
public class ResourceMapPackageImpl extends EPackageImpl implements ResourceMapPackage {
	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	private EClass resourceMapEClass = null;

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	private EClass resourceEntryEClass = null;

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	private EClass parentEntryEClass = null;

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	private EClass childEntryEClass = null;

	/**
	 * Creates an instance of the model <b>Package</b>, registered with
	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
	 * package URI value.
	 * <p>Note: the correct way to create the package is via the static
	 * factory method {@link #init init()}, which also performs
	 * initialization of the package, or returns the registered package,
	 * if one already exists.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.emf.ecore.EPackage.Registry
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage#eNS_URI
	 * @see #init()
	 * @generated
	 */
	private ResourceMapPackageImpl() {
		super(eNS_URI, ResourceMapFactory.eINSTANCE);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	private static boolean isInited = false;

	/**
	 * Creates, registers, and initializes the <b>Package</b> for this
	 * model, and for any others upon which it depends.  Simple
	 * dependencies are satisfied by calling this method on all
	 * dependent packages before doing anything else.  This method drives
	 * initialization for interdependent packages directly, in parallel
	 * with this package, itself.
	 * <p>Of this package and its interdependencies, all packages which
	 * have not yet been registered by their URI values are first created
	 * and registered.  The packages are then initialized in two steps:
	 * meta-model objects for all of the packages are created before any
	 * are initialized, since one package's meta-model objects may refer to
	 * those of another.
	 * <p>Invocation of this method will not affect any packages that have
	 * already been initialized.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #eNS_URI
	 * @see #createPackageContents()
	 * @see #initializePackageContents()
	 * @generated
	 */
	public static ResourceMapPackage init() {
		if (isInited) return (ResourceMapPackage)EPackage.Registry.INSTANCE.getEPackage(ResourceMapPackage.eNS_URI);

		// Obtain or create and register package
		ResourceMapPackageImpl theResourceMapPackage = (ResourceMapPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(eNS_URI) instanceof ResourceMapPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(eNS_URI) : new ResourceMapPackageImpl());

		isInited = true;

		// Create package meta-data objects
		theResourceMapPackage.createPackageContents();

		// Initialize created meta-data
		theResourceMapPackage.initializePackageContents();

		// Mark meta-data to indicate it can't be changed
		theResourceMapPackage.freeze();

		return theResourceMapPackage;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EClass getResourceMap() {
		return resourceMapEClass;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EReference getResourceMap_RootMap() {
		return (EReference)resourceMapEClass.getEStructuralFeatures().get(0);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EReference getResourceMap_ParentEntries() {
		return (EReference)resourceMapEClass.getEStructuralFeatures().get(1);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EReference getResourceMap_ChildEntries() {
		return (EReference)resourceMapEClass.getEStructuralFeatures().get(2);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EClass getResourceEntry() {
		return resourceEntryEClass;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EAttribute getResourceEntry_Resource() {
		return (EAttribute)resourceEntryEClass.getEStructuralFeatures().get(0);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EAttribute getResourceEntry_ChildPosition() {
		return (EAttribute)resourceEntryEClass.getEStructuralFeatures().get(1);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EReference getResourceEntry_ChildObject() {
		return (EReference)resourceEntryEClass.getEStructuralFeatures().get(2);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EReference getResourceEntry_ParentEntry() {
		return (EReference)resourceEntryEClass.getEStructuralFeatures().get(3);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EClass getParentEntry() {
		return parentEntryEClass;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EReference getParentEntry_ParentObject() {
		return (EReference)parentEntryEClass.getEStructuralFeatures().get(0);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EReference getParentEntry_ChildSlot() {
		return (EReference)parentEntryEClass.getEStructuralFeatures().get(1);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EReference getParentEntry_ResourceEntries() {
		return (EReference)parentEntryEClass.getEStructuralFeatures().get(2);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EReference getParentEntry_ResourceMap() {
		return (EReference)parentEntryEClass.getEStructuralFeatures().get(3);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EClass getChildEntry() {
		return childEntryEClass;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EReference getChildEntry_ChildObject() {
		return (EReference)childEntryEClass.getEStructuralFeatures().get(0);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EReference getChildEntry_ParentMap() {
		return (EReference)childEntryEClass.getEStructuralFeatures().get(1);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public ResourceMapFactory getResourceMapFactory() {
		return (ResourceMapFactory)getEFactoryInstance();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	private boolean isCreated = false;

	/**
	 * Creates the meta-model objects for the package.  This method is
	 * guarded to have no affect on any invocation but its first.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void createPackageContents() {
		if (isCreated) return;
		isCreated = true;

		// Create classes and their features
		resourceMapEClass = createEClass(RESOURCE_MAP);
		createEReference(resourceMapEClass, RESOURCE_MAP__ROOT_MAP);
		createEReference(resourceMapEClass, RESOURCE_MAP__PARENT_ENTRIES);
		createEReference(resourceMapEClass, RESOURCE_MAP__CHILD_ENTRIES);

		resourceEntryEClass = createEClass(RESOURCE_ENTRY);
		createEAttribute(resourceEntryEClass, RESOURCE_ENTRY__RESOURCE);
		createEAttribute(resourceEntryEClass, RESOURCE_ENTRY__CHILD_POSITION);
		createEReference(resourceEntryEClass, RESOURCE_ENTRY__CHILD_OBJECT);
		createEReference(resourceEntryEClass, RESOURCE_ENTRY__PARENT_ENTRY);

		parentEntryEClass = createEClass(PARENT_ENTRY);
		createEReference(parentEntryEClass, PARENT_ENTRY__PARENT_OBJECT);
		createEReference(parentEntryEClass, PARENT_ENTRY__CHILD_SLOT);
		createEReference(parentEntryEClass, PARENT_ENTRY__RESOURCE_ENTRIES);
		createEReference(parentEntryEClass, PARENT_ENTRY__RESOURCE_MAP);

		childEntryEClass = createEClass(CHILD_ENTRY);
		createEReference(childEntryEClass, CHILD_ENTRY__CHILD_OBJECT);
		createEReference(childEntryEClass, CHILD_ENTRY__PARENT_MAP);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	private boolean isInitialized = false;

	/**
	 * Complete the initialization of the package and its meta-model.  This
	 * method is guarded to have no affect on any invocation but its first.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void initializePackageContents() {
		if (isInitialized) return;
		isInitialized = true;

		// Initialize package
		setName(eNAME);
		setNsPrefix(eNS_PREFIX);
		setNsURI(eNS_URI);

		// Add supertypes to classes

		// Initialize classes and features; add operations and parameters
		initEClass(resourceMapEClass, ResourceMap.class, "ResourceMap", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
		initEReference(getResourceMap_RootMap(), this.getResourceMap(), null, "rootMap", null, 0, 1, ResourceMap.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getResourceMap_ParentEntries(), this.getParentEntry(), null, "parentEntries", null, 0, -1, ResourceMap.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
		initEReference(getResourceMap_ChildEntries(), this.getChildEntry(), null, "childEntries", null, 0, -1, ResourceMap.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$

		EOperation op = addEOperation(resourceMapEClass, this.getParentEntry(), "getParentEntry"); //$NON-NLS-1$
		addEParameter(op, ecorePackage.getEObject(), "parent"); //$NON-NLS-1$
		addEParameter(op, ecorePackage.getEReference(), "slot"); //$NON-NLS-1$

		op = addEOperation(resourceMapEClass, this.getResourceEntry(), "getResourceEntry"); //$NON-NLS-1$
		addEParameter(op, ecorePackage.getEObject(), "child"); //$NON-NLS-1$

		op = addEOperation(resourceMapEClass, this.getResourceMap(), "getParentMap"); //$NON-NLS-1$
		addEParameter(op, ecorePackage.getEObject(), "child"); //$NON-NLS-1$

		initEClass(resourceEntryEClass, ResourceEntry.class, "ResourceEntry", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
		initEAttribute(getResourceEntry_Resource(), ecorePackage.getEResource(), "resource", null, 0, 1, ResourceEntry.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEAttribute(getResourceEntry_ChildPosition(), ecorePackage.getEInt(), "childPosition", "-1", 0, 1, ResourceEntry.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$ //$NON-NLS-2$
		initEReference(getResourceEntry_ChildObject(), ecorePackage.getEObject(), null, "childObject", null, 1, 1, ResourceEntry.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getResourceEntry_ParentEntry(), this.getParentEntry(), null, "parentEntry", null, 0, 1, ResourceEntry.class, IS_TRANSIENT, IS_VOLATILE, !IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

		initEClass(parentEntryEClass, ParentEntry.class, "ParentEntry", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
		initEReference(getParentEntry_ParentObject(), ecorePackage.getEObject(), null, "parentObject", null, 0, 1, ParentEntry.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getParentEntry_ChildSlot(), ecorePackage.getEReference(), null, "childSlot", null, 0, 1, ParentEntry.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getParentEntry_ResourceEntries(), this.getResourceEntry(), null, "resourceEntries", null, 1, -1, ParentEntry.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getParentEntry_ResourceMap(), this.getResourceMap(), null, "resourceMap", null, 0, 1, ParentEntry.class, IS_TRANSIENT, IS_VOLATILE, !IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

		op = addEOperation(parentEntryEClass, this.getResourceEntry(), "getResourceEntry"); //$NON-NLS-1$
		addEParameter(op, ecorePackage.getEObject(), "child"); //$NON-NLS-1$

		initEClass(childEntryEClass, ChildEntry.class, "ChildEntry", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
		initEReference(getChildEntry_ChildObject(), ecorePackage.getEObject(), null, "childObject", null, 1, 1, ChildEntry.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getChildEntry_ParentMap(), this.getResourceMap(), null, "parentMap", null, 1, 1, ChildEntry.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

		// Create resource
		createResource(eNS_URI);
	}

} //ResourceMapPackageImpl




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resourcemap.impl;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.impl.EFactoryImpl;

import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapFactory;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage;

/**
 * <!-- begin-user-doc -->
 * An implementation of the model <b>Factory</b>.
 * <!-- end-user-doc -->
 * @generated
 */
public class ResourceMapFactoryImpl extends EFactoryImpl implements ResourceMapFactory {
	/**
	 * Creates an instance of the factory.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public ResourceMapFactoryImpl() {
		super();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EObject create(EClass eClass) {
		switch (eClass.getClassifierID()) {
			case ResourceMapPackage.RESOURCE_MAP: return createResourceMap();
			case ResourceMapPackage.RESOURCE_ENTRY: return createResourceEntry();
			case ResourceMapPackage.PARENT_ENTRY: return createParentEntry();
			case ResourceMapPackage.CHILD_ENTRY: return createChildEntry();
			default:
				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier"); //$NON-NLS-1$ //$NON-NLS-2$
		}
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public ResourceMap createResourceMap() {
		ResourceMapImpl resourceMap = new ResourceMapImpl();
		return resourceMap;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public ResourceEntry createResourceEntry() {
		ResourceEntryImpl resourceEntry = new ResourceEntryImpl();
		return resourceEntry;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public ParentEntry createParentEntry() {
		ParentEntryImpl parentEntry = new ParentEntryImpl();
		return parentEntry;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public ChildEntry createChildEntry() {
		ChildEntryImpl childEntry = new ChildEntryImpl();
		return childEntry;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public ResourceMapPackage getResourceMapPackage() {
		return (ResourceMapPackage)getEPackage();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @deprecated
	 * @generated
	 */
	public static ResourceMapPackage getPackage() {
		return ResourceMapPackage.eINSTANCE;
	}

} //ResourceMapFactoryImpl




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resourcemap.impl;

import java.util.Collection;
import java.util.Iterator;

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.NotificationChain;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.ecore.impl.EObjectImpl;
import org.eclipse.emf.ecore.util.EObjectContainmentEList;
import org.eclipse.emf.ecore.util.InternalEList;

import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage;

/**
 * <!-- begin-user-doc -->
 * An implementation of the model object '<em><b>Resource Map</b></em>'.
 * <!-- end-user-doc -->
 * <p>
 * The following features are implemented:
 * <ul>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ResourceMapImpl#getRootMap <em>Root Map</em>}</li>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ResourceMapImpl#getParentEntries <em>Parent Entries</em>}</li>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ResourceMapImpl#getChildEntries <em>Child Entries</em>}</li>
 * </ul>
 * </p>
 *
 * @generated
 */
public class ResourceMapImpl extends EObjectImpl implements ResourceMap {
	/**
	 * The cached value of the '{@link #getRootMap() <em>Root Map</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getRootMap()
	 * @generated
	 * @ordered
	 */
	protected ResourceMap rootMap = null;

	/**
	 * The cached value of the '{@link #getParentEntries() <em>Parent Entries</em>}' containment reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getParentEntries()
	 * @generated
	 * @ordered
	 */
	protected EList parentEntries = null;

	/**
	 * The cached value of the '{@link #getChildEntries() <em>Child Entries</em>}' containment reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getChildEntries()
	 * @generated
	 * @ordered
	 */
	protected EList childEntries = null;

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected ResourceMapImpl() {
		super();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected EClass eStaticClass() {
		return ResourceMapPackage.eINSTANCE.getResourceMap();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public ResourceMap getRootMap() {
		if (rootMap != null && rootMap.eIsProxy()) {
			ResourceMap oldRootMap = rootMap;
			rootMap = (ResourceMap)eResolveProxy((InternalEObject)rootMap);
			if (rootMap != oldRootMap) {
				if (eNotificationRequired())
					eNotify(new ENotificationImpl(this, Notification.RESOLVE, ResourceMapPackage.RESOURCE_MAP__ROOT_MAP, oldRootMap, rootMap));
			}
		}
		return rootMap;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public ResourceMap basicGetRootMap() {
		return rootMap;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void setRootMap(ResourceMap newRootMap) {
		ResourceMap oldRootMap = rootMap;
		rootMap = newRootMap;
		if (eNotificationRequired())
			eNotify(new ENotificationImpl(this, Notification.SET, ResourceMapPackage.RESOURCE_MAP__ROOT_MAP, oldRootMap, rootMap));
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EList getParentEntries() {
		if (parentEntries == null) {
			parentEntries = new EObjectContainmentEList(ParentEntry.class, this, ResourceMapPackage.RESOURCE_MAP__PARENT_ENTRIES);
		}
		return parentEntries;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EList getChildEntries() {
		if (childEntries == null) {
			childEntries = new EObjectContainmentEList(ChildEntry.class, this, ResourceMapPackage.RESOURCE_MAP__CHILD_ENTRIES);
		}
		return childEntries;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated NOT
	 */
	public ParentEntry getParentEntry(EObject parent, EReference slot) {
		ParentEntry result = null;
		
		for (Iterator iter = getParentEntries().iterator();
				(result == null) && iter.hasNext();) {
			
			ParentEntry next = (ParentEntry) iter.next();
			
			if ((next.getParentObject() == parent) && (next.getChildSlot() == slot)) {
				result = next;
			}
		}
		
		return result;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated NOT
	 */
	public ResourceEntry getResourceEntry(EObject child) {
		ResourceEntry result = null;
		
		// do not attempt to find the correct parent entry by the child's
		//   eContainer and eContainmentFeature, as it may not have either
		//   of these at this moment, or they may be different than expected
		for (Iterator iter = getParentEntries().iterator();
				(result == null) && iter.hasNext();) {
			
			ParentEntry parentEntry = (ParentEntry) iter.next();
			
			result = parentEntry.getResourceEntry(child);
		}
		
		return result;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated NOT
	 */
	public ResourceMap getParentMap(EObject child) {
		ResourceMap result = null;
		ChildEntry childEntry = getChildEntry(child);
		
		if (childEntry != null) {
			result = childEntry.getParentMap();
		}
		
		return result;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated NOT
	 */
	public ChildEntry getChildEntry(EObject child) {
		ChildEntry result = null;
		
		for (Iterator iter = getChildEntries().iterator();
				(result == null) && iter.hasNext();) {
			
			ChildEntry next = (ChildEntry) iter.next();
			
			if (next.getChildObject() == child) {
				result = next;
			}
		}
		
		return result;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
		if (featureID >= 0) {
			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
				case ResourceMapPackage.RESOURCE_MAP__PARENT_ENTRIES:
					return ((InternalEList)getParentEntries()).basicRemove(otherEnd, msgs);
				case ResourceMapPackage.RESOURCE_MAP__CHILD_ENTRIES:
					return ((InternalEList)getChildEntries()).basicRemove(otherEnd, msgs);
				default:
					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
			}
		}
		return eBasicSetContainer(null, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
		switch (eDerivedStructuralFeatureID(eFeature)) {
			case ResourceMapPackage.RESOURCE_MAP__ROOT_MAP:
				if (resolve) return getRootMap();
				return basicGetRootMap();
			case ResourceMapPackage.RESOURCE_MAP__PARENT_ENTRIES:
				return getParentEntries();
			case ResourceMapPackage.RESOURCE_MAP__CHILD_ENTRIES:
				return getChildEntries();
		}
		return eDynamicGet(eFeature, resolve);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void eSet(EStructuralFeature eFeature, Object newValue) {
		switch (eDerivedStructuralFeatureID(eFeature)) {
			case ResourceMapPackage.RESOURCE_MAP__ROOT_MAP:
				setRootMap((ResourceMap)newValue);
				return;
			case ResourceMapPackage.RESOURCE_MAP__PARENT_ENTRIES:
				getParentEntries().clear();
				getParentEntries().addAll((Collection)newValue);
				return;
			case ResourceMapPackage.RESOURCE_MAP__CHILD_ENTRIES:
				getChildEntries().clear();
				getChildEntries().addAll((Collection)newValue);
				return;
		}
		eDynamicSet(eFeature, newValue);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void eUnset(EStructuralFeature eFeature) {
		switch (eDerivedStructuralFeatureID(eFeature)) {
			case ResourceMapPackage.RESOURCE_MAP__ROOT_MAP:
				setRootMap((ResourceMap)null);
				return;
			case ResourceMapPackage.RESOURCE_MAP__PARENT_ENTRIES:
				getParentEntries().clear();
				return;
			case ResourceMapPackage.RESOURCE_MAP__CHILD_ENTRIES:
				getChildEntries().clear();
				return;
		}
		eDynamicUnset(eFeature);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public boolean eIsSet(EStructuralFeature eFeature) {
		switch (eDerivedStructuralFeatureID(eFeature)) {
			case ResourceMapPackage.RESOURCE_MAP__ROOT_MAP:
				return rootMap != null;
			case ResourceMapPackage.RESOURCE_MAP__PARENT_ENTRIES:
				return parentEntries != null && !parentEntries.isEmpty();
			case ResourceMapPackage.RESOURCE_MAP__CHILD_ENTRIES:
				return childEntries != null && !childEntries.isEmpty();
		}
		return eDynamicIsSet(eFeature);
	}

} //ResourceMapImpl




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resourcemap.impl;

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.ecore.impl.EObjectImpl;
import org.eclipse.emf.ecore.resource.Resource;

import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage;

/**
 * <!-- begin-user-doc -->
 * An implementation of the model object '<em><b>Resource Entry</b></em>'.
 * <!-- end-user-doc -->
 * <p>
 * The following features are implemented:
 * <ul>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ResourceEntryImpl#getResource <em>Resource</em>}</li>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ResourceEntryImpl#getChildPosition <em>Child Position</em>}</li>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ResourceEntryImpl#getChildObject <em>Child Object</em>}</li>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ResourceEntryImpl#getParentEntry <em>Parent Entry</em>}</li>
 * </ul>
 * </p>
 *
 * @generated
 */
public class ResourceEntryImpl extends EObjectImpl implements ResourceEntry {
	/**
	 * The default value of the '{@link #getResource() <em>Resource</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getResource()
	 * @generated
	 * @ordered
	 */
	protected static final Resource RESOURCE_EDEFAULT = null;

	/**
	 * The cached value of the '{@link #getResource() <em>Resource</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getResource()
	 * @generated
	 * @ordered
	 */
	protected Resource resource = RESOURCE_EDEFAULT;

	/**
	 * The default value of the '{@link #getChildPosition() <em>Child Position</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getChildPosition()
	 * @generated
	 * @ordered
	 */
	protected static final int CHILD_POSITION_EDEFAULT = -1;

	/**
	 * The cached value of the '{@link #getChildPosition() <em>Child Position</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getChildPosition()
	 * @generated
	 * @ordered
	 */
	protected int childPosition = CHILD_POSITION_EDEFAULT;

	/**
	 * The cached value of the '{@link #getChildObject() <em>Child Object</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getChildObject()
	 * @generated
	 * @ordered
	 */
	protected EObject childObject = null;

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected ResourceEntryImpl() {
		super();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected EClass eStaticClass() {
		return ResourceMapPackage.eINSTANCE.getResourceEntry();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public Resource getResource() {
		return resource;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void setResource(Resource newResource) {
		Resource oldResource = resource;
		resource = newResource;
		if (eNotificationRequired())
			eNotify(new ENotificationImpl(this, Notification.SET, ResourceMapPackage.RESOURCE_ENTRY__RESOURCE, oldResource, resource));
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public int getChildPosition() {
		return childPosition;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void setChildPosition(int newChildPosition) {
		int oldChildPosition = childPosition;
		childPosition = newChildPosition;
		if (eNotificationRequired())
			eNotify(new ENotificationImpl(this, Notification.SET, ResourceMapPackage.RESOURCE_ENTRY__CHILD_POSITION, oldChildPosition, childPosition));
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EObject getChildObject() {
		if (childObject != null && childObject.eIsProxy()) {
			EObject oldChildObject = childObject;
			childObject = eResolveProxy((InternalEObject)childObject);
			if (childObject != oldChildObject) {
				if (eNotificationRequired())
					eNotify(new ENotificationImpl(this, Notification.RESOLVE, ResourceMapPackage.RESOURCE_ENTRY__CHILD_OBJECT, oldChildObject, childObject));
			}
		}
		return childObject;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EObject basicGetChildObject() {
		return childObject;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void setChildObject(EObject newChildObject) {
		EObject oldChildObject = childObject;
		childObject = newChildObject;
		if (eNotificationRequired())
			eNotify(new ENotificationImpl(this, Notification.SET, ResourceMapPackage.RESOURCE_ENTRY__CHILD_OBJECT, oldChildObject, childObject));
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public ParentEntry getParentEntry() {
		ParentEntry parentEntry = basicGetParentEntry();
		return parentEntry == null ? null : (ParentEntry)eResolveProxy((InternalEObject)parentEntry);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated NOT
	 */
	public ParentEntry basicGetParentEntry() {
		if (eContainer() instanceof ParentEntry) {
			return (ParentEntry) eContainer();
		}
		
		return null;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
		switch (eDerivedStructuralFeatureID(eFeature)) {
			case ResourceMapPackage.RESOURCE_ENTRY__RESOURCE:
				return getResource();
			case ResourceMapPackage.RESOURCE_ENTRY__CHILD_POSITION:
				return new Integer(getChildPosition());
			case ResourceMapPackage.RESOURCE_ENTRY__CHILD_OBJECT:
				if (resolve) return getChildObject();
				return basicGetChildObject();
			case ResourceMapPackage.RESOURCE_ENTRY__PARENT_ENTRY:
				if (resolve) return getParentEntry();
				return basicGetParentEntry();
		}
		return eDynamicGet(eFeature, resolve);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void eSet(EStructuralFeature eFeature, Object newValue) {
		switch (eDerivedStructuralFeatureID(eFeature)) {
			case ResourceMapPackage.RESOURCE_ENTRY__RESOURCE:
				setResource((Resource)newValue);
				return;
			case ResourceMapPackage.RESOURCE_ENTRY__CHILD_POSITION:
				setChildPosition(((Integer)newValue).intValue());
				return;
			case ResourceMapPackage.RESOURCE_ENTRY__CHILD_OBJECT:
				setChildObject((EObject)newValue);
				return;
		}
		eDynamicSet(eFeature, newValue);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void eUnset(EStructuralFeature eFeature) {
		switch (eDerivedStructuralFeatureID(eFeature)) {
			case ResourceMapPackage.RESOURCE_ENTRY__RESOURCE:
				setResource(RESOURCE_EDEFAULT);
				return;
			case ResourceMapPackage.RESOURCE_ENTRY__CHILD_POSITION:
				setChildPosition(CHILD_POSITION_EDEFAULT);
				return;
			case ResourceMapPackage.RESOURCE_ENTRY__CHILD_OBJECT:
				setChildObject((EObject)null);
				return;
		}
		eDynamicUnset(eFeature);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public boolean eIsSet(EStructuralFeature eFeature) {
		switch (eDerivedStructuralFeatureID(eFeature)) {
			case ResourceMapPackage.RESOURCE_ENTRY__RESOURCE:
				return RESOURCE_EDEFAULT == null ? resource != null : !RESOURCE_EDEFAULT.equals(resource);
			case ResourceMapPackage.RESOURCE_ENTRY__CHILD_POSITION:
				return childPosition != CHILD_POSITION_EDEFAULT;
			case ResourceMapPackage.RESOURCE_ENTRY__CHILD_OBJECT:
				return childObject != null;
			case ResourceMapPackage.RESOURCE_ENTRY__PARENT_ENTRY:
				return basicGetParentEntry() != null;
		}
		return eDynamicIsSet(eFeature);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public String toString() {
		if (eIsProxy()) return super.toString();

		StringBuffer result = new StringBuffer(super.toString());
		result.append(" (resource: "); //$NON-NLS-1$
		result.append(resource);
		result.append(", childPosition: "); //$NON-NLS-1$
		result.append(childPosition);
		result.append(')');
		return result.toString();
	}

} //ResourceEntryImpl




<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<head>
<!--

/******************************************************************************
 * Copyright (c) 2004,2005 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 
 ****************************************************************************/





/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resourcemap.impl;

import java.util.Collection;
import java.util.Iterator;

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.NotificationChain;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.ecore.impl.EObjectImpl;
import org.eclipse.emf.ecore.util.EObjectContainmentEList;
import org.eclipse.emf.ecore.util.InternalEList;

import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage;

/**
 * <!-- begin-user-doc -->
 * An implementation of the model object '<em><b>Parent Entry</b></em>'.
 * <!-- end-user-doc -->
 * <p>
 * The following features are implemented:
 * <ul>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ParentEntryImpl#getParentObject <em>Parent Object</em>}</li>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ParentEntryImpl#getChildSlot <em>Child Slot</em>}</li>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ParentEntryImpl#getResourceEntries <em>Resource Entries</em>}</li>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ParentEntryImpl#getResourceMap <em>Resource Map</em>}</li>
 * </ul>
 * </p>
 *
 * @generated
 */
public class ParentEntryImpl extends EObjectImpl implements ParentEntry {
	/**
	 * The cached value of the '{@link #getParentObject() <em>Parent Object</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getParentObject()
	 * @generated
	 * @ordered
	 */
	protected EObject parentObject = null;

	/**
	 * The cached value of the '{@link #getChildSlot() <em>Child Slot</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getChildSlot()
	 * @generated
	 * @ordered
	 */
	protected EReference childSlot = null;

	/**
	 * The cached value of the '{@link #getResourceEntries() <em>Resource Entries</em>}' containment reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getResourceEntries()
	 * @generated
	 * @ordered
	 */
	protected EList resourceEntries = null;

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected ParentEntryImpl() {
		super();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected EClass eStaticClass() {
		return ResourceMapPackage.eINSTANCE.getParentEntry();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EObject getParentObject() {
		if (parentObject != null && parentObject.eIsProxy()) {
			EObject oldParentObject = parentObject;
			parentObject = eResolveProxy((InternalEObject)parentObject);
			if (parentObject != oldParentObject) {
				if (eNotificationRequired())
					eNotify(new ENotificationImpl(this, Notification.RESOLVE, ResourceMapPackage.PARENT_ENTRY__PARENT_OBJECT, oldParentObject, parentObject));
			}
		}
		return parentObject;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EObject basicGetParentObject() {
		return parentObject;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void setParentObject(EObject newParentObject) {
		EObject oldParentObject = parentObject;
		parentObject = newParentObject;
		if (eNotificationRequired())
			eNotify(new ENotificationImpl(this, Notification.SET, ResourceMapPackage.PARENT_ENTRY__PARENT_OBJECT, oldParentObject, parentObject));
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EReference getChildSlot() {
		if (childSlot != null && childSlot.eIsProxy()) {
			EReference oldChildSlot = childSlot;
			childSlot = (EReference)eResolveProxy((InternalEObject)childSlot);
			if (childSlot != oldChildSlot) {
				if (eNotificationRequired())
					eNotify(new ENotificationImpl(this, Notification.RESOLVE, ResourceMapPackage.PARENT_ENTRY__CHILD_SLOT, oldChildSlot, childSlot));
			}
		}
		return childSlot;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EReference basicGetChildSlot() {
		return childSlot;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void setChildSlot(EReference newChildSlot) {
		EReference oldChildSlot = childSlot;
		childSlot = newChildSlot;
		if (eNotificationRequired())
			eNotify(new ENotificationImpl(this, Notification.SET, ResourceMapPackage.PARENT_ENTRY__CHILD_SLOT, oldChildSlot, childSlot));
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public EList getResourceEntries() {
		if (resourceEntries == null) {
			resourceEntries = new EObjectContainmentEList(ResourceEntry.class, this, ResourceMapPackage.PARENT_ENTRY__RESOURCE_ENTRIES);
		}
		return resourceEntries;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public ResourceMap getResourceMap() {
		ResourceMap resourceMap = basicGetResourceMap();
		return resourceMap == null ? null : (ResourceMap)eResolveProxy((InternalEObject)resourceMap);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated NOT
	 */
	public ResourceMap basicGetResourceMap() {
		if (eContainer() instanceof ResourceMap) {
			return (ResourceMap) eContainer();
		}
		
		return null;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated NOT
	 */
	public ResourceEntry getResourceEntry(EObject child) {
		ResourceEntry result = null;
		
		for (Iterator iter = getResourceEntries().iterator();
				(result == null) && iter.hasNext();) {
			
			ResourceEntryImpl next = (ResourceEntryImpl) iter.next();
			
			if (next.basicGetChildObject() == child) {
				result = next;
			}
		}
		
		return result;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
		if (featureID >= 0) {
			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
				case ResourceMapPackage.PARENT_ENTRY__RESOURCE_ENTRIES:
					return ((InternalEList)getResourceEntries()).basicRemove(otherEnd, msgs);
				default:
					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
			}
		}
		return eBasicSetContainer(null, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
		switch (eDerivedStructuralFeatureID(eFeature)) {
			case ResourceMapPackage.PARENT_ENTRY__PARENT_OBJECT:
				if (resolve) return getParentObject();
				return basicGetParentObject();
			case ResourceMapPackage.PARENT_ENTRY__CHILD_SLOT:
				if (resolve) return getChildSlot();
				return basicGetChildSlot();
			case ResourceMapPackage.PARENT_ENTRY__RESOURCE_ENTRIES:
				return getResourceEntries();
			case ResourceMapPackage.PARENT_ENTRY__RESOURCE_MAP:
				if (resolve) return getResourceMap();
				return basicGetResourceMap();
		}
		return eDynamicGet(eFeature, resolve);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void eSet(EStructuralFeature eFeature, Object newValue) {
		switch (eDerivedStructuralFeatureID(eFeature)) {
			case ResourceMapPackage.PARENT_ENTRY__PARENT_OBJECT:
				setParentObject((EObject)newValue);
				return;
			case ResourceMapPackage.PARENT_ENTRY__CHILD_SLOT:
				setChildSlot((EReference)newValue);
				return;
			case ResourceMapPackage.PARENT_ENTRY__RESOURCE_ENTRIES:
				getResourceEntries().clear();
				getResourceEntries().addAll((Collection)newValue);
				return;
		}
		eDynamicSet(eFeature, newValue);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void eUnset(EStructuralFeature eFeature) {
		switch (eDerivedStructuralFeatureID(eFeature)) {
			case ResourceMapPackage.PARENT_ENTRY__PARENT_OBJECT:
				setParentObject((EObject)null);
				return;
			case ResourceMapPackage.PARENT_ENTRY__CHILD_SLOT:
				setChildSlot((EReference)null);
				return;
			case ResourceMapPackage.PARENT_ENTRY__RESOURCE_ENTRIES:
				getResourceEntries().clear();
				return;
		}
		eDynamicUnset(eFeature);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public boolean eIsSet(EStructuralFeature eFeature) {
		switch (eDerivedStructuralFeatureID(eFeature)) {
			case ResourceMapPackage.PARENT_ENTRY__PARENT_OBJECT:
				return parentObject != null;
			case ResourceMapPackage.PARENT_ENTRY__CHILD_SLOT:
				return childSlot != null;
			case ResourceMapPackage.PARENT_ENTRY__RESOURCE_ENTRIES:
				return resourceEntries != null && !resourceEntries.isEmpty();
			case ResourceMapPackage.PARENT_ENTRY__RESOURCE_MAP:
				return basicGetResourceMap() != null;
		}
		return eDynamicIsSet(eFeature);
	}

} //ParentEntryImpl




import java.util.Collections;
import java.util.Map;

import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl;
import org.eclipse.gmf.runtime.emf.core.EventTypes;
import org.eclipse.gmf.runtime.emf.core.internal.l10n.EMFCoreMessages;
import org.eclipse.gmf.runtime.emf.core.internal.plugin.MSLDebugOptions;
import org.eclipse.gmf.runtime.emf.core.internal.resources.AbstractResourceWrapper;
import org.eclipse.gmf.runtime.emf.core.internal.resources.LogicalResourcePolicyManager;
import org.eclipse.gmf.runtime.emf.core.internal.resources.LogicalResourceUtil;
import org.eclipse.gmf.runtime.emf.core.internal.resources.UnmodifiableResourceView;
import org.eclipse.gmf.runtime.emf.core.internal.util.Trace;


/**

 * @see ILogicalResourcePolicy
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @deprecated Use the cross-resource containment support provided by EMF,
 *     instead, by defining containment features that are capable of storing
 *     proxies.
 */
public abstract class AbstractLogicalResource
	extends XMIResourceImpl
	implements ILogicalResource {

	private final Map resourceMap = new java.util.HashMap();
	private final Map unmodifiableResourceMap = new java.util.HashMap();
	
	/**
	 * A map remembering the resource that used to store a separate object
	 * after that object has been detached (in the hope that it will be
	 * re-attached soon).
	 * Maps {@link String} element ID to resource {@link URI}
	 */
	private final Map detachedIdToResourceMap = new java.util.HashMap(); 
	
	/**
	 * Initializes me.

	}
	
	/**
	 * I cannot separate any elements.
	 * resource policies, with the additional constraint that the
	 * <code>eObject</code> must not already be
	 * {@linkplain ILogicalResource#isSeparate(EObject) separate}.
	 * 
	 * @return <code>false</code>, always
	 */
	public boolean canSeparate(EObject eObject) {
		return false;
		
		// the logical resource roots are not considered as separate or
		//   as separable
		return !isSeparate(eObject) && customCanSeparate(eObject)
			&& LogicalResourcePolicyManager.getInstance().canSeparate(this, eObject);
	}

	/**
	 * I cannot separate any elements.
	 * can be separated.  May be overridden by subclasses to provide custom
	 * behaviour.
	 * <p>
	 * This default implementation just returns <code>true</code>.
	 * </p>
	 * 
	 * @return <code>false</code>, always
	 * @return whether it meets the resource implementation's additional criteria
	 */
	public boolean isSeparate(EObject eObject) {
		return false;
	}

	public void separate(EObject eObject, URI uri) {
		throw new IllegalArgumentException("cannot separate eObject"); //$NON-NLS-1$
	}

	public void absorb(EObject eObject) {
		throw new IllegalArgumentException("eObject is not separate"); //$NON-NLS-1$
	}
	
	public boolean isLoaded(EObject eObject) {
		return true;  // no object in a non-logical-resource can be unloaded
	}
	
	public void load(EObject eObject)
		throws IOException {
	 *       policies before and after separation</li>
	 *   <li>fires the {@link org.eclipse.gmf.runtime.emf.core.EventTypes#SEPARATE}
	 *       notification when (and if) separation succeeds</li>
	 *   <li>delegates the actual separation implementation to the
	 *       {@link #doSeparate(EObject, URI)} method implemented by the
	 *       subclass</li>
	 * </ul> 
	 * 
	 * @see #doSeparate(EObject, URI)
	 * @see ILogicalResourcePolicy
	 */
	public final void separate(EObject eObject, URI physUri) throws CannotSeparateException {
		assert eObject.eResource() == this : "eObject is not in receiver" ; //$NON-NLS-1$
		
		if (isSeparate(eObject)) {
			throw new IllegalArgumentException("eObject is already separate"); //$NON-NLS-1$
		}
		
		physUri = LogicalResourcePolicyManager.getInstance().preSeparate(this, eObject, physUri);
		
		Resource oldUnit = getPhysicalResource(eObject);
		
		if (Trace.isEnabled(MSLDebugOptions.RESOURCES)) {
			Trace.trace(
				MSLDebugOptions.RESOURCES,
				"Separating: " + oldUnit.getURI() + " ==> " + physUri + ": " + eObject);  //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
		}
		
		if (physUri == null) {
			// not provided by user and no policy had a suggestion
			CannotSeparateException e = new CannotSeparateException(
				EMFCoreMessages.separate_noUri_ERROR_);
			Trace.throwing(LogicalResourceUtil.class, "separate", e); //$NON-NLS-1$
			throw e;
		}
		
		if (physUri.equals(oldUnit.getURI())) {
			// not allowed to separate into current storage unit
			CannotSeparateException e = new CannotSeparateException(
				EMFCoreMessages.separate_sameUnit_ERROR_);
			Trace.throwing(LogicalResourceUtil.class, "separate", e); //$NON-NLS-1$
			throw e;
		}
		
		doSeparate(eObject, physUri);
		
		Resource newUnit = getPhysicalResource(eObject);
		
		LogicalResourcePolicyManager.getInstance().postSeparate(this, eObject, physUri);
		
		// notify listeners
		LogicalResourceUtil.fireSeparationEvent(eObject, oldUnit, newUnit);
		
		throw new IllegalArgumentException("eObject is not separate"); //$NON-NLS-1$
	}

	public Map getMappedResources() {
		return Collections.EMPTY_MAP;
	}

	public Object getAdapter(Class adapter) {
		return Platform.getAdapterManager().getAdapter(this, adapter);
	}
	
	/**

	protected abstract void doSeparate(EObject eObject, URI physUri) throws CannotSeparateException;
	
	/**
	 * Implementation of the element absorption operation, which does the
	 * following:
	 * <ul>
	 *   <li>enforces the preconditions declared by the interface</li>
	 *   <li>consults the registered {@linkplain ILogicalResourcePolicy}
	 *       policies before and after absorption</li>
	 *   <li>fires the {@link org.eclipse.gmf.runtime.emf.core.EventTypes#ABSORB}
	 *       notification when (and if) absorption succeeds</li>
	 *   <li>delegates the actual absorption implementation to the
	 *       {@link #doAbsorb(EObject)} method implemented by the subclass</li>
	 * </ul> 
	 * 
	 * @see #doAbsorb(EObject)
	 * @see ILogicalResourcePolicy
	 */
	public final void absorb(EObject eObject) throws CannotAbsorbException {
		assert eObject.eResource() == this : "eObject is not in receiver" ; //$NON-NLS-1$
		
		if (!isSeparate(eObject)) {
			throw new IllegalArgumentException("eObject is not separate"); //$NON-NLS-1$
		}
		
		if (!isLoaded(eObject)) {
			throw new IllegalArgumentException("eObject is not loaded"); //$NON-NLS-1$
		}
		
		Resource oldUnit = getPhysicalResource(eObject);
		EObject parent = eObject.eContainer();
		
		Resource newUnit;
		if (parent == null) {
			// the parent unit of a separate root must be to physical root unit
			newUnit = getPhysicalResource(getURI());
		} else {
			newUnit = getPhysicalResource(eObject.eContainer());
		}
		
		if (Trace.isEnabled(MSLDebugOptions.RESOURCES)) {
			Trace.trace(
				MSLDebugOptions.RESOURCES,
				"Absorbing: " + oldUnit.getURI() //$NON-NLS-1$
				+ " ==> " + newUnit.getURI() + ": " + eObject);  //$NON-NLS-1$//$NON-NLS-2$
		}
		
		LogicalResourcePolicyManager.getInstance().preAbsorb(this, eObject);
		
		doAbsorb(eObject);
		
		LogicalResourcePolicyManager.getInstance().postAbsorb(this, eObject);
		
		// notify listeners
		LogicalResourceUtil.fireAbsorptionEvent(eObject, oldUnit, newUnit);
		
		setModified(true);
	}
	
	/**
	 * Implemented by the subclass to perform the absorption operation.
	 * 
	 * @param eObject the element to be absorbed

	protected abstract void doAbsorb(EObject eObject) throws CannotAbsorbException;
	
	/**
	 * Implementation of the element load operation, which does the
	 * following:
	 * <ul>
	 *   <li>enforces the preconditions declared by the interface</li>
	 *   <li>delegates the actual load implementation to the
	 *       {@link #doLoad(EObject)} method implemented by the subclass, if
	 *       the element is not already loaded</li>
	 * </ul> 
	 * <p>
	 * <b>Note</b> that, because loading an object may also load other objects
	 * from the same sub-unit, this template method does not fire the
	 * {@link EventTypes#LOAD} notification, as it would not know how many
	 * to fire for which objects.  This is the responsibility of the subclass's
	 * {@link #doLoad(EObject)} implementation.
	 * </p>
	 * 
	 * @see #doLoad(EObject)
	 */
	public final void load(EObject eObject) throws IOException {
		assert eObject.eResource() == this : "eObject is not in receiver" ; //$NON-NLS-1$
		
		if (!isSeparate(eObject)) {
			throw new IllegalArgumentException("eObject is not separate"); //$NON-NLS-1$
		}
		
		if (!isLoaded(eObject)) {
			doLoad(eObject);
		}
	}
	
	/**
	 * Implemented by the subclass to perform the load operation.  This method
	 * will only be invoked if the element is not already loaded.
	 * 

	 */
	protected abstract void doLoad(EObject eObject) throws IOException;
	
	public final Map getMappedResources() {
		return Collections.unmodifiableMap(unmodifiableResourceMap);
	}
	
	/**
	 * Adds the specified <code>subunit</code> resource to the map.
	 * Subclasses implementing this method must invoke <code>super</code>.

	 *     was detached
	 */
	protected void addMappedResource(EObject object, Resource unit) {
		// no need to do anything any longer
			// look to see whether this object was previously a separate element
			//    that was detached from me
			URI unitUri = (URI) detachedIdToResourceMap.remove(getID(object));
			
			if ((unitUri != null) && !uri.equals(getURI())) {
				unit = getPhysicalResource(unitUri);
			}
		}
		
		if (unit != null) {
			// unwrap just in case
			resourceMap.put(object, AbstractResourceWrapper.unwrap(unit));
			
			// wrap just in case
			unmodifiableResourceMap.put(object, UnmodifiableResourceView.get(unit));
		}
	}
	
	/**

	 * @param object the (formerly) separate element
	 */
	protected void removeMappedResource(EObject object) {
		// no need to do anything any longer
		//    in case it is re-attached later
		Resource unit = (Resource) getMappedResources().get(object);
		
		if (unit != null) {
			// the object's ID is retained by the detached object ID map
			detachedIdToResourceMap.put(getID(object), unit.getURI());
		}
		
		resourceMap.remove(object);
		unmodifiableResourceMap.remove(object);
	}
	
	/**

	 * Subclasses implementing this method must invoke <code>super</code>.
	 */
	protected void clearMappedResources() {
		// no need to do anything any longer
		unmodifiableResourceMap.clear();
		detachedIdToResourceMap.clear();
	}
	
	/**

	protected final Resource getPhysicalResource(EObject eObject) {
		assert eObject.eResource() == this : "eObject is not in receiver" ; //$NON-NLS-1$
		
		return eObject.eResource();
	}

	/**

Lines 21-26 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/resources/AbstractLogicalResourcePolicy.java (+4 lines)
21	* subclasses.	21	* subclasses.
22	*	22	*
23	* @author Christian W. Damus (cdamus)	23	* @author Christian W. Damus (cdamus)
		24	*
		25	* @deprecated Use the cross-resource containment support provided by EMF,
		26	* instead, by defining containment features that are capable of storing
		27	* proxies.
24	*/	28	*/
25	public abstract class AbstractLogicalResourcePolicy	29	public abstract class AbstractLogicalResourcePolicy
26	implements ILogicalResourcePolicy {	30	implements ILogicalResourcePolicy {

Lines 21-26 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/resources/CannotSeparateException.java (+4 lines)
21	* some reason (such as being read-only).	21	* some reason (such as being read-only).
22	*	22	*
23	* @author Christian W. Damus (cdamus)	23	* @author Christian W. Damus (cdamus)
		24	*
		25	* @deprecated Use the cross-resource containment support provided by EMF,
		26	* instead, by defining containment features that are capable of storing
		27	* proxies.
24	*/	28	*/
25	public class CannotSeparateException	29	public class CannotSeparateException
26	extends MSLCheckedException {	30	extends MSLCheckedException {

Lines 36-41 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/resources/ILogicalResourcePolicy.java (+4 lines)
36	* @author Christian W. Damus (cdamus)	36	* @author Christian W. Damus (cdamus)
37	*	37	*
38	* @see AbstractLogicalResourcePolicy	38	* @see AbstractLogicalResourcePolicy
		39	*
		40	* @deprecated Use the cross-resource containment support provided by EMF,
		41	* instead, by defining containment features that are capable of storing
		42	* proxies.
39	*/	43	*/
40	public interface ILogicalResourcePolicy {	44	public interface ILogicalResourcePolicy {
41		45

Lines 20-25 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/resources/CannotAbsorbException.java (+4 lines)
20	* resource in a logical resource.	20	* resource in a logical resource.
21	*	21	*
22	* @author Christian W. Damus (cdamus)	22	* @author Christian W. Damus (cdamus)
		23	*
		24	* @deprecated Use the cross-resource containment support provided by EMF,
		25	* instead, by defining containment features that are capable of storing
		26	* proxies.
23	*/	27	*/
24	public class CannotAbsorbException	28	public class CannotAbsorbException
25	extends MSLCheckedException {	29	extends MSLCheckedException {

Lines 50-55 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/resources/ILogicalResource.java (+4 lines)
50	*	50	*
51	* @see org.eclipse.gmf.runtime.emf.core.edit.MEditingDomain#asLogicalResource(Resource)	51	* @see org.eclipse.gmf.runtime.emf.core.edit.MEditingDomain#asLogicalResource(Resource)
52	* @see org.eclipse.gmf.runtime.emf.core.resources.MResourceFactory	52	* @see org.eclipse.gmf.runtime.emf.core.resources.MResourceFactory
		53	*
		54	* @deprecated Use the cross-resource containment support provided by EMF,
		55	* instead, by defining containment features that are capable of storing
		56	* proxies.
53	*/	57	*/
54	public interface ILogicalResource	58	public interface ILogicalResource
55	extends Resource, IAdaptable {	59	extends Resource, IAdaptable {




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resourcemap;

import org.eclipse.emf.ecore.EFactory;

/**
 * <!-- begin-user-doc -->
 * The <b>Factory</b> for the logical resource physical mapping metamodel.
 * It provides a create method for each non-abstract class of the metamodel.
 * <!-- end-user-doc -->
 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage
 * @generated
 */
public interface ResourceMapFactory extends EFactory{
	/**
	 * The singleton instance of the factory.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	ResourceMapFactory eINSTANCE = new org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ResourceMapFactoryImpl();

	/**
	 * Returns a new object of class '<em>Resource Map</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Resource Map</em>'.
	 * @generated
	 */
	ResourceMap createResourceMap();

	/**
	 * Returns a new object of class '<em>Resource Entry</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Resource Entry</em>'.
	 * @generated
	 */
	ResourceEntry createResourceEntry();

	/**
	 * Returns a new object of class '<em>Parent Entry</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Parent Entry</em>'.
	 * @generated
	 */
	ParentEntry createParentEntry();

	/**
	 * Returns a new object of class '<em>Child Entry</em>'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return a new object of class '<em>Child Entry</em>'.
	 * @generated
	 */
	ChildEntry createChildEntry();

	/**
	 * Returns the package supported by this factory.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the package supported by this factory.
	 * @generated
	 */
	ResourceMapPackage getResourceMapPackage();

} //ResourceMapFactory




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resourcemap;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;

/**
 * <!-- begin-user-doc -->
 * An entry in a {@link ParentEntry} in the physical resource map, that
 * indicates which separate child of the parent element fits into the
 * containment reference at what position.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * <ul>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry#getResource <em>Resource</em>}</li>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry#getChildPosition <em>Child Position</em>}</li>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry#getChildObject <em>Child Object</em>}</li>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry#getParentEntry <em>Parent Entry</em>}</li>
 * </ul>
 * </p>
 *
 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage#getResourceEntry()
 * @model
 * @generated
 */
public interface ResourceEntry extends EObject{
	/**
	 * Returns the value of the '<em><b>Resource</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Obtains the transient reference to the sub-unit resource containing the
	 * separate child element.
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Resource</em>' attribute.
	 * @see #setResource(Resource)
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage#getResourceEntry_Resource()
	 * @model transient="true"
	 * @generated
	 */
	Resource getResource();

	/**
	 * Sets the value of the '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry#getResource <em>Resource</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Sets the transient reference to the sub-unit resource containing the
	 * separate child element.
	 * </p>
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Resource</em>' attribute.
	 * @see #getResource()
	 * @generated
	 */
	void setResource(Resource value);

	/**
	 * Returns the value of the '<em><b>Child Position</b></em>' attribute.
	 * The default value is <code>"-1"</code>.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Gets the index in the containment reference at which this child resides.
	 * The index is <code>-1</code> (the default value) for scalar references.
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Child Position</em>' attribute.
	 * @see #setChildPosition(int)
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage#getResourceEntry_ChildPosition()
	 * @model default="-1"
	 * @generated
	 */
	int getChildPosition();

	/**
	 * Sets the value of the '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry#getChildPosition <em>Child Position</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Sets the index in the containment reference at which this child resides,
	 * or <code>-1</code> (the default value) for scalar references.
	 * </p>
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Child Position</em>' attribute.
	 * @see #getChildPosition()
	 * @generated
	 */
	void setChildPosition(int value);

	/**
	 * Returns the value of the '<em><b>Child Object</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Obtains the separate child object.
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Child Object</em>' reference.
	 * @see #setChildObject(EObject)
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage#getResourceEntry_ChildObject()
	 * @model required="true"
	 * @generated
	 */
	EObject getChildObject();

	/**
	 * Sets the value of the '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry#getChildObject <em>Child Object</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Sets the separate child object.
	 * </p>
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Child Object</em>' reference.
	 * @see #getChildObject()
	 * @generated
	 */
	void setChildObject(EObject value);

	/**
	 * Returns the value of the '<em><b>Parent Entry</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Obtains the parent entry that contains me.
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Parent Entry</em>' reference.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage#getResourceEntry_ParentEntry()
	 * @model transient="true" changeable="false" volatile="true"
	 * @generated
	 */
	ParentEntry getParentEntry();

} // ResourceEntry




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resourcemap;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;

/**
 * <!-- begin-user-doc -->
 * An entry in the physical resource map for an element in the unit that has
 * one or more separate children in some containment reference.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * <ul>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry#getParentObject <em>Parent Object</em>}</li>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry#getChildSlot <em>Child Slot</em>}</li>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry#getResourceEntries <em>Resource Entries</em>}</li>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry#getResourceMap <em>Resource Map</em>}</li>
 * </ul>
 * </p>
 *
 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage#getParentEntry()
 * @model
 * @generated
 */
public interface ParentEntry extends EObject{
	/**
	 * Returns the value of the '<em><b>Parent Object</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Obtains the model element that is the parent of some separate children.
	 * For the parent entry representing the logical resource, itself (whose
	 * roots may be separate), the parent is <code>null</code>.
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Parent Object</em>' reference.
	 * @see #setParentObject(EObject)
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage#getParentEntry_ParentObject()
	 * @model
	 * @generated
	 */
	EObject getParentObject();

	/**
	 * Sets the value of the '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry#getParentObject <em>Parent Object</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Sets the model element that is the parent of some separate children.
	 * </p>
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Parent Object</em>' reference.
	 * @see #getParentObject()
	 * @generated
	 */
	void setParentObject(EObject value);

	/**
	 * Returns the value of the '<em><b>Child Slot</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Obtains the containment reference of the
	 * {@linkplain #getParentObject() parent} element that contains one or more
	 * separate children.
	 * For the parent entry representing the logical resource, itself (whose
	 * roots may be separate), the child slot is <code>null</code>.
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Child Slot</em>' reference.
	 * @see #setChildSlot(EReference)
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage#getParentEntry_ChildSlot()
	 * @model
	 * @generated
	 */
	EReference getChildSlot();

	/**
	 * Sets the value of the '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry#getChildSlot <em>Child Slot</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Sets the containment reference of the
	 * {@linkplain #getParentObject() parent} element that contains one or more
	 * separate children.
	 * </p>
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Child Slot</em>' reference.
	 * @see #getChildSlot()
	 * @generated
	 */
	void setChildSlot(EReference value);

	/**
	 * Returns the value of the '<em><b>Resource Entries</b></em>' containment reference list.
	 * The list contents are of type {@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Obtains the list of entries for the separate children of the parent in
	 * the slot.
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Resource Entries</em>' containment reference list.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage#getParentEntry_ResourceEntries()
	 * @model type="org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry" containment="true" required="true"
	 * @generated
	 */
	EList getResourceEntries();

	/**
	 * Returns the value of the '<em><b>Resource Map</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Obtains the resource map that contains me.
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Resource Map</em>' reference.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage#getParentEntry_ResourceMap()
	 * @model transient="true" changeable="false" volatile="true"
	 * @generated
	 */
	ResourceMap getResourceMap();

	/**
	 * <!-- begin-user-doc -->
	 * Obtains the resource entry within me for the specified <code>child</code>
	 * of my parent element.
	 * 
	 * @param child a child of my parent element
	 * @return the resource entry, or <code>null</code> if the
	 *    <code>child</code> is not containment by this parent in this slot or
	 *    if it is not separate
	 * <!-- end-user-doc -->
	 * @model childRequired="true"
	 * @generated
	 */
	ResourceEntry getResourceEntry(EObject child);

} // ParentEntry




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resourcemap;

import org.eclipse.emf.ecore.EObject;

/**
 * <!-- begin-user-doc -->
 * An entry in the physical resource map that links a separate element (as a
 * root of a sub-unit) to its parent unit.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * <ul>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry#getChildObject <em>Child Object</em>}</li>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry#getParentMap <em>Parent Map</em>}</li>
 * </ul>
 * </p>
 *
 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage#getChildEntry()
 * @model
 * @generated
 */
public interface ChildEntry extends EObject {
	/**
	 * Returns the value of the '<em><b>Child Object</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Obtains the child object for which I indicate the parent unit.
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Child Object</em>' reference.
	 * @see #setChildObject(EObject)
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage#getChildEntry_ChildObject()
	 * @model required="true"
	 * @generated
	 */
	EObject getChildObject();

	/**
	 * Sets the value of the '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry#getChildObject <em>Child Object</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Sets the child object for which I indicate the parent unit.
	 * </p>
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Child Object</em>' reference.
	 * @see #getChildObject()
	 * @generated
	 */
	void setChildObject(EObject value);

	/**
	 * Returns the value of the '<em><b>Parent Map</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Obtains the resource map of the child's parent unit.  This serves as
	 * a handle on the parent unit, itself.
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Parent Map</em>' reference.
	 * @see #setParentMap(ResourceMap)
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage#getChildEntry_ParentMap()
	 * @model required="true"
	 * @generated
	 */
	ResourceMap getParentMap();

	/**
	 * Sets the value of the '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry#getParentMap <em>Parent Map</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Sets the resource map of the child's parent unit.  This serves as
	 * a handle on the parent unit, itself.
	 * </p>
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Parent Map</em>' reference.
	 * @see #getParentMap()
	 * @generated
	 */
	void setParentMap(ResourceMap value);

} // ChildEntry




<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<head>
<!--

/******************************************************************************
 * Copyright (c) 2004,2005 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 
 ****************************************************************************/





/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resourcemap;

import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EReference;

/**
 * <!-- begin-user-doc -->
 * The <b>Package</b> for the logical resource physical mapping metamodel.
 * It contains accessors for the meta objects to represent
 * <ul>
 *   <li>each class,</li>
 *   <li>each feature of each class,</li>
 *   <li>each enum,</li>
 *   <li>and each data type</li>
 * </ul>
 * <!-- end-user-doc -->
 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapFactory
 * @model kind="package"
 * @generated
 */
public interface ResourceMapPackage extends EPackage{
	/**
	 * The package name.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	String eNAME = "resourcemap"; //$NON-NLS-1$

	/**
	 * The package namespace URI.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	String eNS_URI = "http://www.ibm.com/RMP-MSL/7.0.0/ResourceMap"; //$NON-NLS-1$

	/**
	 * The package namespace name.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	String eNS_PREFIX = "resmap"; //$NON-NLS-1$

	/**
	 * The singleton instance of the package.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	ResourceMapPackage eINSTANCE = org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ResourceMapPackageImpl.init();

	/**
	 * The meta object id for the '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ResourceMapImpl <em>Resource Map</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ResourceMapImpl
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ResourceMapPackageImpl#getResourceMap()
	 * @generated
	 */
	int RESOURCE_MAP = 0;

	/**
	 * The feature id for the '<em><b>Root Map</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int RESOURCE_MAP__ROOT_MAP = 0;

	/**
	 * The feature id for the '<em><b>Parent Entries</b></em>' containment reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int RESOURCE_MAP__PARENT_ENTRIES = 1;

	/**
	 * The feature id for the '<em><b>Child Entries</b></em>' containment reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int RESOURCE_MAP__CHILD_ENTRIES = 2;

	/**
	 * The number of structural features of the the '<em>Resource Map</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int RESOURCE_MAP_FEATURE_COUNT = 3;

	/**
	 * The meta object id for the '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ResourceEntryImpl <em>Resource Entry</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ResourceEntryImpl
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ResourceMapPackageImpl#getResourceEntry()
	 * @generated
	 */
	int RESOURCE_ENTRY = 1;

	/**
	 * The feature id for the '<em><b>Resource</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int RESOURCE_ENTRY__RESOURCE = 0;

	/**
	 * The feature id for the '<em><b>Child Position</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int RESOURCE_ENTRY__CHILD_POSITION = 1;

	/**
	 * The feature id for the '<em><b>Child Object</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int RESOURCE_ENTRY__CHILD_OBJECT = 2;

	/**
	 * The feature id for the '<em><b>Parent Entry</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int RESOURCE_ENTRY__PARENT_ENTRY = 3;

	/**
	 * The number of structural features of the the '<em>Resource Entry</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int RESOURCE_ENTRY_FEATURE_COUNT = 4;

	/**
	 * The meta object id for the '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ParentEntryImpl <em>Parent Entry</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ParentEntryImpl
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ResourceMapPackageImpl#getParentEntry()
	 * @generated
	 */
	int PARENT_ENTRY = 2;

	/**
	 * The feature id for the '<em><b>Parent Object</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PARENT_ENTRY__PARENT_OBJECT = 0;

	/**
	 * The feature id for the '<em><b>Child Slot</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PARENT_ENTRY__CHILD_SLOT = 1;

	/**
	 * The feature id for the '<em><b>Resource Entries</b></em>' containment reference list.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PARENT_ENTRY__RESOURCE_ENTRIES = 2;

	/**
	 * The feature id for the '<em><b>Resource Map</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PARENT_ENTRY__RESOURCE_MAP = 3;

	/**
	 * The number of structural features of the the '<em>Parent Entry</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int PARENT_ENTRY_FEATURE_COUNT = 4;


	/**
	 * The meta object id for the '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ChildEntryImpl <em>Child Entry</em>}' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ChildEntryImpl
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.impl.ResourceMapPackageImpl#getChildEntry()
	 * @generated
	 */
	int CHILD_ENTRY = 3;

	/**
	 * The feature id for the '<em><b>Child Object</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CHILD_ENTRY__CHILD_OBJECT = 0;

	/**
	 * The feature id for the '<em><b>Parent Map</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CHILD_ENTRY__PARENT_MAP = 1;

	/**
	 * The number of structural features of the the '<em>Child Entry</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 * @ordered
	 */
	int CHILD_ENTRY_FEATURE_COUNT = 2;


	/**
	 * Returns the meta object for class '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap <em>Resource Map</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Resource Map</em>'.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap
	 * @generated
	 */
	EClass getResourceMap();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap#getRootMap <em>Root Map</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Root Map</em>'.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap#getRootMap()
	 * @see #getResourceMap()
	 * @generated
	 */
	EReference getResourceMap_RootMap();

	/**
	 * Returns the meta object for the containment reference list '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap#getParentEntries <em>Parent Entries</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference list '<em>Parent Entries</em>'.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap#getParentEntries()
	 * @see #getResourceMap()
	 * @generated
	 */
	EReference getResourceMap_ParentEntries();

	/**
	 * Returns the meta object for the containment reference list '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap#getChildEntries <em>Child Entries</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference list '<em>Child Entries</em>'.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap#getChildEntries()
	 * @see #getResourceMap()
	 * @generated
	 */
	EReference getResourceMap_ChildEntries();

	/**
	 * Returns the meta object for class '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry <em>Resource Entry</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Resource Entry</em>'.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry
	 * @generated
	 */
	EClass getResourceEntry();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry#getResource <em>Resource</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Resource</em>'.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry#getResource()
	 * @see #getResourceEntry()
	 * @generated
	 */
	EAttribute getResourceEntry_Resource();

	/**
	 * Returns the meta object for the attribute '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry#getChildPosition <em>Child Position</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the attribute '<em>Child Position</em>'.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry#getChildPosition()
	 * @see #getResourceEntry()
	 * @generated
	 */
	EAttribute getResourceEntry_ChildPosition();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry#getChildObject <em>Child Object</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Child Object</em>'.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry#getChildObject()
	 * @see #getResourceEntry()
	 * @generated
	 */
	EReference getResourceEntry_ChildObject();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry#getParentEntry <em>Parent Entry</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Parent Entry</em>'.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceEntry#getParentEntry()
	 * @see #getResourceEntry()
	 * @generated
	 */
	EReference getResourceEntry_ParentEntry();

	/**
	 * Returns the meta object for class '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry <em>Parent Entry</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Parent Entry</em>'.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry
	 * @generated
	 */
	EClass getParentEntry();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry#getParentObject <em>Parent Object</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Parent Object</em>'.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry#getParentObject()
	 * @see #getParentEntry()
	 * @generated
	 */
	EReference getParentEntry_ParentObject();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry#getChildSlot <em>Child Slot</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Child Slot</em>'.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry#getChildSlot()
	 * @see #getParentEntry()
	 * @generated
	 */
	EReference getParentEntry_ChildSlot();

	/**
	 * Returns the meta object for the containment reference list '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry#getResourceEntries <em>Resource Entries</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the containment reference list '<em>Resource Entries</em>'.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry#getResourceEntries()
	 * @see #getParentEntry()
	 * @generated
	 */
	EReference getParentEntry_ResourceEntries();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry#getResourceMap <em>Resource Map</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Resource Map</em>'.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry#getResourceMap()
	 * @see #getParentEntry()
	 * @generated
	 */
	EReference getParentEntry_ResourceMap();

	/**
	 * Returns the meta object for class '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry <em>Child Entry</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Child Entry</em>'.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry
	 * @generated
	 */
	EClass getChildEntry();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry#getChildObject <em>Child Object</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Child Object</em>'.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry#getChildObject()
	 * @see #getChildEntry()
	 * @generated
	 */
	EReference getChildEntry_ChildObject();

	/**
	 * Returns the meta object for the reference '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry#getParentMap <em>Parent Map</em>}'.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the meta object for the reference '<em>Parent Map</em>'.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry#getParentMap()
	 * @see #getChildEntry()
	 * @generated
	 */
	EReference getChildEntry_ParentMap();

	/**
	 * Returns the factory that creates the instances of the model.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @return the factory that creates the instances of the model.
	 * @generated
	 */
	ResourceMapFactory getResourceMapFactory();

} //ResourceMapPackage




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.resourcemap;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;

/**
 * <!-- begin-user-doc -->
 * Physical mapping of child and parent units for a unit of a logical resource.
 * The resource map has a list of {@link ParentEntry}s with physical-URI
 * references to sub-units and a list of {@link ChildEntry}s with physical-URI
 * references to parent units.  The resource map also has a direct reference
 * to the root resource in the structure, so that each unit individually knows
 * the logical URI of the logical resource that owns it.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * <ul>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap#getRootMap <em>Root Map</em>}</li>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap#getParentEntries <em>Parent Entries</em>}</li>
 *   <li>{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap#getChildEntries <em>Child Entries</em>}</li>
 * </ul>
 * </p>
 *
 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage#getResourceMap()
 * @model
 * @generated
 */
public interface ResourceMap extends EObject{
	/**
	 * Returns the value of the '<em><b>Root Map</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Obtains the reference to the root resource, via its resource map object.
	 * Only the root resource, itself, does not have this reference.
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Root Map</em>' reference.
	 * @see #setRootMap(ResourceMap)
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage#getResourceMap_RootMap()
	 * @model
	 * @generated
	 */
	ResourceMap getRootMap();

	/**
	 * Sets the value of the '{@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap#getRootMap <em>Root Map</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Sets the root resource map reference.  Only the root resource should
	 * have a <code>null</code> value.
	 * </p>
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Root Map</em>' reference.
	 * @see #getRootMap()
	 * @generated
	 */
	void setRootMap(ResourceMap value);

	/**
	 * Returns the value of the '<em><b>Parent Entries</b></em>' containment reference list.
	 * The list contents are of type {@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Obtains the list of parent entries indicating child units.
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Parent Entries</em>' containment reference list.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage#getResourceMap_ParentEntries()
	 * @model type="org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ParentEntry" containment="true" ordered="false"
	 * @generated
	 */
	EList getParentEntries();

	/**
	 * Returns the value of the '<em><b>Child Entries</b></em>' containment reference list.
	 * The list contents are of type {@link org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * Obtains the list of child entries indicating parent units.
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Child Entries</em>' containment reference list.
	 * @see org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage#getResourceMap_ChildEntries()
	 * @model type="org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ChildEntry" containment="true" ordered="false"
	 * @generated
	 */
	EList getChildEntries();

	/**
	 * <!-- begin-user-doc -->
	 * Obtains the parent entry for the specified <code>parent</code> element
	 * and containment <code>slot</code>.
	 * 
	 * @param parent a model element
	 * @param slot a containment reference of the <code>parent</code>'s class
	 * @return the matching parent entry object, or <code>null</code> if there
	 *     is none such
	 * <!-- end-user-doc -->
	 * @model parentRequired="true" slotRequired="true"
	 * @generated
	 */
	ParentEntry getParentEntry(EObject parent, EReference slot);

	/**
	 * <!-- begin-user-doc -->
	 * Obtains the resource entry for the specified <code>child</code> element
	 * in whatever parent element it is currently defined.
	 * 
	 * @param child a model element
	 * @return the matching resource entry object, or <code>null</code> if there
	 *     is none such
	 * <!-- end-user-doc -->
	 * @model childRequired="true"
	 * @generated
	 */
	ResourceEntry getResourceEntry(EObject child);

	/**
	 * <!-- begin-user-doc -->
	 * Obtains the resource map of the parent unit of the speified
	 * <code>child</code> element.
	 * 
	 * @param child a model element
	 * @return the parent unit's resource map (as a handle on the parent
	 *     resource), or <code>null</code> if there is none
	 * <!-- end-user-doc -->
	 * @model childRequired="true"
	 * @generated
	 */
	ResourceMap getParentMap(EObject child);

	/**
	 * <!-- begin-user-doc -->
	 * Obtains the child entry for the speified <code>child</code> element.
	 * 
	 * @param child a model element
	 * @return the child entry, or <code>null</code> if there is none
	 * <!-- end-user-doc -->
	 * @model childRequired="true"
	 * @generated
	 */
	ChildEntry getChildEntry(EObject child);

} // ResourceMap





package org.eclipse.gmf.runtime.emf.core.util;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;

import org.eclipse.gmf.runtime.emf.core.internal.resources.LogicalResourceUtil;


/**
 * Specialized containment reference list (with inverse) that automatically
 * loads sub-unit objects when they are retrieved from the list.
 *
 * @author Christian W. Damus (cdamus)
 * 
 * @deprecated Use the cross-resource containment support provided by EMF,
 *     instead, by defining containment features that are capable of storing
 *     proxies.
 */
public class EObjectContainmentWithInverseLoadingEList
	extends EObjectContainmentWithInverseEList {

			InternalEObject owner, int featureID, int inverseFeatureID) {
		super(dataClass, owner, featureID, inverseFeatureID);
	}

	protected Object resolve(int index, Object object) {
		EObject eObject = (EObject) object;
		Resource res = getEObject().eResource();
		
		if (res != null) {
			LogicalResourceUtil.autoload(res, eObject);
		}
		
		return eObject;
	}

}





package org.eclipse.gmf.runtime.emf.core.util;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.util.EObjectContainmentEList;

import org.eclipse.gmf.runtime.emf.core.internal.resources.LogicalResourceUtil;


/**
 * Specialized containment reference list that automatically loads sub-unit
 * objects when they are retrieved from the list.
 *
 * @author Christian W. Damus (cdamus)
 * 
 * @deprecated Use the cross-resource containment support provided by EMF,
 *     instead, by defining containment features that are capable of storing
 *     proxies.
 */
public class EObjectContainmentLoadingEList
	extends EObjectContainmentEList {

			InternalEObject owner, int featureID) {
		super(dataClass, owner, featureID);
	}

	protected Object resolve(int index, Object object) {
		EObject eObject = (EObject) object;
		Resource res = getEObject().eResource();
		
		if (res != null) {
			LogicalResourceUtil.autoload(res, eObject);
		}
		
		return eObject;
	}
}

Lines 79-84 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/util/ResourceUtil.java (-1 / +9 lines)
79	* @return whether the <code>resource</code> is a logical resource	79	* @return whether the <code>resource</code> is a logical resource
80	*	80	*
81	* @see ILogicalResource	81	* @see ILogicalResource
		82	*
		83	* @deprecated Use the cross-resource containment support provided by EMF,
		84	* instead, by defining containment features that are capable of storing
		85	* proxies.
82	*/	86	*/
83	public static boolean isLogicalResource(Resource resource) {	87	public static boolean isLogicalResource(Resource resource) {
84	return MEditingDomain.INSTANCE.isLogicalResource(resource);	88	return MEditingDomain.INSTANCE.isLogicalResource(resource);
Lines 93-99 Link Here
93	*	97	*
94	* @param resource a resource for which we want to obtain a logical view	98	* @param resource a resource for which we want to obtain a logical view
95	* @return the logical view of the resource	99	* @return the logical view of the resource
96	*/	100	*
		101	* @deprecated Use the cross-resource containment support provided by EMF,
		102	* instead, by defining containment features that are capable of storing
		103	* proxies.
		104	s */
97	public static ILogicalResource asLogicalResource(Resource resource) {	105	public static ILogicalResource asLogicalResource(Resource resource) {
98	return MEditingDomain.INSTANCE.asLogicalResource(resource);	106	return MEditingDomain.INSTANCE.asLogicalResource(resource);
99	}	107	}




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.commands;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.gmf.runtime.common.core.util.Trace;
import org.eclipse.gmf.runtime.emf.core.exceptions.MSLRuntimeException;
import org.eclipse.gmf.runtime.emf.core.internal.domain.MSLEditingDomain;
import org.eclipse.gmf.runtime.emf.core.internal.l10n.EMFCoreMessages;
import org.eclipse.gmf.runtime.emf.core.internal.plugin.MSLDebugOptions;
import org.eclipse.gmf.runtime.emf.core.internal.plugin.MSLPlugin;
import org.eclipse.gmf.runtime.emf.core.resources.CannotAbsorbException;
import org.eclipse.gmf.runtime.emf.core.resources.CannotSeparateException;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;


/**
 * Command that undoes/redoes separation of an element into another resource.
 *
 * @author Christian W. Damus (cdamus)
 */
public class MSLSeparateCommand
	extends MSLBasicCommand {

	private EObject child;
	private ILogicalResource res;
	private Resource subres;
	
	/**
	 * Initializes me.
	 * 
	 * @param domain the editing domain in which I occurred
	 * @param owner the container element that notified
	 * @param feature the containment feature
	 * @param position the index in the containment feature of the separated
	 *     object (or -1 if not a list feature)
	 * @param resource the new physical resource of the child element
	 */
	public MSLSeparateCommand(MSLEditingDomain domain, EObject owner,
			EStructuralFeature feature, int position, Resource resource) {
		super(domain, owner, feature);
		
		if (position < 0) {
			// must be a scalar feature
			this.child = (EObject) owner.eGet(feature);
		} else {
			// no need to worry about proxies in a containment feature
			this.child = (EObject) ((EList) owner.eGet(feature)).get(position);
		}
		
		this.res = (ILogicalResource) child.eResource();
		this.subres = resource;
	}

	public void dispose() {
		super.dispose();
		
		child = null;
		res = null;
		subres = null;
	}
	
	public Type getType() {
		return MCommand.SEPARATE;
	}

	public void undo() {
		try {
			res.absorb(child);
		} catch (CannotAbsorbException e) {
			RuntimeException re = new MSLRuntimeException(
				EMFCoreMessages.absorption_failed_EXC_,
					e);
	
			Trace.throwing(MSLPlugin.getDefault(),
				MSLDebugOptions.EXCEPTIONS_THROWING, getClass(), "undo", e); //$NON-NLS-1$
	
			throw re;
		}
	}

	public void redo() {
		try {
			res.separate(child, subres.getURI());
		} catch (CannotSeparateException e) {
			RuntimeException re = new MSLRuntimeException(
				EMFCoreMessages.separation_failed_EXC_,
					e);

			Trace.throwing(MSLPlugin.getDefault(),
				MSLDebugOptions.EXCEPTIONS_THROWING, getClass(), "redo", e); //$NON-NLS-1$

			throw re;
		}
	}
}




/******************************************************************************
 * Copyright (c) 2005 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.core.internal.commands;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.gmf.runtime.common.core.util.Trace;
import org.eclipse.gmf.runtime.emf.core.exceptions.MSLRuntimeException;
import org.eclipse.gmf.runtime.emf.core.internal.domain.MSLEditingDomain;
import org.eclipse.gmf.runtime.emf.core.internal.l10n.EMFCoreMessages;
import org.eclipse.gmf.runtime.emf.core.internal.plugin.MSLDebugOptions;
import org.eclipse.gmf.runtime.emf.core.internal.plugin.MSLPlugin;
import org.eclipse.gmf.runtime.emf.core.resources.CannotAbsorbException;
import org.eclipse.gmf.runtime.emf.core.resources.CannotSeparateException;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;


/**
 * Command that undoes/redoes absorption of an element from another resource.
 *
 * @author Christian W. Damus (cdamus)
 */
public class MSLAbsorbCommand
	extends MSLBasicCommand {

	private EObject child;
	private ILogicalResource res;
	private Resource subres;
	
	/**
	 * Initializes me.
	 * 
	 * @param domain the editing domain in which I occurred
	 * @param owner the container element that notified
	 * @param feature the containment feature
	 * @param position the index in the containment feature of the absorbed
	 *     object (or -1 if not a list feature)
	 * @param resource the old physical resource of the child element
	 */
	public MSLAbsorbCommand(MSLEditingDomain domain, EObject owner,
			EStructuralFeature feature, int position, Resource resource) {
		super(domain, owner, feature);
		
		if (position < 0) {
			// must be a scalar feature
			this.child = (EObject) owner.eGet(feature);
		} else {
			// no need to worry about proxies in a containment feature
			this.child = (EObject) ((EList) owner.eGet(feature)).get(position);
		}
		
		this.res = (ILogicalResource) child.eResource();
		this.subres = resource;
	}

	public void dispose() {
		super.dispose();
		
		child = null;
		res = null;
		subres = null;
	}
	
	public Type getType() {
		return MCommand.ABSORB;
	}

	public void undo() {
		try {
			res.separate(child, subres.getURI());
		} catch (CannotSeparateException e) {
			RuntimeException re = new MSLRuntimeException(
				EMFCoreMessages.separation_failed_EXC_,
					e);

			Trace.throwing(MSLPlugin.getDefault(),
				MSLDebugOptions.EXCEPTIONS_THROWING, getClass(), "undo", e); //$NON-NLS-1$

			throw re;
		}
	}

	public void redo() {
		try {
			res.absorb(child);
		} catch (CannotAbsorbException e) {
			RuntimeException re = new MSLRuntimeException(
				EMFCoreMessages.absorption_failed_EXC_,
					e);
	
			Trace.throwing(MSLPlugin.getDefault(),
				MSLDebugOptions.EXCEPTIONS_THROWING, getClass(), "redo", e); //$NON-NLS-1$
	
			throw re;
		}
	}
}





					break;
				}
				
				case EventTypes.SEPARATE: {
					MSLUtil.execute(domain, new MSLSeparateCommand(domain,
						notifier, structuralFeature, position, (Resource) newValue));
					
					break;
				}
				
				case EventTypes.ABSORB: {
					MSLUtil.execute(domain, new MSLAbsorbCommand(domain,
						notifier, structuralFeature, position, (Resource) oldValue));
					
					break;
				}
			}
		}
	}




				loadOptions.put(XMLResource.OPTION_EXTENDED_META_DATA,
					extendedMetaData);
			}

			if ((options & MResourceOption.LOAD_ALL_SUBUNITS) != 0) {
				loadOptions.put(ILogicalResource.OPTION_LOAD_ALL_UNITS,
					Boolean.TRUE);
			} else if ((options & MResourceOption.DONT_AUTO_LOAD_SUBUNITS) != 0) {
				loadOptions.put(ILogicalResource.OPTION_AUTO_LOAD_UNITS,
					Boolean.FALSE);
			}
			
			if (null == inputStream)
				resource.load(loadOptions);

		}
	}

	/** @deprecated */
	public boolean isLogicalResource(Resource resource) {
		return resource instanceof ILogicalResource;
	}
	
	/** @deprecated */
	public ILogicalResource asLogicalResource(Resource resource) {
		ILogicalResource result = null;
		

Lines 51-56 Link Here

(-)schema/resourcePolicies.exsd (-6 / +11 lines)
51		51
52	<element name="policy">	52	<element name="policy">
53	<annotation>	53	<annotation>
		54	<appInfo>
		55	<meta.element deprecated="true"/>
		56	</appInfo>
54	<documentation>	57	<documentation>
55	A policy applies certain metamodel- or application-specific constraints on the management of logical resources. The policy implements a callback interface defining hooks for these constraints and for insertion of additional behaviour.	58	A policy applies certain metamodel- or application-specific constraints on the management of logical resources. The policy implements a callback interface defining hooks for these constraints and for insertion of additional behaviour.
56	</documentation>	59	</documentation>
Lines 74-79 Link Here
74		77
75	<element name="efactory">	78	<element name="efactory">
76	<annotation>	79	<annotation>
		80	<appInfo>
		81	<meta.element deprecated="true"/>
		82	</appInfo>
77	<documentation>	83	<documentation>
78	A custom <code>EFactory</code> implementation that the logical resource may use to create model elements that will automatically load their children. This is commonly done by defining subclasses of the metamodel's basic "Impl" classes that substitute special containment lists for the default implementations. These containment lists are defined in the <code>org.eclipse.gmf.runtime.emf.core.util</code> package.	84	A custom <code>EFactory</code> implementation that the logical resource may use to create model elements that will automatically load their children. This is commonly done by defining subclasses of the metamodel's basic "Impl" classes that substitute special containment lists for the default implementations. These containment lists are defined in the <code>org.eclipse.gmf.runtime.emf.core.util</code> package.
79	</documentation>	85	</documentation>
Lines 185-196 Link Here
185	<meta.section type="copyright"/>	191	<meta.section type="copyright"/>
186	</appInfo>	192	</appInfo>
187	<documentation>	193	<documentation>
188	Copyright (c) 2005 IBM Corporation and others.<br>	194	Copyright (c) 2005 IBM Corporation and others.<br>
189	All rights reserved. This program and the accompanying materials	195	All rights reserved. This program and the accompanying materials
190	are made available under the terms of the Eclipse Public License v1.0	196	are made available under the terms of the Eclipse Public License v1.0
191	which accompanies this distribution, and is available at	197	which accompanies this distribution, and is available at
192	<a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>	198	<a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
193
194	</documentation>	199	</documentation>
195	</annotation>	200	</annotation>
196		201

Lines 127-137 Link Here

(-)plugin.xml (-7 lines)
127	</elementTypeFactory>	127	</elementTypeFactory>
128	</extension>	128	</extension>
129		129
130	<extension
131	point="org.eclipse.emf.ecore.generated_package">
132	<package
133	class="org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMapPackage"
134	uri="http://www.ibm.com/RMP-MSL/7.0.0/ResourceMap"/>
135	</extension>
136
137	</plugin>	130	</plugin>




 *   <dt>objectType</dt>
 *     <dd>string-valued property denoting an <code>EObject</code>'s
 *         {@linkplain org.eclipse.gmf.runtime.emf.core.internal.MObjectType object type}</dd>
 *   <dt>canSeparate</dt>
 *     <dd>boolean-valued property indicating whether an <code>EObject</code>
 *         can be
 *         {@linkplain org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource#canSeparate(EObject) separated}</dd>
 *   <dt>isSeparate</dt>
 *     <dd>boolean-valued property indicating whether an <code>EObject</code> is
 *         {@linkplain org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource#isSeparate(EObject) separate}</dd>
 * </dl>
 *
 * @author Christian W. Damus (cdamus)
 */
public class EObjectPropertyTester extends PropertyTester {
	private static final String OBJECT_TYPE_PROPERTY = "objectType"; //$NON-NLS-1$
	
	/**
	 * 
	 * @deprecated Use the cross-resource containment support provided by EMF,
	 *     instead, by defining containment features that are capable of storing
	 *     proxies.
	 */
	private static final String CAN_SEPARATE_PROPERTY = "canSeparate"; //$NON-NLS-1$
	/**
	 * 
	 * @deprecated Use the cross-resource containment support provided by EMF,
	 *     instead, by defining containment features that are capable of storing
	 *     proxies.
	 */
	private static final String IS_SEPARATE_PROPERTY = "isSeparate"; //$NON-NLS-1$
	
	/**

		if (property.equals(OBJECT_TYPE_PROPERTY)) {
			result = EObjectUtil.getType(eObject).getName().equals(expectedValue);
		} else if (property.equals(CAN_SEPARATE_PROPERTY)) {
			return Boolean.FALSE;
			MEditingDomain domain = MEditingDomain.getEditingDomain(res);
			
			if (domain != null) {
				result = domain.asLogicalResource(res).canSeparate(eObject);
			}
		} else if (property.equals(IS_SEPARATE_PROPERTY)) {
			return Boolean.FALSE;
			MEditingDomain domain = MEditingDomain.getEditingDomain(res);
			
			if (domain != null) {
				result = domain.asLogicalResource(res).isSeparate(eObject);
			}
		}
		
		return Boolean.valueOf(result);

Lines 181-186 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/EventTypes.java (+12 lines)
181	* {@link Notification#getNewValue()}.	181	* {@link Notification#getNewValue()}.
182	*	182	*
183	* @see org.eclipse.emf.common.notify.Notification#getEventType	183	* @see org.eclipse.emf.common.notify.Notification#getEventType
		184	*
		185	* @deprecated Use the cross-resource containment support provided by EMF,
		186	* instead, by defining containment features that are capable of storing
		187	* proxies.
184	*/	188	*/
185	public static final int SEPARATE = 1006;	189	public static final int SEPARATE = 1006;
186		190
Lines 193-198 Link Here
193	* {@link Notification#getOldValue()}.	197	* {@link Notification#getOldValue()}.
194	*	198	*
195	* @see org.eclipse.emf.common.notify.Notification#getEventType	199	* @see org.eclipse.emf.common.notify.Notification#getEventType
		200	*
		201	* @deprecated Use the cross-resource containment support provided by EMF,
		202	* instead, by defining containment features that are capable of storing
		203	* proxies.
196	*/	204	*/
197	public static final int ABSORB = 1007;	205	public static final int ABSORB = 1007;
198		206
Lines 205-210 Link Here
205	* {@link Notification#getNewValue()} of the notification.	213	* {@link Notification#getNewValue()} of the notification.
206	*	214	*
207	* @see org.eclipse.emf.common.notify.Notification#getEventType	215	* @see org.eclipse.emf.common.notify.Notification#getEventType
		216	*
		217	* @deprecated Use the cross-resource containment support provided by EMF,
		218	* instead, by defining containment features that are capable of storing
		219	* proxies.
208	*/	220	*/
209	public static final int LOAD = 1008;	221	public static final int LOAD = 1008;
210		222




import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
import org.eclipse.emf.examples.extlibrary.actions.EXTLibraryExtendedActionBarContributor;
import org.eclipse.emf.examples.extlibrary.presentation.EXTLibraryEditorPlugin;
import org.eclipse.gmf.examples.runtime.emf.MSLExamplePlugin;
import org.eclipse.gmf.examples.runtime.emf.constraints.ValidationDelegateClientSelector;
import org.eclipse.gmf.examples.runtime.emf.dialogs.ValidationErrorDialog;
import org.eclipse.gmf.examples.runtime.emf.editor.MSLLibraryEditor;
import org.eclipse.gmf.examples.runtime.emf.internal.l10n.MSLExampleMessages;
import org.eclipse.gmf.examples.runtime.emf.properties.PropertySheetDialog;
import org.eclipse.gmf.runtime.common.core.util.Log;
import org.eclipse.gmf.runtime.emf.core.edit.MEditingDomain;
import org.eclipse.gmf.runtime.emf.core.edit.MFilter;
import org.eclipse.gmf.runtime.emf.core.edit.MListener;
import org.eclipse.gmf.runtime.emf.core.edit.MRunnable;
import org.eclipse.gmf.runtime.emf.core.edit.MUndoInterval;
import org.eclipse.gmf.runtime.emf.core.exceptions.MSLActionAbandonedException;
import org.eclipse.gmf.runtime.emf.core.resources.CannotAbsorbException;
import org.eclipse.gmf.runtime.emf.core.resources.CannotSeparateException;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;
import org.eclipse.gmf.runtime.emf.core.util.EObjectUtil;
import org.eclipse.gmf.runtime.emf.core.util.MetaModelUtil;
import org.eclipse.jface.action.Action;

import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IInputValidator;
import org.eclipse.jface.dialogs.InputDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;

		}
  	}
	
	/**
	 * This action delegate refactors the selected element into a seaparate
	 * controlled unit.
	 */
	public static class ControlUnitDelegate
		implements IEditorActionDelegate, IActionDelegate2 {

		/**
		 * Error message to display when an exception occured
		 */
		protected static final String MESSAGE_EXCEPTION = MSLExampleMessages.message_exception;

		/**
		 * The shell this action is hosted in
		 */
		protected Shell shell = null;

		/**
		 * The active editor
		 */
		protected MSLLibraryEditor editor = null;

		/**
		 * Selected EObjects
		 */
		protected List selectedEObjects = null;

		/**
		 * The title for the action.
		 */
		private String title = MSLExampleMessages.ControlUnitAction_label;
		
		/** Action bar contributor of the MSL Library example editor. */
		private MSLLibraryActionBarContributor actionBarContrib;
		
		public void selectionChanged(IAction action, final ISelection selection) {
			this.selectedEObjects = null;
			try {
				if (selection instanceof IStructuredSelection) {
					IStructuredSelection structuredSelection = (IStructuredSelection) selection;
					this.selectedEObjects = structuredSelection.toList();
				}
			} catch (Exception e) {
				// Exceptions are not expected
				MessageDialog.openInformation(shell, title, MESSAGE_EXCEPTION);
				throw new RuntimeException(e);
			} finally {
				if ((null != selectedEObjects) && (selectedEObjects.size() == 1)
						&& (selectedEObjects.get(0) instanceof EObject)) {
					EObject selected = (EObject) selectedEObjects.get(0);
					final MEditingDomain domain = MEditingDomain.getEditingDomain(
						selected.eResource());
					ILogicalResource res = domain.asLogicalResource(
						selected.eResource());
					
					action.setEnabled(res.canSeparate(selected));
				} else {
					action.setEnabled(false);
				}
			}
		}

		public void dispose() {
			//No-op
		}

		public void setActiveEditor(IAction action, IEditorPart targetEditor) {
			this.editor = (MSLLibraryEditor) targetEditor;
			if ( targetEditor != null ) {
				this.shell = targetEditor.getSite().getShell();
				actionBarContrib = (MSLLibraryActionBarContributor)((MSLLibraryEditor)targetEditor).getActionBarContributor();
			} else {
				actionBarContrib = null;
			}
		}

		public void init(IAction action) {
			// No-op
		}

		public void runWithEvent(IAction action, Event event) {
			run(action);
		}

		public void run(final IAction action) {
			final EObject selected = (EObject) selectedEObjects.get(0);
			final MEditingDomain domain = MEditingDomain.getEditingDomain(
				selected.eResource());
			final ILogicalResource res = domain.asLogicalResource(
				selected.eResource());
			
			final Exception[] caught = new Exception[1];
			
			MUndoInterval undo = domain.runInUndoInterval(title, new Runnable() {
				public void run() {
					try {
						domain.runAsWrite(new MRunnable() {
							
							public Object run() {
								try {
									res.separate(selected, null);
									action.setEnabled(false);
								} catch (CannotSeparateException e) {
									caught[0] = e;
									MessageDialog.openError(
										shell,
										title,
										e.getLocalizedMessage());
								}
								return null;
							}});
					} catch (MSLActionAbandonedException e) {
						caught[0] = e;
						Log.log(MSLExamplePlugin.getDefault(), e.getStatus());
					}
				}});
			
			if (caught[0] != null) {
				undo.undo();
			} else {
				actionBarContrib.addUndoInterval(undo);
			}
		}
	}
	
	/**
	 * This action delegate refactors the selected element into a seaparate
	 * controlled unit.
	 */
	public static class UncontrolUnitDelegate
		implements IEditorActionDelegate, IActionDelegate2 {

		/**
		 * Error message to display when an exception occured
		 */
		protected static final String MESSAGE_EXCEPTION = MSLExampleMessages.message_exception;

		/**
		 * The shell this action is hosted in
		 */
		protected Shell shell = null;

		/**
		 * The active editor
		 */
		protected MSLLibraryEditor editor = null;

		/**
		 * Selected EObjects
		 */
		protected List selectedEObjects = null;

		/**
		 * The title for the action.
		 */
		private String title = MSLExampleMessages.UncontrolUnitAction_label;
		
		/** Action bar contributor of the MSL Library example editor. */
		private MSLLibraryActionBarContributor actionBarContrib;
		
		public void selectionChanged(IAction action, final ISelection selection) {
			this.selectedEObjects = null;
			try {
				if (selection instanceof IStructuredSelection) {
					IStructuredSelection structuredSelection = (IStructuredSelection) selection;
					this.selectedEObjects = structuredSelection.toList();
				}
			} catch (Exception e) {
				// Exceptions are not expected
				MessageDialog.openInformation(shell, title, MESSAGE_EXCEPTION);
				throw new RuntimeException(e);
			} finally {
				if ((null != selectedEObjects) && (selectedEObjects.size() == 1)
						&& (selectedEObjects.get(0) instanceof EObject)) {
					EObject selected = (EObject) selectedEObjects.get(0);
					final MEditingDomain domain = MEditingDomain.getEditingDomain(
						selected.eResource());
					ILogicalResource res = domain.asLogicalResource(
						selected.eResource());
					
					action.setEnabled(res.isSeparate(selected));
				} else {
					action.setEnabled(false);
				}
			}
		}

		public void dispose() {
			//No-op
		}

		public void setActiveEditor(IAction action, IEditorPart targetEditor) {
			this.editor = (MSLLibraryEditor) targetEditor;
			if ( targetEditor != null ) {
				this.shell = targetEditor.getSite().getShell();
				actionBarContrib = (MSLLibraryActionBarContributor)((MSLLibraryEditor)targetEditor).getActionBarContributor();
			} else {
				actionBarContrib = null;
			}
		}

		public void init(IAction action) {
			// No-op
		}

		public void runWithEvent(IAction action, Event event) {
			run(action);
		}

		public void run(final IAction action) {
			final EObject selected = (EObject) selectedEObjects.get(0);
			final MEditingDomain domain = MEditingDomain.getEditingDomain(
				selected.eResource());
			final ILogicalResource res = domain.asLogicalResource(
				selected.eResource());
			
			final Exception[] caught = new Exception[1];
			
			MUndoInterval undo = domain.runInUndoInterval(title, new Runnable() {
				public void run() {
					try {
						domain.runAsWrite(new MRunnable() {
							
							public Object run() {
								try {
									res.absorb(selected);
									action.setEnabled(false);
								} catch (CannotAbsorbException e) {
									caught[0] = e;
									MessageDialog.openError(
										shell,
										title,
										e.getLocalizedMessage());
								}
								return null;
							}});
					} catch (MSLActionAbandonedException e) {
						caught[0] = e;
						Log.log(MSLExamplePlugin.getDefault(), e.getStatus());
					}
				}});
			
			if (caught[0] != null) {
				undo.undo();
			} else {
				actionBarContrib.addUndoInterval(undo);
			}
		}
	}
	
	private class MSLDeleteAction extends DeleteAction {
		private Collection objects;
		

Lines 17-23 Link Here

(-)src/org/eclipse/gmf/examples/runtime/emf/actions/UnloadResourceDelegate.java (-2 / +1 lines)
17	import org.eclipse.emf.ecore.resource.Resource;	17	import org.eclipse.emf.ecore.resource.Resource;
18	import org.eclipse.gmf.examples.runtime.emf.editor.MSLLibraryEditor;	18	import org.eclipse.gmf.examples.runtime.emf.editor.MSLLibraryEditor;
19	import org.eclipse.gmf.examples.runtime.emf.internal.l10n.MSLExampleMessages;	19	import org.eclipse.gmf.examples.runtime.emf.internal.l10n.MSLExampleMessages;
20	import org.eclipse.gmf.runtime.emf.core.edit.MEditingDomain;
21	import org.eclipse.jface.action.IAction;	20	import org.eclipse.jface.action.IAction;
22	import org.eclipse.jface.dialogs.MessageDialog;	21	import org.eclipse.jface.dialogs.MessageDialog;
23	import org.eclipse.jface.viewers.ISelection;	22	import org.eclipse.jface.viewers.ISelection;
Lines 130-136 Link Here
130	for (Iterator i = selectedResources.iterator(); i.hasNext();) {	129	for (Iterator i = selectedResources.iterator(); i.hasNext();) {
131	Resource res = (Resource)i.next();	130	Resource res = (Resource)i.next();
132		131
133	((MEditingDomain)editor.getEditingDomain()).unloadResource(res);	132	res.unload();
134	}	133	}
135	}	134	}
136	}	135	}




/******************************************************************************
 * Copyright (c) 2005 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.examples.runtime.emf.resources;

import org.eclipse.emf.examples.extlibrary.EXTLibraryPackage;
import org.eclipse.emf.examples.extlibrary.Library;
import org.eclipse.emf.examples.extlibrary.impl.LibraryImpl;
import org.eclipse.gmf.runtime.emf.core.util.EObjectContainmentWithInverseLoadingEList;


/**
 * Example of a custom implementation for an {@link org.eclipse.emf.ecore.EClass}
 * that needs to support auto-loading of sub-unit resource in one or more of
 * its containment features.
 */
class LoadingLibraryImpl
	extends LibraryImpl {

	/**
	 * Initializes me.
	 */
	public LoadingLibraryImpl() {
		super();
		
		// use the custom containment-with-inverse list to perform automatic
		//   loading of contained elements in this feature.  This pre-empts
		//   the superclass's lazy initialization of this list
		branches = new EObjectContainmentWithInverseLoadingEList(
			Library.class, this, EXTLibraryPackage.LIBRARY__BRANCHES,
			EXTLibraryPackage.LIBRARY__PARENT_BRANCH);
	}

}




/******************************************************************************
 * Copyright (c) 2005 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.examples.runtime.emf.resources;

import org.eclipse.emf.ecore.EPackage;

import org.eclipse.emf.examples.extlibrary.EXTLibraryPackage;
import org.eclipse.emf.examples.extlibrary.Library;
import org.eclipse.emf.examples.extlibrary.impl.EXTLibraryFactoryImpl;


/**
 * Example of a custom {@link org.eclipse.emf.ecore.EFactory} implementation
 * for auto-loading the sub-units of a logical resource, for the EXT Library
 * example metamodel.
 */
public class LoadingEXTLibraryFactoryImpl
	extends EXTLibraryFactoryImpl {

	/**
	 * Initializes me.
	 */
	public LoadingEXTLibraryFactoryImpl() {
		super();
	}

	/**
	 * Creates {@link Library} implementations that automatically load their
	 * contained {@link Library#getBranches() branches}.
	 */
	public Library createLibrary() {
		return new LoadingLibraryImpl();
	}
	
	public EPackage getEPackage() {
		// must appear to belong to the EXT Library Package.  Note that we
		//   cannot assign our EPackage using the setEPackage(...) method
		//   because that would inverse-add us to the EPackage, which is
		//   not good
		return EXTLibraryPackage.eINSTANCE;
	}

}




/******************************************************************************
 * Copyright (c) 2005 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.examples.runtime.emf.resources;

import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.xmi.XMIResource;

import org.eclipse.emf.examples.extlibrary.Library;
import org.eclipse.gmf.runtime.emf.core.resources.AbstractLogicalResourcePolicy;
import org.eclipse.gmf.runtime.emf.core.resources.CannotSeparateException;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;


/**
 * Logical resource management policy implementation for the example library
 * metamodel.
 */
public class LibraryResourcePolicy
	extends AbstractLogicalResourcePolicy {

	/**
	 * Initializes me.
	 */
	public LibraryResourcePolicy() {
		super();
	}

	/**
	 * Only libraries may be stored in separate physical units.
	 */
	public boolean canSeparate(ILogicalResource resource, EObject eObject) {
		return eObject instanceof Library;
	}
	
	/**
	 * Suggests a URI for the new library sub-resource.
	 * <p>
	 * <b>Note</b> that this URI convention is not intended as a common design
	 * practice.  It is just a sample.
	 * </p>
	 */
	public URI preSeparate(ILogicalResource resource, EObject eObject, URI uri)
		throws CannotSeparateException {
		// construct a sensibly unique URI for the new
		//    controlled unit by constructing a path based on library names
		//    or, where not available, IDs
		URI result = resource.getURI().trimFileExtension();
		
		result = appendSegments(result, resource, (Library) eObject);
		
		result = result.appendFileExtension(resource.getURI().fileExtension());
		
		return result;
	}
	
	/**
	 * Appends segments to a URI corresponding to the nesting of libraries.
	 * 
	 * @param uri a uri to append segments to
	 * @param resource the resource containing the <code>library</code>
	 * @param library a library whose "name path" is to be appended to the URI
	 * @return the appended URI
	 */
	private URI appendSegments(URI uri, Resource resource, Library library) {
		Library parent = library.getParentBranch();
		if (parent != null) {
			uri = appendSegments(uri, resource, parent);
		}
		
		String segment = library.getName();
		if ((segment == null) || (segment.length() == 0)) {
			segment = ((XMIResource) resource).getID(library);
		}
		
		return uri.appendSegment(segment);
	}
}




              label="%EditEObject"
              menubarPath="org.eclipse.gmf.examples.runtime.emf.mslMenu/edit"/>
        <action
              class="org.eclipse.gmf.examples.runtime.emf.actions.MSLLibraryActionBarContributor$UncontrolUnitDelegate"
              id="org.eclipse.gmf.examples.runtime.emf.uncontrol"
              label="%UncontrolUnitAction.label"
              menubarPath="org.eclipse.gmf.examples.runtime.emf.mslMenu/units"/>
        <action
              class="org.eclipse.gmf.examples.runtime.emf.actions.MSLLibraryActionBarContributor$ControlUnitDelegate"
              id="org.eclipse.gmf.examples.runtime.emf.control"
              label="%ControlUnitAction.label"
              menubarPath="org.eclipse.gmf.examples.runtime.emf.mslMenu/units"/>
        <action
              class="org.eclipse.gmf.examples.runtime.emf.actions.FindReferencers"
              id="org.eclipse.gmf.examples.runtime.emf.referencers"
              label="%FindReferencersAction.label"

           nsURI="http:///org/eclipse/emf/examples/library/extlibrary.ecore/1.0.0"
           priority="highest"/>
  </extension>
  <extension
        point="org.eclipse.gmf.runtime.emf.core.resourcePolicies">
     <policy
           class="org.eclipse.gmf.examples.runtime.emf.resources.LibraryResourcePolicy">
        <epackage 
              nsURI="http:///org/eclipse/emf/examples/library/extlibrary.ecore/1.0.0"/>
      </policy>
      
      <efactory
            class="org.eclipse.gmf.examples.runtime.emf.resources.LoadingEXTLibraryFactoryImpl"
            nsURI="http:///org/eclipse/emf/examples/library/extlibrary.ecore/1.0.0"/>
  </extension>
   
</plugin>

Lines 604-610 Link Here

(-)src/org/eclipse/gmf/examples/runtime/emf/editor/MSLLibraryEditor.java (-2 / +4 lines)
604	try {	604	try {
605	// Load the resource through the editing domain.	605	// Load the resource through the editing domain.
606	//	606	//
607	editingDomain.loadResource(modelFile.getFile().getLocation().toOSString());	607	Resource res = editingDomain.createResource(
		608	modelFile.getFile().getLocation().toOSString());
		609	editingDomain.loadResource(res);
608	} catch (Exception exception) {	610	} catch (Exception exception) {
609	EXTLibraryEditorPlugin.INSTANCE.log(exception);	611	EXTLibraryEditorPlugin.INSTANCE.log(exception);
610	}	612	}
Lines 1075-1081 Link Here
1075	while (iter.hasNext()) {	1077	while (iter.hasNext()) {
1076	Resource res = (Resource) iter.next();	1078	Resource res = (Resource) iter.next();
1077	if (res != null && res.isLoaded() && res.isModified()	1079	if (res != null && res.isLoaded() && res.isModified()
1078	&& ResourceUtil.isModifiable(res)) { //$NON-NLS-1$	1080	&& ResourceUtil.isModifiable(res)) {
1079	dirtyResources.add(res);	1081	dirtyResources.add(res);
1080	}	1082	}
1081	}	1083	}




/******************************************************************************
 * Copyright (c) 2005 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.tests.runtime.emf.core.internal.resources;

import java.io.IOException;
import java.util.List;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFileState;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.Path;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EcoreUtil;

import org.eclipse.emf.examples.extlibrary.Book;
import org.eclipse.emf.examples.extlibrary.EXTLibraryFactory;
import org.eclipse.emf.examples.extlibrary.EXTLibraryPackage;
import org.eclipse.emf.examples.extlibrary.Library;
import org.eclipse.emf.examples.extlibrary.Writer;
import org.eclipse.gmf.runtime.emf.core.EventTypes;
import org.eclipse.gmf.runtime.emf.core.edit.DemuxedMListener;
import org.eclipse.gmf.runtime.emf.core.edit.MEditingDomain;
import org.eclipse.gmf.runtime.emf.core.edit.MFilter;
import org.eclipse.gmf.runtime.emf.core.edit.MResourceOption;
import org.eclipse.gmf.runtime.emf.core.edit.MRunnable;
import org.eclipse.gmf.runtime.emf.core.edit.MUndoInterval;
import org.eclipse.gmf.runtime.emf.core.exceptions.MSLActionAbandonedException;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap;
import org.eclipse.gmf.runtime.emf.core.resources.CannotAbsorbException;
import org.eclipse.gmf.runtime.emf.core.resources.CannotSeparateException;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;


/**
 * Tests the {@link org.eclipse.gmf.runtime.emf.core.internal.resources.LogicalResource}
 * class and its load/save/handler/helper/util cohorts.
 *
 * @author Christian W. Damus (cdamus)
 */
public class LogicalResourceTest
	extends BaseLogicalResourceTest {
	
	public LogicalResourceTest(String name) {
		super(name);
	}
	
	public static Test suite() {
		return new TestSuite(LogicalResourceTest.class, "Basic Tests"); //$NON-NLS-1$
	}
	
	DemuxedMListener aListener;

	/**
	 * Tests the getMappedResources() method.
	 */
	public void test_getMappedResources() {
		Map resources = logres.getMappedResources();
		assertEquals(1, resources.size());
		
		Resource nested = (Resource) resources.get(root);
		assertNotNull(nested);
		assertEquals(logres.getURI(), nested.getURI());
		
		nested = (ILogicalResource) resources.get(subunit1);
		assertNull(nested);
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		nested = (Resource) resources.get(subunit1);
		assertNotNull(nested);
		
		try {
			logres.absorb(subunit1);
		} catch (CannotAbsorbException e) {
			fail("Should not fail to absorb: " + e); //$NON-NLS-1$
		}
		nested = (Resource) resources.get(subunit1);
		assertNull(nested);
		
		assertEquals(1, resources.size());
	}

	/**
	 * Specifically tests the representation of the logical resource's roots
	 * in the getMappedResources() map.
	 */
	public void test_getMappedResources_logicalRoots() {
		Map resources = logres.getMappedResources();
		assertEquals(1, resources.size());
		
		Resource unit = (Resource) resources.get(root);
		assertNotNull(unit);
		assertEquals(logres.getURI(), unit.getURI());
		
		// test adding another root
		Library otherRoot = EXTLibraryFactory.eINSTANCE.createLibrary();
		logres.getContents().add(otherRoot);
		
		assertEquals(2, resources.size());
		unit = (Resource) resources.get(otherRoot);
		assertNotNull(unit);
		assertEquals(logres.getURI(), unit.getURI());
		
		// test replacing a root using the set() method
		Library yetAnotherRoot = EXTLibraryFactory.eINSTANCE.createLibrary();
		logres.getContents().set(1, yetAnotherRoot);
		
		assertEquals(2, resources.size());
		unit = (Resource) resources.get(otherRoot);
		assertNull(unit);  // the old root is no longer mapped to a unit
		unit = (Resource) resources.get(yetAnotherRoot);
		assertNotNull(unit);  // the new one is
		assertEquals(logres.getURI(), unit.getURI());
		
		// test removing a root
		logres.getContents().remove(yetAnotherRoot);
		
		assertEquals(1, resources.size());
		unit = (Resource) resources.get(yetAnotherRoot);
		assertNull(unit);  // the old root is no longer mapped to a unit
	}
	
	/**
	 * Tests the URIs of sub-units and objects in the logical resource.
	 */
	public void test_uris() {
		String subunitFrag = logres.getURIFragment(subunit1);
		URI subunitUri = EcoreUtil.getURI(subunit1);
		
		URI nestedUri = URI.createPlatformResourceURI(SUBUNIT_NAME1);
		
		try {
			logres.separate(subunit1, nestedUri);
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Resource nested = (Resource) logres.getMappedResources().get(
			subunit1);
		assertNotNull(nested);
		assertEquals(nestedUri, nested.getURI());
		
		assertEquals(subunitFrag, logres.getURIFragment(subunit1));
		assertEquals(subunitUri, EcoreUtil.getURI(subunit1));
	}
	
	/**
	 * Tests a monolithic resource (no sub-units).
	 */
	public void test_saveLoad_monolith() {
		String rootFrag = logres.getURIFragment(root);
		String subunitFrag = logres.getURIFragment(subunit1);
		
		saveLogicalResource();
		
		assertFalse(logres.isModified());
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		loadLogicalResource();
		
		assertFalse(logres.isModified());
		
		Map resources = logres.getMappedResources();
		assertEquals(1, resources.size());
		
		assertEquals(1, logres.getContents().size());
		assertFalse(logres.getContents().get(0) instanceof ResourceMap);
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		
		// in monolithic case, there should be no resource map.  Should look
		//    just like any old XMI resource
		assertFalse(
			((Resource) resources.get(root)).getContents().get(0) instanceof ResourceMap);
		
		subunit1 = lookupLibrary(subunitFrag);
		assertNotNull(subunit1);
		assertTrue(EcoreUtil.isAncestor(root, subunit1));
	}
	
	/**
	 * Tests single-level subunit nesting.
	 */
	public void test_saveLoad_singleNesting() {
		String rootFrag = logres.getURIFragment(root);
		String subunitFrag = logres.getURIFragment(subunit1);
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		assertTrue(logres.isModified());
		
		saveLogicalResource();
		
		assertFalse(logres.isModified());
		
		IFile subunitFile = project.getParent().getFile(new Path(SUBUNIT_NAME1));
		assertNotNull(subunitFile);
		assertTrue(subunitFile.exists());
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		loadLogicalResource();
		
		assertFalse(logres.isModified());
		
		Map resources = logres.getMappedResources();
		assertEquals(2, resources.size());
		
		assertEquals(1, logres.getContents().size());
		assertFalse(logres.getContents().get(0) instanceof ResourceMap);
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		
		subunit1 = lookupLibrary(subunitFrag);
		assertNotNull(subunit1);
		assertTrue(EcoreUtil.isAncestor(root, subunit1));
	}
	
	/**
	 * Tests multi-level subunit nesting.
	 */
	public void test_saveLoad_multiNesting() {
		String rootFrag = logres.getURIFragment(root);
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit2Frag = logres.getURIFragment(subunit2);
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit2, URI.createPlatformResourceURI(SUBUNIT_NAME2));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		assertTrue(logres.isModified());
		
		saveLogicalResource();
		
		assertFalse(logres.isModified());
		
		IFile subunitFile = project.getParent().getFile(new Path(SUBUNIT_NAME1));
		assertNotNull(subunitFile);
		assertTrue(subunitFile.exists());
		
		subunitFile = project.getParent().getFile(new Path(SUBUNIT_NAME2));
		assertNotNull(subunitFile);
		assertTrue(subunitFile.exists());
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		loadLogicalResource();
		
		assertFalse(logres.isModified());
		
		Map resources = logres.getMappedResources();
		assertEquals(3, resources.size());
		
		assertEquals(1, logres.getContents().size());
		assertFalse(logres.getContents().get(0) instanceof ResourceMap);
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		subunit2 = lookupLibrary(subunit2Frag);
		assertNotNull(subunit2);
		assertTrue(EcoreUtil.isAncestor(root, subunit2));
		assertTrue(EcoreUtil.isAncestor(subunit1, subunit2));
	}
	
	/**
	 * Tests multi-level subunit nesting in which two different sub-units
	 * are stored in the same physical resource.
	 */
	public void test_saveLoad_multiNestingSameUnit() {
		String rootFrag = logres.getURIFragment(root);
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit2Frag = logres.getURIFragment(subunit2);
		String subunit3Frag = logres.getURIFragment(subunit3);
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit2, URI.createPlatformResourceURI(SUBUNIT_NAME2));
			logres.separate(subunit3, URI.createPlatformResourceURI(SUBUNIT_NAME2)); // same file
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		assertTrue(logres.isModified());
		
		saveLogicalResource();
		
		assertFalse(logres.isModified());
		
		IFile subunitFile = project.getParent().getFile(new Path(SUBUNIT_NAME1));
		assertNotNull(subunitFile);
		assertTrue(subunitFile.exists());
		
		subunitFile = project.getParent().getFile(new Path(SUBUNIT_NAME2));
		assertNotNull(subunitFile);
		assertTrue(subunitFile.exists());
		
		try {
			// the sub-unit file should only have been written to once, to write
			//   both roots
			IFileState[] history = subunitFile.getHistory(null);
			assertNotNull(history);
			assertEquals(0, history.length);  // file was only written once
		} catch (CoreException e) {
			fail("Failed to get file history: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		loadLogicalResource();
		
		Map resources = logres.getMappedResources();
		assertEquals(4, resources.size());
		
		assertEquals(1, logres.getContents().size());
		assertFalse(logres.getContents().get(0) instanceof ResourceMap);
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		subunit2 = lookupLibrary(subunit2Frag);
		assertNotNull(subunit2);
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);
		assertTrue(EcoreUtil.isAncestor(subunit1, subunit2));
		assertTrue(EcoreUtil.isAncestor(root, subunit3));
	}
	
	/**
	 * Tests logical roots as sub-units.
	 */
	public void test_saveLoad_separateLogicalRoot() {
		String rootFrag = logres.getURIFragment(root);
		
		try {
			logres.separate(root, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		assertTrue(logres.isModified());
		
		saveLogicalResource();
		
		assertFalse(logres.isModified());
		
		IFile subunitFile = project.getParent().getFile(new Path(SUBUNIT_NAME1));
		assertNotNull(subunitFile);
		assertTrue(subunitFile.exists());
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		loadLogicalResource();
		
		assertFalse(logres.isModified());
		
		Map resources = logres.getMappedResources();
		assertEquals(1, resources.size());  // nothing maps to the physical root resource
		
		assertEquals(1, logres.getContents().size());
		assertFalse(logres.getContents().get(0) instanceof ResourceMap);
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		assertTrue(logres.isSeparate(root));
		assertNull(root.eContainer());
		assertTrue(logres.getContents().contains(root));
		
		// absorb the root again
		try {
			logres.absorb(root);
		} catch (CannotAbsorbException e) {
			fail("Should not fail to absorb: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		assertFalse(logres.isSeparate(root));
		assertNull(root.eContainer());
		assertTrue(logres.getContents().contains(root));
	}
	
	/**
	 * Tests multiple sub-units under the same parent, to verify that they are
	 * loaded again in the correct order.  This method uses the
	 * <tt>subunit<i>n</i></tt> fields to store different elements than the
	 * other tests.
	 */
	public void test_multipleSubunitsOfSameParent() {
		// create a third child of the root element
		subunit3 = EXTLibraryFactory.eINSTANCE.createLibrary();
		root.getBranches().add(subunit3);
		subunit3.setName("level1-2"); //$NON-NLS-1$
		
		subunit1 = (Library) root.getBranches().get(0);
		subunit2 = (Library) root.getBranches().get(1);
		subunit3 = (Library) root.getBranches().get(2);
		
		String rootFrag = logres.getURIFragment(root);
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit2Frag = logres.getURIFragment(subunit2);
		String subunit3Frag = logres.getURIFragment(subunit3);
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit2, URI.createPlatformResourceURI(SUBUNIT_NAME2));
			logres.separate(subunit3, URI.createPlatformResourceURI(SUBUNIT_NAME2));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		assertTrue(logres.isModified());
		
		saveLogicalResource();
		
		assertFalse(logres.isModified());
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		loadLogicalResource();
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		subunit2 = lookupLibrary(subunit2Frag);
		assertNotNull(subunit2);
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);
		
		// verify the ordering of the sub-units
		assertEquals(0, root.getBranches().indexOf(subunit1));
		assertEquals(1, root.getBranches().indexOf(subunit2));
		assertEquals(2, root.getBranches().indexOf(subunit3));
	}
	
	/**
	 * Tests absorption of an internal (middle) unit in multi-level subunit
	 * nesting.
	 */
	public void test_absorb_internal_multiNesting() {
		String rootFrag = logres.getURIFragment(root);
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit2Frag = logres.getURIFragment(subunit2);
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit2, URI.createPlatformResourceURI(SUBUNIT_NAME2));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		// get the file modification stamps for later comparison
		IFile file = project.getParent().getFile(new Path(RESOURCE_NAME));
		assertNotNull(file);
		long rootStamp = file.getModificationStamp();
		file = project.getParent().getFile(new Path(SUBUNIT_NAME1));
		assertNotNull(file);
		long subunit1Stamp = file.getModificationStamp();
		file = project.getParent().getFile(new Path(SUBUNIT_NAME2));
		assertNotNull(file);
		long subunit2Stamp = file.getModificationStamp();
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		loadLogicalResource();
		
		Map resources = logres.getMappedResources();
		assertEquals(3, resources.size());
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		subunit2 = lookupLibrary(subunit2Frag);
		assertNotNull(subunit2);
		assertTrue(EcoreUtil.isAncestor(root, subunit2));
		assertTrue(EcoreUtil.isAncestor(subunit1, subunit2));
		
		assertTrue(logres.isSeparate(subunit1));
		
		try {
			logres.absorb(subunit1);
		} catch (CannotAbsorbException e) {
			fail("Should not fail to absorb: " + e); //$NON-NLS-1$
		}
		
		assertFalse(logres.isSeparate(subunit1));
		assertEquals(2, resources.size());
		
		saveLogicalResource();
		
		// all files needed to be rewritten by the save, because the subunit2
		//   was updated to reference the root unit as its parent when subunit1
		//   was absorbed
		file = project.getParent().getFile(new Path(RESOURCE_NAME));
		assertNotNull(file);
		assertFalse(rootStamp == file.getModificationStamp());
		file = project.getParent().getFile(new Path(SUBUNIT_NAME1));
		assertNotNull(file);
		assertFalse(subunit1Stamp == file.getModificationStamp());
		file = project.getParent().getFile(new Path(SUBUNIT_NAME2));
		assertNotNull(file);
		assertFalse(subunit2Stamp == file.getModificationStamp());
	}
	
	/**
	 * Tests absorption of a leaf unit in multi-level subunit nesting.
	 */
	public void test_absorb_leaf_multiNesting() {
		String rootFrag = logres.getURIFragment(root);
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit2Frag = logres.getURIFragment(subunit2);
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit2, URI.createPlatformResourceURI(SUBUNIT_NAME2));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		// get the file modification stamps for later comparison
		IFile file = project.getParent().getFile(new Path(RESOURCE_NAME));
		assertNotNull(file);
		long rootStamp = file.getModificationStamp();
		file = project.getParent().getFile(new Path(SUBUNIT_NAME1));
		assertNotNull(file);
		long subunit1Stamp = file.getModificationStamp();
		file = project.getParent().getFile(new Path(SUBUNIT_NAME2));
		assertNotNull(file);
		long subunit2Stamp = file.getModificationStamp();
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		loadLogicalResource();
		
		Map resources = logres.getMappedResources();
		assertEquals(3, resources.size());
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		subunit2 = lookupLibrary(subunit2Frag);
		assertNotNull(subunit2);
		assertTrue(EcoreUtil.isAncestor(root, subunit2));
		assertTrue(EcoreUtil.isAncestor(subunit1, subunit2));
		
		assertTrue(logres.isSeparate(subunit2));
		
		try {
			logres.absorb(subunit2);
		} catch (CannotAbsorbException e) {
			fail("Should not fail to absorb: " + e); //$NON-NLS-1$
		}
		
		assertFalse(logres.isSeparate(subunit2));
		assertEquals(2, resources.size());
		
		saveLogicalResource();
		
		// the subunit1 and subunit2 files should have been written by the
		//   second save, but not the root file
		file = project.getParent().getFile(new Path(RESOURCE_NAME));
		assertNotNull(file);
		assertEquals(rootStamp, file.getModificationStamp());
		file = project.getParent().getFile(new Path(SUBUNIT_NAME1));
		assertNotNull(file);
		assertFalse(subunit1Stamp == file.getModificationStamp());
		file = project.getParent().getFile(new Path(SUBUNIT_NAME2));
		assertNotNull(file);
		assertFalse(subunit2Stamp == file.getModificationStamp());
	}
	
	/**
	 * Test saving a logical resource with sub-units under a new URI.
	 */
	public void test_saveAs() {
		String rootFrag = logres.getURIFragment(root);
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit2Frag = logres.getURIFragment(subunit2);
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit2, URI.createPlatformResourceURI(SUBUNIT_NAME2));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		assertTrue(logres.isModified());
		
		saveLogicalResource();
		
		assertFalse(logres.isModified());
		
		// record the modification stamps of the various units for later
		//   comparison
		IFile file = project.getParent().getFile(new Path(RESOURCE_NAME));
		assertNotNull(file);
		long rootStamp = file.getModificationStamp();
		
		file = project.getParent().getFile(new Path(SUBUNIT_NAME1));
		assertNotNull(file);
		long subunit1Stamp = file.getModificationStamp();
		
		file = project.getParent().getFile(new Path(SUBUNIT_NAME2));
		assertNotNull(file);
		long subunit2Stamp = file.getModificationStamp();
		
		Map resources = logres.getMappedResources();
		assertEquals(3, resources.size());
		
		String newName = "/" + PROJECT_NAME + "/newuri.extlibrary"; //$NON-NLS-1$ //$NON-NLS-2$
		logres.setURI(URI.createPlatformResourceURI(newName));
		
		// reduced to a single physical resource
		assertEquals(1, resources.size());
		
		saveLogicalResource();
		
		// discard and re-load the resource
		createLogicalResource(newName);
		
		loadLogicalResource();
		resources = logres.getMappedResources();
		assertEquals(1, resources.size());
		
		// verify the structure of the file (that nothing is missing)
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		subunit2 = lookupLibrary(subunit2Frag);
		assertNotNull(subunit2);
		assertTrue(EcoreUtil.isAncestor(root, subunit2));
		assertTrue(EcoreUtil.isAncestor(subunit1, subunit2));
		
		// load the former URI again
		createLogicalResource(RESOURCE_NAME);
		
		loadLogicalResource();
		
		// the old one still has three units
		resources = logres.getMappedResources();
		assertEquals(3, resources.size());
		
		// verify the structure of the file (that nothing is missing)
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		subunit2 = lookupLibrary(subunit2Frag);
		assertNotNull(subunit2);
		assertTrue(EcoreUtil.isAncestor(root, subunit2));
		assertTrue(EcoreUtil.isAncestor(subunit1, subunit2));
		
		// check the modification stamps to verify that the old units are
		//   not changed
		file = project.getParent().getFile(new Path(RESOURCE_NAME));
		assertNotNull(file);
		assertEquals(rootStamp, file.getModificationStamp());
		
		file = project.getParent().getFile(new Path(SUBUNIT_NAME1));
		assertNotNull(file);
		assertEquals(subunit1Stamp, file.getModificationStamp());
		
		file = project.getParent().getFile(new Path(SUBUNIT_NAME2));
		assertNotNull(file);
		assertEquals(subunit2Stamp, file.getModificationStamp());
	}
	
	/** Tests undo/redo of unit separation and absorption. */
	public void test_undoRedo() {
		Map resources = logres.getMappedResources();
		assertEquals(1, resources.size());
		
		Resource nested = (Resource) resources.get(root);
		assertNotNull(nested);
		assertEquals(logres.getURI(), nested.getURI());
		
		nested = (Resource) resources.get(subunit1);
		assertNull(nested);
		
		stopWriting();
		startWriting();
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		nested = (Resource) resources.get(subunit1);
		assertNotNull(nested);
		
		MUndoInterval undo = stopWriting();
		
		// test undo of separation
		undo.undo();
		
		startReading();
		
		nested = (Resource) resources.get(subunit1);
		assertNull(nested);
		assertFalse(logres.isSeparate(subunit1));
		
		stopReading();
		
		// test redo of separation
		undo.redo();
		
		startReading();
		
		nested = (Resource) resources.get(subunit1);
		assertNotNull(nested);
		assertTrue(logres.isSeparate(subunit1));
		
		stopReading();
		
		startWriting();
		
		try {
			logres.absorb(subunit1);
		} catch (CannotAbsorbException e) {
			fail("Should not fail to absorb: " + e); //$NON-NLS-1$
		}
		nested = (Resource) resources.get(subunit1);
		assertNull(nested);
		
		undo = stopWriting();
		
		// test undo of absorption
		undo.undo();
		
		startReading();
		
		nested = (Resource) resources.get(subunit1);
		assertNotNull(nested);
		assertTrue(logres.isSeparate(subunit1));
		
		stopReading();
		
		// test undo of absorption
		undo.redo();
		
		startReading();
		
		nested = (Resource) resources.get(subunit1);
		assertNull(nested);
		assertFalse(logres.isSeparate(subunit1));
		
		stopReading();
	}
	
	/**
	 * Tests that the dirty states of units are correctly updated when
	 * separating an element.
	 */
	public void test_dirtyState_separate() {
		saveLogicalResource();
		
		Resource rootRes = (Resource) logres.getMappedResources().get(root);
		
		assertFalse(logres.isModified());
		assertFalse(rootRes.isModified());
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Resource sub1Res = (Resource) logres.getMappedResources().get(subunit1);
		
		assertTrue(logres.isModified());
		assertTrue(rootRes.isModified());
		assertTrue(sub1Res.isModified());
		
		saveLogicalResource();
		
		assertFalse(logres.isModified());
		assertFalse(rootRes.isModified());
		assertFalse(sub1Res.isModified());
	}
	
	/**
	 * Tests that the dirty states of units are correctly updated when
	 * absorbing an element.
	 */
	public void test_dirtyState_absorb() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		Resource rootRes = (Resource) logres.getMappedResources().get(root);
		Resource sub1Res = (Resource) logres.getMappedResources().get(subunit1);
		
		assertFalse(logres.isModified());
		assertFalse(rootRes.isModified());
		assertFalse(sub1Res.isModified());
		
		try {
			logres.absorb(subunit1);
		} catch (CannotAbsorbException e) {
			fail("Should not fail to absorb: " + e); //$NON-NLS-1$
		}
		
		assertTrue(logres.isModified());
		assertTrue(rootRes.isModified());
		assertTrue(sub1Res.isModified());
		
		saveLogicalResource();
		
		assertFalse(logres.isModified());
		assertFalse(rootRes.isModified());
		assertFalse(sub1Res.isModified());
	}
	
	/**
	 * Tests that the dirty states of units are correctly updated when
	 * modifying an element.
	 */
	public void test_dirtyState_modify() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		Resource rootRes = (Resource) logres.getMappedResources().get(root);
		Resource sub1Res = (Resource) logres.getMappedResources().get(subunit1);
		
		assertFalse(logres.isModified());
		assertFalse(rootRes.isModified());
		assertFalse(sub1Res.isModified());
		
		subunit1.setAddress("500 Pennsylvania Ave."); //$NON-NLS-1$
		
		assertTrue(logres.isModified());
		assertFalse(rootRes.isModified());  // didn't update the root unit
		assertTrue(sub1Res.isModified());
		
		saveLogicalResource();
		
		assertFalse(logres.isModified());
		assertFalse(rootRes.isModified());
		assertFalse(sub1Res.isModified());
		
		root.setAddress("10 Downing St."); //$NON-NLS-1$
		
		assertTrue(logres.isModified());
		assertTrue(rootRes.isModified());
		assertFalse(sub1Res.isModified());  // didn't update the sub-unit
	}
	
	/** Tests the EMF-style listening for notifications from adapters. */
	public void test_basicEventing() {
		class TestAdapter extends AdapterImpl {
			List notifications = new java.util.ArrayList();
			
			public void notifyChanged(Notification msg) {
				if (!(msg.getNotifier() instanceof Resource) ||
						(msg.getFeatureID(Resource.class) == Resource.RESOURCE__CONTENTS)) {
					// don't want the touch events for resource isModified
					notifications.add(msg);
				}
			}
		}
		
		TestAdapter adapter = new TestAdapter();
		
		URI logicalUri = logres.getURI();
		URI subunitUri = URI.createPlatformResourceURI(SUBUNIT_NAME1);
		
		// listen for notifications of separation/absorption on the parent
		EObject parent = subunit1.eContainer();
		parent.eAdapters().add(adapter);
		
		try {
			logres.separate(subunit1, subunitUri);
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		assertEquals(1, adapter.notifications.size());
		Notification event = (Notification) adapter.notifications.get(0);
		adapter.notifications.clear();
		
		assertSame(parent, event.getNotifier());
		assertEquals(EventTypes.SEPARATE, event.getEventType());
		assertSame(EXTLibraryPackage.eINSTANCE.getLibrary_Branches(), event.getFeature());
		assertEquals(logicalUri, ((Resource) event.getOldValue()).getURI());
		assertEquals(subunitUri, ((Resource) event.getNewValue()).getURI());
		
		try {
			logres.absorb(subunit1);
		} catch (CannotAbsorbException e) {
			fail("Should not fail to absorb: " + e); //$NON-NLS-1$
		}
		
		assertEquals(1, adapter.notifications.size());
		event = (Notification) adapter.notifications.get(0);
		adapter.notifications.clear();
		
		assertSame(parent, event.getNotifier());
		assertEquals(EventTypes.ABSORB, event.getEventType());
		assertSame(EXTLibraryPackage.eINSTANCE.getLibrary_Branches(), event.getFeature());
		assertEquals(subunitUri, ((Resource) event.getOldValue()).getURI());
		assertEquals(logicalUri, ((Resource) event.getNewValue()).getURI());
		
		logres.eAdapters().add(adapter);
		
		try {
			logres.separate(root, subunitUri); // logical root
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		assertEquals(1, adapter.notifications.size());
		event = (Notification) adapter.notifications.get(0);
		adapter.notifications.clear();
		
		assertSame(logres, event.getNotifier());
		assertEquals(EventTypes.SEPARATE, event.getEventType());
		assertSame(null, event.getFeature());
		assertEquals(Resource.RESOURCE__CONTENTS, event.getFeatureID(Resource.class));
		assertEquals(logicalUri, ((Resource) event.getOldValue()).getURI());
		assertEquals(subunitUri, ((Resource) event.getNewValue()).getURI());
		
		try {
			logres.absorb(root);  // logical root
		} catch (CannotAbsorbException e) {
			fail("Should not fail to absorb: " + e); //$NON-NLS-1$
		}
		
		assertEquals(1, adapter.notifications.size());
		event = (Notification) adapter.notifications.get(0);
		adapter.notifications.clear();
		
		assertSame(logres, event.getNotifier());
		assertEquals(EventTypes.ABSORB, event.getEventType());
		assertSame(null, event.getFeature());
		assertEquals(Resource.RESOURCE__CONTENTS, event.getFeatureID(Resource.class));
		assertEquals(subunitUri, ((Resource) event.getOldValue()).getURI());
		assertEquals(logicalUri, ((Resource) event.getNewValue()).getURI());
	}
	
	/** Tests the MSL-style listening for notifications from MListeners. */
	public void test_mslEventing() {
		class TestListener extends DemuxedMListener {
			Notification event;
			ILogicalResource res;
			EObject element;
			Resource subunit;
			
			TestListener() {
				super(domain);
			}
			
			public MFilter getFilter() {
				return MFilter.SEPARATED_ABSORBED_FILTER;
			}
			
			public void handleElementSeparatedEvent(
					Notification notification, ILogicalResource resource,
					EObject eObject, Resource newResource) {
				event = notification;
				res = resource;
				element = eObject;
				subunit = newResource;
			}
			
			public void handleElementAbsorbedEvent(
					Notification notification, ILogicalResource resource,
					EObject eObject, Resource oldResource) {
				event = notification;
				res = resource;
				element = eObject;
				subunit = oldResource;
			}
		}
		
		TestListener listener = new TestListener();
		listener.startListening();
		
		URI subunitUri = URI.createPlatformResourceURI(SUBUNIT_NAME1);
		
		try {
			logres.separate(subunit1, subunitUri);
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		// must complete the write action in order for events to fire
		stopWriting();
		
		assertSame(subunit1, listener.element);
		assertEquals(EventTypes.SEPARATE, listener.event.getEventType());
		assertSame(logres, listener.res);
		assertEquals(subunitUri, listener.subunit.getURI());
		
		startWriting();
		
		try {
			logres.absorb(subunit1);
		} catch (CannotAbsorbException e) {
			fail("Should not fail to absorb: " + e); //$NON-NLS-1$
		}
		
		// must complete the write action in order for events to fire
		stopWriting();
		
		assertSame(subunit1, listener.element);
		assertEquals(EventTypes.ABSORB, listener.event.getEventType());
		assertSame(logres, listener.res);
		assertEquals(subunitUri, listener.subunit.getURI());
		
		try {
			logres.separate(root, subunitUri);  // logical root
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		// must complete the write action in order for events to fire
		stopWriting();
		
		assertSame(root, listener.element);
		assertEquals(EventTypes.SEPARATE, listener.event.getEventType());
		assertSame(logres, listener.res);
		assertEquals(subunitUri, listener.subunit.getURI());
		
		startWriting();
		
		try {
			logres.absorb(root);  // logical root
		} catch (CannotAbsorbException e) {
			fail("Should not fail to absorb: " + e); //$NON-NLS-1$
		}
		
		// must complete the write action in order for events to fire
		stopWriting();
		
		assertSame(root, listener.element);
		assertEquals(EventTypes.ABSORB, listener.event.getEventType());
		assertSame(logres, listener.res);
		assertEquals(subunitUri, listener.subunit.getURI());
	}
	
	/**
	 * Tests that we can correctly load models from the 6.x physical structure.
	 */
	public void test_compatibility_6_0() {
		URI uri = URI.createURI(MslCoreTestsBundle.getEntry(
				"/test_models/test_6_0_format.extlibrary").toString()); //$NON-NLS-1$
		logres = createNewLogicalResource(uri);
		loadLogicalResource();
		
		assertTrue(logres.isLoaded());
		assertEquals(1, ((ResourceSet) logres.getAdapter(ResourceSet.class)).getResources().size());
		
		assertEquals(1, logres.getContents().size());
		Library library = (Library) logres.getContents().get(0);
		
		assertEquals("Library of Congress", library.getName()); //$NON-NLS-1$
		
		assertEquals(1, library.getWriters().size());
		Writer writer = (Writer) library.getWriters().get(0);
		assertEquals("Master Librarian", writer.getName()); //$NON-NLS-1$
		
		assertEquals(1, library.getBooks().size());
		Book book = (Book) library.getBooks().get(0);
		assertEquals("All Books In Existence", book.getTitle()); //$NON-NLS-1$
		
		assertSame(writer, book.getAuthor());
		assertEquals(1, writer.getBooks().size());
		assertSame(book, writer.getBooks().get(0));
	}
	
	/**
	 * Tests that we properly propagate errors from the unit to the logical
	 *  resource.
	 */
	public void test_load_errors_RATLC00537775() {
		URI uri = URI.createURI(MslCoreTestsBundle.getEntry(
				"/test_models/test_corrupted_model.extlibrary").toString()); //$NON-NLS-1$
		logres = createNewLogicalResource(uri);

		Map options = new java.util.HashMap();
		
		options.put(ILogicalResource.OPTION_LOAD_ALL_UNITS,
			Boolean.TRUE);
		options.put(ILogicalResource.OPTION_AUTO_LOAD_UNITS,
			Boolean.TRUE);
		
		try {
			logres.load(options);
		} catch (IOException e) {
			// Check to ensure that the resource is loaded but it has
			//  errors.
			assertTrue(logres.isLoaded());
			assertTrue(!logres.getErrors().isEmpty());
			return;
		}
		
		fail("Logical resource load should have failed because of corrupted XML."); //$NON-NLS-1$
	}
	
	/**
	 * Tests that the DemuxingMListener will not report a model unloaded when
	 *  the errors list of a resource is emptied.
	 */
	public void test_load_errors_RATLC00537693() {
		final MEditingDomain editingDomain = MEditingDomain.createNewDomain();
		URI uri = URI.createURI(MslCoreTestsBundle.getEntry(
				"/test_models/test_corrupted_model.extlibrary").toString()); //$NON-NLS-1$
		
		final Resource[] r = new Resource[1];
		
		try {
			r[0] = editingDomain.createResource(uri.toString(),MResourceOption.URI);
			r[0].unload();
		} catch (Exception e) {
			// Do nothing, just proceed.
		}
		
		Map options = new java.util.HashMap();
		
		options.put(ILogicalResource.OPTION_LOAD_ALL_UNITS,
			Boolean.TRUE);
		options.put(ILogicalResource.OPTION_AUTO_LOAD_UNITS,
			Boolean.TRUE);
		
		try {
			r[0].load(options);
			// We shouldn't get this far.
			fail();
		} catch (IOException e) {
			// Do nothing.
		}
		
		// Make sure that there are errors to be cleared from the resource.
		assertTrue(r[0].getErrors().size() > 0);
		
		final int[] listenerCalled = new int[1];
		listenerCalled[0] = 0;
		
		aListener = new DemuxedMListener(editingDomain) {
			public void handleResourceUnloadedEvent(Notification notification, Resource resource, EObject modelRoot) {
				listenerCalled[0]++;
			}
		};
		aListener.startListening();
		
		// Clear all of the errors from the resource in a proper write action.
		editingDomain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					editingDomain.runAsWrite(new MRunnable() {
						public Object run() {
							r[0].getErrors().clear();
							return null;
						}
					});
				} catch (MSLActionAbandonedException e) {
					fail();
				}
			}
		});
		
		assertEquals(0,listenerCalled[0]);
	}
}




/******************************************************************************
 * Copyright (c) 2005 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.tests.runtime.emf.core.internal.resources;

import java.io.IOException;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.examples.extlibrary.AudioVisualItem;
import org.eclipse.emf.examples.extlibrary.Book;
import org.eclipse.emf.examples.extlibrary.Library;
import org.eclipse.emf.examples.extlibrary.Periodical;
import org.eclipse.emf.examples.extlibrary.Person;
import org.eclipse.emf.examples.extlibrary.Writer;
import org.eclipse.emf.examples.extlibrary.util.EXTLibrarySwitch;
import org.eclipse.gmf.runtime.emf.core.edit.MEditingDomain;
import org.eclipse.gmf.runtime.emf.core.edit.MResourceOption;
import org.eclipse.gmf.runtime.emf.core.edit.MUndoInterval;
import org.eclipse.gmf.runtime.emf.core.internal.commands.MSLUndoStack;
import org.eclipse.gmf.runtime.emf.core.internal.commands.MSLUndoStack.ActionLockMode;
import org.eclipse.gmf.runtime.emf.core.internal.domain.MSLEditingDomain;
import org.eclipse.gmf.runtime.emf.core.internal.resources.AbstractResourceWrapper;
import org.eclipse.gmf.runtime.emf.core.internal.resources.LogicalResourceWrapper;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;
import org.osgi.framework.Bundle;


/**
 * Mini-framework class for logical resource test cases.
 *
 * @author Christian W. Damus (cdamus)
 */
public abstract class BaseLogicalResourceTest extends TestCase {
	static final Bundle MslCoreTestsBundle =
		Platform.getBundle("org.eclipse.gmf.tests.runtime.emf.core"); //$NON-NLS-1$
	
	protected static final String PROJECT_NAME = "logrestest"; //$NON-NLS-1$
	protected static final String RESOURCE_NAME = "/" + PROJECT_NAME + "/logres.extlibrary";  //$NON-NLS-1$//$NON-NLS-2$
	protected static final String RESOURCE_NAME2 = "/" + PROJECT_NAME + "/logres2.extlibrary";  //$NON-NLS-1$//$NON-NLS-2$
	protected static final String SUBUNIT_NAME1 = "/" + PROJECT_NAME + "/logres.1.extlibrary";  //$NON-NLS-1$//$NON-NLS-2$
	protected static final String SUBUNIT_NAME2 = "/" + PROJECT_NAME + "/logres.2.extlibrary";  //$NON-NLS-1$//$NON-NLS-2$
	protected static final String SUBUNIT_NAME3 = "/" + PROJECT_NAME + "/logres.3.extlibrary";  //$NON-NLS-1$//$NON-NLS-2$
	
	protected MEditingDomain domain;
	private boolean isReading;
	
	protected IProject project;
	protected ILogicalResource logres;
	
	//
	// Model structure created by setUp():
	//
	// root
	//  +- level1
	//  |    +- level2-subunit  (== subunit1)
	//  |          +- level3
	//  |               +- level4-subunit   (== subunit2)
	//  +- level1-1
	//       +- level2-1-subunit   (== subunit3)
	//
	// In each library at each level, there is a book and a writer, named
	// according to the library name (nesting level).
	// 
	
	protected Library root;
	protected Library subunit1;
	protected Library subunit2;
	protected Library subunit3;

	/**
	 * Initializes me with my name.
	 * 
	 * @param name my name
	 */
	protected BaseLogicalResourceTest(String name) {
		super(name);
	}

	/**
	 * Test suite encompassing all of the logical resource tests.
	 * 
	 * @return the suite of logical resource tests
	 */
	public static Test suite() {
		TestSuite suite = new TestSuite("MSL Logical Resource Tests"); //$NON-NLS-1$

		suite.addTest(LogicalResourceTest.suite());
		suite.addTest(CrossReferenceTest.suite());
		suite.addTest(IncrementalLoadingTest.suite());
		suite.addTest(RefactoringTest.suite());
		suite.addTest(LogicalResourcePolicyManagerTest.suite());
		suite.addTest(LogicalResourceWrapperTest.suite());
		suite.addTest(UnmodifiableResourceViewTest.suite());
		suite.addTest(ErrorConditionsTest.suite());
		suite.addTest(RegressionTest.suite());
		suite.addTest(GarbageCollectionTest.suite());

		return suite;
	}

	//
	// Test configuration methods
	//
	
	protected void setUp()
		throws Exception {
		
		project = ResourcesPlugin.getWorkspace().getRoot().getProject(PROJECT_NAME);
		if (!project.exists()) {
			project.create(null);
		}
		
		project.open(null);
	
		domain = MEditingDomain.INSTANCE;
		
		startWriting();
		
		createLogicalResource(RESOURCE_NAME);
		
		initializeTestModel();
	}

	protected void tearDown()
		throws Exception {
		
		stopWriting();  // in case a write action is left open
		stopReading();  // in case a read action is left open
		
		unloadLogicalResource();
		
		// clean up any others that a unit test may have created
		for (Iterator iter = new java.util.HashSet(domain.getResourceSet().getResources()).iterator(); iter.hasNext();) {
			unloadResource((Resource) iter.next());
		}
		
		subunit1 = null;
		root = null;
		
		if ((project != null) && project.exists()) {
			project.delete(true, true, null);
		}
		
		project = null;
		
		domain = null;
	}

	//
	// Other framework methods
	//
	
	/**
	 * Initializes the test model by loading it and stores certain key
	 * elements in the <tt>root</tt> and <tt>subunit<i>n</i></tt>
	 * variables.
	 */
	protected void initializeTestModel() {
		loadFromTestModel(logres);
		
		root = (Library) find("root"); //$NON-NLS-1$
		subunit1 = (Library) find(root, "level1/level2-subunit"); //$NON-NLS-1$
		subunit2 = (Library) find(subunit1, "level3/level4-subunit"); //$NON-NLS-1$
		subunit3 = (Library) find(root, "level1-1/level2-1-subunit"); //$NON-NLS-1$
	}
	
	/**
	 * Populates the specified resource with data from the test model file.
	 * 
	 * @param res the resource to load
	 */
	protected void loadFromTestModel(ILogicalResource res) {
		URI original = res.getURI();
		
		try {
			res.setURI(URI.createURI(MslCoreTestsBundle.getEntry(
				"/test_models/test_model.extlibrary").toString())); //$NON-NLS-1$
		
			// no special options needed to load the monolithic test model
			res.load(Collections.EMPTY_MAP);
		} catch (IOException e) {
			fail("Failed to load test model: " + e.getLocalizedMessage()); //$NON-NLS-1$
		} finally {
			res.setURI(original);
		}
	}
	
	/**
	 * Unloads the test resource.
	 */
	protected void unloadLogicalResource() {
		unloadLogicalResource(logres);
		
		logres = null;
	}

	/**
	 * Unloads the specified resource.
	 * 
	 * @param res the resource to unload
	 */
	protected void unloadResource(Resource res) {
		if (res != null) {
			if (res.isLoaded()) {
				res.unload();
			}
			
			if (res.getResourceSet() != null) {
				res.getResourceSet().getResources().remove(res);
			}
		}
	}

	/**
	 * Unloads the specified resource.
	 * 
	 * @param res the resource to unload
	 */
	protected void unloadLogicalResource(ILogicalResource res) {
		unloadResource(AbstractResourceWrapper.unwrap(res));
	}

	/**
	 * Creates a new logical resource on the specified path and assigns it
	 * to the <tt>logres</tt> test resource variable.
	 * 
	 * @param path a path relative to the workspace root
	 */
	protected void createLogicalResource(String path) {
		logres = createNewLogicalResource(
			URI.createPlatformResourceURI(path));
	}

	/**
	 * Creates a new logical resource on the specified URI.
	 * 
	 * @param uri the new resource's URI
	 * @return the new resource (not assigned to <tt>logres</tt>)
	 */
	protected ILogicalResource createNewLogicalResource(URI uri) {
		unloadResource(
			MEditingDomain.INSTANCE.getResourceSet().getResource(uri, false));
		
		return domain.asLogicalResource(
			domain.createResource(
				uri.toString(),
				MResourceOption.URI));
	}

	/**
	 * Saves the test resource.  This method stops writing and
	 * resumes again after saving.
	 */
	protected void saveLogicalResource() {
		saveLogicalResource(logres);
	}

	/**
	 * Saves the specified logical resource.  This method stops writing and
	 * resumes again after saving.
	 * 
	 * @param res the resource to save
	 */
	protected void saveLogicalResource(ILogicalResource res) {
		try {
			stopWriting();
			
			res.save(Collections.EMPTY_MAP);
			
			startWriting();
		} catch (IOException e) {
			fail("Exception in saving: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
	}

	/**
	 * Loads the test resource from its workspace location, initially loading
	 * all units.
	 */
	protected void loadLogicalResource() {
		loadLogicalResource(true);
	}

	/**
	 * Loads the test resource.
	 * 
	 * @param loadAllUnits whether to initially load all units.  If
	 *    <code>false</code>, units are not auto-loaded
	 */
	protected void loadLogicalResource(boolean loadAllUnits) {
		loadLogicalResource(logres, loadAllUnits, false);
	}

	/**
	 * Loads the test resource.
	 * 
	 * @param loadAllUnits whether to initially load all units
	 * @param autoLoadUnits if <code>loadAllUnits</code> is <code>false</code>,
	 *     whether to auto-load the units
	 */
	protected void loadLogicalResource(boolean loadAllUnits, boolean autoLoadUnits) {
		loadLogicalResource(logres, loadAllUnits, autoLoadUnits);
	}

	/**
	 * Loads the specified resource from its workspace location, initially loading
	 * all units.
	 * 
	 * @param res the resource to load
	 */
	protected void loadLogicalResource(ILogicalResource res) {
		loadLogicalResource(res, true, false);
	}

	/**
	 * Loads the specified resource.
	 * 
	 * @param res the resource to load
	 * @param loadAllUnits whether to initially load all units
	 * @param autoLoadUnits if <code>loadAllUnits</code> is <code>false</code>,
	 *     whether to auto-load the units
	 */
	protected void loadLogicalResource(ILogicalResource res, boolean loadAllUnits, boolean autoLoadUnits) {
		Map options = new java.util.HashMap();
		
		options.put(ILogicalResource.OPTION_LOAD_ALL_UNITS,
			Boolean.valueOf(loadAllUnits));
		options.put(ILogicalResource.OPTION_AUTO_LOAD_UNITS,
			Boolean.valueOf(autoLoadUnits));
		
		loadLogicalResource(res, options);
	}

	/**
	 * Loads the test resource with options.
	 * 
	 * @param res the resource to load
	 * @param options the load options to apply
	 */
	protected void loadLogicalResource(ILogicalResource res, Map options) {
		try {
			res.load(options);
			
			// verify that none of the physical resources was accidentally
			//    loaded by the resource set containing the logical resource,
			//    if the resource is not a wrapper
			if (!(res instanceof LogicalResourceWrapper)) {
				Set resources = new java.util.HashSet();
				resources.addAll(res.getMappedResources().values());
				assertFalse(resources.removeAll(res.getResourceSet().getResources()));
			}
		} catch (IOException e) {
			fail("Exception in loading: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
	}

	/**
	 * Finds the object in the test model having the specified qualified name.
	 * 
	 * @param qname a slash-delimited qualified name
	 * @return the matching object, or <code>null</code> if not found
	 */
	protected EObject find(String qname) {
		return find(logres, qname);
	}
	
	/**
	 * Finds the object in the test model having the specified qualified name,
	 * starting from some object.
	 * 
	 * @param object the starting object (resource or element)
	 * @param qname a slash-delimited qualified name, relative to the
	 *     provided <code>object</code>
	 * @return the matching object, or <code>null</code> if not found
	 */
	protected EObject find(Object start, String qname) {
		EObject result = null;
		Object current = start;
		
		String[] names = tokenize(qname);
		
		for (int i = 0; (current != null) && (i < names.length); i++) {
			String name = names[i];
			result = null;
			
			for (Iterator iter = getContents(current).iterator(); iter.hasNext();) {
				EObject child = (EObject) iter.next();
				
				if (name.equals(getName(child))) {
					result = child;
					break;
				}
			}
			
			current = result;
		}
		
		return result;
	}

	/**
	 * Gets the contents of an object.
	 * 
	 * @param object an object, which may be a resource or an element
	 * @return its immediate contents (children)
	 */
	private List getContents(Object object) {
		if (object instanceof EObject) {
			return ((EObject) object).eContents();
		} else if (object instanceof Resource) {
			return ((Resource) object).getContents();
		} else {
			return Collections.EMPTY_LIST;
		}
	}
	
	/**
	 * Tokenizes a qualified name on the slashes.
	 * 
	 * @param qname a qualified name
	 * @return the parts between the slashes
	 */
	private String[] tokenize(String qname) {
		return qname.split("/"); //$NON-NLS-1$
	}
	
	/** Looks up a library by its URI fragment. */
	protected Library lookupLibrary(String fragment) {
		return lookupLibrary(logres, fragment);
	}

	/** Looks up a library by its URI fragment. */
	protected Library lookupLibrary(ILogicalResource res, String fragment) {
		return (Library) res.getEObject(fragment);
	}

	/** Looks up a writer by its URI fragment. */
	protected Writer lookupWriter(String fragment) {
		return lookupWriter(logres, fragment);
	}

	/** Looks up a writer by its URI fragment. */
	protected Writer lookupWriter(ILogicalResource res, String fragment) {
		return (Writer) res.getEObject(fragment);
	}

	/** Looks up a book by its URI fragment. */
	protected Book lookupBook(String fragment) {
		return lookupBook(logres, fragment);
	}

	/** Looks up a book by its URI fragment. */
	protected Book lookupBook(ILogicalResource res, String fragment) {
		return (Book) res.getEObject(fragment);
	}

	/**
	 * Opens a write action (if necessary) in an undo interval (if necessary).
	 */
	protected void startWriting() {
		MSLUndoStack stack = ((MSLEditingDomain) domain).getUndoStack();
		
		if (!stack.isUndoIntervalOpen()) {
			stack.openUndoInterval("Test", "Logical Resource Test");  //$NON-NLS-1$//$NON-NLS-2$
		}
		
		if (!stack.isWriteActionInProgress()) {
			stack.startAction(ActionLockMode.WRITE);
		}
	}

	/**
	 * Stops writing, if we were writing.
	 * 
	 * @return the closed undo interval, if any needed to be closed; otherwise
	 *    <code>null</code>
	 */
	protected MUndoInterval stopWriting() {
		MSLUndoStack stack = ((MSLEditingDomain) domain).getUndoStack();
		MUndoInterval result = null;
		
		if (stack.isWriteActionInProgress()) {
			stack.completeAction();
		}
		
		if (stack.isUndoIntervalOpen()) {
			result = stack.closeUndoInterval();
		}
		
		return result;
	}

	/**
	 * Opens a read action (if necessary).
	 */
	protected void startReading() {
		MSLUndoStack stack = ((MSLEditingDomain) domain).getUndoStack();
		stack.startAction(ActionLockMode.READ);
		isReading = true;
	}

	/**
	 * Closes a read action, if one was open.
	 */
	protected void stopReading() {
		MSLUndoStack stack = ((MSLEditingDomain) domain).getUndoStack();
		if (isReading) {
			isReading = false;
			stack.completeAction();
		}
	}
	
	/**
	 * Gets the file corresponding to the specified workspace path.
	 * 
	 * @param path a path relative to the workspace root
	 * @return the corresponding file
	 */
	protected IFile getFile(String path) {
		return getFile(new Path(path));
	}
	
	/**
	 * Gets the file corresponding to the specified workspace path.
	 * 
	 * @param path a path relative to the workspace root
	 * @return the corresponding file
	 */
	protected IFile getFile(IPath path) {
		IWorkspaceRoot wsRoot = (IWorkspaceRoot) project.getParent();
		return wsRoot.getFile(path);
	}
	
	/**
	 * Gets the name of a library object.
	 * 
	 * @param object the object
	 * @return its name
	 */
	private String getName(EObject object) {
		return (String) GetName.INSTANCE.doSwitch(object);
	}
	
	/**
	 * Switch to compute the names of library objects.
	 *
	 * @author Christian W. Damus (cdamus)
	 */
	private static final class GetName extends EXTLibrarySwitch {
		static final GetName INSTANCE = new GetName();
		
		private GetName() {
			super();
		}
		
		public Object caseAudoVisualItem(AudioVisualItem object) {
			return object.getTitle();
		}

		public Object caseBook(Book object) {
			return object.getTitle();
		}

		public Object caseLibrary(Library object) {
			return object.getName();
		}

		public Object casePeriodical(Periodical object) {
			return object.getTitle();
		}
		
		public Object caseWriter(Writer object) {
			return object.getName();
		}

		public Object casePerson(Person object) {
			if (object.getFirstName() == null) {
				if (object.getLastName() == null) {
					return ""; //$NON-NLS-1$
				} else {
					return object.getLastName();
				}
			} else if (object.getLastName() == null) {
				return object.getFirstName();
			} else {
				StringBuffer result = new StringBuffer();

				result.append(object.getFirstName()).append(' ').append(
					object.getLastName());

				return result.toString();
			}
		}

		public Object defaultCase(EObject object) {
			return ""; //$NON-NLS-1$
		}
	}
}




/******************************************************************************
 * Copyright (c) 2005 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.tests.runtime.emf.core.internal.resources;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EFactory;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EcoreFactory;
import org.eclipse.emf.ecore.EcorePackage;

import org.eclipse.gmf.runtime.emf.core.edit.MEditingDomain;
import org.eclipse.gmf.runtime.emf.core.internal.resources.LogicalResourcePolicyManager;
import org.eclipse.gmf.runtime.emf.core.resources.CannotAbsorbException;
import org.eclipse.gmf.runtime.emf.core.resources.CannotSeparateException;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResourcePolicy;
import org.eclipse.gmf.runtime.emf.core.resources.MResourceFactory;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

/**
 * Tests the {@link LogicalResourcePolicyManager} class.
 *
 * @author Christian W. Damus (cdamus)
 */
public class LogicalResourcePolicyManagerTest
	extends TestCase {
	
	private EPackage dynamicPackage;
	private EClass dynamicClass;
	static EAttribute dynamicPoliciesAttribute;
	private EObject dynamicObject;
	private ILogicalResource res;
	
	public static Test suite() {
		return new TestSuite(LogicalResourcePolicyManagerTest.class, "Policy Manager Tests"); //$NON-NLS-1$
	}
	
	public void test_canSeparate() {
		assertTrue(LogicalResourcePolicyManager.getInstance().canSeparate(
			res, dynamicObject));
		checkTokens();
		
		TestPolicy.shouldBalk = true;
		
		assertFalse(LogicalResourcePolicyManager.getInstance().canSeparate(
			res, dynamicObject));
		checkTokens();
	}
	
	public void test_preSeparate() {
		URI uri = null;
		try {
			uri = LogicalResourcePolicyManager.getInstance().preSeparate(
				res, dynamicObject, null);
		} catch (CannotSeparateException e) {
			fail("Should not have thrown: " + e); //$NON-NLS-1$
		}
		checkTokens();
		assertNotNull(uri);
		// check that the first suggestion was accepted
		assertEquals(URI.createFileURI("/tmp/Foo.xmi"), uri); //$NON-NLS-1$
		
		try {
			uri = LogicalResourcePolicyManager.getInstance().preSeparate(
				res, dynamicObject, URI.createFileURI("/tmp/User.xmi")); //$NON-NLS-1$
		} catch (CannotSeparateException e) {
			fail("Should not have thrown: " + e); //$NON-NLS-1$
		}
		checkTokens();
		assertNotNull(uri);
		// check that the no suggestion was accepted
		assertEquals(URI.createFileURI("/tmp/User.xmi"), uri); //$NON-NLS-1$
		
		TestPolicy.shouldBalk = true;
		
		try {
			uri = LogicalResourcePolicyManager.getInstance().preSeparate(
				res, dynamicObject, null);
			fail("Should have thrown exception."); //$NON-NLS-1$
		} catch (CannotSeparateException e) {
			checkTokens();
		}
	}
	
	public void test_postSeparate() {
		LogicalResourcePolicyManager.getInstance().postSeparate(
			res, dynamicObject, URI.createFileURI("/tmp/User.xmi")); //$NON-NLS-1$
		checkTokens();
	}
	
	public void test_preAbsorb() {
		try {
			LogicalResourcePolicyManager.getInstance().preAbsorb(
				res, dynamicObject);
		} catch (CannotAbsorbException e) {
			fail("Should not have thrown: " + e); //$NON-NLS-1$
		}
		checkTokens();
		
		TestPolicy.shouldBalk = true;
		
		try {
			LogicalResourcePolicyManager.getInstance().preAbsorb(
				res, dynamicObject);
			fail("Should have thrown exception."); //$NON-NLS-1$
		} catch (CannotAbsorbException e) {
			checkTokens();
		}
	}
	
	public void test_postAbsorb() {
		LogicalResourcePolicyManager.getInstance().postAbsorb(
			res, dynamicObject);
		checkTokens();
	}
	
	/**
	 * Tests the robustness of the policy manager against run-time exceptions
	 * in the policies.
	 */
	public void test_robustness() {
		TestPolicy.shouldThrow = true;
		
		LogicalResourcePolicyManager.getInstance().canSeparate(res, dynamicObject);
		checkTokens();
		
		try {
			LogicalResourcePolicyManager.getInstance().preSeparate(res, dynamicObject, null);
			checkTokens();
		} catch (CannotSeparateException e) {
			fail("Should not have thrown: " + e); //$NON-NLS-1$
		}
		
		LogicalResourcePolicyManager.getInstance().postSeparate(res, dynamicObject, null);
		checkTokens();
		
		try {
			LogicalResourcePolicyManager.getInstance().preAbsorb(res, dynamicObject);
			checkTokens();
		} catch (CannotAbsorbException e) {
			fail("Should not have thrown: " + e); //$NON-NLS-1$
		}
		
		LogicalResourcePolicyManager.getInstance().postAbsorb(res, dynamicObject);
		checkTokens();
	}
	
	//
	// Fixtures
	//
	
	protected void setUp()
		throws Exception {
		
		super.setUp();
		
		// create the dynamic metamodel and an object
		dynamicPackage = EcoreFactory.eINSTANCE.createEPackage();
		dynamicPackage.setName("logrestest"); //$NON-NLS-1$
		dynamicPackage.setNsPrefix("logrestest"); //$NON-NLS-1$
		dynamicPackage.setNsURI("http:///com/ibm/xtools/emf/msl/core/tests/logrestest.ecore"); //$NON-NLS-1$
		
		EFactory factory = EcoreFactory.eINSTANCE.createEFactory();
		factory.setEPackage(dynamicPackage);
		dynamicPackage.setEFactoryInstance(factory);

		dynamicClass = EcoreFactory.eINSTANCE.createEClass();
		dynamicPackage.getEClassifiers().add(dynamicClass);
		dynamicClass.setName("TestClass"); //$NON-NLS-1$
		
		dynamicPoliciesAttribute = EcoreFactory.eINSTANCE.createEAttribute();
		dynamicClass.getEStructuralFeatures().add(dynamicPoliciesAttribute);
		dynamicPoliciesAttribute.setName("policies"); //$NON-NLS-1$
		dynamicPoliciesAttribute.setUpperBound(EAttribute.UNBOUNDED_MULTIPLICITY);
		dynamicPoliciesAttribute.setEType(EcorePackage.eINSTANCE.getEJavaObject());
		
		dynamicObject = factory.create(dynamicClass);
		
		res = (ILogicalResource) new MResourceFactory().createResource(
			URI.createFileURI("/tmp/logrespolmgrtest.xmi")); //$NON-NLS-1$
		MEditingDomain.INSTANCE.getResourceSet().getResources().add(res);
	}
	
	protected void tearDown()
		throws Exception {
		
		res.unload();
		MEditingDomain.INSTANCE.getResourceSet().getResources().remove(res);
		
		TestPolicy.shouldThrow = false;
		TestPolicy.shouldBalk = false;
		
		dynamicObject = null;
		dynamicPoliciesAttribute = null;
		dynamicClass = null;
		dynamicPackage = null;
		
		super.tearDown();
	}

	/**
	 * Checks that both tokens were added to the dynamic eObject by the test,
	 * then clears them.
	 */
	private void checkTokens() {
		EList value = (EList) dynamicObject.eGet(dynamicPoliciesAttribute);
		
		// check that both tokens were added
		assertEquals(2, value.size());
		
		if (TestPolicy.shouldThrow) {
			assertTrue(value.get(0) instanceof RuntimeException);
			assertTrue(value.get(1) instanceof RuntimeException);
		} else {
			assertTrue(value.get(0) instanceof TestPolicy);
			assertTrue(value.get(1) instanceof TestPolicy);
		}
		
		value.clear();
	}
	
	/**
	 * Test policy implementation.  Two instances are created, 0 and 1.
	 * If the 1 instance is invoked when the <code>shouldBalk</code> flag is
	 * set, then it either returns false or throws an exception, as appropriate
	 * to the method being called.  The 0 instance always behaves nicely.
	 *
	 * @author Christian W. Damus (cdamus)
	 */
	public static class TestPolicy implements ILogicalResourcePolicy {
		static boolean shouldBalk = false;
		static boolean shouldThrow = false;
		
		private static int nextSerialNum = 0;
		
		private final int serialNum;
		
		public TestPolicy() {
			serialNum = nextSerialNum++;
		}
		
		public boolean canSeparate(ILogicalResource resource, EObject eObject) {
			recordToken(eObject);
			
			return serialNum == 0 || !shouldBalk;
		}

		public URI preSeparate(ILogicalResource resource, EObject eObject, URI uri)
			throws CannotSeparateException {
			
			recordToken(eObject);
			
			if (serialNum == 0) {
				return URI.createFileURI("/tmp/Foo.xmi"); //$NON-NLS-1$
			} else {
				if (shouldBalk) {
					throw new CannotSeparateException("I should balk."); //$NON-NLS-1$
				}
				
				return URI.createFileURI("/tmp/Bar.xmi"); //$NON-NLS-1$;
			}
		}

		public void postSeparate(ILogicalResource resource, EObject eObject, URI uri) {
			recordToken(eObject);
		}

		public void preAbsorb(ILogicalResource resource, EObject eObject)
			throws CannotAbsorbException {
			
			recordToken(eObject);
			
			if (serialNum == 1 && shouldBalk) {
				throw new CannotAbsorbException("I should balk."); //$NON-NLS-1$
			}
		}

		public void postAbsorb(ILogicalResource resource, EObject eObject) {
			recordToken(eObject);
		}
		
		private void recordToken(EObject eObject) {
			EList value = (EList) eObject.eGet(dynamicPoliciesAttribute);
			
			if (shouldThrow) {
				RuntimeException e = new RuntimeException(
					"I am supposed to throw."); //$NON-NLS-1$
				
				value.add(e);
				throw e; 
			} else {
				value.add(this);
			}
		}
	}
}




/******************************************************************************
 * Copyright (c) 2005 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.tests.runtime.emf.core.internal.resources;

import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.util.InternalEList;

import org.eclipse.emf.examples.extlibrary.Book;
import org.eclipse.emf.examples.extlibrary.EXTLibraryFactory;
import org.eclipse.emf.examples.extlibrary.EXTLibraryPackage;
import org.eclipse.emf.examples.extlibrary.Library;
import org.eclipse.emf.examples.extlibrary.Writer;
import org.eclipse.gmf.runtime.emf.core.resources.CannotSeparateException;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;


/**
 * Tests the the management of cross-references (between units and logical
 * resources) in a logical resource, as well as the loading of (non-root)
 * sub-units in logical and physical mode.
 *
 * @author Christian W. Damus (cdamus)
 */
public class CrossReferenceTest
	extends BaseLogicalResourceTest {
	
	public CrossReferenceTest(String name) {
		super(name);
	}
	
	public static Test suite() {
		return new TestSuite(CrossReferenceTest.class, "Cross-Reference Tests"); //$NON-NLS-1$
	}

	/**
	 * Tests resolution of cross-unit references on loading.  This case has
	 * a bidirectional reference between unrelated units.
	 */
	public void test_crossUnitReferences_unrelated() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit3, URI.createPlatformResourceURI(SUBUNIT_NAME2));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Book book = (Book) find(subunit1, "Level2 Book"); //$NON-NLS-1$
		String bookFrag = logres.getURIFragment(book);
		
		Writer writer = (Writer) find(subunit3, "Level2-1 Writer"); //$NON-NLS-1$
		writer.getBooks().add(book);  // cross-unit reference
		String writerFrag = logres.getURIFragment(writer);
		
		saveLogicalResource();
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		loadLogicalResource();
		
		book = lookupBook(bookFrag);
		assertNotNull(book);
		
		writer = lookupWriter(writerFrag);
		assertNotNull(writer);
		
		assertTrue(writer.getBooks().contains(book));
		assertSame(writer, book.getAuthor());
	}
	
	/**
	 * Tests resolution of cross-unit references on loading.  This case has
	 * a bidirectional reference between parent and child units.
	 */
	public void test_crossUnitReferences_parentChild() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit2, URI.createPlatformResourceURI(SUBUNIT_NAME2));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Book book = (Book) find(subunit1, "Level2 Book"); //$NON-NLS-1$
		String bookFrag = logres.getURIFragment(book);
		
		Writer writer = (Writer) find(subunit2, "Level4 Writer"); //$NON-NLS-1$
		writer.getBooks().add(book);  // cross-unit reference
		String writerFrag = logres.getURIFragment(writer);
		
		saveLogicalResource();
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		loadLogicalResource();
		
		book = lookupBook(bookFrag);
		assertNotNull(book);
		
		writer = lookupWriter(writerFrag);
		assertNotNull(writer);
		
		assertTrue(writer.getBooks().contains(book));
		assertSame(writer, book.getAuthor());
	}
	
	/**
	 * Tests resolution of cross-unit references on loading.  This case has
	 * a bidirectional reference between the root unit and a child unit.
	 */
	public void test_crossUnitReferences_rootChild() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Book book = (Book) find("root/Root Book"); //$NON-NLS-1$
		String bookFrag = logres.getURIFragment(book);
		
		Writer writer = (Writer) find(subunit1, "Level2 Writer"); //$NON-NLS-1$
		writer.getBooks().add(book);  // cross-unit reference
		String writerFrag = logres.getURIFragment(writer);
		
		saveLogicalResource();
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		loadLogicalResource();
		
		book = lookupBook(bookFrag);
		assertNotNull(book);
		
		writer = lookupWriter(writerFrag);
		assertNotNull(writer);
		
		assertTrue(writer.getBooks().contains(book));
		assertSame(writer, book.getAuthor());
	}
	
	/**
	 * Tests the on-the-fly replacement of the logical resource by its proper
	 * root when loading a non-root unit, loading the units required to trace
	 * containment to the root unit.
	 */
	public void test_loadNonRootUnit() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit2, URI.createPlatformResourceURI(SUBUNIT_NAME2));
			logres.separate(subunit3, URI.createPlatformResourceURI(SUBUNIT_NAME3));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Book bookRoot = (Book) find(root, "Root Book"); //$NON-NLS-1$
		String bookRootFrag = logres.getURIFragment(bookRoot);
		Book book1 = (Book) find(subunit1, "Level2 Book"); //$NON-NLS-1$
		String book1Frag = logres.getURIFragment(book1);
		Book book2 = (Book) find(subunit2, "Level4 Book"); //$NON-NLS-1$
		String book2Frag = logres.getURIFragment(book2);
		Book book3 = (Book) find(subunit3, "Level2-1 Book"); //$NON-NLS-1$
		String book3Frag = logres.getURIFragment(book3);
		
		saveLogicalResource();
		
		URI logicalUri = logres.getURI();
		URI subunitUri = URI.createPlatformResourceURI(SUBUNIT_NAME2);
		
		// discard the logical resource and load the subunit
		unloadLogicalResource();
		createLogicalResource(SUBUNIT_NAME2);
		
		// so, we're trying to load the second-level unit.  We want to
		//   actually load the second-, first-, and root-level units, but not
		//   the other unit that contains book3 (subunit3)
		loadLogicalResource(false);
		
		// the logical resource has assumed the logical URI, despite its having
		//    been created with a subunit's URI
		assertEquals(logicalUri, logres.getURI());
		
		// make sure we didn't get an extra logical resource by this means
		assertNull(domain.getResourceSet().getResource(subunitUri, false));
		
		// make sure that we didn't get too many physical resources, either
		ResourceSet rset = (ResourceSet) logres.getAdapter(ResourceSet.class);
		assertEquals(4, rset.getResources().size());
		
		// make sure that we find the books we expect and not the ones we don't.
		bookRoot = lookupBook(bookRootFrag);
		assertNotNull(bookRoot);
		book1 = lookupBook(book1Frag);
		assertNotNull(book1);
		book2 = lookupBook(book2Frag);
		assertNotNull(book2);
		book3 = lookupBook(book3Frag);
		assertNull(book3);  // didn't load this unit
		
		// Repeat by walking the tree instead of looking by fragment, to check
		// that the content tree is correctly connected
		Set notFound = new java.util.HashSet();
		notFound.add(bookRootFrag);
		notFound.add(book1Frag);
		notFound.add(book2Frag);
		notFound.add(book3Frag);
		
		for (Iterator iter = logres.getAllContents(); iter.hasNext();) {
			notFound.remove(logres.getURIFragment((EObject) iter.next()));
		}
		
		assertEquals(Collections.singleton(book3Frag), notFound);  // didn't load this unit
	}
	
	/**
	 * Tests the on-the-fly replacement of the logical resource by its proper
	 * root when loading a non-root unit storing a logical root.
	 */
	public void test_loadNonRootUnit_logicalRoot() {
		logres.getContents().add(subunit3);  // create another root
		
		try {
			// separating a root element
			logres.separate(subunit3, URI.createPlatformResourceURI(SUBUNIT_NAME3));
			
			// just for fun, separate another root's descendent into same unit
			logres.separate(subunit2, URI.createPlatformResourceURI(SUBUNIT_NAME3));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Book bookRoot = (Book) find(root, "Root Book"); //$NON-NLS-1$
		String bookRootFrag = logres.getURIFragment(bookRoot);
		Book book1 = (Book) find(subunit1, "Level2 Book"); //$NON-NLS-1$
		String book1Frag = logres.getURIFragment(book1);
		Book book2 = (Book) find(subunit2, "Level4 Book"); //$NON-NLS-1$
		String book2Frag = logres.getURIFragment(book2);
		Book book3 = (Book) find(subunit3, "Level2-1 Book"); //$NON-NLS-1$
		String book3Frag = logres.getURIFragment(book3);
		
		saveLogicalResource();
		
		URI logicalUri = logres.getURI();
		URI subunitUri = URI.createPlatformResourceURI(SUBUNIT_NAME3);
		
		// discard the logical resource and load the subunit
		unloadLogicalResource();
		createLogicalResource(SUBUNIT_NAME3);
		
		// so, we're trying to load the second-level unit with the logical root
		loadLogicalResource();
		
		// the logical resource has assumed the logical URI, despite its having
		//    been created with a subunit's URI
		assertEquals(logicalUri, logres.getURI());
		
		// make sure we didn't get an extra logical resource by this means
		assertNull(domain.getResourceSet().getResource(subunitUri, false));
		
		// make sure that we didn't get too many physical resources, either
		ResourceSet rset = (ResourceSet) logres.getAdapter(ResourceSet.class);
		assertEquals(2, rset.getResources().size());
		assertEquals(3, logres.getMappedResources().size());
		
		// make sure that we find the books we expect
		bookRoot = lookupBook(bookRootFrag);
		assertNotNull(bookRoot);
		book1 = lookupBook(book1Frag);
		assertNotNull(book1);
		book2 = lookupBook(book2Frag);
		assertNotNull(book2);
		book3 = lookupBook(book3Frag);
		assertNotNull(book3);
		
		// Repeat by walking the tree instead of looking by fragment, to check
		// that the content tree is correctly connected
		Set notFound = new java.util.HashSet();
		notFound.add(bookRootFrag);
		notFound.add(book1Frag);
		notFound.add(book2Frag);
		notFound.add(book3Frag);
		
		for (Iterator iter = logres.getAllContents(); iter.hasNext();) {
			notFound.remove(logres.getURIFragment((EObject) iter.next()));
		}
		
		assertEquals(Collections.EMPTY_SET, notFound);
	}
	
	/**
	 * Tests the case where the sub-unit that we are trying to load has
	 * multiple parent units.  Both parents must be loaded, recursively.
	 */
	public void test_loadNonRootUnit_multiParents() {
		Library subunit4 = EXTLibraryFactory.eINSTANCE.createLibrary();
		subunit3.getBranches().add(subunit4);
		subunit4.setName("level 3-1-Subunit"); //$NON-NLS-1$
		Book book4 = EXTLibraryFactory.eINSTANCE.createBook();
		subunit4.getBooks().add(book4);
		book4.setTitle("Level3-1 Book"); //$NON-NLS-1$
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit2, URI.createPlatformResourceURI(SUBUNIT_NAME2));
			logres.separate(subunit3, URI.createPlatformResourceURI(SUBUNIT_NAME3));
			
			// another 2nd-level sub-unit into the same file as subunit2, with
			// a different parent unit
			logres.separate(subunit4, URI.createPlatformResourceURI(SUBUNIT_NAME2));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Book bookRoot = (Book) find(root, "Root Book"); //$NON-NLS-1$
		String bookRootFrag = logres.getURIFragment(bookRoot);
		Book book1 = (Book) find(subunit1, "Level2 Book"); //$NON-NLS-1$
		String book1Frag = logres.getURIFragment(book1);
		Book book2 = (Book) find(subunit2, "Level4 Book"); //$NON-NLS-1$
		String book2Frag = logres.getURIFragment(book2);
		Book book3 = (Book) find(subunit3, "Level2-1 Book"); //$NON-NLS-1$
		String book3Frag = logres.getURIFragment(book3);
		String book4Frag = logres.getURIFragment(book4);
		
		saveLogicalResource();
		
		URI logicalUri = logres.getURI();
		URI subunitUri = URI.createPlatformResourceURI(SUBUNIT_NAME2);
		
		// discard the logical resource and load the subunit
		unloadLogicalResource();
		createLogicalResource(SUBUNIT_NAME2);
		
		// so, we're trying to load the second-level unit.  We want to
		//   actually load the second-, first-, and root-level units, and this
		//   time also the other unit that contains book3 (subunit3)
		loadLogicalResource(false);
		
		// the logical resource has assumed the logical URI, despite its having
		//    been created with a subunit's URI
		assertEquals(logicalUri, logres.getURI());
		
		// make sure we didn't get an extra logical resource by this means
		assertNull(domain.getResourceSet().getResource(subunitUri, false));
		
		// make sure that we didn't get too many physical resources, either
		ResourceSet rset = (ResourceSet) logres.getAdapter(ResourceSet.class);
		assertEquals(4, rset.getResources().size());
		
		// make sure that we find the books we expect
		bookRoot = lookupBook(bookRootFrag);
		assertNotNull(bookRoot);
		book1 = lookupBook(book1Frag);
		assertNotNull(book1);
		book2 = lookupBook(book2Frag);
		assertNotNull(book2);
		book3 = lookupBook(book3Frag);
		assertNotNull(book3);  // did load this unit this time
		book4 = lookupBook(book4Frag);
		assertNotNull(book4);
		
		// Repeat by walking the tree instead of looking by fragment, to check
		// that the content tree is correctly connected
		Set notFound = new java.util.HashSet();
		notFound.add(bookRoot);
		notFound.add(book1);
		notFound.add(book2);
		notFound.add(book3);
		notFound.add(book4);
		
		for (Iterator iter = logres.getAllContents(); iter.hasNext();) {
			notFound.remove(iter.next());
		}
		
		assertEquals(Collections.EMPTY_SET, notFound);  // did load book3 this time
	}
	
	/**
	 * Tests the support for loading only a single physical resource.
	 */
	public void test_loadAsPhysical() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit2, URI.createPlatformResourceURI(SUBUNIT_NAME2));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Book bookRoot = (Book) find(root, "Root Book"); //$NON-NLS-1$
		String bookRootFrag = logres.getURIFragment(bookRoot);
		Book book1 = (Book) find(subunit1, "Level2 Book"); //$NON-NLS-1$
		String book1Frag = logres.getURIFragment(book1);
		Book book2 = (Book) find(subunit2, "Level4 Book"); //$NON-NLS-1$
		String book2Frag = logres.getURIFragment(book2);
		
		saveLogicalResource();
		
		URI logicalUri = logres.getURI();
		URI subunitUri = URI.createPlatformResourceURI(SUBUNIT_NAME1);
		
		// discard the logical resource and load the subunit
		unloadLogicalResource();
		createLogicalResource(SUBUNIT_NAME1);
		
		// we're trying to load the middle-level unit, and only it
		Map options = new java.util.HashMap();
		options.put(ILogicalResource.OPTION_LOAD_AS_LOGICAL, Boolean.FALSE);
		loadLogicalResource(logres, options);
		
		// the logical resource has not assumed the logical URI, despite its having
		//    been created with a subunit's URI
		assertEquals(subunitUri, logres.getURI());
		
		// make sure we didn't get an extra logical resource by this means
		assertNull(domain.getResourceSet().getResource(logicalUri, false));
		
		// make sure that we didn't get too many physical resources, either
		ResourceSet rset = (ResourceSet) logres.getAdapter(ResourceSet.class);
		assertEquals(2, rset.getResources().size());  // the resource and its sub-unit
		
		// make sure that we find the books we expect, and not the ones we don't
		bookRoot = lookupBook(bookRootFrag);
		assertNull(bookRoot);
		book1 = lookupBook(book1Frag);
		assertNotNull(book1);
		book2 = lookupBook(book2Frag);
		assertNull(book2);
		
		// check that the resource has the expected contents list
		assertEquals(
			Collections.singletonList(book1.eContainer()),
			logres.getContents());
	}
	
	/**
	 * Tests the support for saving a resource loaded as a single physical
	 * resource.
	 */
	public void test_savePhysical() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit2, URI.createPlatformResourceURI(SUBUNIT_NAME2));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Book bookRoot = (Book) find(root, "Root Book"); //$NON-NLS-1$
		String bookRootFrag = logres.getURIFragment(bookRoot);
		Book book1 = (Book) find(subunit1, "Level2 Book"); //$NON-NLS-1$
		String book1Frag = logres.getURIFragment(book1);
		Book book2 = (Book) find(subunit2, "Level4 Book"); //$NON-NLS-1$
		String book2Frag = logres.getURIFragment(book2);
		
		saveLogicalResource();
		
		// discard the logical resource and load the subunit
		unloadLogicalResource();
		createLogicalResource(SUBUNIT_NAME1);
		
		// we're trying to load the middle-level unit, and only it
		Map options = new java.util.HashMap();
		options.put(ILogicalResource.OPTION_LOAD_AS_LOGICAL, Boolean.FALSE);
		loadLogicalResource(logres, options);
		
		// get the book and change its title
		book1 = lookupBook(book1Frag);
		assertNotNull(book1);
		String newTitle = "New Title"; //$NON-NLS-1$
		book1.setTitle(newTitle);
		
		saveLogicalResource();
		
		// discard the logical resource and load the whole logical resource
		unloadLogicalResource();
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		
		// make sure that we find the books we expect with the right containment
		bookRoot = lookupBook(bookRootFrag);
		assertNotNull(bookRoot);
		book1 = lookupBook(book1Frag);
		assertNotNull(book1);
		book2 = lookupBook(book2Frag);
		assertNotNull(book2);
		
		assertTrue(EcoreUtil.isAncestor(logres.getContents(), book1));

		// check the title
		assertEquals(newTitle, book1.getTitle());
	}
	
	/**
	 * Tests that we can correctly resolve references between logical models.
	 */
	public void test_interLogicalModelReference() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		ILogicalResource logres2 = createNewLogicalResource(
			URI.createPlatformResourceURI(RESOURCE_NAME2));
		Library library2 = EXTLibraryFactory.eINSTANCE.createLibrary();
		logres2.getContents().add(library2);
		library2.setName("Library 2"); //$NON-NLS-1$
		
		subunit3 = EXTLibraryFactory.eINSTANCE.createLibrary();
		library2.getBranches().add(subunit3);
		subunit3.setName("Library 2 Subunit"); //$NON-NLS-1$
		
		String library2SubunitName = "/" + PROJECT_NAME + "/logres2.1.extlibrary"; //$NON-NLS-1$//$NON-NLS-2$
		try {
			logres2.separate(subunit3, URI.createPlatformResourceURI(library2SubunitName));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
			
		Book book = (Book) find(subunit1, "Level2 Book"); //$NON-NLS-1$
		String bookFrag = logres.getURIFragment(book);
		
		Writer writer = EXTLibraryFactory.eINSTANCE.createWriter();
		subunit3.getWriters().add(writer);
		writer.setName("Level2 Writer"); //$NON-NLS-1$
		writer.getBooks().add(book);  // cross-resource reference
		String writerFrag = logres2.getURIFragment(writer);
		
		saveLogicalResource();
		saveLogicalResource(logres2);
		
		// discard and re-load the resources
		createLogicalResource(RESOURCE_NAME);
		logres2 = createNewLogicalResource(
			URI.createPlatformResourceURI(RESOURCE_NAME2));
		
		loadLogicalResource();
		loadLogicalResource(logres2);
		
		book = lookupBook(bookFrag);
		assertNotNull(book);
		
		writer = lookupWriter(logres2, writerFrag);
		assertNotNull(writer);
		
		// first, test the proxies without resolving them
		EObject proxy = (EObject) ((InternalEList) writer.getBooks()).basicGet(0);
		assertTrue(proxy.eIsProxy());
		assertEquals(logres.getURI(), EcoreUtil.getURI(proxy).trimFragment());
		
		proxy = (EObject) book.eGet(EXTLibraryPackage.eINSTANCE.getBook_Author(), false);
		// cannot assertTrue(proxy.eIsProxy()) because MSL's indexer resolves it
		assertEquals(logres2.getURI(), EcoreUtil.getURI(proxy).trimFragment());
		
		// these method invocations will cause proxy resolution
		assertTrue(writer.getBooks().contains(book));
		assertSame(writer, book.getAuthor());
	}
}




/******************************************************************************
 * Copyright (c) 2005 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.tests.runtime.emf.core.internal.resources;

import java.io.IOException;
import java.util.List;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.Path;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.util.InternalEList;

import org.eclipse.emf.examples.extlibrary.Book;
import org.eclipse.emf.examples.extlibrary.EXTLibraryFactory;
import org.eclipse.emf.examples.extlibrary.EXTLibraryPackage;
import org.eclipse.emf.examples.extlibrary.Library;
import org.eclipse.emf.examples.extlibrary.Writer;
import org.eclipse.gmf.runtime.emf.core.EventTypes;
import org.eclipse.gmf.runtime.emf.core.edit.DemuxedMListener;
import org.eclipse.gmf.runtime.emf.core.edit.MFilter;
import org.eclipse.gmf.runtime.emf.core.internal.exceptions.MSLActionProtocolException;
import org.eclipse.gmf.runtime.emf.core.internal.resources.LogicalResourceUtil;
import org.eclipse.gmf.runtime.emf.core.resources.CannotSeparateException;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;


/**
 * Tests the incremental loading support in the logical resource implementation
 * (both automatic and not).
 *
 * @author Christian W. Damus (cdamus)
 */
public class IncrementalLoadingTest
	extends BaseLogicalResourceTest {
	
	public IncrementalLoadingTest(String name) {
		super(name);
	}
	
	public static Test suite() {
		return new TestSuite(IncrementalLoadingTest.class, "Incremental Loading Tests"); //$NON-NLS-1$
	}
	
	/**
	 * Tests incremental loading of a logical resource, where there are
	 * references between the sub-units.
	 */
	public void test_incrementalLoading() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit3, URI.createPlatformResourceURI(SUBUNIT_NAME2));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit3Frag = logres.getURIFragment(subunit3);
		
		Book book = EXTLibraryFactory.eINSTANCE.createBook();
		subunit1.getBooks().add(book);
		book.setTitle("Book"); //$NON-NLS-1$
		String bookFrag = logres.getURIFragment(book);
		
		Writer writer = EXTLibraryFactory.eINSTANCE.createWriter();
		subunit3.getWriters().add(writer);
		writer.setName("Sherlock Holmes"); //$NON-NLS-1$
		writer.getBooks().add(book);  // cross-unit reference
		String writerFrag = logres.getURIFragment(writer);
		
		saveLogicalResource();
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		loadLogicalResource(false); // don't load sub-units, yet
		
		// check that the subunits are unloaded
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		assertFalse(subunit1.eIsProxy());
		assertFalse(logres.isLoaded(subunit1));
		
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);
		assertFalse(subunit3.eIsProxy());
		assertFalse(logres.isLoaded(subunit3));
		
		// check that the book and writer don't exist
		book = lookupBook(bookFrag);
		assertNull(book);
		
		writer = lookupWriter(writerFrag);
		assertNull(writer);
		
		// check that we can load subunit1 and its contents (incl. the book)
		try {
			logres.load(subunit1);
		} catch (IOException e) {
			fail("Should not fail to load sub-unit: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
		assertTrue(logres.isLoaded(subunit1));
		book = lookupBook(bookFrag);
		assertNotNull(book);
		
		// the author reference (intra-logical-resource) must not have been
		//   discarded on loading, and must be unresolved
		assertNotNull(book.getAuthor());
		assertTrue(book.getAuthor().eIsProxy());
		
		// check that we can load subunit3 and its contents (incl. the writer)
		try {
			logres.load(subunit3);
		} catch (IOException e) {
			fail("Should not fail to load sub-unit: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
		assertTrue(logres.isLoaded(subunit3));
		writer = lookupWriter(writerFrag);
		assertNotNull(writer);
		
		// now the references resolve
		assertTrue(writer.getBooks().contains(book));
		assertSame(writer, book.getAuthor());
	}
	
	/**
	 * Tests that we can incrementally load logical resources where other
	 * logical resources have references to the as-yet-unloaded units.
	 */
	public void test_incrementalLoadingWithCrossModelRefs() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		String library2Name = "/" + PROJECT_NAME + "/logres2.extlibrary"; //$NON-NLS-1$//$NON-NLS-2$
		ILogicalResource logres2 = createNewLogicalResource(
			URI.createPlatformResourceURI(library2Name));
		Library library2 = EXTLibraryFactory.eINSTANCE.createLibrary();
		logres2.getContents().add(library2);
		library2.setName("Library 2"); //$NON-NLS-1$
		
		subunit3 = EXTLibraryFactory.eINSTANCE.createLibrary();
		library2.getBranches().add(subunit3);
		subunit3.setName("Library 2 Subunit"); //$NON-NLS-1$
		
		String library2SubunitName = "/" + PROJECT_NAME + "/logres2.1.extlibrary"; //$NON-NLS-1$//$NON-NLS-2$
		try {
			logres2.separate(subunit3, URI.createPlatformResourceURI(library2SubunitName));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
			
		Book book = EXTLibraryFactory.eINSTANCE.createBook();
		subunit1.getBooks().add(book);
		book.setTitle("Book"); //$NON-NLS-1$
		String bookFrag = logres.getURIFragment(book);
		
		Writer writer = EXTLibraryFactory.eINSTANCE.createWriter();
		subunit3.getWriters().add(writer);
		writer.setName("Sherlock Holmes"); //$NON-NLS-1$
		writer.getBooks().add(book);  // cross-unit reference
		String writerFrag = logres.getURIFragment(writer);
		
		saveLogicalResource();
		saveLogicalResource(logres2);
		
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit3Frag = logres.getURIFragment(subunit3);
		
		// discard and re-load the resources
		createLogicalResource(RESOURCE_NAME);
		logres2 = createNewLogicalResource(
			URI.createPlatformResourceURI(library2Name));
		
		loadLogicalResource(false);
		loadLogicalResource(logres2, false, false);
				
		// check that the subunits are unloaded
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		assertFalse(subunit1.eIsProxy());
		assertFalse(logres.isLoaded(subunit1));
		
		subunit3 = lookupLibrary(logres2, subunit3Frag);
		assertNotNull(subunit3);
		assertFalse(subunit3.eIsProxy());
		assertFalse(logres2.isLoaded(subunit3));
		
		// check that the book and writer don't exist
		book = lookupBook(bookFrag);
		assertNull(book);
		
		writer = lookupWriter(logres2, writerFrag);
		assertNull(writer);
		
		// check that we can load subunit1 and its contents (incl. the book)
		try {
			logres.load(subunit1);
		} catch (IOException e) {
			fail("Should not fail to load sub-unit: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
		assertTrue(logres.isLoaded(subunit1));
		book = lookupBook(bookFrag);
		assertNotNull(book);
		
		// the author reference (intra-logical-resource) must not have been
		//   discarded on loading, and must be unresolved
		assertNotNull(book.getAuthor());
		assertTrue(book.getAuthor().eIsProxy());
		
		// check that we can load subunit3 and its contents (incl. the writer)
		try {
			logres2.load(subunit3);
		} catch (IOException e) {
			fail("Should not fail to load sub-unit: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
		assertTrue(logres2.isLoaded(subunit3));
		writer = lookupWriter(logres2, writerFrag);
		assertNotNull(writer);
		
		// now the references resolve
		assertTrue(writer.getBooks().contains(book));
		assertSame(writer, book.getAuthor());
	}
	
	/**
	 * Tests the notification of incremental load events, EMF style.
	 */
	public void test_incrementalLoading_basicEventing() {
		class TestAdapter extends AdapterImpl {
			List notifications = new java.util.ArrayList();
			
			public void notifyChanged(Notification msg) {
				notifications.add(msg);
			}
		}
		
		TestAdapter adapter = new TestAdapter();
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit3, URI.createPlatformResourceURI(SUBUNIT_NAME2));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit3Frag = logres.getURIFragment(subunit3);
		
		saveLogicalResource();
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		loadLogicalResource(false); // don't load sub-units, yet
		
		root = (Library) logres.getContents().get(0);
		
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);
		
		// listen for notifications of loading on the parent element
		Library parent = subunit1.getParentBranch();
		assertNotNull(parent);
		parent.eAdapters().add(adapter);

		try {
			logres.load(subunit1);
		} catch (IOException e) {
			fail("Should not fail to load unit: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
		
		assertEquals(1, adapter.notifications.size());
		Notification event = (Notification) adapter.notifications.get(0);
		adapter.notifications.clear();
		
		assertSame(parent, event.getNotifier());
		assertEquals(EventTypes.LOAD, event.getEventType());
		assertSame(EXTLibraryPackage.eINSTANCE.getLibrary_Branches(), event.getFeature());
		assertSame(subunit1, parent.getBranches().get(event.getPosition()));
		
		// listen for notifications of loading on the parent element
		parent = subunit3.getParentBranch();
		assertNotNull(parent);
		parent.eAdapters().add(adapter);

		try {
			logres.load(subunit3);
		} catch (IOException e) {
			fail("Should not fail to load unit: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
		
		assertEquals(1, adapter.notifications.size());
		event = (Notification) adapter.notifications.get(0);
		adapter.notifications.clear();
		
		assertSame(parent, event.getNotifier());
		assertEquals(EventTypes.LOAD, event.getEventType());
		assertSame(EXTLibraryPackage.eINSTANCE.getLibrary_Branches(), event.getFeature());
		assertSame(subunit3, parent.getBranches().get(event.getPosition()));
	}
	
	/**
	 * Tests the notification of incremental load events, MSL style.
	 */
	public void test_incrementalLoading_mslEventing() {
		class TestListener extends DemuxedMListener {
			Notification event;
			ILogicalResource res;
			EObject element;
			
			TestListener() {
				super(domain);
			}
			
			public MFilter getFilter() {
				return MFilter.ELEMENT_LOADED_FILTER;
			}
			
			public void handleElementLoadedEvent(
					Notification notification, ILogicalResource resource,
					EObject eObject) {
				event = notification;
				res = resource;
				element = eObject;
			}
		}
		
		TestListener listener = new TestListener();
		listener.startListening();
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit3, URI.createPlatformResourceURI(SUBUNIT_NAME2));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit3Frag = logres.getURIFragment(subunit3);
		
		saveLogicalResource();
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		loadLogicalResource(false); // don't load sub-units, yet
		
		root = (Library) logres.getContents().get(0);
		
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);

		try {
			logres.load(subunit1);
		} catch (IOException e) {
			fail("Should not fail to load unit: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
		
		// must complete the write action in order for events to fire
		stopWriting();
		
		assertSame(subunit1, listener.element);
		assertEquals(EventTypes.LOAD, listener.event.getEventType());
		assertSame(logres, listener.res);
		
		startWriting();
		
		try {
			logres.load(subunit3);
		} catch (IOException e) {
			fail("Should not fail to load unit: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
		
		// must complete the write action in order for events to fire
		stopWriting();
		
		assertSame(subunit3, listener.element);
		assertEquals(EventTypes.LOAD, listener.event.getEventType());
		assertSame(logres, listener.res);
	}
	
	/**
	 * Tests that we do not need a write operation to incrementally load a
	 * model that we are reading; a read operation is OK.
	 */
	public void test_incrementalLoading_readAction() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit3, URI.createPlatformResourceURI(SUBUNIT_NAME2));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit3Frag = logres.getURIFragment(subunit3);
		
		Book book = EXTLibraryFactory.eINSTANCE.createBook();
		subunit1.getBooks().add(book);
		book.setTitle("Book"); //$NON-NLS-1$
		String bookFrag = logres.getURIFragment(book);
		
		Writer writer = EXTLibraryFactory.eINSTANCE.createWriter();
		subunit3.getWriters().add(writer);
		writer.setName("Sherlock Holmes"); //$NON-NLS-1$
		writer.getBooks().add(book);  // cross-unit reference
		String writerFrag = logres.getURIFragment(writer);
		
		saveLogicalResource();
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		loadLogicalResource(false);
		
		// go into read-only mode
		stopWriting();
		startReading();
		
		// get the sub-units again
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);
		
		// check that the book and writer don't exist
		book = lookupBook(bookFrag);
		assertNull(book);
		
		writer = lookupWriter(writerFrag);
		assertNull(writer);
		
		// check that we can load subunit1 and its contents (incl. the book)
		try {
			logres.load(subunit1);
		} catch (IOException e) {
			fail("Should not fail to load sub-unit: " + e.getLocalizedMessage()); //$NON-NLS-1$
		} catch (MSLActionProtocolException e) {
			fail("Should have been able to load in a read action: " + e); //$NON-NLS-1$
		}
		assertTrue(logres.isLoaded(subunit1));
		book = lookupBook(bookFrag);
		assertNotNull(book);
		
		// check that we can load subunit3 and its contents (incl. the writer)
		try {
			logres.load(subunit3);
		} catch (IOException e) {
			fail("Should not fail to load sub-unit: " + e.getLocalizedMessage()); //$NON-NLS-1$
		} catch (MSLActionProtocolException e) {
			fail("Should have been able to load in a read action: " + e); //$NON-NLS-1$
		}
		assertTrue(logres.isLoaded(subunit3));
		writer = lookupWriter(writerFrag);
		assertNotNull(writer);
		
		// now the references resolve
		assertTrue(writer.getBooks().contains(book));
		assertSame(writer, book.getAuthor());
	}
	
	/**
	 * Tests the utility method that loads all unloaded units of a resource.
	 */
	public void test_loadAllUnloadedUnits() {
		String rootFrag = logres.getURIFragment(root);
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit2Frag = logres.getURIFragment(subunit2);
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit2, URI.createPlatformResourceURI(SUBUNIT_NAME2));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		assertTrue(logres.isModified());
		
		saveLogicalResource();
		
		assertFalse(logres.isModified());
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		loadLogicalResource(false);  // don't load any sub-units
		
		assertFalse(logres.isModified());
		
		// only the root is loaded
		Map resources = logres.getMappedResources();
		assertEquals(2, resources.size());
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		assertFalse(logres.isLoaded(subunit1));
		subunit2 = lookupLibrary(subunit2Frag);
		assertNull(subunit2);
		
		try {
			LogicalResourceUtil.loadAllUnloadedUnits(logres);
		} catch (IOException e) {
			fail("Should not fail to load all unloaded units: " + e); //$NON-NLS-1$
		}
		
		// all units are now loaded
		assertEquals(3, resources.size());
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		assertTrue(logres.isLoaded(subunit1));
		subunit2 = lookupLibrary(subunit2Frag);
		assertNotNull(subunit2);
		assertTrue(logres.isLoaded(subunit2));

		// verify the model structure just to be sure
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		assertTrue(EcoreUtil.isAncestor(root, subunit2));
		assertTrue(EcoreUtil.isAncestor(subunit1, subunit2));
	}
	
	/**
	 * Tests automatic loading by walking the containment tree.
	 */
	public void test_autoLoading() {
		String rootFrag = logres.getURIFragment(root);
		String subunit1ParentFrag = logres.getURIFragment(subunit1.eContainer());
		String subunit2ParentFrag = logres.getURIFragment(subunit2.eContainer());
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit2, URI.createPlatformResourceURI(SUBUNIT_NAME2));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		assertTrue(logres.isModified());
		
		saveLogicalResource();
		
		assertFalse(logres.isModified());
		
		IFile subunitFile = project.getParent().getFile(new Path(SUBUNIT_NAME1));
		assertNotNull(subunitFile);
		assertTrue(subunitFile.exists());
		
		subunitFile = project.getParent().getFile(new Path(SUBUNIT_NAME2));
		assertNotNull(subunitFile);
		assertTrue(subunitFile.exists());
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		// do not load all sub-units, but load them automatically as needed
		loadLogicalResource(false, true);
		
		assertFalse(logres.isModified());
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		
		Library subunit1Parent = lookupLibrary(subunit1ParentFrag);
		assertNotNull(subunit1Parent); // this one should exist
		Library subunit2Parent = lookupLibrary(subunit2ParentFrag);
		assertNull(subunit2Parent);  // shouldn't exist, yet
		
		// use internal list capabilities for non-resolving/non-loading access
		InternalEList branches = (InternalEList) subunit1Parent.getBranches();
		assertEquals(1, branches.size());
		subunit1 = (Library) branches.basicGet(0);
		assertNotNull(subunit1);
		assertFalse(logres.isLoaded(subunit1));
		
		// loading access (branches.get(0) would work just as well)
		subunit1 = (Library) branches.iterator().next();
		assertNotNull(subunit1);
		assertTrue(logres.isLoaded(subunit1));
		
		subunit2Parent = lookupLibrary(subunit2ParentFrag);
		assertNotNull(subunit2Parent);  // now it should exist
		
		// use internal list capabilities for non-resolving/non-loading access
		branches = (InternalEList) subunit2Parent.getBranches();
		assertEquals(1, branches.size());
		subunit2 = (Library) branches.basicGet(0);
		assertNotNull(subunit2);
		assertFalse(logres.isLoaded(subunit2));
		
		// loading access (branches.iterator().next() would work just as well)
		subunit2 = (Library) branches.get(0);
		assertNotNull(subunit2);
		assertTrue(logres.isLoaded(subunit2));
	}
	
	/**
	 * Tests that loading a resource to load one of its roots also loads
	 * other unloaded elements from its other roots.
	 */
	public void test_loadingMultiRootedUnit() {
		String rootFrag = logres.getURIFragment(root);
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit3Frag = logres.getURIFragment(subunit3);
		
		try {
			// separate these two elements into the same resource
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit3, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		// do not load all sub-units
		loadLogicalResource(false);
		
		assertFalse(logres.isModified());
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);

		// not loaded, yet
		assertFalse(logres.isLoaded(subunit1));
		assertFalse(logres.isLoaded(subunit3));
		
		// load one of them
		try {
			logres.load(subunit3);
		} catch (IOException e) {
			fail("Should not fail to load unit: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
		assertTrue(logres.isLoaded(subunit3));
		
		// check that subunit1 was also loaded
		assertTrue(logres.isLoaded(subunit1));
		
		// check some contents
		assertTrue(!subunit1.eContents().isEmpty());
	}
	
	/**
	 * Tests that loading a resource to auto-load one of its roots also loads
	 * other unloaded elements from its other roots.
	 */
	public void test_autoLoadingMultiRootedUnit() {
		String rootFrag = logres.getURIFragment(root);
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit3Frag = logres.getURIFragment(subunit3);
		
		try {
			// separate these two elements into the same resource
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit3, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		// do not load all sub-units, but let them load automatically
		loadLogicalResource(false, true);
		
		assertFalse(logres.isModified());
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);

		// not loaded, yet
		assertFalse(logres.isLoaded(subunit1));
		assertFalse(logres.isLoaded(subunit3));
		
		// load one of them automatically
		assertSame(subunit3, ((Library) root.getBranches().get(1)).getBranches().get(0));
		assertTrue(logres.isLoaded(subunit3));
		
		// check that subunit1 was also loaded
		assertTrue(logres.isLoaded(subunit1));
		
		// check some contents
		assertTrue(!subunit1.eContents().isEmpty());
	}
	
	/**
	 * Tests that separating an element into a sub-unit that already exists but
	 * is not yet loaded, will first load and resolve its roots.
	 */
	public void test_separatingIntoUnloadedUnit() {
		String rootFrag = logres.getURIFragment(root);
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit3Frag = logres.getURIFragment(subunit3);
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		// do not load all sub-units
		loadLogicalResource(false);
		
		assertFalse(logres.isModified());
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);

		assertFalse(logres.isLoaded(subunit1));
		assertTrue(logres.isLoaded(subunit3));
		
		try {
			// separate into the same resource (not previously loaded)
			logres.separate(subunit3, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		// now subunit1 is loaded
		assertTrue(logres.isLoaded(subunit1));
		assertTrue(logres.isLoaded(subunit3)); // still loaded
		
		// check some contents
		assertTrue(!subunit1.eContents().isEmpty());
	}
	
	/**
	 * Tests that incremental loading does not apply to the logical roots;
	 * they are always loaded.
	 */
	public void test_logicalRoots() {
		// create another couple of roots
		logres.getContents().add(subunit1);
		logres.getContents().add(subunit3);
		
		try {
			logres.separate(root, URI.createPlatformResourceURI(SUBUNIT_NAME2));
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit3, URI.createPlatformResourceURI(SUBUNIT_NAME3));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		String rootFrag = logres.getURIFragment(root);
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit3Frag = logres.getURIFragment(subunit3);
		
		Book book = EXTLibraryFactory.eINSTANCE.createBook();
		subunit1.getBooks().add(book);
		book.setTitle("Book"); //$NON-NLS-1$
		String bookFrag = logres.getURIFragment(book);
		
		Writer writer = EXTLibraryFactory.eINSTANCE.createWriter();
		subunit3.getWriters().add(writer);
		writer.setName("Sherlock Holmes"); //$NON-NLS-1$
		writer.getBooks().add(book);  // cross-unit reference
		String writerFrag = logres.getURIFragment(writer);
		
		saveLogicalResource();
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		// don't load sub-units, yet (except, we have to load the roots)
		loadLogicalResource(false);
		
		// check that the subunits are loaded
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		assertFalse(root.eIsProxy());
		assertTrue(logres.isLoaded(root));
		
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		assertFalse(subunit1.eIsProxy());
		assertTrue(logres.isLoaded(subunit1));
		
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);
		assertFalse(subunit3.eIsProxy());
		assertTrue(logres.isLoaded(subunit3));
		
		// check books and cross-refs
		
		book = lookupBook(bookFrag);
		assertNotNull(book);
		writer = lookupWriter(writerFrag);
		assertNotNull(book);
		assertSame(writer, book.getAuthor());
	}
}




/******************************************************************************
 * Copyright (c) 2005 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.tests.runtime.emf.core.internal.resources;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EFactory;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EcoreFactory;
import org.eclipse.emf.ecore.resource.impl.ResourceImpl;

import org.eclipse.emf.examples.extlibrary.EXTLibraryFactory;
import org.eclipse.emf.examples.extlibrary.Library;
import org.eclipse.gmf.runtime.emf.core.resources.CannotSeparateException;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;


/**
 * Tests a variety of refactoring scenarios in logical resources, involving
 * the relocation in the content tree of separate elements, to check that the
 * resource map is correctly updated on saving.
 *
 * @author Christian W. Damus (cdamus)
 */
public class RefactoringTest
	extends BaseLogicalResourceTest {
	
	public RefactoringTest(String name) {
		super(name);
	}
	
	public static Test suite() {
		return new TestSuite(RefactoringTest.class, "Refactoring Tests"); //$NON-NLS-1$
	}

	/**
	 * Tests correct save and re-load when moving a separate element to a
	 * different position in its containment reference.
	 */
	public void test_moveWithinContainmentList() {
		String subunit1Frag = logres.getURIFragment(subunit1);
		
		Library parent = subunit1.getParentBranch();
		EList branches = parent.getBranches();
		
		Library newLibrary = EXTLibraryFactory.eINSTANCE.createLibrary();
		branches.add(newLibrary);
		newLibrary.setName("New Library"); //$NON-NLS-1$
		String newFrag = logres.getURIFragment(newLibrary);
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		
		subunit1 = lookupLibrary(subunit1Frag);
		newLibrary = lookupLibrary(newFrag);
		
		parent = subunit1.getParentBranch();
		assertNotNull(parent);
		
		branches = parent.getBranches();
		
		assertEquals(0, branches.indexOf(subunit1));
		assertEquals(1, branches.indexOf(newLibrary));
		
		// reposition the sub-unit
		branches.move(1, subunit1);
		
		saveLogicalResource();
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		
		subunit1 = lookupLibrary(subunit1Frag);
		newLibrary = lookupLibrary(newFrag);
		
		parent = subunit1.getParentBranch();
		assertNotNull(parent);
		
		branches = parent.getBranches();
		
		// correctly restored the reverse order
		assertEquals(1, branches.indexOf(subunit1));
		assertEquals(0, branches.indexOf(newLibrary));
	}

	/**
	 * Tests correct save and re-load when moving a separate element to a
	 * different containment reference in its parent.
	 */
	public void test_moveWithinParentElement() {
		// create a test metamodel that has two features of the same kind
		EPackage dynamicPackage;
		EClass dynamicClass;
		EReference dynamicRef1;
		EReference dynamicRef2;
		
		dynamicPackage = EcoreFactory.eINSTANCE.createEPackage();
		dynamicPackage.setName("logresrefactor"); //$NON-NLS-1$
		dynamicPackage.setNsPrefix("lrr"); //$NON-NLS-1$
		dynamicPackage.setNsURI("http:///com/ibm/xtools/emf/msl/core/tests/logresrefactor.ecore"); //$NON-NLS-1$
		// make sure that we can serialize references to the package's contents
		new ResourceImpl(URI.createURI(dynamicPackage.getNsURI())).getContents().add(
			dynamicPackage);
		EPackage.Registry.INSTANCE.put(dynamicPackage.getNsURI(), dynamicPackage);
		
		EFactory factory = EcoreFactory.eINSTANCE.createEFactory();
		factory.setEPackage(dynamicPackage);
		dynamicPackage.setEFactoryInstance(factory);

		dynamicClass = EcoreFactory.eINSTANCE.createEClass();
		dynamicPackage.getEClassifiers().add(dynamicClass);
		dynamicClass.setName("TestClass"); //$NON-NLS-1$
		
		dynamicRef1 = EcoreFactory.eINSTANCE.createEReference();
		dynamicClass.getEStructuralFeatures().add(dynamicRef1);
		dynamicRef1.setName("ref1"); //$NON-NLS-1$
		dynamicRef1.setChangeable(true);
		dynamicRef1.setContainment(true);
		dynamicRef1.setUpperBound(EAttribute.UNBOUNDED_MULTIPLICITY);
		dynamicRef1.setEType(dynamicClass);
		
		dynamicRef2 = EcoreFactory.eINSTANCE.createEReference();
		dynamicClass.getEStructuralFeatures().add(dynamicRef2);
		dynamicRef2.setName("ref2"); //$NON-NLS-1$
		dynamicRef2.setChangeable(true);
		dynamicRef2.setContainment(true);
		dynamicRef2.setUpperBound(EAttribute.UNBOUNDED_MULTIPLICITY);
		dynamicRef2.setEType(dynamicClass);
		
		try {
			EObject dynamicContainer = factory.create(dynamicClass);
			EObject dynamicSubunit = factory.create(dynamicClass);

			logres.getContents().add(dynamicContainer);
			((EList) dynamicContainer.eGet(dynamicRef1)).add(dynamicSubunit);
			
			String containerFrag = logres.getURIFragment(dynamicContainer);
			String subunitFrag = logres.getURIFragment(dynamicSubunit);
			
			try {
				logres.separate(dynamicSubunit, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			} catch (CannotSeparateException e) {
				fail("Should not fail to separate: " + e); //$NON-NLS-1$
			}
			
			saveLogicalResource();
			
			// discard the resource and re-load from disk
			createLogicalResource(RESOURCE_NAME);
			loadLogicalResource();
			
			dynamicContainer = logres.getEObject(containerFrag);
			dynamicSubunit = logres.getEObject(subunitFrag);
			assertNotNull(dynamicContainer);
			assertNotNull(dynamicSubunit);
			
			assertSame(dynamicContainer, dynamicSubunit.eContainer());
			assertSame(dynamicRef1, dynamicSubunit.eContainmentFeature());
			
			// move the sub-unit to another containment reference of the same parent
			((EList) dynamicContainer.eGet(dynamicRef2)).add(dynamicSubunit);
			
			saveLogicalResource();
			
			// discard the resource and re-load from disk
			createLogicalResource(RESOURCE_NAME);
			loadLogicalResource();
			
			dynamicContainer = logres.getEObject(containerFrag);
			dynamicSubunit = logres.getEObject(subunitFrag);
			assertNotNull(dynamicContainer);
			assertNotNull(dynamicSubunit);
			
			// correctly restored the containment reference
			assertSame(dynamicContainer, dynamicSubunit.eContainer());
			assertSame(dynamicRef2, dynamicSubunit.eContainmentFeature());
		} finally {			
			// must unload before we remove the dynamic package
			unloadLogicalResource();
			EPackage.Registry.INSTANCE.remove(dynamicPackage.getNsURI());
		}
	}

	/**
	 * Tests correct save and re-load when moving a separate element to a
	 * different parent element in the same (parent) unit.
	 */
	public void test_moveWithinParentUnit() {
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit3Frag = logres.getURIFragment(subunit3);
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);
		
		subunit3.getBranches().add(subunit1);
		
		saveLogicalResource();
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);
		
		// correctly restored the parent relationship
		assertSame(subunit3, subunit1.getParentBranch());
	}

	/**
	 * Tests correct save and re-load when moving a separate element to a
	 * different parent element in a different (parent) unit.
	 */
	public void test_moveToNewParentUnit() {
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit3Frag = logres.getURIFragment(subunit3);
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit3, URI.createPlatformResourceURI(SUBUNIT_NAME3));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);
		
		subunit3.getBranches().add(subunit1);
		
		saveLogicalResource();
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);
		
		// correctly restored the parent relationship
		assertSame(subunit3, subunit1.getParentBranch());
	}
	
	/**
	 * Tests correct save and re-load when deleting a separate element from
	 * the logical model.
	 */
	public void test_deleteSeparateElement() {
		String subunit2Frag = logres.getURIFragment(subunit2);
		
		try {
			logres.separate(subunit2, URI.createPlatformResourceURI(SUBUNIT_NAME2));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		
		subunit2 = lookupLibrary(subunit2Frag);
		assertNotNull(subunit2);
		
		assertEquals(2, logres.getMappedResources().size());
		
		// disconnect from the logical contents tree
		subunit2.getParentBranch().getBranches().remove(subunit2);
		
		assertEquals(1, logres.getMappedResources().size());
		
		saveLogicalResource();
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();

		// check that it doesn't exist any more, even as an unloaded "proxy"
		subunit2 = lookupLibrary(subunit2Frag);
		assertNull(subunit2);
	}

	/**
	 * Tests correct save and re-load when moving a separate element from one
	 * logical resource to another.
	 */
	public void test_moveToNewLogicalResource() {
		String subunit1Frag = logres.getURIFragment(subunit1);
		String subunit3Frag = logres.getURIFragment(subunit3);
		
		ILogicalResource logres2 = createNewLogicalResource(
			URI.createPlatformResourceURI(RESOURCE_NAME2));
		Library library2 = EXTLibraryFactory.eINSTANCE.createLibrary();
		logres2.getContents().add(library2);
		library2.setName("Library 2"); //$NON-NLS-1$
		
		String root2Frag = logres2.getURIFragment(library2);
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit3, URI.createPlatformResourceURI(SUBUNIT_NAME3));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		saveLogicalResource(logres2);
		
		// discard the resources and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		logres2 = createNewLogicalResource(
			URI.createPlatformResourceURI(RESOURCE_NAME2));
		loadLogicalResource(logres2);
		
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);
		library2 = lookupLibrary(logres2, root2Frag);
		assertNotNull(library2);
		
		assertEquals(3, logres.getMappedResources().size());
		assertEquals(1, logres2.getMappedResources().size());
		
		library2.getBranches().add(subunit1); // inter-resource move
		subunit1Frag = logres2.getURIFragment(subunit1);  // in case of re-guid
		
		assertEquals(2, logres.getMappedResources().size());
		assertEquals(1, logres2.getMappedResources().size()); // not a sub-unit here
		
		saveLogicalResource();
		saveLogicalResource(logres2);
		
		// discard the resources and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		logres2 = createNewLogicalResource(
			URI.createPlatformResourceURI(RESOURCE_NAME2));
		loadLogicalResource(logres2);
		
		subunit1 = lookupLibrary(subunit1Frag);
		assertNull(subunit1);
		subunit1 = lookupLibrary(logres2, subunit1Frag);
		assertNotNull(subunit1);  // found it in the other resource this time
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);
		library2 = lookupLibrary(logres2, root2Frag);
		assertNotNull(library2);
		
		// correctly restored the parent relationship
		assertSame(library2, subunit1.getParentBranch());
	}

	/**
	 * Tests correct save and re-load when moving a separate root to a
	 * different position in its containment reference.
	 */
	public void test_moveRootWithinContentsList() {
		String rootFrag = logres.getURIFragment(root);
		
		Library newLibrary = EXTLibraryFactory.eINSTANCE.createLibrary();
		EList contents = logres.getContents();
		contents.add(newLibrary);
		newLibrary.setName("New Library"); //$NON-NLS-1$
		String newFrag = logres.getURIFragment(newLibrary);
		
		try {
			logres.separate(root, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		
		root = lookupLibrary(rootFrag);
		newLibrary = lookupLibrary(newFrag);
		
		contents = logres.getContents();
		
		assertEquals(0, contents.indexOf(root));
		assertEquals(1, contents.indexOf(newLibrary));
		
		// reposition the sub-unit
		contents.move(1, root);
		
		saveLogicalResource();
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		
		root = lookupLibrary(rootFrag);
		newLibrary = lookupLibrary(newFrag);
		
		contents = logres.getContents();
		
		// correctly restored the reverse order
		assertEquals(1, contents.indexOf(root));
		assertEquals(0, contents.indexOf(newLibrary));
	}

	/**
	 * Tests correct save and re-load when moving a separate root to a
	 * different parent element in the same (root) unit.
	 */
	public void test_moveRootWithinParentUnit() {
		String rootFrag = logres.getURIFragment(root);
		String subunit3Frag = logres.getURIFragment(subunit3);
		
		EList contents = logres.getContents();
		contents.add(subunit3);  // second root in the root resource
		
		try {
			logres.separate(root, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);
		
		subunit3.getBranches().add(root);
		
		saveLogicalResource();
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);
		
		// correctly restored the parent relationship
		assertSame(subunit3, root.getParentBranch());
	}

	/**
	 * Tests correct save and re-load when moving a separate root to a
	 * different parent element in a different (parent) unit.
	 */
	public void test_moveRootToNewParentUnit() {
		String rootFrag = logres.getURIFragment(root);
		String subunit3Frag = logres.getURIFragment(subunit3);
		
		logres.getContents().add(subunit3);  // make it another root
		
		try {
			logres.separate(root, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit3, URI.createPlatformResourceURI(SUBUNIT_NAME3));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);
		
		subunit3.getBranches().add(root);
		
		saveLogicalResource();
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);
		
		// correctly restored the parent relationship
		assertSame(subunit3, root.getParentBranch());
	}
	
	/**
	 * Tests correct save and re-load when deleting a separate root from
	 * the logical model.
	 */
	public void test_deleteSeparateRootElement() {
		String rootFrag = logres.getURIFragment(root);
		String subunit2Frag = logres.getURIFragment(subunit2);
		
		logres.getContents().add(subunit2);
		
		try {
			logres.separate(root, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit2, URI.createPlatformResourceURI(SUBUNIT_NAME2));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		subunit2 = lookupLibrary(subunit2Frag);
		assertNotNull(subunit2);
		
		assertEquals(2, logres.getMappedResources().size());
		
		// disconnect from the logical contents tree
		logres.getContents().remove(root);
		
		assertEquals(1, logres.getMappedResources().size());
		
		saveLogicalResource();
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();

		subunit2 = lookupLibrary(subunit2Frag);
		assertNotNull(subunit2);
		
		// check that it doesn't exist any more, even as an unloaded "proxy"
		root = lookupLibrary(rootFrag);
		assertNull(root);
	}

	/**
	 * Tests correct save and re-load when moving a separate root from one
	 * logical resource to another.  This is an extra special case, because
	 * not only is a logical root moved, but it brings with it content from
	 * another sub-unit also.
	 */
	public void test_moveRootToNewLogicalResource() {
		String rootFrag = logres.getURIFragment(root);
		String subunit3Frag = logres.getURIFragment(subunit3);
		
		ILogicalResource logres2 = createNewLogicalResource(
			URI.createPlatformResourceURI(RESOURCE_NAME2));
		Library library2 = EXTLibraryFactory.eINSTANCE.createLibrary();
		logres2.getContents().add(library2);
		library2.setName("Library 2"); //$NON-NLS-1$
		
		String root2Frag = logres2.getURIFragment(library2);
		
		try {
			logres.separate(root, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit3, URI.createPlatformResourceURI(SUBUNIT_NAME3));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		saveLogicalResource(logres2);
		
		// discard the resources and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		logres2 = createNewLogicalResource(
			URI.createPlatformResourceURI(RESOURCE_NAME2));
		loadLogicalResource(logres2);
		
		root = lookupLibrary(rootFrag);
		assertNotNull(root);
		subunit3 = lookupLibrary(subunit3Frag);
		assertNotNull(subunit3);
		library2 = lookupLibrary(logres2, root2Frag);
		assertNotNull(library2);
		
		assertEquals(2, logres.getMappedResources().size());
		assertEquals(1, logres2.getMappedResources().size());
		
		library2.getBranches().add(root); // inter-resource move
		rootFrag = logres2.getURIFragment(root);  // in case of re-guid
		subunit3Frag = logres2.getURIFragment(subunit3);  // in case of re-guid
		
		assertEquals(1, logres.getMappedResources().size());
		assertEquals(1, logres2.getMappedResources().size()); // not a sub-unit here
		
		saveLogicalResource();
		saveLogicalResource(logres2);
		
		// discard the resources and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		loadLogicalResource();
		logres2 = createNewLogicalResource(
			URI.createPlatformResourceURI(RESOURCE_NAME2));
		loadLogicalResource(logres2);
		
		root = lookupLibrary(rootFrag);
		assertNull(root);
		root = lookupLibrary(logres2, rootFrag);
		assertNotNull(root);  // found it in the other resource this time
		subunit3 = lookupLibrary(logres2, subunit3Frag);
		assertNotNull(subunit3);  // this sub-unit content followed the root!
		library2 = lookupLibrary(logres2, root2Frag);
		assertNotNull(library2);
		
		// correctly restored the parent relationship
		assertSame(library2, root.getParentBranch());
	}
}




/******************************************************************************
 * Copyright (c) 2005 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.tests.runtime.emf.core.internal.resources;

import java.io.IOException;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;

import org.eclipse.emf.examples.extlibrary.EXTLibraryFactory;
import org.eclipse.emf.examples.extlibrary.Library;
import org.eclipse.gmf.runtime.emf.core.internal.resources.AbstractResourceWrapper;
import org.eclipse.gmf.runtime.emf.core.resources.CannotAbsorbException;
import org.eclipse.gmf.runtime.emf.core.resources.CannotSeparateException;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;


/**
 * Tests the {@link LogicalResourceWrapper} class.
 *
 * @author Christian W. Damus (cdamus)
 */
public class LogicalResourceWrapperTest
	extends BaseLogicalResourceTest {
	
	public LogicalResourceWrapperTest(String name) {
		super(name);
	}
	
	public static Test suite() {
		return new TestSuite(LogicalResourceWrapperTest.class, "Wrapper Tests"); //$NON-NLS-1$
	}

	/**
	 * Tests that nothing can be separated in a non-logical resource.
	 */
	public void test_canSeparate() {
		assertFalse(logres.canSeparate(root)); // wouldn't be separable, anyway
		assertFalse(logres.canSeparate(subunit1)); // would be separable in MSL resource
	}

	/**
	 * Tests that nothing appears to be separate in a non-logical resource.
	 */
	public void test_isSeparate() {
		assertFalse(logres.isSeparate(root)); // wouldn't be separate, anyway
		assertFalse(logres.isSeparate(subunit1)); // same here, actually
	}

	/**
	 * Tests that everything appears to be loaded in a non-logical resource.
	 */
	public void test_isLoaded() {
		saveLogicalResource();
		logres.unload();
		
		Map options = new java.util.HashMap();
		options.put(ILogicalResource.OPTION_LOAD_ALL_UNITS, Boolean.FALSE);
		options.put(ILogicalResource.OPTION_AUTO_LOAD_UNITS, Boolean.FALSE);
		
		// try loading without loading sub-units and without auto-loading
		loadLogicalResource(false, false);
		
		assertTrue(logres.isLoaded(root)); // wouldn't be unloaded, anyway
		assertTrue(logres.isLoaded(subunit1)); // same here, actually
	}
	
	/**
	 * Tests that attempting to load an element always fails.
	 */
	public void test_load() {
		try {
			logres.load(root);  // would fail, anyway
			fail("Should have failed to load"); //$NON-NLS-1$
		} catch (IllegalArgumentException e) {
			// passed the test
		} catch (IOException e) {
			fail("Wrong exception thrown: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
		
		try {
			logres.load(subunit1);  // would also fail in MSL resource because it's not separate
			fail("Should have failed to load"); //$NON-NLS-1$
		} catch (IllegalArgumentException e) {
			// passed the test
		} catch (IOException e) {
			fail("Wrong exception thrown: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
	}
	
	/**
	 * Tests that attempting to separate always fails.
	 */
	public void test_separate() {
		URI subunitUri = URI.createPlatformResourceURI(SUBUNIT_NAME1);
		
		try {
			logres.separate(root, subunitUri);  // would fail, anyway
			fail("Should have failed to separate"); //$NON-NLS-1$
		} catch (IllegalArgumentException e) {
			// passed the test
		} catch (CannotSeparateException e) {
			fail("Wrong exception thrown: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
		
		try {
			logres.separate(subunit1, subunitUri);  // would not fail in MSL resource
			fail("Should have failed to separate"); //$NON-NLS-1$
		} catch (IllegalArgumentException e) {
			// passed the test
		} catch (CannotSeparateException e) {
			fail("Wrong exception thrown: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
	}
	
	/**
	 * Tests that attempting to absorb always fails.
	 */
	public void test_absorb() {
		try {
			logres.absorb(root);  // would fail, anyway
			fail("Should have failed to absorb"); //$NON-NLS-1$
		} catch (IllegalArgumentException e) {
			// passed the test
		} catch (CannotAbsorbException e) {
			fail("Wrong exception thrown: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
		
		try {
			logres.absorb(subunit1);  // would actually fail in MSL resource, too
			fail("Should have failed to absorb"); //$NON-NLS-1$
		} catch (IllegalArgumentException e) {
			// passed the test
		} catch (CannotAbsorbException e) {
			fail("Wrong exception thrown: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
	}
	
	/**
	 * Tests that we do get a correct mapped-resources map.
	 */
	public void test_getMappedResources() {
		Map resources = logres.getMappedResources();
		
		assertEquals(1, resources.size());
		assertSame(
			AbstractResourceWrapper.unwrap(logres),
			AbstractResourceWrapper.unwrap((Resource) resources.get(root)));
		
		Library second = EXTLibraryFactory.eINSTANCE.createLibrary();
		logres.getContents().add(second);  // test adding a root
		
		// check that the resource map is dynamically updated
		assertEquals(2, resources.size());
		assertSame(
			AbstractResourceWrapper.unwrap(logres),
			AbstractResourceWrapper.unwrap((Resource) resources.get(root)));
		assertSame(
			AbstractResourceWrapper.unwrap(logres),
			AbstractResourceWrapper.unwrap((Resource) resources.get(second)));
		
		Library third = EXTLibraryFactory.eINSTANCE.createLibrary();
		logres.getContents().set(1, third);  // test setting a root
		assertEquals(2, resources.size());
		assertSame(
			AbstractResourceWrapper.unwrap(logres),
			AbstractResourceWrapper.unwrap((Resource) resources.get(third)));
		
		logres.getContents().remove(0);  // test removing a root
		assertEquals(1, resources.size());
		assertSame(
			AbstractResourceWrapper.unwrap(logres),
			AbstractResourceWrapper.unwrap((Resource) resources.get(third)));
	}
	
	/** Test that notifications appear correctly to come from the wrapper. */
	public void test_notifications() {
		class TestAdapter extends AdapterImpl {
			Notification notification;
			
			public void notifyChanged(Notification msg) {
				notification = msg;
			}
		}
		
		TestAdapter adapter = new TestAdapter();
		
		logres.eAdapters().add(adapter);
		
		logres.setModified(true);
		
		Notification notification = adapter.notification;
		assertNotNull(notification);
		assertSame(logres, notification.getNotifier());  // not the wrapped XMI
		assertEquals(Resource.RESOURCE__IS_MODIFIED, notification.getFeatureID(null));
		assertFalse(notification.getOldBooleanValue());
		assertTrue(notification.getNewBooleanValue());
	}
	
	public void test_unwrap() {
		Resource unwrapped = AbstractResourceWrapper.unwrap(logres);
		
		assertNotNull(unwrapped);
		assertNotSame(logres, unwrapped);
		assertSame(
			logres.getResourceSet().getResource(getXmiUri(), false),
			unwrapped);
	}
	
	//
	// Framework methods
	//
	
	/**
	 * Replaces the *.extlibrary extension with *.xmi so that the editing domain
	 * will not create logical resources, but instead default XMI resources.
	 */
	protected ILogicalResource createNewLogicalResource(URI uri) {
		return super.createNewLogicalResource(getXmiUri(uri));
	}
	
	/**
	 * Converts a URI to *.xmi.
	 * 
	 * @param uri a URI
	 * @return the same URI, except with a *.xmi extension
	 */
	private URI getXmiUri(URI uri) {
		return uri.trimFileExtension().appendFileExtension("xmi"); //$NON-NLS-1$
	}
	
	/**
	 * Gets the default test resource URI as an XMI URI.
	 * 
	 * @return the *.xmi variant of our default test resource URI
	 */
	private URI getXmiUri() {
		return getXmiUri(URI.createPlatformResourceURI(RESOURCE_NAME));
	}
}




/******************************************************************************
 * Copyright (c) 2005 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.tests.runtime.emf.core.internal.resources;

import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;

import org.eclipse.gmf.runtime.emf.core.resources.CannotSeparateException;


/**
 * Tests the unmodifiable resource views that are made available to clients
 * by the {@link ILogicalResource#getMappedResources()} method and the
 * logical-resource-related notifications.
 *
 * @author Christian W. Damus (cdamus)
 */
public class UnmodifiableResourceViewTest
	extends BaseLogicalResourceTest {
	
	public UnmodifiableResourceViewTest(String name) {
		super(name);
	}
	
	public static Test suite() {
		return new TestSuite(UnmodifiableResourceViewTest.class, "Unmodifiable Resource View Tests"); //$NON-NLS-1$
	}

	/**
	 * Tests that the APIs clients need to access are available.
	 */
	public void test_getURI() {
		// get the map first, to test that its view of the resource set changes
		//    in synch with reality
		Map resources = logres.getMappedResources();
		
		URI subunitUri = URI.createPlatformResourceURI(SUBUNIT_NAME1);
		
		try {
			logres.separate(subunit1, subunitUri);
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Resource unit = (Resource) resources.get(subunit1);
		assertNotNull(unit);
		
		try {
			assertEquals(subunitUri, unit.getURI());
		} catch (UnsupportedOperationException e) {
			fail("Operation should be supported: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
	}

	/**
	 * Tests that the APIs clients need to access are available.
	 */
	public void test_isModified() {
		// get the map first, to test that its view of the resource set changes
		//    in synch with reality
		Map resources = logres.getMappedResources();
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Resource unit = (Resource) resources.get(subunit1);
		assertNotNull(unit);
		
		try {
			assertTrue(unit.isModified());
		} catch (UnsupportedOperationException e) {
			fail("Operation should be supported: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		try {
			assertFalse(unit.isModified());
		} catch (UnsupportedOperationException e) {
			fail("Operation should be supported: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
	}

	/**
	 * Tests that the APIs clients need to access are available.
	 */
	public void test_isLoaded() {
		// get the map first, to test that its view of the resource set changes
		//    in synch with reality
		Map resources = logres.getMappedResources();
		
		String subunit1Frag = logres.getURIFragment(subunit1);
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Resource unit = (Resource) resources.get(subunit1);
		assertNotNull(unit);
		
		try {
			assertTrue(unit.isLoaded());
		} catch (UnsupportedOperationException e) {
			fail("Operation should be supported: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		logres.unload();
		
		loadLogicalResource(false, false);  // load without sub-units
		
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		
		unit = (Resource) resources.get(subunit1);
		assertNotNull(unit);
		
		try {
			assertFalse(unit.isLoaded());
		} catch (UnsupportedOperationException e) {
			fail("Operation should be supported: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
	}

	/**
	 * Tests that the APIs clients need to access are available.
	 */
	public void test_eAdapters() {
		// get the map first, to test that its view of the resource set changes
		//    in synch with reality
		Map resources = logres.getMappedResources();
		
		String subunit1Frag = logres.getURIFragment(subunit1);
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Resource unit = (Resource) resources.get(subunit1);
		assertNotNull(unit);
		
		try {
			assertTrue(unit.isLoaded());
		} catch (UnsupportedOperationException e) {
			fail("Operation should be supported: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		logres.unload();
		
		loadLogicalResource(false, false);  // load without sub-units
		
		subunit1 = lookupLibrary(subunit1Frag);
		assertNotNull(subunit1);
		
		unit = (Resource) resources.get(subunit1);
		assertNotNull(unit);
		
		class TestAdapter extends AdapterImpl {
			Notification notification;
			
			public void notifyChanged(Notification msg) {
				// capture the change in isLoaded feature
				if (msg.getFeatureID(Resource.class) == Resource.RESOURCE__IS_LOADED) {
					notification = msg;
				}
			}
		}
		
		TestAdapter adapter = new TestAdapter();
		
		try {
			unit.eAdapters().add(adapter);
		} catch (UnsupportedOperationException e) {
			fail("Operation should be supported: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
		
		try {
			logres.load(subunit1);
		} catch (IOException e) {
			fail("Should not have failed to load: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
		
		Notification notification = adapter.notification;
		assertNotNull(notification);
		assertSame(unit, notification.getNotifier()); // view is the notifier
		assertEquals(
			Resource.RESOURCE__IS_LOADED,
			notification.getFeatureID(Resource.class));
		assertFalse(notification.getOldBooleanValue());
		assertTrue(notification.getNewBooleanValue());
	}

	/**
	 * Tests that the APIs clients need to access are available.
	 */
	public void test_getContents() {
		// get the map first, to test that its view of the resource set changes
		//    in synch with reality
		Map resources = logres.getMappedResources();
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Resource unit = (Resource) resources.get(subunit1);
		assertNotNull(unit);
		
		try {
			List contents = unit.getContents();
			assertNotNull(contents);
			assertFalse(contents.isEmpty());
			assertSame(subunit1, contents.get(0));
		} catch (UnsupportedOperationException e) {
			fail("Operation should be supported: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
	}

	/**
	 * Tests that the APIs clients need to access are available.
	 */
	public void test_getAllContents() {
		// get the map first, to test that its view of the resource set changes
		//    in synch with reality
		Map resources = logres.getMappedResources();
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Resource unit = (Resource) resources.get(subunit1);
		assertNotNull(unit);
		
		try {
			Iterator allContents = unit.getAllContents();
			assertNotNull(allContents);
			
			boolean foundSubunit2 = false;
			while (allContents.hasNext() && !foundSubunit2) {
				foundSubunit2 = allContents.next() == subunit2;
			}
			
			assertTrue(foundSubunit2);
		} catch (UnsupportedOperationException e) {
			fail("Operation should be supported: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
	}

	/**
	 * Tests that the APIs clients need to access are available.
	 */
	public void test_getEObject() {
		// get the map first, to test that its view of the resource set changes
		//    in synch with reality
		Map resources = logres.getMappedResources();
		
		String subunit2Frag = logres.getURIFragment(subunit2);
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Resource unit = (Resource) resources.get(subunit1);
		assertNotNull(unit);
		
		try {
			assertSame(subunit2, unit.getEObject(subunit2Frag));
		} catch (UnsupportedOperationException e) {
			fail("Operation should be supported: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
	}

	/**
	 * Tests that the APIs clients need to access are available.
	 */
	public void test_getURIFragment() {
		// get the map first, to test that its view of the resource set changes
		//    in synch with reality
		Map resources = logres.getMappedResources();
		
		String subunit2Frag = logres.getURIFragment(subunit2);
		
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Resource unit = (Resource) resources.get(subunit1);
		assertNotNull(unit);
		
		try {
			assertEquals(subunit2Frag, unit.getURIFragment(subunit2));
		} catch (UnsupportedOperationException e) {
			fail("Operation should be supported: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
	}
}




/******************************************************************************
 * Copyright (c) 2005 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.tests.runtime.emf.core.internal.resources;

import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.impl.ResourceImpl;

import org.eclipse.gmf.runtime.emf.core.internal.domain.MSLEditingDomain;
import org.eclipse.gmf.runtime.emf.core.resources.CannotSeparateException;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;


/**
 * Tests that we do not introduce uncollected or uncollectable garbage in the
 * logical resources API.
 *
 * @author Christian W. Damus (cdamus)
 */
public class GarbageCollectionTest
	extends BaseLogicalResourceTest {
	
	public GarbageCollectionTest(String name) {
		super(name);
	}
	
	public static Test suite() {
		return new TestSuite(GarbageCollectionTest.class, "Garbage Collection Tests"); //$NON-NLS-1$
	}

	/**
	 * Tests that sub-unit resources and their unmodifiable views are properly
	 * collectable.
	 */
	public void test_collectSubunitResources() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		ReferenceQueue q = new ReferenceQueue();
		WeakReference ref = new WeakReference(
			logres.getMappedResources().get(subunit1), q);
		
		unloadLogicalResource();
		
		// just in case, clear all fields that can reference this resource
		root = null;
		subunit1 = null;
		subunit2 = null;
		subunit3 = null;
		
		// stop writing and clear the MSL undo stack
		stopWriting();
		((MSLEditingDomain) domain).getUndoStack().flushAll();
		
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// won't happen
		}
		
		Runtime.getRuntime().gc();
		
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// won't happen
		}
		
		Reference enqueued = q.poll();
		assertSame(ref, enqueued);
	}

	/**
	 * Tests that resources and their logical views are properly
	 * collectable.
	 */
	public void test_collectLogicalResourceWrappers() {
		Resource res = new ResourceImpl();
		ILogicalResource logical = domain.asLogicalResource(res);
		
		ReferenceQueue q = new ReferenceQueue();
		WeakReference ref = new WeakReference(logical, q);
		
		logical = null;
		res = null;
		
		// stop writing and clear the MSL undo stack
		stopWriting();
		((MSLEditingDomain) domain).getUndoStack().flushAll();
		
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// won't happen
		}
		
		Runtime.getRuntime().gc();
		
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// won't happen
		}
		
		Reference enqueued = q.poll();
		assertSame(ref, enqueued);
	}
}




/******************************************************************************
 * Copyright (c) 2005 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.tests.runtime.emf.core.internal.resources;

import java.io.IOException;
import java.util.Collections;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.ResourceAttributes;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.emf.common.util.URI;

import org.eclipse.emf.examples.extlibrary.Library;
import org.eclipse.gmf.runtime.emf.core.resources.CannotAbsorbException;
import org.eclipse.gmf.runtime.emf.core.resources.CannotSeparateException;
import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;


/**
 * Tests a variety of error conditions in loading and saving, to see that the
 * appropriate response is relayed to the client.
 *
 * @author Christian W. Damus (cdamus)
 */
public class ErrorConditionsTest
	extends BaseLogicalResourceTest {
	
	public ErrorConditionsTest(String name) {
		super(name);
	}
	
	public static Test suite() {
		return new TestSuite(ErrorConditionsTest.class, "Error Condition Tests"); //$NON-NLS-1$
	}

	/**
	 * Tests failure to load a monolithic resource that does not exist.
	 */
	public void test_loadNonExistentFile_monolith() {
		saveLogicalResource();
		
		delete(RESOURCE_NAME);
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		
		try {
			logres.load(Collections.EMPTY_MAP);
			fail("Should have thrown IOException on non-existent file."); //$NON-NLS-1$
		} catch (IOException e) {
			// success
		}
	}

	/**
	 * Tests failure to load a sub-unit resource that does not exist.
	 */
	public void test_loadNonExistentFile_subunit() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		delete(SUBUNIT_NAME1);
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		
		try {
			Map options = new java.util.HashMap();
			options.put(ILogicalResource.OPTION_LOAD_ALL_UNITS, Boolean.TRUE);
			
			logres.load(options);
		} catch (IOException e) {
			// non-existent sub-units just cause proxies to be unresolved
			//   and separate elements to be unresolved
			fail("Should not have thrown IOException on non-existent file."); //$NON-NLS-1$
		}
		
		subunit1 = (Library) find("root/level1/level2-subunit"); //$NON-NLS-1$
		assertNotNull(subunit1);
		assertFalse(logres.isLoaded(subunit1));
		
		try {
			// now we should get an exception, when explicitly trying to
			//    load the non-existent sub-unit
			logres.load(subunit1);
			fail("Should have thrown IOException on non-existent file."); //$NON-NLS-1$
		} catch (IOException e) {
			// success
		}
	}

	/**
	 * Tests failure to save a monolithic resource that is read-only.
	 */
	public void test_saveReadOnlyFile_monolith() {
		saveLogicalResource();
		
		setReadOnly(RESOURCE_NAME);
		
		// modify the resource
		root.setName("Library of Congress"); //$NON-NLS-1$
		
		try {
			logres.save(Collections.EMPTY_MAP);
			fail("Should have thrown IOException on read-only file."); //$NON-NLS-1$
		} catch (IOException e) {
			// success
		}
	}

	/**
	 * Tests failure to save a sub-unit resource that is read-only.
	 */
	public void test_saveReadOnlyFile_subunit() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		setReadOnly(SUBUNIT_NAME1);
		
		// modify the resource (subunit2 isin the subunit1 file)
		subunit2.setName("Library of Congress"); //$NON-NLS-1$
		
		try {
			logres.save(Collections.EMPTY_MAP);
			fail("Should have thrown IOException on read-only file."); //$NON-NLS-1$
		} catch (IOException e) {
			// success
		}
	}

	/**
	 * Tests the exception to the don't-save-what-isn't-dirty rule for the
	 * case of a monolithic resource, which behaviour should be compatible with
	 * the basic XMI resource behaviour.
	 */
	public void test_saveNonDirtyReadOnlyFile_monolith() {
		saveLogicalResource();
		
		setReadOnly(RESOURCE_NAME);
		
		// do not modify the resource, so that it is not dirty when we save
		//    again
		
		try {
			logres.save(Collections.EMPTY_MAP);
			fail("Should have thrown IOException on read-only file."); //$NON-NLS-1$
		} catch (IOException e) {
			// success
		}
	}

	/**
	 * Tests that when we have multiple units in our resource, we only save
	 * what's dirty, if we save anything at all.
	 */
	public void test_saveNonDirtyReadOnlyFile_subunit() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		setReadOnly(RESOURCE_NAME);
		setReadOnly(SUBUNIT_NAME1);
		
		// do not modify the resource, so that it is not dirty when we save
		//    again
		
		try {
			logres.save(Collections.EMPTY_MAP);
		} catch (IOException e) {
			fail("Should not have thrown IOException on read-only file."); //$NON-NLS-1$
		}
	}

	/**
	 * Tests that when we have multiple units in our resource, we only save
	 * what's dirty.
	 */
	public void test_saveOnlyDirtyFile_subunit() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		setReadOnly(RESOURCE_NAME);
		
		// modify only the sub-unit, which is not read-only
		subunit2.setName("Library of Congress"); //$NON-NLS-1$
		
		try {
			logres.save(Collections.EMPTY_MAP);
		} catch (IOException e) {
			fail("Should not have thrown IOException on read-only file."); //$NON-NLS-1$
		}
	}
	
	/**
	 * Tests that absorption of an unloaded element is not allowed.
	 */
	public void test_absorbUnloadedElement() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		saveLogicalResource();
		
		delete(SUBUNIT_NAME1);
		
		// discard the resource and re-load from disk
		createLogicalResource(RESOURCE_NAME);
		
		try {
			Map options = new java.util.HashMap();
			options.put(ILogicalResource.OPTION_LOAD_ALL_UNITS, Boolean.TRUE);
			
			logres.load(options);
		} catch (IOException e) {
			// non-existent sub-units just cause proxies to be unresolved
			//   and separate elements to be unresolved
			fail("Should not have thrown IOException on non-existent file."); //$NON-NLS-1$
		}
		
		subunit1 = (Library) find("root/level1/level2-subunit"); //$NON-NLS-1$
		assertNotNull(subunit1);
		assertFalse(logres.isLoaded(subunit1));
		
		try {
			logres.absorb(subunit1);
			fail("Should have thrown IllegalArgumentException"); //$NON-NLS-1$
		} catch (CannotAbsorbException e) {
			fail("Should not thrown CannotAbsorbException: " + e.getLocalizedMessage()); //$NON-NLS-1$
		} catch (IllegalArgumentException e) {
			// success
		}
	}
	
	/**
	 * Tests that seaparation of an element into its current storage unit is
	 * not allowed.
	 */
	public void test_separateIntoSameUnit() {
		URI subunitUri = URI.createPlatformResourceURI(SUBUNIT_NAME1);
		
		try {
			logres.separate(subunit1, subunitUri);
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		try {
			logres.separate(subunit2, subunitUri);
			fail("Should have thrown IllegalArgumentException"); //$NON-NLS-1$
		} catch (CannotSeparateException e) {
			// success
		} catch (IllegalArgumentException e) {
			fail("Should not thrown IllegalArgumentException: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
	}
	
	//
	// Framework methods
	//
	
	/**
	 * Deletes the file specified by a workspace-relative path.
	 * 
	 * @param filePath the workspace-relative path
	 */
	private void delete(String filePath) {
		IFile file = getFile(filePath);
		assertNotNull(file);
		
		try {
			file.delete(true, null);
		} catch (CoreException e) {
			fail("Should not fail to delete file: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
	}
	
	/**
	 * Sets the file specified by a workspace-relative path as read-only.
	 * 
	 * @param filePath the workspace-relative path
	 */
	private void setReadOnly(String filePath) {
		IFile file = getFile(filePath);
		assertNotNull(file);
		
		try {
			ResourceAttributes attrs = new ResourceAttributes();
			attrs.setReadOnly(true);
			file.setResourceAttributes(attrs);
		} catch (CoreException e) {
			fail("Should not fail to set read-only: " + e.getLocalizedMessage()); //$NON-NLS-1$
		}
	}
}




/******************************************************************************
 * Copyright (c) 2005 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.tests.runtime.emf.core.internal.resources;

import java.util.Collections;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.examples.extlibrary.EXTLibraryFactory;
import org.eclipse.emf.examples.extlibrary.EXTLibraryPackage;
import org.eclipse.emf.examples.extlibrary.Library;
import org.eclipse.gmf.runtime.emf.core.internal.resourcemap.ResourceMap;
import org.eclipse.gmf.runtime.emf.core.internal.resources.AbstractResourceWrapper;
import org.eclipse.gmf.runtime.emf.core.resources.CannotAbsorbException;
import org.eclipse.gmf.runtime.emf.core.resources.CannotSeparateException;
import org.eclipse.gmf.runtime.emf.core.util.EObjectUtil;


/**
 * Tests for regressions in RATLC defects.
 *
 * @author Christian W. Damus (cdamus)
 */
public class RegressionTest
	extends BaseLogicalResourceTest {
	
	public RegressionTest(String name) {
		super(name);
	}
	
	public static Test suite() {
		return new TestSuite(RegressionTest.class, "Regression Tests"); //$NON-NLS-1$
	}

	/**
	 * Tests that moving a logical root into another container does not get
	 * it moved back into the resource contents.
	 */
	public void test_reparentLogicalRoot_RATLC00537428() {
		Library other = EXTLibraryFactory.eINSTANCE.createLibrary();
		logres.getContents().add(other);
		
		root.getBranches().add(other);
		
		assertSame(root, other.eContainer());
		assertSame(
			EXTLibraryPackage.eINSTANCE.getLibrary_Branches(),
			other.eContainmentFeature());
		assertEquals(Collections.singletonList(root), logres.getContents());
	}
	
	/**
	 * Tests that units correctly transfer ownership of their sub-units to
	 * other units when intervening elements in the containment tree are
	 * separated.
	 */
	public void test_unitsTransferSubunitOwnership_separate_RATLC00538037() {
		try {
			logres.separate(subunit2, URI.createPlatformResourceURI(SUBUNIT_NAME2));
			
			// now, separating parent is supposed to cause it to get subunit2
			//    as a child instead of the root unit owning it
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		}
		
		Resource unit = (Resource) logres.getMappedResources().get(root);
		
		// unwrap so that we don't get a view that hides the resource map
		unit = AbstractResourceWrapper.unwrap(unit);
		ResourceMap resmap = (ResourceMap) unit.getContents().get(0);
		
		assertEquals(
			"Root resource has wrong number of child units", //$NON-NLS-1$
			1,
			resmap.getParentEntries().size());
		
		// this unit must also have a single child unit
		unit = (Resource) logres.getMappedResources().get(subunit1);
		unit = AbstractResourceWrapper.unwrap(unit);
		ResourceMap resmap2 = (ResourceMap) unit.getContents().get(0);
		
		assertEquals(
			"Root resource has wrong number of child units", //$NON-NLS-1$
			1,
			resmap2.getParentEntries().size());
		
		// the leaf unit must have middle unit as its parent
		unit = (Resource) logres.getMappedResources().get(subunit2);
		unit = AbstractResourceWrapper.unwrap(unit);
		ResourceMap resmap3 = (ResourceMap) unit.getContents().get(0);
		
		assertSame(
			"Subunit has wrong parent", //$NON-NLS-1$
			resmap2,
			resmap3.getChildEntry(subunit2).getParentMap());
	}
	
	/**
	 * Tests that units correctly transfer ownership of their sub-units to
	 * other units when intervening elements in the containment tree are
	 * absorbed.
	 */
	public void test_unitsTransferSubunitOwnership_absorb_RATLC00538037() {
		try {
			logres.separate(subunit1, URI.createPlatformResourceURI(SUBUNIT_NAME1));
			logres.separate(subunit2, URI.createPlatformResourceURI(SUBUNIT_NAME2));
			
			// take out the middle unit.  subunit2's parent should now be the
			//    root
			logres.absorb(subunit1);
		} catch (CannotSeparateException e) {
			fail("Should not fail to separate: " + e); //$NON-NLS-1$
		} catch (CannotAbsorbException e) {
			fail("Should not fail to absorb: " + e); //$NON-NLS-1$
		}
		
		Resource unit = (Resource) logres.getMappedResources().get(root);
		
		// unwrap so that we don't get a view that hides the resource map
		unit = AbstractResourceWrapper.unwrap(unit);
		ResourceMap resmap = (ResourceMap) unit.getContents().get(0);
		
		assertEquals(
			"Root resource has wrong number of child units", //$NON-NLS-1$
			1,
			resmap.getParentEntries().size());
		
		// the remaining sub-unit must reference the root unit as parent
		unit = (Resource) logres.getMappedResources().get(subunit2);
		unit = AbstractResourceWrapper.unwrap(unit);
		ResourceMap resmap2 = (ResourceMap) unit.getContents().get(0);
		
		assertSame(
			"Subunit has wrong parent", //$NON-NLS-1$
			resmap,
			resmap2.getChildEntry(subunit2).getParentMap());
	}

	/**
	 * Tests that after moving a logical root into another container and then
	 * back to being a logical root, the logical root is properly saved.
	 */
	public void test_rerootLogicalRoot_RATLC00538194() {
		Library library = EXTLibraryFactory.eINSTANCE.createLibrary();

		// add the library to the logical resource
		logres.getContents().add(library);
		
		// logical resource should contain library
		assertEquals(2, logres.getContents().size());
		assertSame(logres.getContents().get(1), library);
		
		// remove the library from the logical resource
		logres.getContents().remove(library);

		assertFalse(logres.getMappedResources().containsKey(library));

		// move the library into the branches containment list of another library
		root.getBranches().add(library);
		
		// library should not be part of the resource map because it was added
		// to the list of branches in the root
		assertFalse(logres.getMappedResources().containsKey(library));
		
		// move the library back to being a root
		logres.getContents().add(library);
		
		// logical resource should contain library
		assertEquals(2, logres.getContents().size());
		assertSame(logres.getContents().get(1), library);

		// store the library ID for comparison later
		String libraryID = EObjectUtil.getID(library);

		saveLogicalResource();
		
		assertFalse(logres.isModified());
		
		// discard and re-load the resource
		createLogicalResource(RESOURCE_NAME);
		
		loadLogicalResource();
		
		// logical resource unit should contain library after reloading
		assertEquals(2, logres.getContents().size());
		assertEquals(libraryID, EObjectUtil.getID((EObject)logres.getContents().get(1)));
	}
}

Lines 8-14 Link Here

(-)META-INF/MANIFEST.MF (-1 lines)
8	Export-Package: org.eclipse.gmf.tests.runtime.emf.core.internal.commands,	8	Export-Package: org.eclipse.gmf.tests.runtime.emf.core.internal.commands,
9	org.eclipse.gmf.tests.runtime.emf.core.internal.expressions,	9	org.eclipse.gmf.tests.runtime.emf.core.internal.expressions,
10	org.eclipse.gmf.tests.runtime.emf.core.internal.multithread.testcases,	10	org.eclipse.gmf.tests.runtime.emf.core.internal.multithread.testcases,
11	org.eclipse.gmf.tests.runtime.emf.core.internal.resources,
12	org.eclipse.gmf.tests.runtime.emf.core.internal,	11	org.eclipse.gmf.tests.runtime.emf.core.internal,
13	org.eclipse.gmf.tests.runtime.emf.core	12	org.eclipse.gmf.tests.runtime.emf.core
14	Require-Bundle: org.junit,	13	Require-Bundle: org.junit,

Lines 33-39 Link Here

(-)src/org/eclipse/gmf/tests/runtime/emf/core/AllTests.java (-1 lines)
33	import org.eclipse.gmf.tests.runtime.emf.core.internal.multithread.testcases.ReadOperationTest;	33	import org.eclipse.gmf.tests.runtime.emf.core.internal.multithread.testcases.ReadOperationTest;
34	import org.eclipse.gmf.tests.runtime.emf.core.internal.multithread.testcases.ReadWriteOperationTest;	34	import org.eclipse.gmf.tests.runtime.emf.core.internal.multithread.testcases.ReadWriteOperationTest;
35	import org.eclipse.gmf.tests.runtime.emf.core.internal.multithread.testcases.WriteOperationTest;	35	import org.eclipse.gmf.tests.runtime.emf.core.internal.multithread.testcases.WriteOperationTest;
36	import org.eclipse.gmf.tests.runtime.emf.core.internal.resources.BaseLogicalResourceTest;
37	import org.osgi.service.prefs.BackingStoreException;	36	import org.osgi.service.prefs.BackingStoreException;
38	import org.osgi.service.prefs.Preferences;	37	import org.osgi.service.prefs.Preferences;
39		38

Return to bug 113863

Lines 143-162 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/internal/commands/MSLCommandGenerator.java (-14 lines)
143		143
144	break;	144	break;
145	}	145	}
146
147	case EventTypes.SEPARATE: {
148	MSLUtil.execute(domain, new MSLSeparateCommand(domain,
149	notifier, structuralFeature, position, (Resource) newValue));
150
151	break;
152	}
153
154	case EventTypes.ABSORB: {
155	MSLUtil.execute(domain, new MSLAbsorbCommand(domain,
156	notifier, structuralFeature, position, (Resource) oldValue));
157
158	break;
159	}
160	}	146	}
161	}	147	}
162	}	148	}

Lines 650-663 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/internal/domain/MSLEditingDomain.java (-8 / +2 lines)
650	loadOptions.put(XMLResource.OPTION_EXTENDED_META_DATA,	650	loadOptions.put(XMLResource.OPTION_EXTENDED_META_DATA,
651	extendedMetaData);	651	extendedMetaData);
652	}	652	}
653
654	if ((options & MResourceOption.LOAD_ALL_SUBUNITS) != 0) {
655	loadOptions.put(ILogicalResource.OPTION_LOAD_ALL_UNITS,
656	Boolean.TRUE);
657	} else if ((options & MResourceOption.DONT_AUTO_LOAD_SUBUNITS) != 0) {
658	loadOptions.put(ILogicalResource.OPTION_AUTO_LOAD_UNITS,
659	Boolean.FALSE);
660	}
661		653
662	if (null == inputStream)	654	if (null == inputStream)
663	resource.load(loadOptions);	655	resource.load(loadOptions);
Lines 1967-1976 Link Here
1967	}	1959	}
1968	}	1960	}
1969		1961
		1962	/** @deprecated */
1970	public boolean isLogicalResource(Resource resource) {	1963	public boolean isLogicalResource(Resource resource) {
1971	return resource instanceof ILogicalResource;	1964	return resource instanceof ILogicalResource;
1972	}	1965	}
1973		1966
		1967	/** @deprecated */
1974	public ILogicalResource asLogicalResource(Resource resource) {	1968	public ILogicalResource asLogicalResource(Resource resource) {
1975	ILogicalResource result = null;	1969	ILogicalResource result = null;
1976		1970

Removed Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/internal/resources/LogicalHelper.java (-88 lines)
1	/******************************************************************************
2	* Copyright (c) 2005 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	****************************************************************************/
11
12
13	package org.eclipse.gmf.runtime.emf.core.internal.resources;
14
15	import org.eclipse.emf.common.util.URI;
16	import org.eclipse.emf.ecore.EObject;
17	import org.eclipse.emf.ecore.resource.Resource;
18	import org.eclipse.emf.ecore.util.EcoreUtil;
19	import org.eclipse.emf.ecore.xmi.impl.XMIHelperImpl;
20
21
22	public class LogicalHelper
23	extends XMIHelperImpl {
24
25	private final LogicalResource logicalResource;
26	private final LogicalResourceUnit unit;
27	private boolean urisRelativeToRoot = true;
28
29	public LogicalHelper(LogicalResourceUnit resource) {
30	super(resource);
31
32	logicalResource = resource.getLogicalResource();
33	unit = resource;
34	}
35
36	LogicalResource getLogicalResource() {
37	return logicalResource;
38	}
39
40	LogicalResourceUnit getUnit() {
41	return unit;
42	}
43
44	boolean urisRelativeToRoot() {
45	return urisRelativeToRoot;
46	}
47
48	void setUrisRelativeToRoot(boolean b) {
49	urisRelativeToRoot = b;
50	}
51
52	protected URI getHREF(Resource otherResource, EObject obj) {
53	if (otherResource instanceof LogicalResource) {
54	LogicalResource otherLogical = (LogicalResource) otherResource;
55	URI uri;
56
57	if (urisRelativeToRoot()) {
58	uri = otherLogical.getURI();
59	} else {
60	uri = otherLogical.getUnit(obj).getURI();
61	}
62
63	return uri.appendFragment(otherResource.getURIFragment(obj));
64	}
65
66	return super.getHREF(otherResource, obj);
67	}
68
69	/**
70	* Extends the superclass implementation to ensure that proxies for elements
71	* in unloaded resources are not discarded.
72	*/
73	protected URI handleDanglingHREF(EObject object) {
74	URI result;
75
76	URI proxyUri = EcoreUtil.getURI(object);
77	if ((proxyUri != null)
78	&& proxyUri.trimFragment().equals(getLogicalResource().getURI())) {
79	// do not discard unresolved references to unloaded units
80	// of the logical resource
81	result = proxyUri;
82	} else {
83	result = super.handleDanglingHREF(object);
84	}
85
86	return result;
87	}
88	}

Removed Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/internal/resources/MSLResourceUnit.java (-82 lines)
1	/******************************************************************************
2	* Copyright (c) 2004 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	****************************************************************************/
11
12	package org.eclipse.gmf.runtime.emf.core.internal.resources;
13
14	import org.eclipse.emf.common.util.URI;
15	import org.eclipse.emf.ecore.xmi.XMLHelper;
16	import org.eclipse.emf.ecore.xmi.XMLLoad;
17	import org.eclipse.emf.ecore.xmi.XMLSave;
18
19	import org.eclipse.gmf.runtime.emf.core.edit.MEditingDomain;
20
21	/**
22	* Companion sub-unit class for the MSL resource implementation.
23	*
24	* @author Christian W. Damus (cdamus)
25	*/
26	public class MSLResourceUnit
27	extends LogicalResourceUnit {
28
29	private MSLResource logicalMslResource;
30
31	/**
32	* Initializes me.
33	*/
34	public MSLResourceUnit(URI uri, LogicalResource logicalResource) {
35	super(MEditingDomain.INSTANCE.convertURI(uri), logicalResource);
36
37	logicalMslResource = (MSLResource) logicalResource;
38	}
39
40	protected boolean useIDAttributes() {
41	return logicalMslResource.useIDAttributes();
42	}
43
44	protected boolean useUUIDs() {
45	return logicalMslResource.useUUIDs();
46	}
47
48	protected XMLHelper createXMLHelper() {
49	return new MSLHelper(this);
50	}
51
52	protected XMLLoad createXMLLoad() {
53	return new MSLLoad(createXMLHelper());
54	}
55
56	protected XMLSave createXMLSave() {
57	return new MSLSave(createXMLHelper());
58	}
59
60	public void setURI(URI uri) {
61
62	MEditingDomain domain = MEditingDomain.getEditingDomain(this);
63
64	if (domain == null)
65	domain = MEditingDomain.INSTANCE;
66
67	setRawURI(domain.convertURI(uri));
68	}
69
70	/**
71	* Set the URI of the resource without processing it.
72	*/
73	public void setRawURI(URI uri) {
74
75	URI oldURI = getURI();
76
77	if ((uri == oldURI) \|\| ((uri != null) && (uri.equals(oldURI))))
78	return;
79
80	super.setURI(uri);
81	}
82	}

Lines 16-29 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/edit/DemuxingMListener.java (-80 lines)
16	import java.util.List;	16	import java.util.List;
17		17
18	import org.eclipse.emf.common.notify.Notification;	18	import org.eclipse.emf.common.notify.Notification;
19	import org.eclipse.emf.common.util.EList;
20	import org.eclipse.emf.ecore.EObject;	19	import org.eclipse.emf.ecore.EObject;
21	import org.eclipse.emf.ecore.EReference;	20	import org.eclipse.emf.ecore.EReference;
22	import org.eclipse.emf.ecore.resource.Resource;	21	import org.eclipse.emf.ecore.resource.Resource;
23
24	import org.eclipse.gmf.runtime.emf.core.EventTypes;	22	import org.eclipse.gmf.runtime.emf.core.EventTypes;
25	import org.eclipse.gmf.runtime.emf.core.internal.notifications.MSLResourceListener;	23	import org.eclipse.gmf.runtime.emf.core.internal.notifications.MSLResourceListener;
26	import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;
27	import org.eclipse.gmf.runtime.emf.core.util.ResourceUtil;	24	import org.eclipse.gmf.runtime.emf.core.util.ResourceUtil;
28		25
29	/**	26	/**
Lines 146-184 Link Here
146	Resource resource = (Resource) notifier;	143	Resource resource = (Resource) notifier;
147	eventListener	144	eventListener
148	.handleResourceExportedEvent(notification, resource);	145	.handleResourceExportedEvent(notification, resource);
149	} else if (notification.getEventType() == EventTypes.SEPARATE) {
150	int featureID = notification.getFeatureID(Resource.class);
151	if ((featureID == Resource.RESOURCE__CONTENTS) && (eventListener2 != null)) {
152	ILogicalResource res = (ILogicalResource) notifier;
153	Resource newRes = (Resource) notification.getNewValue();
154	int position = notification.getPosition();
155
156	EObject element = (EObject) res.getContents().get(position);
157
158	eventListener2.handleElementSeparatedEvent(
159	notification, res, element, newRes);
160	}
161	} else if (notification.getEventType() == EventTypes.ABSORB) {
162	int featureID = notification.getFeatureID(Resource.class);
163	if ((featureID == Resource.RESOURCE__CONTENTS) && (eventListener2 != null)) {
164	ILogicalResource res = (ILogicalResource) notifier;
165	Resource oldRes = (Resource) notification.getOldValue();
166	int position = notification.getPosition();
167
168	EObject element = (EObject) res.getContents().get(position);
169
170	eventListener2.handleElementAbsorbedEvent(
171	notification, res, element, oldRes);
172	}
173	} else if (notification.getEventType() == EventTypes.LOAD) {
174	int featureID = notification.getFeatureID(Resource.class);
175	if ((featureID == Resource.RESOURCE__CONTENTS) && (eventListener2 != null)) {
176	EObject element = (EObject) notification.getNewValue();
177	ILogicalResource res = (ILogicalResource) notifier;
178
179	eventListener2.handleElementLoadedEvent(
180	notification, res, element);
181	}
182	}	146	}
183	} else if (notifier instanceof EObject) {	147	} else if (notifier instanceof EObject) {
184	if (notification.getEventType() == EventTypes.ADD) {	148	if (notification.getEventType() == EventTypes.ADD) {
Lines 265-314 Link Here
265	EObject element = (EObject) notifier;	229	EObject element = (EObject) notifier;
266	eventListener.handleElementModifiedEvent(notification,	230	eventListener.handleElementModifiedEvent(notification,
267	element);	231	element);
268	} else if (notification.getEventType() == EventTypes.SEPARATE) {
269	if (eventListener2 != null) {
270	EObject element = (EObject) notifier;
271	ILogicalResource res = (ILogicalResource) element.eResource();
272	EReference feature = (EReference) notification.getFeature();
273	Resource newRes = (Resource) notification.getNewValue();
274	int position = notification.getPosition();
275
276	if (position < 0) {
277	// scalar reference
278	element = (EObject) element.eGet(feature);
279	} else {
280	element = (EObject) ((EList) element.eGet(feature)).get(position);
281	}
282
283	eventListener2.handleElementSeparatedEvent(
284	notification, res, element, newRes);
285	}
286	} else if (notification.getEventType() == EventTypes.ABSORB) {
287	if (eventListener2 != null) {
288	EObject element = (EObject) notifier;
289	ILogicalResource res = (ILogicalResource) element.eResource();
290	EReference feature = (EReference) notification.getFeature();
291	Resource oldRes = (Resource) notification.getOldValue();
292	int position = notification.getPosition();
293
294	if (position < 0) {
295	// scalar reference
296	element = (EObject) element.eGet(feature);
297	} else {
298	element = (EObject) ((EList) element.eGet(feature)).get(position);
299	}
300
301	eventListener2.handleElementAbsorbedEvent(
302	notification, res, element, oldRes);
303	}
304	} else if (notification.getEventType() == EventTypes.LOAD) {
305	if (eventListener2 != null) {
306	EObject element = (EObject) notification.getNewValue();
307	ILogicalResource res = (ILogicalResource) element.eResource();
308
309	eventListener2.handleElementLoadedEvent(
310	notification, res, element);
311	}
312	}	232	}
313	} else if (notifier instanceof MUndoInterval) {	233	} else if (notifier instanceof MUndoInterval) {
314	MUndoInterval undoInterval = (MUndoInterval) notifier;	234	MUndoInterval undoInterval = (MUndoInterval) notifier;

Removed Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/internal/resourcemap/util/package.html (-16 lines)
1	<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
2	<html>
3	<head>
4	<!--
5
6	/******************************************************************************
7	* Copyright (c) 2004,2005 IBM Corporation and others.
8	* All rights reserved. This program and the accompanying materials
9	* are made available under the terms of the Eclipse Public License v1.0
10	* which accompanies this distribution, and is available at
11	* http://www.eclipse.org/legal/epl-v10.html
12	*
13	* Contributors:
14	* IBM Corporation - initial API and implementation
15	****************************************************************************/
16

Lines 28-47 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/internal/expressions/EObjectPropertyTester.java (-19 / +15 lines)
28	* <dt>objectType</dt>	28	* <dt>objectType</dt>
29	* <dd>string-valued property denoting an <code>EObject</code>'s	29	* <dd>string-valued property denoting an <code>EObject</code>'s
30	* {@linkplain org.eclipse.gmf.runtime.emf.core.internal.MObjectType object type}</dd>	30	* {@linkplain org.eclipse.gmf.runtime.emf.core.internal.MObjectType object type}</dd>
31	* <dt>canSeparate</dt>
32	* <dd>boolean-valued property indicating whether an <code>EObject</code>
33	* can be
34	* {@linkplain org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource#canSeparate(EObject) separated}</dd>
35	* <dt>isSeparate</dt>
36	* <dd>boolean-valued property indicating whether an <code>EObject</code> is
37	* {@linkplain org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource#isSeparate(EObject) separate}</dd>
38	* </dl>	31	* </dl>
39	*	32	*
40	* @author Christian W. Damus (cdamus)	33	* @author Christian W. Damus (cdamus)
41	*/	34	*/
42	public class EObjectPropertyTester extends PropertyTester {	35	public class EObjectPropertyTester extends PropertyTester {
43	private static final String OBJECT_TYPE_PROPERTY = "objectType"; //$NON-NLS-1$	36	private static final String OBJECT_TYPE_PROPERTY = "objectType"; //$NON-NLS-1$
		37
		38	/**
		39	*
		40	* @deprecated Use the cross-resource containment support provided by EMF,
		41	* instead, by defining containment features that are capable of storing
		42	* proxies.
		43	*/
44	private static final String CAN_SEPARATE_PROPERTY = "canSeparate"; //$NON-NLS-1$	44	private static final String CAN_SEPARATE_PROPERTY = "canSeparate"; //$NON-NLS-1$
		45	/**
		46	*
		47	* @deprecated Use the cross-resource containment support provided by EMF,
		48	* instead, by defining containment features that are capable of storing
		49	* proxies.
		50	*/
45	private static final String IS_SEPARATE_PROPERTY = "isSeparate"; //$NON-NLS-1$	51	private static final String IS_SEPARATE_PROPERTY = "isSeparate"; //$NON-NLS-1$
46		52
47	/**	53	/**
Lines 98-116 Link Here
98	if (property.equals(OBJECT_TYPE_PROPERTY)) {	104	if (property.equals(OBJECT_TYPE_PROPERTY)) {
99	result = EObjectUtil.getType(eObject).getName().equals(expectedValue);	105	result = EObjectUtil.getType(eObject).getName().equals(expectedValue);
100	} else if (property.equals(CAN_SEPARATE_PROPERTY)) {	106	} else if (property.equals(CAN_SEPARATE_PROPERTY)) {
101	Resource res = eObject.eResource();	107	return Boolean.FALSE;
102	MEditingDomain domain = MEditingDomain.getEditingDomain(res);
103
104	if (domain != null) {
105	result = domain.asLogicalResource(res).canSeparate(eObject);
106	}
107	} else if (property.equals(IS_SEPARATE_PROPERTY)) {	108	} else if (property.equals(IS_SEPARATE_PROPERTY)) {
108	Resource res = eObject.eResource();	109	return Boolean.FALSE;
109	MEditingDomain domain = MEditingDomain.getEditingDomain(res);
110
111	if (domain != null) {
112	result = domain.asLogicalResource(res).isSeparate(eObject);
113	}
114	}	110	}
115		111
116	return Boolean.valueOf(result);	112	return Boolean.valueOf(result);

Lines 37-58 Link Here

(-)src/org/eclipse/gmf/examples/runtime/emf/actions/MSLLibraryActionBarContributor.java (-256 lines)
37	import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;	37	import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
38	import org.eclipse.emf.examples.extlibrary.actions.EXTLibraryExtendedActionBarContributor;	38	import org.eclipse.emf.examples.extlibrary.actions.EXTLibraryExtendedActionBarContributor;
39	import org.eclipse.emf.examples.extlibrary.presentation.EXTLibraryEditorPlugin;	39	import org.eclipse.emf.examples.extlibrary.presentation.EXTLibraryEditorPlugin;
40	import org.eclipse.gmf.examples.runtime.emf.MSLExamplePlugin;
41	import org.eclipse.gmf.examples.runtime.emf.constraints.ValidationDelegateClientSelector;	40	import org.eclipse.gmf.examples.runtime.emf.constraints.ValidationDelegateClientSelector;
42	import org.eclipse.gmf.examples.runtime.emf.dialogs.ValidationErrorDialog;	41	import org.eclipse.gmf.examples.runtime.emf.dialogs.ValidationErrorDialog;
43	import org.eclipse.gmf.examples.runtime.emf.editor.MSLLibraryEditor;	42	import org.eclipse.gmf.examples.runtime.emf.editor.MSLLibraryEditor;
44	import org.eclipse.gmf.examples.runtime.emf.internal.l10n.MSLExampleMessages;	43	import org.eclipse.gmf.examples.runtime.emf.internal.l10n.MSLExampleMessages;
45	import org.eclipse.gmf.examples.runtime.emf.properties.PropertySheetDialog;	44	import org.eclipse.gmf.examples.runtime.emf.properties.PropertySheetDialog;
46	import org.eclipse.gmf.runtime.common.core.util.Log;
47	import org.eclipse.gmf.runtime.emf.core.edit.MEditingDomain;	45	import org.eclipse.gmf.runtime.emf.core.edit.MEditingDomain;
48	import org.eclipse.gmf.runtime.emf.core.edit.MFilter;	46	import org.eclipse.gmf.runtime.emf.core.edit.MFilter;
49	import org.eclipse.gmf.runtime.emf.core.edit.MListener;	47	import org.eclipse.gmf.runtime.emf.core.edit.MListener;
50	import org.eclipse.gmf.runtime.emf.core.edit.MRunnable;	48	import org.eclipse.gmf.runtime.emf.core.edit.MRunnable;
51	import org.eclipse.gmf.runtime.emf.core.edit.MUndoInterval;	49	import org.eclipse.gmf.runtime.emf.core.edit.MUndoInterval;
52	import org.eclipse.gmf.runtime.emf.core.exceptions.MSLActionAbandonedException;	50	import org.eclipse.gmf.runtime.emf.core.exceptions.MSLActionAbandonedException;
53	import org.eclipse.gmf.runtime.emf.core.resources.CannotAbsorbException;
54	import org.eclipse.gmf.runtime.emf.core.resources.CannotSeparateException;
55	import org.eclipse.gmf.runtime.emf.core.resources.ILogicalResource;
56	import org.eclipse.gmf.runtime.emf.core.util.EObjectUtil;	51	import org.eclipse.gmf.runtime.emf.core.util.EObjectUtil;
57	import org.eclipse.gmf.runtime.emf.core.util.MetaModelUtil;	52	import org.eclipse.gmf.runtime.emf.core.util.MetaModelUtil;
58	import org.eclipse.jface.action.Action;	53	import org.eclipse.jface.action.Action;
Lines 64-70 Link Here
64	import org.eclipse.jface.dialogs.Dialog;	59	import org.eclipse.jface.dialogs.Dialog;
65	import org.eclipse.jface.dialogs.IInputValidator;	60	import org.eclipse.jface.dialogs.IInputValidator;
66	import org.eclipse.jface.dialogs.InputDialog;	61	import org.eclipse.jface.dialogs.InputDialog;
67	import org.eclipse.jface.dialogs.MessageDialog;
68	import org.eclipse.jface.viewers.ISelection;	62	import org.eclipse.jface.viewers.ISelection;
69	import org.eclipse.jface.viewers.IStructuredSelection;	63	import org.eclipse.jface.viewers.IStructuredSelection;
70	import org.eclipse.jface.viewers.SelectionChangedEvent;	64	import org.eclipse.jface.viewers.SelectionChangedEvent;
Lines 248-503 Link Here
248	}	242	}
249	}	243	}
250		244
251	/**
252	* This action delegate refactors the selected element into a seaparate
253	* controlled unit.
254	*/
255	public static class ControlUnitDelegate
256	implements IEditorActionDelegate, IActionDelegate2 {
257
258	/**
259	* Error message to display when an exception occured
260	*/
261	protected static final String MESSAGE_EXCEPTION = MSLExampleMessages.message_exception;
262
263	/**
264	* The shell this action is hosted in
265	*/
266	protected Shell shell = null;
267
268	/**
269	* The active editor
270	*/
271	protected MSLLibraryEditor editor = null;
272
273	/**
274	* Selected EObjects
275	*/
276	protected List selectedEObjects = null;
277
278	/**
279	* The title for the action.
280	*/
281	private String title = MSLExampleMessages.ControlUnitAction_label;
282
283	/** Action bar contributor of the MSL Library example editor. */
284	private MSLLibraryActionBarContributor actionBarContrib;
285
286	public void selectionChanged(IAction action, final ISelection selection) {
287	this.selectedEObjects = null;
288	try {
289	if (selection instanceof IStructuredSelection) {
290	IStructuredSelection structuredSelection = (IStructuredSelection) selection;
291	this.selectedEObjects = structuredSelection.toList();
292	}
293	} catch (Exception e) {
294	// Exceptions are not expected
295	MessageDialog.openInformation(shell, title, MESSAGE_EXCEPTION);
296	throw new RuntimeException(e);
297	} finally {
298	if ((null != selectedEObjects) && (selectedEObjects.size() == 1)
299	&& (selectedEObjects.get(0) instanceof EObject)) {
300	EObject selected = (EObject) selectedEObjects.get(0);
301	final MEditingDomain domain = MEditingDomain.getEditingDomain(
302	selected.eResource());
303	ILogicalResource res = domain.asLogicalResource(
304	selected.eResource());
305
306	action.setEnabled(res.canSeparate(selected));
307	} else {
308	action.setEnabled(false);
309	}
310	}
311	}
312
313	public void dispose() {
314	//No-op
315	}
316
317	public void setActiveEditor(IAction action, IEditorPart targetEditor) {
318	this.editor = (MSLLibraryEditor) targetEditor;
319	if ( targetEditor != null ) {
320	this.shell = targetEditor.getSite().getShell();
321	actionBarContrib = (MSLLibraryActionBarContributor)((MSLLibraryEditor)targetEditor).getActionBarContributor();
322	} else {
323	actionBarContrib = null;
324	}
325	}
326
327	public void init(IAction action) {
328	// No-op
329	}
330
331	public void runWithEvent(IAction action, Event event) {
332	run(action);
333	}
334
335	public void run(final IAction action) {
336	final EObject selected = (EObject) selectedEObjects.get(0);
337	final MEditingDomain domain = MEditingDomain.getEditingDomain(
338	selected.eResource());
339	final ILogicalResource res = domain.asLogicalResource(
340	selected.eResource());
341
342	final Exception[] caught = new Exception[1];
343
344	MUndoInterval undo = domain.runInUndoInterval(title, new Runnable() {
345	public void run() {
346	try {
347	domain.runAsWrite(new MRunnable() {
348
349	public Object run() {
350	try {
351	res.separate(selected, null);
352	action.setEnabled(false);
353	} catch (CannotSeparateException e) {
354	caught[0] = e;
355	MessageDialog.openError(
356	shell,
357	title,
358	e.getLocalizedMessage());
359	}
360	return null;
361	}});
362	} catch (MSLActionAbandonedException e) {
363	caught[0] = e;
364	Log.log(MSLExamplePlugin.getDefault(), e.getStatus());
365	}
366	}});
367
368	if (caught[0] != null) {
369	undo.undo();
370	} else {
371	actionBarContrib.addUndoInterval(undo);
372	}
373	}
374	}
375
376	/**
377	* This action delegate refactors the selected element into a seaparate
378	* controlled unit.
379	*/
380	public static class UncontrolUnitDelegate
381	implements IEditorActionDelegate, IActionDelegate2 {
382
383	/**
384	* Error message to display when an exception occured
385	*/
386	protected static final String MESSAGE_EXCEPTION = MSLExampleMessages.message_exception;
387
388	/**
389	* The shell this action is hosted in
390	*/
391	protected Shell shell = null;
392
393	/**
394	* The active editor
395	*/
396	protected MSLLibraryEditor editor = null;
397
398	/**
399	* Selected EObjects
400	*/
401	protected List selectedEObjects = null;
402
403	/**
404	* The title for the action.
405	*/
406	private String title = MSLExampleMessages.UncontrolUnitAction_label;
407
408	/** Action bar contributor of the MSL Library example editor. */
409	private MSLLibraryActionBarContributor actionBarContrib;
410
411	public void selectionChanged(IAction action, final ISelection selection) {
412	this.selectedEObjects = null;
413	try {
414	if (selection instanceof IStructuredSelection) {
415	IStructuredSelection structuredSelection = (IStructuredSelection) selection;
416	this.selectedEObjects = structuredSelection.toList();
417	}
418	} catch (Exception e) {
419	// Exceptions are not expected
420	MessageDialog.openInformation(shell, title, MESSAGE_EXCEPTION);
421	throw new RuntimeException(e);
422	} finally {
423	if ((null != selectedEObjects) && (selectedEObjects.size() == 1)
424	&& (selectedEObjects.get(0) instanceof EObject)) {
425	EObject selected = (EObject) selectedEObjects.get(0);
426	final MEditingDomain domain = MEditingDomain.getEditingDomain(
427	selected.eResource());
428	ILogicalResource res = domain.asLogicalResource(
429	selected.eResource());
430
431	action.setEnabled(res.isSeparate(selected));
432	} else {
433	action.setEnabled(false);
434	}
435	}
436	}
437
438	public void dispose() {
439	//No-op
440	}
441
442	public void setActiveEditor(IAction action, IEditorPart targetEditor) {
443	this.editor = (MSLLibraryEditor) targetEditor;
444	if ( targetEditor != null ) {
445	this.shell = targetEditor.getSite().getShell();
446	actionBarContrib = (MSLLibraryActionBarContributor)((MSLLibraryEditor)targetEditor).getActionBarContributor();
447	} else {
448	actionBarContrib = null;
449	}
450	}
451
452	public void init(IAction action) {
453	// No-op
454	}
455
456	public void runWithEvent(IAction action, Event event) {
457	run(action);
458	}
459
460	public void run(final IAction action) {
461	final EObject selected = (EObject) selectedEObjects.get(0);
462	final MEditingDomain domain = MEditingDomain.getEditingDomain(
463	selected.eResource());
464	final ILogicalResource res = domain.asLogicalResource(
465	selected.eResource());
466
467	final Exception[] caught = new Exception[1];
468
469	MUndoInterval undo = domain.runInUndoInterval(title, new Runnable() {
470	public void run() {
471	try {
472	domain.runAsWrite(new MRunnable() {
473
474	public Object run() {
475	try {
476	res.absorb(selected);
477	action.setEnabled(false);
478	} catch (CannotAbsorbException e) {
479	caught[0] = e;
480	MessageDialog.openError(
481	shell,
482	title,
483	e.getLocalizedMessage());
484	}
485	return null;
486	}});
487	} catch (MSLActionAbandonedException e) {
488	caught[0] = e;
489	Log.log(MSLExamplePlugin.getDefault(), e.getStatus());
490	}
491	}});
492
493	if (caught[0] != null) {
494	undo.undo();
495	} else {
496	actionBarContrib.addUndoInterval(undo);
497	}
498	}
499	}
500
501	private class MSLDeleteAction extends DeleteAction {	245	private class MSLDeleteAction extends DeleteAction {
502	private Collection objects;	246	private Collection objects;
503		247

Lines 170-185 Link Here

(-)plugin.xml (-22 lines)
170	label="%EditEObject"	170	label="%EditEObject"
171	menubarPath="org.eclipse.gmf.examples.runtime.emf.mslMenu/edit"/>	171	menubarPath="org.eclipse.gmf.examples.runtime.emf.mslMenu/edit"/>
172	<action	172	<action
173	class="org.eclipse.gmf.examples.runtime.emf.actions.MSLLibraryActionBarContributor$UncontrolUnitDelegate"
174	id="org.eclipse.gmf.examples.runtime.emf.uncontrol"
175	label="%UncontrolUnitAction.label"
176	menubarPath="org.eclipse.gmf.examples.runtime.emf.mslMenu/units"/>
177	<action
178	class="org.eclipse.gmf.examples.runtime.emf.actions.MSLLibraryActionBarContributor$ControlUnitDelegate"
179	id="org.eclipse.gmf.examples.runtime.emf.control"
180	label="%ControlUnitAction.label"
181	menubarPath="org.eclipse.gmf.examples.runtime.emf.mslMenu/units"/>
182	<action
183	class="org.eclipse.gmf.examples.runtime.emf.actions.FindReferencers"	173	class="org.eclipse.gmf.examples.runtime.emf.actions.FindReferencers"
184	id="org.eclipse.gmf.examples.runtime.emf.referencers"	174	id="org.eclipse.gmf.examples.runtime.emf.referencers"
185	label="%FindReferencersAction.label"	175	label="%FindReferencersAction.label"
Lines 200-216 Link Here
200	nsURI="http:///org/eclipse/emf/examples/library/extlibrary.ecore/1.0.0"	190	nsURI="http:///org/eclipse/emf/examples/library/extlibrary.ecore/1.0.0"
201	priority="highest"/>	191	priority="highest"/>
202	</extension>	192	</extension>
203	<extension
204	point="org.eclipse.gmf.runtime.emf.core.resourcePolicies">
205	<policy
206	class="org.eclipse.gmf.examples.runtime.emf.resources.LibraryResourcePolicy">
207	<epackage
208	nsURI="http:///org/eclipse/emf/examples/library/extlibrary.ecore/1.0.0"/>
209	</policy>
210
211	<efactory
212	class="org.eclipse.gmf.examples.runtime.emf.resources.LoadingEXTLibraryFactoryImpl"
213	nsURI="http:///org/eclipse/emf/examples/library/extlibrary.ecore/1.0.0"/>
214	</extension>
215		193
216	</plugin>	194	</plugin>