Attachment #33894 for bug #113892

View | Details | Raw Unified | Return to bug 113892
Collapse All | Expand All

Lines 1-5 Link Here

(-)src/org/eclipse/gmf/tests/runtime/emf/core/EditingDomainExtensibilityTests.java (-2 / +2 lines)
1	/******************************************************************************	1	/******************************************************************************
2	* Copyright (c) 2005 IBM Corporation and others.	2	* Copyright (c) 2005, 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 653-659 Link Here
653	projectName);	653	projectName);
654		654
655	if (proj != null) {	655	if (proj != null) {
656	result = (MyResourceSet) getResourceSet(proj);	656	result = getResourceSet(proj);
657	}	657	}
658	}	658	}
659		659

Lines 1-5 Link Here

(-)src/org/eclipse/gmf/tests/runtime/emf/core/AllTests.java (-1 / +2 lines)
1	/******************************************************************************	1	/******************************************************************************
2	* Copyright (c) 2002, 2005 IBM Corporation and others.	2	* Copyright (c) 2002-2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 88-93 Link Here
88	suite.addTestSuite(MSLEditingDomainTestCase.class);	88	suite.addTestSuite(MSLEditingDomainTestCase.class);
89	suite.addTestSuite(MFilterTests.class);	89	suite.addTestSuite(MFilterTests.class);
90	suite.addTestSuite(MListenerTest.class);	90	suite.addTestSuite(MListenerTest.class);
		91	suite.addTestSuite(CrossReferenceAdapterTests.class);
91		92
92	return suite;	93	return suite;
93	}	94	}




/******************************************************************************
 * Copyright (c) 2006 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;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.common.util.TreeIterator;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.ECrossReferenceAdapter;
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.Employee;
import org.eclipse.emf.examples.extlibrary.Library;
import org.eclipse.emf.examples.extlibrary.Writer;
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.domain.MSLEditingDomain;
import org.eclipse.gmf.runtime.emf.core.internal.index.MSLCrossReferenceAdapter;
import org.eclipse.gmf.runtime.emf.core.util.EObjectUtil;
import org.eclipse.gmf.runtime.emf.core.util.ResourceUtil;

/**
 * Test cases for the MSLCrossReferenceAdapter.
 * 
 * @author Christian Vogt (cvogt)
 */
public class CrossReferenceAdapterTests extends BaseCoreTests {

	private Resource otherRes;
	private Library otherRoot;
	private Book otherBook;
	private Writer otherWriter;
	private Employee otherEmp;

	/**
	 * Tests to ensure that every object in the resource has
	 * an attached CrossReferenceAdapter
	 */
	public void test_hasCrossReferenceAdapter() {
		checkHasCrossReferenceAdapter(testResource);
	}
	
	/**
	 * Helper method to check that the notifier and all its contents
	 * have an attached CrossReferenceAdapter.
	 * 
	 * @param notifier
	 */
	private void checkHasCrossReferenceAdapter(Notifier notifier) {
		boolean result = hasCrossRefenenceAdapter(notifier);
		if (result) {
			TreeIterator iter = null;
			if (notifier instanceof ResourceSet) {
				iter = ((ResourceSet)notifier).getAllContents();
			} else if (notifier instanceof Resource) {
				iter = ((Resource)notifier).getAllContents();
			} else if (notifier instanceof EObject) {
				iter = ((EObject)notifier).eAllContents();
			} else {
				fail("Invalid Object Type"); //$NON-NLS-1$
			}
			
			while (iter.hasNext()) {
				if (!hasCrossRefenenceAdapter((Notifier)iter.next())) {
					result = false;
					break;
				}
			}
		}
		if (!result) {
			fail("CrossReferenceAdapter is missing."); //$NON-NLS-1$
		}
	}
	
	/**
	 * Returns true if the notifier has an attached CrossReferenceAdapter.
	 * 
	 * @param notifier the notifier to check
	 * @return
	 */
	private boolean hasCrossRefenenceAdapter(Notifier notifier) {
		boolean result = false;
		for (Iterator i = notifier.eAdapters().iterator(); i.hasNext(); ) {
			if (i.next() instanceof MSLCrossReferenceAdapter) {
				result = true;
			}
		}
		return result;
	}

	/**
	 * Tests that resource import and exports information is properly
	 * maintained when many cross references are added and removed.
	 */
	public void test_importsExportsAddRemoveMany() {
		Book rootBook = (Book)root.getBooks().get(0);
		Book level1Book = (Book)((Library)root.getBranches().get(0)).getBooks().get(0);
		final List books = new ArrayList();
		books.add(rootBook);
		books.add(level1Book);
		
		MUndoInterval undo = domain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					domain.runAsWrite(new MRunnable() {
					
						public Object run() {
							otherWriter.getBooks().addAll(books);
							
							return null;
						}});
				} catch (MSLActionAbandonedException e) {
					fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
				}
			}});

		Collection imports = domain.getImports(otherRes);
		assertTrue(imports.contains(testResource));
		
		imports = domain.getAllImports(otherRes);
		assertTrue(imports.contains(testResource));
		
		Collection exports = domain.getExports(testResource);
		assertTrue(exports.contains(otherRes));
		
		exports = domain.getAllExports(testResource);
		assertTrue(exports.contains(otherRes));

		// remove books by undo
		undo.undo();
		
		imports = domain.getImports(otherRes);
		assertFalse(imports.contains(testResource));
		
		imports = domain.getAllImports(otherRes);
		assertFalse(imports.contains(testResource));

		exports = domain.getExports(testResource);
		assertFalse(exports.contains(otherRes));
		
		exports = domain.getAllExports(testResource);
		assertFalse(exports.contains(otherRes));
	}

	/**
	 * Tests that resource import and exports information is properly
	 * maintained when many cross references are added and removed
	 * one at a time.
	 */
	public void test_importsExportsAddManyRemoveOneAtATime() {
		final Book rootBook = (Book)root.getBooks().get(0);
		final Book level1Book = (Book)((Library)root.getBranches().get(0)).getBooks().get(0);
		final List books = new ArrayList();
		books.add(rootBook);
		books.add(level1Book);
		
		domain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					domain.runAsWrite(new MRunnable() {
					
						public Object run() {
							otherWriter.getBooks().addAll(books);
							
							return null;
						}});
				} catch (MSLActionAbandonedException e) {
					fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
				}
			}});
		
		Collection imports = domain.getImports(otherRes);
		assertTrue(imports.contains(testResource));
		
		imports = domain.getAllImports(otherRes);
		assertTrue(imports.contains(testResource));
		
		Collection exports = domain.getExports(testResource);
		assertTrue(exports.contains(otherRes));
		
		exports = domain.getAllExports(testResource);
		assertTrue(exports.contains(otherRes));

		domain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					domain.runAsWrite(new MRunnable() {
					
						public Object run() {
							otherWriter.getBooks().remove(rootBook);
							
							return null;
						}});
				} catch (MSLActionAbandonedException e) {
					fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
				}
			}});
		
		imports = domain.getImports(otherRes);
		assertTrue(imports.contains(testResource));
		
		imports = domain.getAllImports(otherRes);
		assertTrue(imports.contains(testResource));
		
		exports = domain.getExports(testResource);
		assertTrue(exports.contains(otherRes));
		
		exports = domain.getAllExports(testResource);
		assertTrue(exports.contains(otherRes));
		
		domain.runUnvalidated(new MRunnable() {
			public Object run() {
				return domain.runInUndoInterval(new Runnable() {
					public void run() {
						try {
							domain.runAsWrite(new MRunnable() {
							
								public Object run() {
									otherWriter.getBooks().remove(level1Book);
									
									return null;
								}});
						} catch (MSLActionAbandonedException e) {
							fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
						}
					}
				});
			}
		});
		
		imports = domain.getImports(otherRes);
		assertFalse(imports.contains(testResource));
		
		imports = domain.getAllImports(otherRes);
		assertFalse(imports.contains(testResource));

		exports = domain.getExports(testResource);
		assertFalse(exports.contains(otherRes));
		
		exports = domain.getAllExports(testResource);
		assertFalse(exports.contains(otherRes));
	}

	/**
	 * Tests that resource import and exports information is properly
	 * maintained when a cross reference is set and unset.
	 */
	public void test_importsExportsSetUnset() {
		final Writer rootWriter = (Writer)root.getWriters().get(0);

		
		MUndoInterval undo = domain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					domain.runAsWrite(new MRunnable() {
					
						public Object run() {
							otherBook.setAuthor(rootWriter);
							
							return null;
						}});
				} catch (MSLActionAbandonedException e) {
					fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
				}
			}});

		Collection imports = domain.getImports(otherRes);
		assertTrue(imports.contains(testResource));
		
		imports = domain.getAllImports(otherRes);
		assertTrue(imports.contains(testResource));
		
		Collection exports = domain.getExports(testResource);
		assertTrue(exports.contains(otherRes));
		
		exports = domain.getAllExports(testResource);
		assertTrue(exports.contains(otherRes));

		// unset author by undo
		undo.undo();
		
		imports = domain.getImports(otherRes);
		assertFalse(imports.contains(testResource));
		
		imports = domain.getAllImports(otherRes);
		assertFalse(imports.contains(testResource));

		exports = domain.getExports(testResource);
		assertFalse(exports.contains(otherRes));
		
		exports = domain.getAllExports(testResource);
		assertFalse(exports.contains(otherRes));
	}
	
	/**
	 * Tests that resource import and exports information is properly
	 * maintained when a cross reference is added and removed.
	 */
	public void test_importsExportsAddRemove() {
		final Book rootBook = (Book)root.getBooks().get(0);

		MUndoInterval undo = domain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					domain.runAsWrite(new MRunnable() {
					
						public Object run() {
							otherWriter.getBooks().add(rootBook);
							
							return null;
						}});
				} catch (MSLActionAbandonedException e) {
					fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
				}
			}});

		Collection imports = domain.getImports(otherRes);
		assertTrue(imports.contains(testResource));
		
		imports = domain.getAllImports(otherRes);
		assertTrue(imports.contains(testResource));
		
		Collection exports = domain.getExports(testResource);
		assertTrue(exports.contains(otherRes));
		
		exports = domain.getAllExports(testResource);
		assertTrue(exports.contains(otherRes));

		// remove book by undo
		undo.undo();
		
		imports = domain.getImports(otherRes);
		assertFalse(imports.contains(testResource));
		
		imports = domain.getAllImports(otherRes);
		assertFalse(imports.contains(testResource));

		exports = domain.getExports(testResource);
		assertFalse(exports.contains(otherRes));
		
		exports = domain.getAllExports(testResource);
		assertFalse(exports.contains(otherRes));
	}

	/**
	 * Tests that when a resource containing a cross reference is unload,
	 * the cross reference information is maintained and not accessible.
	 */
	public void test_unloadedCrossReference() {
		final Employee boss = EXTLibraryFactory.eINSTANCE.createEmployee();

		domain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					domain.runAsWrite(new MRunnable() {
					
						public Object run() {
							root.getEmployees().add(boss);
							otherEmp.setManager(boss);

							return null;
						}});
				} catch (MSLActionAbandonedException e) {
					fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
				}
			}});
		
		Collection xrefs = EObjectUtil.getReferencers(
				boss,
				new EReference[] {EXTLibraryPackage.eINSTANCE.getEmployee_Manager()});
			
		assertTrue(xrefs.contains(otherEmp));

		// unload the resource containing the employee
		otherRes.unload();
		
		xrefs = EObjectUtil.getReferencers(
				boss,
				new EReference[] {EXTLibraryPackage.eINSTANCE.getEmployee_Manager()});
			
		// cannot find references because resource was unloaded and are not returned
		assertTrue(xrefs.isEmpty());
	}
	
	/**
	 * Tests when a resource containing a cross reference and the referencer
	 * is destroyed, that the cross reference information is updated.
	 */
	public void test_destroyReferencer() {
		final Employee boss = EXTLibraryFactory.eINSTANCE.createEmployee();

		domain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					domain.runAsWrite(new MRunnable() {
					
						public Object run() {
							root.getEmployees().add(boss);
							domain.getResourceSet().eAdapters().add(new ECrossReferenceAdapter());
							otherEmp.setManager(boss);
							return null;
						}});
				} catch (MSLActionAbandonedException e) {
					fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
				}
			}});

		Collection xrefs = EObjectUtil.getReferencers(
				boss,
				new EReference[] {EXTLibraryPackage.eINSTANCE.getEmployee_Manager()});

		assertTrue(xrefs.contains(otherEmp));

		domain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					domain.runAsWrite(new MRunnable() {
					
						public Object run() {
							EObjectUtil.destroy(otherEmp);
							return null;
						}});
				} catch (MSLActionAbandonedException e) {
					fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
				}
			}});
		xrefs = EObjectUtil.getReferencers(
				boss,
				new EReference[] {EXTLibraryPackage.eINSTANCE.getEmployee_Manager()});
			
		assertTrue(xrefs.isEmpty());
	}

	/**
	 * Tests when a resource containing a cross reference and the referencer
	 * is detached, that the cross reference information is maintained.
	 */
	public void test_detachReferencer() {
		final Employee boss = EXTLibraryFactory.eINSTANCE.createEmployee();

		domain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					domain.runAsWrite(new MRunnable() {
					
						public Object run() {
							root.getEmployees().add(boss);
							otherEmp.setManager(boss);
							return null;
						}});
				} catch (MSLActionAbandonedException e) {
					fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
				}
			}});

		Collection xrefs = EObjectUtil.getReferencers(
				boss,
				new EReference[] {EXTLibraryPackage.eINSTANCE.getEmployee_Manager()});

		assertTrue(xrefs.contains(otherEmp));

		domain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					domain.runAsWrite(new MRunnable() {
					
						public Object run() {
							otherRoot.getEmployees().remove(otherEmp);
							return null;
						}});
				} catch (MSLActionAbandonedException e) {
					fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
				}
			}});
		xrefs = EObjectUtil.getReferencers(
				boss,
				new EReference[] {EXTLibraryPackage.eINSTANCE.getEmployee_Manager()});
			
		assertTrue(xrefs.contains(otherEmp));
	}

	/**
	 * Tests when a resource containing a cross reference and the referenced object
	 * is detached, that the cross reference information is maintained.
	 */
	public void test_detachReferenced() {
		final Employee boss = EXTLibraryFactory.eINSTANCE.createEmployee();

		domain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					domain.runAsWrite(new MRunnable() {
					
						public Object run() {
							root.getEmployees().add(boss);
							otherEmp.setManager(boss);
							return null;
						}});
				} catch (MSLActionAbandonedException e) {
					fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
				}
			}});

		Collection xrefs = EObjectUtil.getReferencers(
				boss,
				new EReference[] {EXTLibraryPackage.eINSTANCE.getEmployee_Manager()});

		assertTrue(xrefs.contains(otherEmp));

		domain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					domain.runAsWrite(new MRunnable() {
					
						public Object run() {
							root.getEmployees().remove(boss);
							return null;
						}});
				} catch (MSLActionAbandonedException e) {
					fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
				}
			}});
		xrefs = EObjectUtil.getReferencers(
				boss,
				new EReference[] {EXTLibraryPackage.eINSTANCE.getEmployee_Manager()});
			
		assertTrue(xrefs.contains(otherEmp));
	}

	/**
	 * Tests when a resource containing a bi-directional cross reference
	 * to an object and the reference is destroyed, that the cross
	 * reference information is updated correctly
	 */
	public void test_biDirectionalReference() {
		final Book rootBook = (Book)root.getBooks().get(0);

		domain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					domain.runAsWrite(new MRunnable() {
					
						public Object run() {
							otherWriter.getBooks().add(rootBook);
							return null;
						}});
				} catch (MSLActionAbandonedException e) {
					fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
				}
			}});

		Collection xrefs = EObjectUtil.getReferencers(
				rootBook,
				new EReference[] {EXTLibraryPackage.eINSTANCE.getWriter_Books()});
			
		assertTrue(xrefs.contains(otherWriter));

		domain.runUnvalidated(new MRunnable() {
			public Object run() {
				return domain.runInUndoInterval(new Runnable() {
					public void run() {
						try {
							domain.runAsWrite(new MRunnable() {
							
								public Object run() {
									EObjectUtil.destroy(otherWriter);
									otherWriter = null;
									return null;
								}});
						} catch (MSLActionAbandonedException e) {
							fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
						}
					}
				});
			}
		});

		xrefs = EObjectUtil.getReferencers(
				rootBook,
				new EReference[] {EXTLibraryPackage.eINSTANCE.getWriter_Books()});
			
		assertTrue(xrefs.isEmpty());
	}

	/**
	 * Tests when a resource containing a uni-directional cross reference
	 * to an object in another resource and the reference is destroyed,
	 * that the cross reference information is updated correctly
	 */
	public void test_uniDirectionalReference() {
		final Employee boss = EXTLibraryFactory.eINSTANCE.createEmployee();

		domain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					domain.runAsWrite(new MRunnable() {
					
						public Object run() {
							root.getEmployees().add(boss);
							otherEmp.setManager(boss);
							return null;
						}});
				} catch (MSLActionAbandonedException e) {
					fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
				}
			}});

		Collection xrefs = EObjectUtil.getReferencers(
				boss,
				new EReference[] {EXTLibraryPackage.eINSTANCE.getEmployee_Manager()});
			
		assertTrue(xrefs.contains(otherEmp));

		domain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					domain.runAsWrite(new MRunnable() {
					
						public Object run() {
							EObjectUtil.destroy(otherEmp);
							otherEmp = null;
							return null;
						}});
				} catch (MSLActionAbandonedException e) {
					fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
				}
			}});

		xrefs = EObjectUtil.getReferencers(
				boss,
				new EReference[] {EXTLibraryPackage.eINSTANCE.getEmployee_Manager()});
			
		assertTrue(xrefs.isEmpty());
	}

	/**
	 * Tests retrieving referencers of a specific type.
	 */
	public void test_getReferencersOfType() {
		final Employee boss = EXTLibraryFactory.eINSTANCE.createEmployee();

		domain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					domain.runAsWrite(new MRunnable() {
					
						public Object run() {
							root.getEmployees().add(boss);
							otherEmp.setManager(boss);
							return null;
						}});
				} catch (MSLActionAbandonedException e) {
					fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
				}
			}});

		MSLCrossReferenceAdapter crossReferenceAdapter =
			MSLCrossReferenceAdapter.getCrossReferenceAdapter(boss);
		
		// tests valid type
		Collection xrefs = crossReferenceAdapter.getInverseReferencers(boss,
				EXTLibraryPackage.eINSTANCE.getEmployee_Manager(),
				EXTLibraryPackage.eINSTANCE.getEmployee());
			
		assertTrue(xrefs.contains(otherEmp));
		
		// tests valid type
		xrefs = crossReferenceAdapter.getInverseReferencers(boss,
				null,
				EXTLibraryPackage.eINSTANCE.getEmployee());
			
		assertTrue(xrefs.contains(otherEmp));
		
		// tests invalid type
		xrefs = crossReferenceAdapter.getInverseReferencers(boss,
				EXTLibraryPackage.eINSTANCE.getEmployee_Manager(),
				EXTLibraryPackage.eINSTANCE.getLibrary());
			
		assertTrue(xrefs.isEmpty());
		
		// tests invalid type
		xrefs = crossReferenceAdapter.getInverseReferencers(boss,
				null,
				EXTLibraryPackage.eINSTANCE.getLibrary());
		
		assertTrue(xrefs.isEmpty());
	}

	/**
	 * Tests retrieving referencers when the cross reference adapter
	 * is not added to the ResourceSet when the domain is created, but rather
	 * added at a later point in time.
	 */
	public void test_addLateCrossReferenceAdapter() {
		MSLEditingDomain mslDomain = (MSLEditingDomain)domain;
		
		// remove the cross reference adapter from the ResourceSet
		mslDomain.getResourceSet().eAdapters().remove(mslDomain.getCrossReferenceAdapter());
		
		final Employee boss = EXTLibraryFactory.eINSTANCE.createEmployee();

		domain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					domain.runAsWrite(new MRunnable() {
					
						public Object run() {
							root.getEmployees().add(boss);
							otherEmp.setManager(boss);
							return null;
						}});
				} catch (MSLActionAbandonedException e) {
					fail("Failed to update model: " + e.getLocalizedMessage()); //$NON-NLS-1$
				}
			}});

		Collection xrefs = EObjectUtil.getReferencers(
				boss,
				new EReference[] {EXTLibraryPackage.eINSTANCE.getEmployee_Manager()});
			
		assertTrue(xrefs.isEmpty());

		// add the cross reference adapter back to the ResourceSet
		mslDomain.getResourceSet().eAdapters().add(mslDomain.getCrossReferenceAdapter());

		// check that all children of the ResourceSet have a cross reference adapter
		checkHasCrossReferenceAdapter(mslDomain.getResourceSet());
		
		xrefs = EObjectUtil.getReferencers(
				boss,
				new EReference[] {EXTLibraryPackage.eINSTANCE.getEmployee_Manager()});
			
		assertTrue(xrefs.contains(otherEmp));
	}

	/* 
	 * Sets up a library test model:
	 * 
	 * Library     (otherRoot)
	 *  - Book     (otherBook)
	 *  - Writer   (otherWiter)
	 *  - Employee (otherEmp)
	 */
	protected void setUp() throws Exception {

		super.setUp();

		otherRes = ResourceUtil.create("/tmp/otherLibrary.extLibrary", //$NON-NLS-1$
				EXTLibraryPackage.eINSTANCE.getLibrary());
	
		domain.getResourceSet().getResources().add(otherRes);

		otherRoot = (Library)otherRes.getContents().get(0);
		otherBook = EXTLibraryFactory.eINSTANCE.createBook();
		otherWriter = EXTLibraryFactory.eINSTANCE.createWriter();
		otherEmp = EXTLibraryFactory.eINSTANCE.createEmployee();

		domain.runInUndoInterval(new Runnable() {
			public void run() {
				try {
					domain.runAsWrite(new MRunnable() {
					
						public Object run() {
							
							otherRoot.getBooks().add(otherBook);
							otherRoot.getWriters().add(otherWriter);
							otherRoot.getEmployees().add(otherEmp);
							
							return null;
						}});
				} catch (MSLActionAbandonedException e) {
					fail("Failed to setup test model: " + e.getLocalizedMessage()); //$NON-NLS-1$
				}
			}});
	}

	protected void tearDown() throws Exception {

		try {
			if (otherRes != null) {
				if (otherRes.isLoaded()) {
					otherRes.unload();
				}

				otherRes.getResourceSet().getResources().remove(otherRes);
			}
		} finally {
			super.tearDown();
		}
	}
}

Lines 1-5 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/internal/notifications/MSLResourceListener.java (-4 / +1 lines)
1	/******************************************************************************	1	/******************************************************************************
2	* Copyright (c) 2002, 2003 IBM Corporation and others.	2	* Copyright (c) 2002-2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 182-190 Link Here
182		182
183	loadedResources.remove(notifier);	183	loadedResources.remove(notifier);
184		184
185	domain.getResourceIndexer().deregisterReferences(
186	notifier);
187
188	domain.getUndoStack().flushAll();	185	domain.getUndoStack().flushAll();
189		186
190	EObject root = null;	187	EObject root = null;




/******************************************************************************
 * Copyright (c) 2002-2006 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


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

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import org.eclipse.emf.common.notify.Notification;
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.domain.MSLEditingDomain;
import org.eclipse.gmf.runtime.emf.core.internal.resources.MResource;
import org.eclipse.gmf.runtime.emf.core.internal.util.MSLUtil;

/**


		int eventType = notification.getEventType();

		Object feature = notification.getFeature();

		if (resource != null) {

			if (!domain.getResouceListener().resourceFinishedLoading(resource))

		// populate undo stack.
		domain.getCommandGenerator().generateCommand(notification);

		// process references.
		processReferences(notifier, eventType, newValue, oldValue, feature,
				resource);

		// forward event to broker.
		domain.getEventBroker().addEvent(notification);
	}

	/**
	 * Process references and update reference maps.
	 */
	private void processReferences(EObject notifier, int eventType,
			Object newValue, Object oldValue, Object feature, Resource resource) {

		if (feature instanceof EReference) {

			// maintain the reverese reference map.
			EReference reference = (EReference) feature;

			List newObjects = new ArrayList();
			List oldObjects = new ArrayList();

			if ((eventType == Notification.SET)
					|| (eventType == Notification.UNSET)
					|| (eventType == Notification.ADD)
					|| (eventType == Notification.REMOVE)
					|| (eventType == Notification.ADD_MANY)
					|| (eventType == Notification.REMOVE_MANY)
					|| (eventType == Notification.RESOLVE)) {

				if (newValue instanceof EObject)
					newObjects.add(newValue);

				else if (newValue instanceof Collection) {

					Iterator i = ((Collection) newValue).iterator();

					while (i.hasNext()) {

						Object newObject = i.next();

						if (newObject instanceof EObject)
							newObjects.add(newObject);
					}
				}

				if (oldValue instanceof EObject)
					oldObjects.add(oldValue);

				else if (oldValue instanceof Collection) {

					Iterator i = ((Collection) oldValue).iterator();

					while (i.hasNext()) {

						Object oldObject = i.next();

						if (oldObject instanceof EObject)
							oldObjects.add(oldObject);
					}
				}
			}

			if (resource instanceof MResource)
				((MResource) resource).getHelper().registerReferences(domain,
						notifier, reference, newObjects, oldObjects);
			else
				MSLUtil.registerReferences(domain, notifier, reference,
						newObjects, oldObjects);
		}
	}
}

Lines 1-5 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/internal/index/MSLReferenceVisitor.java (-41 / +73 lines)
1	/******************************************************************************	1	/******************************************************************************
2	* Copyright (c) 2004 IBM Corporation and others.	2	* Copyright (c) 2004-2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 11-23 Link Here
11		11
12	package org.eclipse.gmf.runtime.emf.core.internal.index;	12	package org.eclipse.gmf.runtime.emf.core.internal.index;
13		13
14	import java.lang.ref.WeakReference;	14	import java.util.ArrayList;
		15	import java.util.Collection;
		16	import java.util.Collections;
		17	import java.util.HashMap;
		18	import java.util.Iterator;
15	import java.util.List;	19	import java.util.List;
16	import java.util.Map;	20	import java.util.Map;
		21	import java.util.Set;
17		22
18	import org.eclipse.emf.ecore.EObject;	23	import org.eclipse.emf.ecore.EObject;
19	import org.eclipse.emf.ecore.EReference;	24	import org.eclipse.emf.ecore.EReference;
20		25	import org.eclipse.emf.ecore.EStructuralFeature.Setting;
21	import org.eclipse.gmf.runtime.emf.core.internal.domain.MSLEditingDomain;	26	import org.eclipse.gmf.runtime.emf.core.internal.domain.MSLEditingDomain;
22		27
23	/**	28	/**
Lines 32-64 Link Here
32		37
33	protected EObject referencedObject = null;	38	protected EObject referencedObject = null;
34		39
35	private boolean resolve = true;
36
37	/**	40	/**
38	* Constructor.	41	* Constructor.
39	*/	42	*/
40	public MSLReferenceVisitor(MSLEditingDomain domain, EObject eObject) {	43	public MSLReferenceVisitor(MSLEditingDomain domain, EObject eObject) {
41	this(domain, eObject, true);
42	}
43
44	/**
45	* Constructor.
46	*/
47	public MSLReferenceVisitor(MSLEditingDomain domain, EObject eObject,
48	boolean resolve) {
49
50	this.domain = domain;	44	this.domain = domain;
51	this.referencedObject = eObject;	45	this.referencedObject = eObject;
52	this.resolve = resolve;
53	}	46	}
54		47
		48
55	/**	49	/**
56	* Visit all the referencers.	50	* Visit all the referencers.
57	*/	51	*/
58	public void visitReferencers() {	52	public void visitReferencers() {
59		53
60	Map featureMap = domain.getObjectIndexer().getGroupedReferencers(	54	Map featureMap = getGroupedReferencers(referencedObject);
61	referencedObject, resolve);
62		55
63	// operate on a clone to prevent concurrent access exceptions.	56	// operate on a clone to prevent concurrent access exceptions.
64	Object[] references = featureMap.keySet().toArray();	57	Object[] references = featureMap.keySet().toArray();
Lines 67-112 Link Here
67		60
68	EReference reference = (EReference) references[i];	61	EReference reference = (EReference) references[i];
69		62
70	Object value = featureMap.get(reference);	63	List referencerList = (List)featureMap.get(reference);
71		64
72	if (value instanceof List) {	65	// operate on a clone to prevent concurrent access exceptions.
		66	Object[] referencers = referencerList.toArray();
73		67
74	List referencerList = (List) value;	68	for (int j = 0; j < referencers.length; j++) {
		69	EObject referencer = (EObject) referencerList.get(j);
75		70
76	// operate on a clone to prevent concurrent access exceptions.	71	visitedReferencer(reference, referencer);
77	Object[] referencers = referencerList.toArray();	72	}
		73	}
		74	}
78		75
79	for (int j = 0; j < referencers.length; j++) {	76	/**
		77	* Override to implement processing the visit.
		78	*/
		79	protected abstract void visitedReferencer(EReference reference,
		80	EObject referencer);
80		81
81	WeakReference r = (WeakReference) referencerList.get(j);	82	/**
		83	* For the given referenced EObject, returns a Map whose keys are EReferences
		84	* and values are EObjects that reference the referenced EObject with the key
		85	* EReference.
		86	*
		87	* @param referenced the referenced EObject
		88	* @return a Map of referencers
		89	*/
		90	private Map getGroupedReferencers(EObject referenced) {
82		91
83	if (r != null) {	92	Map newMap = new HashMap();
84		93
85	EObject referencer = (EObject) r.get();	94	MSLCrossReferenceAdapter crossReferenceAdapter = domain.getCrossReferenceAdapter();
86		95
87	if (referencer != null)	96	// first group all the inverse referencers
88	visitedReferencer(reference, referencer);	97	Collection nonNavigableInverseReferences =
89	}	98	crossReferenceAdapter.getNonNavigableInverseReferences(referenced);
		99
		100	if (nonNavigableInverseReferences != null &&
		101	!nonNavigableInverseReferences.isEmpty()) {
		102	for (Iterator iter = nonNavigableInverseReferences.iterator(); iter
		103	.hasNext();) {
		104	Setting setting = (Setting) iter.next();
		105	List list = (List)newMap.get(setting.getEStructuralFeature());
		106	if (list == null) {
		107	list = new ArrayList();
		108	list.add(setting.getEObject());
		109	newMap.put(setting.getEStructuralFeature(), list);
		110	} else {
		111	list.add(setting.getEObject());
90	}	112	}
		113	}
		114	}
		115
		116	// next loop through all the EReferences to find referencers
		117	// for those EReferences with opposites
		118	List features = referenced.eClass().getEAllReferences();
		119
		120	for (Iterator i = features.iterator(); i.hasNext();) {
		121
		122	EReference reference = (EReference) i.next();
91		123
92	} else if (value instanceof WeakReference) {	124	EReference opposite = reference.getEOpposite();
93		125
94	WeakReference r = (WeakReference) value;	126	if (opposite != null && reference.isChangeable()
		127	&& !reference.isContainer() && !reference.isContainment()) {
95		128
96	if (r != null) {	129	Set referencers = crossReferenceAdapter.getInverseReferencers(referenced, opposite, null);
97		130
98	EObject referencer = (EObject) r.get();	131	if (!referencers.isEmpty()) {
99		132
100	if (referencer != null)	133	newMap.put(opposite, new ArrayList(referencers));
101	visitedReferencer(reference, referencer);
102	}	134	}
103	}	135	}
104	}	136	}
105	}
106		137
107	/**	138	if (newMap != null) {
108	* Override to implement processing the visit.	139	return Collections.unmodifiableMap(newMap);
109	*/	140	} else {
110	protected abstract void visitedReferencer(EReference reference,	141	return Collections.EMPTY_MAP;
111	EObject referencer);	142	}
		143	}
112	}	144	}




/******************************************************************************
 * 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.index;

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.emf.common.notify.Adapter;
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.resource.Resource;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.util.InternalEList;

import org.eclipse.gmf.runtime.emf.core.internal.domain.MSLEditingDomain;
import org.eclipse.gmf.runtime.emf.core.internal.resources.MResourceFactory;
import org.eclipse.gmf.runtime.emf.core.internal.util.MSLUtil;
import org.eclipse.gmf.runtime.emf.core.util.EObjectUtil;

/**
 * This class manages the reverse reference map feature at the object level.
 * When resources are loaded the reverse map gets updated without causing more
 * resources to be loaded.
 * 
 * @author rafikj
 */
public class MSLObjectIndexer {

	private MSLEditingDomain domain = null;

	/**
	 * Constructor.
	 */
	public MSLObjectIndexer(MSLEditingDomain domain) {

		super();

		this.domain = domain;
	}

	/**
	 * Registers a reference in the reverse reference map.
	 */
	public boolean registerReference(EObject referencer, EObject referenced,
			EReference reference) {

		// ignore non changeable and container/containment features.
		if ((!reference.isChangeable()) || (reference.isContainer())
			|| (reference.isContainment()))
			return false;

		if (referencer.eIsProxy())
			return false;

		// register resource reference.
		Resource referencerResource = referencer.eResource();

		Resource referencedResource = MSLUtil.getResource(domain, referenced);

		if (referenced.eIsProxy()) {

			URI uri = EcoreUtil.getURI(referenced);

			Resource.Factory factory = Resource.Factory.Registry.INSTANCE
				.getFactory(uri);

			if (!(factory instanceof MResourceFactory)) {

				if ((referencerResource == referencedResource)
					|| ((referencedResource != null) && (referencedResource
						.isLoaded())))
					referenced = EcoreUtil.resolve(referenced, domain
						.getResourceSet());
			}
		}

		domain.getResourceIndexer().registerReference(referencerResource,
			referencedResource);

		return doRegisterReference(referencer, referenced, reference);
	}

	/**
	 * Registers a reference in the reverse reference map.
	 */
	private boolean doRegisterReference(EObject referencer, EObject referenced,
			EReference reference) {

		// ignore features that have opposites.
		if (reference.getEOpposite() != null)
			return false;

		// objects must be resolved.
		if (referenced.eIsProxy())
			return false;

		Map featureMap = getFeatureMap(referenced);

		if (featureMap == null)
			featureMap = createFeatureMap(referenced);

		WeakReference ref = new WeakReference(referencer);

		Object value = featureMap.get(reference);

		// value is a list.
		if (value instanceof List) {

			int index = -1;

			List referencerList = (List) value;

			for (int i = 0, count = referencerList.size(); i < count; i++) {

				WeakReference r = (WeakReference) referencerList.get(i);

				if (r == null) {

					// found empty slot.
					if (index == -1)
						index = i;

				} else {

					Object current = r.get();

					// object already there.
					if (current == referencer)
						ref = null;

					else if (current == null) {

						referencerList.set(i, null);

						// found empty slot.
						if (index == -1)
							index = i;
					}
				}
			}

			// if not already there add.
			if (ref != null) {

				// resuse slot if any.
				if (index != -1)
					referencerList.set(index, ref);
				else
					referencerList.add(ref);
			}

		} else if (value instanceof WeakReference) {

			// value is a weak reference.
			WeakReference r = (WeakReference) value;

			Object current = r.get();

			if (current == referencer) {

				// already there.
				ref = null;

			} else if (current == null) {

				// put in empty slot.
				featureMap.put(reference, ref);

			} else {

				// create a new list if more than one.
				List referencerList = new ArrayList(2);

				referencerList.add(r);
				referencerList.add(ref);

				featureMap.put(reference, referencerList);
			}

		} else if (value == null) {

			// found empty slot.
			featureMap.put(reference, ref);
		}

		return true;
	}

	/**
	 * Deregisters a reference in the reverse reference map.
	 */
	public void deregisterReference(EObject referencer, EObject referenced,
			EReference reference) {

		// ignore non changeable and container/containment features.
		if ((!reference.isChangeable()) || (reference.isContainer())
			|| (reference.isContainment()))
			return;

		if (referencer.eIsProxy())
			return;

		// deregister resource reference.
		Resource referencerResource = referencer.eResource();

		Resource referencedResource = MSLUtil.getResource(domain, referenced);

		domain.getResourceIndexer().deregisterReference(referencerResource,
			referencedResource);

		doDeregisterReference(referencer, referenced, reference);
	}

	/**
	 * Deregisters a reference in the reverse reference map.
	 */
	private void doDeregisterReference(EObject referencer, EObject referenced,
			EReference reference) {

		Map featureMap = getFeatureMap(referenced);

		if (featureMap == null)
			return;

		Object value = featureMap.get(reference);

		if (value instanceof List) {

			// value is a list.
			List referencerList = (List) value;

			boolean empty = true;

			for (int i = 0, count = referencerList.size(); i < count; i++) {

				WeakReference r = (WeakReference) referencerList.get(i);

				if (r != null) {

					Object current = r.get();

					if (current == referencer)
						referencerList.set(i, null);

					else if (current == null)
						referencerList.set(i, null);

					else if (empty)
						empty = false;
				}
			}

			if (empty)
				featureMap.remove(reference);

		} else if (value instanceof WeakReference) {

			// value is a weak reference.
			WeakReference r = (WeakReference) value;

			if (r.get() == referencer)
				featureMap.remove(reference);

		} else
			return;

		if (featureMap.isEmpty())
			removeFeatureMap(referenced);
	}

	/**
	 * Registers references by traversing the referencer object. Referencer is a
	 * non proxy object.
	 */
	public void registerReferences(EObject container, EObject eObject) {

		if (eObject.eIsProxy())
			return;

		EList features = eObject.eClass().getEAllReferences();

		Iterator i = features.iterator();

		while (i.hasNext()) {

			EReference reference = (EReference) i.next();

			if ((reference.isChangeable()) && (!reference.isContainer())
				&& (eObject.eIsSet(reference))) {

				if (reference.isMany()) {

					if (reference.isContainment()) {

						EList objects = (EList) eObject.eGet(reference);

						for (Iterator j = objects.iterator(); j.hasNext();) {

							EObject contained = (EObject) j.next();

							if (contained != null)
								registerReferences(container, contained);
						}

					} else {

						EList objects = (EList) eObject.eGet(reference, false);

						// ensure references are not resolved.
						boolean resolve = true;

						for (Iterator j = ((InternalEList) objects)
							.basicIterator(); j.hasNext();) {

							EObject referenced = (EObject) j.next();

							if (referenced != null) {

								if (!registerReference(eObject, referenced,
									reference))
									resolve = false;
							}
						}

						// if all references were resolveable resolve the whole
						// list.
						if (resolve) {

							for (Iterator k = objects.iterator(); k.hasNext();)
								k.next();
						}
					}

				} else {

					if (reference.isContainment()) {

						EObject contained = (EObject) eObject.eGet(reference);

						if (contained != null)
							registerReferences(container, contained);

					} else {

						// ensure reference is not resolved.
						EObject referenced = (EObject) eObject.eGet(reference,
							false);

						if (referenced != null) {

							boolean resolve = registerReference(eObject,
								referenced, reference);

							// if reference was resolveable resolve it.
							if (resolve)
								eObject.eGet(reference);
						}
					}
				}
			}
		}

		// register referencer resources.
		final Resource containerResource = container.eResource();

		MSLReferenceVisitor visitor = new MSLReferenceVisitor(domain, eObject,
			false) {

			protected void visitedReferencer(EReference reference,
					EObject referencer) {

				Resource referencerResource = referencer.eResource();

				domain.getResourceIndexer().registerReference(
					referencerResource, containerResource);
			}
		};

		visitor.visitReferencers();
	}

	/**
	 * Deregisters references by traversing the referencer object.
	 */
	public void deregisterReferences(EObject container, EObject eObject) {
		deregisterReferences(container, eObject, eObject);
	}

	/**
	 * Deregisters references by traversing the referencer object.
	 */
	public void deregisterReferences(EObject container, final EObject detached,
			EObject eObject) {

		if (eObject.eIsProxy())
			return;

		final Resource containerResource = container.eResource();

		EList features = eObject.eClass().getEAllReferences();

		Iterator i = features.iterator();

		while (i.hasNext()) {

			EReference reference = (EReference) i.next();

			if ((reference.isChangeable()) && (!reference.isContainer())
				&& (eObject.eIsSet(reference))) {

				if (reference.isMany()) {

					if (reference.isContainment()) {

						EList objects = (EList) eObject.eGet(reference);

						for (Iterator j = objects.iterator(); j.hasNext();) {

							EObject contained = (EObject) j.next();

							if (contained != null)
								deregisterReferences(container, detached,
									contained);
						}

					} else {

						EList objects = (EList) eObject.eGet(reference, false);

						// ensure references are not resolved.
						for (Iterator j = ((InternalEList) objects)
							.basicIterator(); j.hasNext();) {

							EObject referenced = (EObject) j.next();

							if ((referenced != null)
								&& (!EObjectUtil.contains(detached, referenced))) {

								Resource referencedResource = MSLUtil
									.getResource(domain, referenced);

								domain.getResourceIndexer()
									.deregisterReference(containerResource,
										referencedResource);
							}
						}
					}

				} else {

					if (reference.isContainment()) {

						EObject contained = (EObject) eObject.eGet(reference);

						if (contained != null)
							deregisterReferences(container, detached, contained);

					} else {

						// ensure reference is not resolved.
						EObject referenced = (EObject) eObject.eGet(reference,
							false);

						if ((referenced != null)
							&& (!EObjectUtil.contains(detached, referenced))) {

							Resource referencedResource = MSLUtil.getResource(
								domain, referenced);

							domain.getResourceIndexer().deregisterReference(
								containerResource, referencedResource);
						}
					}
				}
			}
		}

		// deregister referencer resources.
		MSLReferenceVisitor visitor = new MSLReferenceVisitor(domain, eObject) {

			protected void visitedReferencer(EReference reference,
					EObject referencer) {

				if (!EObjectUtil.contains(detached, referencer)) {

					Resource referencerResource = referencer.eResource();

					domain.getResourceIndexer().deregisterReference(
						referencerResource, containerResource);
				}
			}
		};

		visitor.visitReferencers();
	}

	/**
	 * Resolves references by traversing the referencer object. Referencer is a
	 * non proxy object.
	 */
	public void resolveReferences(EObject container, EObject eObject) {

		if (eObject.eIsProxy())
			return;

		EList features = eObject.eClass().getEAllReferences();

		Iterator i = features.iterator();

		while (i.hasNext()) {

			EReference reference = (EReference) i.next();

			if ((reference.isChangeable()) && (!reference.isContainer())
				&& (eObject.eIsSet(reference))) {

				if (reference.isMany()) {

					if (reference.isContainment()) {

						EList objects = (EList) eObject.eGet(reference);

						for (Iterator j = objects.iterator(); j.hasNext();) {

							EObject contained = (EObject) j.next();

							if (contained != null)
								resolveReferences(container, contained);
						}

					} else {

						EList objects = (EList) eObject.eGet(reference, false);

						// ensure references are not resolved.
						boolean resolve = true;

						for (Iterator j = ((InternalEList) objects)
							.basicIterator(); j.hasNext();) {

							EObject referenced = (EObject) j.next();

							if (referenced != null) {

								if (!resolveReference(eObject, referenced,
									reference))
									resolve = false;
							}
						}

						// if all references were resolveable resolve the whole
						// list.
						if (resolve) {

							for (Iterator k = objects.iterator(); k.hasNext();)
								k.next();
						}
					}

				} else {

					if (reference.isContainment()) {

						EObject contained = (EObject) eObject.eGet(reference);

						if (contained != null)
							resolveReferences(container, contained);

					} else {

						// ensure reference is not resolved.
						EObject referenced = (EObject) eObject.eGet(reference,
							false);

						if (referenced != null) {

							boolean resolve = resolveReference(eObject,
								referenced, reference);

							// if reference was resolveable resolve it.
							if (resolve)
								eObject.eGet(reference);
						}
					}
				}
			}
		}
	}

	/**
	 * Resolves a reference.
	 */
	public boolean resolveReference(EObject referencer, EObject referenced,
			EReference reference) {

		// ignore non changeable and container/containment features.
		if ((!reference.isChangeable()) || (reference.isContainer())
			|| (reference.isContainment()))
			return false;

		if (referencer.eIsProxy())
			return false;

		if (referenced.eIsProxy()) {

			// register resource reference.
			Resource referencerResource = referencer.eResource();

			Resource referencedResource = MSLUtil.getResource(domain,
				referenced);

			URI uri = EcoreUtil.getURI(referenced);

			Resource.Factory factory = Resource.Factory.Registry.INSTANCE
				.getFactory(uri);

			if (!(factory instanceof MResourceFactory)) {

				if ((referencerResource == referencedResource)
					|| ((referencedResource != null) && (referencedResource
						.isLoaded())))
					referenced = EcoreUtil.resolve(referenced, domain
						.getResourceSet());
			}

			if (referenced.eIsProxy())
				return false;
			else
				doRegisterReference(referencer, referenced, reference);
		}

		return true;
	}

	/**
	 * Retrieves reverse references.
	 */
	public Map getGroupedReferencers(EObject referenced) {
		return getGroupedReferencers(referenced, true);
	}

	/**
	 * Retrieves reverse references.
	 */
	public Map getGroupedReferencers(EObject referenced, boolean resolve) {

		Map map = getFeatureMap(referenced);

		Map newMap = null;

		List features = referenced.eClass().getEAllReferences();

		for (Iterator i = features.iterator(); i.hasNext();) {

			EReference reference = (EReference) i.next();

			EReference opposite = reference.getEOpposite();

			if (opposite != null) {

				Set referencers = getReferencers(referenced, opposite, resolve);

				if (!referencers.isEmpty()) {

					if (newMap == null)
						newMap = (map == null) ? (new HashMap())
							: (new HashMap(map));

					List newReferencers = new ArrayList(referencers.size());

					for (Iterator j = referencers.iterator(); j.hasNext();)
						newReferencers.add(new WeakReference(j.next()));

					newMap.put(opposite, newReferencers);
				}
			}
		}

		if (newMap != null)
			return Collections.unmodifiableMap(newMap);

		else if (map != null)
			return Collections.unmodifiableMap(map);

		else
			return Collections.EMPTY_MAP;
	}

	/**
	 * Retrieves reverse references.
	 */
	public Set getAllReferencers(EObject referenced) {
		return getAllReferencers(referenced, true);
	}

	/**
	 * Retrieves reverse references.
	 */
	public Set getAllReferencers(EObject referenced, boolean resolve) {

		if (referenced.eIsProxy())
			return Collections.EMPTY_SET;

		final Set set = new HashSet();

		MSLReferenceVisitor visitor = new MSLReferenceVisitor(domain,
			referenced, resolve) {

			protected void visitedReferencer(EReference reference,
					EObject referencer) {

				if (!referencer.eIsProxy())
					set.add(referencer);
			}
		};

		visitor.visitReferencers();

		return Collections.unmodifiableSet(set);
	}

	/**
	 * Retrieves reverse references.
	 */
	public Set getReferencers(EObject referenced, EReference reference) {
		return getReferencers(referenced, reference, true);
	}

	/**
	 * Retrieves reverse references.
	 */
	public Set getReferencers(EObject referenced, EReference reference,
			boolean resolve) {

		if (referenced.eIsProxy())
			return Collections.EMPTY_SET;

		if ((reference.isChangeable()) && (!reference.isContainer())
			&& (!reference.isContainment())) {

			EReference opposite = reference.getEOpposite();

			if (opposite == null) {

				Map featureMap = getFeatureMap(referenced);

				if (featureMap != null) {

					Object value = featureMap.get(reference);

					if (value instanceof List) {

						// value is a list.
						List referencerList = (List) value;

						Set set = new HashSet();

						for (int i = 0, count = referencerList.size(); i < count; i++) {

							WeakReference r = (WeakReference) referencerList
								.get(i);

							if (r != null) {

								EObject referencer = (EObject) r.get();

								if ((referencer != null)
									&& (!referencer.eIsProxy()))
									set.add(referencer);
							}
						}

						return Collections.unmodifiableSet(set);

					} else if (value instanceof WeakReference) {

						// value is a weak reference.
						WeakReference r = (WeakReference) value;

						EObject referencer = (EObject) r.get();

						if (referencer != null)
							return Collections.singleton(referencer);
					}
				}

			} else {

				if ((opposite.isChangeable()) && (!opposite.isContainer())
					&& (!opposite.isContainment())
					&& (referenced.eIsSet(opposite))) {

					if (opposite.isMany()) {

						List referencers = (List) referenced.eGet(opposite,
							resolve);

						if (!referencers.isEmpty()) {

							// try not to resolve if asked to.
							if (resolve)
								return Collections.unmodifiableSet(new HashSet(
									referencers));
							else {

								Set nonProxyReferencers = new HashSet();

								for (Iterator j = ((InternalEList) referencers)
									.basicIterator(); j.hasNext();) {

									EObject referencer = (EObject) j.next();

									if ((referencer != null)
										&& (!referencer.eIsProxy()))
										nonProxyReferencers.add(referencer);
								}

								return Collections
									.unmodifiableSet(nonProxyReferencers);
							}
						}

					} else {

						// try not to resolve if asked to.
						EObject referencer = (EObject) referenced.eGet(
							opposite, resolve);

						if ((referencer != null) && (!referencer.eIsProxy()))
							return Collections.singleton(referencer);
					}
				}
			}
		}

		return Collections.EMPTY_SET;
	}

	/**
	 * Gets feature map of a given object.
	 */
	private Map getFeatureMap(EObject referenced) {

		for (int i = 0, count = referenced.eAdapters().size(); i < count; i++) {

			Adapter adapter = (Adapter) referenced.eAdapters().get(i);

			if (adapter instanceof MSLReferenceAdapter)
				return (Map) adapter;
		}

		return null;
	}

	/**
	 * Creates feature map of a given object.
	 */
	private Map createFeatureMap(EObject referenced) {

		Map map = new MSLReferenceAdapter();

		referenced.eAdapters().add(map);

		return map;
	}

	/**
	 * Removes feature map of a given object.
	 */
	private Map removeFeatureMap(EObject referenced) {

		for (int i = 0, count = referenced.eAdapters().size(); i < count; i++) {

			Adapter adapter = (Adapter) referenced.eAdapters().get(i);

			if (adapter instanceof MSLReferenceAdapter) {

				referenced.eAdapters().remove(i);

				return (Map) adapter;
			}
		}

		return null;
	}
}





/******************************************************************************
 * Copyright (c) 2002, 2003 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.index;

import java.util.HashMap;

import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.Notifier;

/**
 * This class defines the reference adapter that will hold the exports for a
 * given resource.
 * 
 * @author rafikj
 */
public class MSLExportsAdapter
	extends HashMap
	implements Adapter {

	private static final long serialVersionUID = -9110312883845863489L;

	/**
	 * Constructor.
	 */
	public MSLExportsAdapter() {
		super(2);
	}

	/**
	 * @see org.eclipse.emf.common.notify.Adapter#notifyChanged(org.eclipse.emf.common.notify.Notification)
	 */
	public void notifyChanged(Notification notification) {
		// do nothing.
	}

	/**
	 * @see org.eclipse.emf.common.notify.Adapter#getTarget()
	 */
	public Notifier getTarget() {
		return null;
	}

	/**
	 * @see org.eclipse.emf.common.notify.Adapter#setTarget(org.eclipse.emf.common.notify.Notifier)
	 */
	public void setTarget(Notifier newTarget) {
		// do nothing.
	}

	/**
	 * @see org.eclipse.emf.common.notify.Adapter#isAdapterForType(java.lang.Object)
	 */
	public boolean isAdapterForType(Object type) {
		return false;
	}
}




/******************************************************************************
 * Copyright (c) 2002, 2003 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.index;

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

import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.impl.NotificationImpl;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;

import org.eclipse.gmf.runtime.emf.core.EventTypes;
import org.eclipse.gmf.runtime.emf.core.internal.domain.MSLEditingDomain;

/**
 * This class manages the reverse reference map feature at the resource level.
 * When resources are loaded the reverse map gets updated without causing more
 * resources to be loaded.
 * 
 * @author rafikj
 */
public class MSLResourceIndexer {

	private MSLEditingDomain domain = null;

	/**
	 * Constructor.
	 */
	public MSLResourceIndexer(MSLEditingDomain domain) {

		super();

		this.domain = domain;
	}

	/**
	 * Registers a reference in the imports and exports maps.
	 */
	public void registerReference(final Resource referencer,
			final Resource referenced) {

		if ((referencer != null) && (referenced != null)
			&& (referencer != referenced)) {

			Map importsMap = getImportsMap(referencer);

			if (importsMap == null)
				importsMap = createImportsMap(referencer);

			Integer importsCount = (Integer) importsMap.get(referenced);

			if (importsCount == null) {

				domain.sendNotification(new NotificationImpl(
					EventTypes.IMPORT, (Object) null, referenced, -1) {

					public Object getNotifier() {
						return referencer;
					}
				});

				importsCount = new Integer(1);

			} else
				importsCount = new Integer(importsCount.intValue() + 1);

			importsMap.put(referenced, importsCount);

			Map exportsMap = getExportsMap(referenced);

			if (exportsMap == null)
				exportsMap = createExportsMap(referenced);

			Integer exportsCount = (Integer) exportsMap.get(referencer);

			if (exportsCount == null) {

				domain.sendNotification(new NotificationImpl(
					EventTypes.EXPORT, (Object) null, referencer, -1) {

					public Object getNotifier() {
						return referenced;
					}
				});

				exportsCount = new Integer(1);

			} else
				exportsCount = new Integer(exportsCount.intValue() + 1);

			exportsMap.put(referencer, exportsCount);
		}
	}

	/**
	 * Dregisters a reference in the imports and exports maps.
	 */
	public void deregisterReference(final Resource referencer,
			final Resource referenced) {

		if ((referencer != null) && (referenced != null)
			&& (referencer != referenced)) {

			Map importsMap = getImportsMap(referencer);

			if (importsMap != null) {

				Integer importsCount = (Integer) importsMap.get(referenced);

				if (importsCount != null) {

					if (importsCount.intValue() < 2) {

						importsMap.remove(referenced);

						domain.sendNotification(new NotificationImpl(
							EventTypes.IMPORT, referenced, (Object) null, -1) {

							public Object getNotifier() {
								return referencer;
							}
						});
					} else
						importsMap.put(referenced, new Integer(importsCount
							.intValue() - 1));
				}

				if (importsMap.isEmpty())
					removeImportsMap(referencer);
			}

			Map exportsMap = getExportsMap(referenced);

			if (exportsMap != null) {

				Integer exportsCount = (Integer) exportsMap.get(referencer);

				if (exportsCount != null) {

					if (exportsCount.intValue() < 2) {

						exportsMap.remove(referencer);

						domain.sendNotification(new NotificationImpl(
							EventTypes.EXPORT, referencer, (Object) null, -1) {

							public Object getNotifier() {
								return referenced;
							}
						});
					} else
						exportsMap.put(referencer, new Integer(exportsCount
							.intValue() - 1));
				}

				if (exportsMap.isEmpty())
					removeExportsMap(referenced);
			}
		}
	}

	/**
	 * Registers references by traversing the referencer resource.
	 */
	public void registerReferences(Resource referencer) {

		List referencerContents = referencer.getContents();

		if (referencerContents == null)
			return;

		for (Iterator i = referencerContents.iterator(); i.hasNext();) {

			EObject referencerRoot = (EObject) i.next();

			if (referencerRoot != null) {

				domain.getObjectIndexer().registerReferences(referencerRoot,
					referencerRoot);

				Object[] exports = getExports(referencer).toArray();

				for (int j = 0; j < exports.length; j++) {

					Resource resource = (Resource) exports[j];

					List resourceContents = resource.getContents();

					if (resourceContents == null)
						continue;

					for (Iterator k = resourceContents.iterator(); k.hasNext();) {

						EObject resourceRoot = (EObject) k.next();

						if (resourceRoot != null)
							domain.getObjectIndexer().resolveReferences(
								resourceRoot, resourceRoot);
					}
				}
			}
		}
	}

	/**
	 * Cleans reference maps.
	 */
	public void deregisterReferences(final Resource referencer) {

		Object[] imports = getImports(referencer).toArray();

		for (int i = 0; i < imports.length; i++) {

			final Resource referenced = (Resource) imports[i];

			Map importsMap = getImportsMap(referencer);

			if (importsMap != null) {

				importsMap.remove(referenced);

				domain.sendNotification(new NotificationImpl(
					EventTypes.IMPORT, referenced, (Object) null, -1) {

					public Object getNotifier() {
						return referencer;
					}
				});

				if (importsMap.isEmpty())
					removeImportsMap(referencer);
			}

			Map exportsMap = getExportsMap(referenced);

			if (exportsMap != null) {

				exportsMap.remove(referencer);

				domain.sendNotification(new NotificationImpl(
					EventTypes.EXPORT, referencer, (Object) null, -1) {

					public Object getNotifier() {
						return referenced;
					}
				});

				if (exportsMap.isEmpty())
					removeExportsMap(referenced);
			}
		}
	}

	/**
	 * Gets the imports of a resource.
	 */
	public Set getImports(Resource referencer) {

		Map importsMap = getImportsMap(referencer);

		if (importsMap != null)
			return Collections.unmodifiableSet(importsMap.keySet());
		else
			return Collections.EMPTY_SET;
	}

	/**
	 * Gets the exports of a resource.
	 */
	public Set getExports(Resource referenced) {

		Map exportsMap = getExportsMap(referenced);

		if (exportsMap != null)
			return Collections.unmodifiableSet(exportsMap.keySet());
		else
			return Collections.EMPTY_SET;
	}

	/**
	 * Gets imports map of a given resource.
	 */
	private Map getImportsMap(Resource referencer) {

		for (int i = 0, count = referencer.eAdapters().size(); i < count; i++) {

			Adapter adapter = (Adapter) referencer.eAdapters().get(i);

			if (adapter instanceof MSLImportsAdapter)
				return (Map) adapter;
		}

		return null;
	}

	/**
	 * Creates imports map of a given resource.
	 */
	private Map createImportsMap(Resource referencer) {

		Map map = new MSLImportsAdapter();

		referencer.eAdapters().add(map);

		return map;
	}

	/**
	 * Removes imports map of a given resource.
	 */
	private Map removeImportsMap(Resource referencer) {

		for (int i = 0, count = referencer.eAdapters().size(); i < count; i++) {

			Adapter adapter = (Adapter) referencer.eAdapters().get(i);

			if (adapter instanceof MSLImportsAdapter) {

				referencer.eAdapters().remove(i);

				return (Map) adapter;
			}
		}

		return null;
	}

	/**
	 * Gets exports map of a given resource.
	 */
	private Map getExportsMap(Resource referenced) {

		for (int i = 0, count = referenced.eAdapters().size(); i < count; i++) {

			Adapter adapter = (Adapter) referenced.eAdapters().get(i);

			if (adapter instanceof MSLExportsAdapter)
				return (Map) adapter;
		}

		return null;
	}

	/**
	 * Creates exports map of a given resource.
	 */
	private Map createExportsMap(Resource referenced) {

		Map map = new MSLExportsAdapter();

		referenced.eAdapters().add(map);

		return map;
	}

	/**
	 * Removes exports map of a given resource.
	 */
	private Map removeExportsMap(Resource referenced) {

		for (int i = 0, count = referenced.eAdapters().size(); i < count; i++) {

			Adapter adapter = (Adapter) referenced.eAdapters().get(i);

			if (adapter instanceof MSLExportsAdapter) {

				referenced.eAdapters().remove(i);

				return (Map) adapter;
			}
		}

		return null;
	}
}




/******************************************************************************
 * Copyright (c) 2002, 2003 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.index;

import java.util.HashMap;

import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.Notifier;

/**
 * This class defines the reference adapter that will hold the reverse map for a
 * given EObject.
 * 
 * @author rafikj
 */
public class MSLReferenceAdapter
	extends HashMap
	implements Adapter {

	private static final long serialVersionUID = 1989964645244552123L;

	/**
	 * Constructor.
	 */
	public MSLReferenceAdapter() {
		super(2);
	}

	/**
	 * @see org.eclipse.emf.common.notify.Adapter#notifyChanged(org.eclipse.emf.common.notify.Notification)
	 */
	public void notifyChanged(Notification notification) {
		// do nothing.
	}

	/**
	 * @see org.eclipse.emf.common.notify.Adapter#getTarget()
	 */
	public Notifier getTarget() {
		return null;
	}

	/**
	 * @see org.eclipse.emf.common.notify.Adapter#setTarget(org.eclipse.emf.common.notify.Notifier)
	 */
	public void setTarget(Notifier newTarget) {
		// do nothing.
	}

	/**
	 * @see org.eclipse.emf.common.notify.Adapter#isAdapterForType(java.lang.Object)
	 */
	public boolean isAdapterForType(Object type) {
		return false;
	}
}




/******************************************************************************
 * Copyright (c) 2002, 2003 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.index;

import java.util.HashMap;

import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.Notifier;

/**
 * This class defines the reference adapter that will hold the imports for a
 * given resource.
 * 
 * @author rafikj
 */
public class MSLImportsAdapter
	extends HashMap
	implements Adapter {

	private static final long serialVersionUID = 7770242431763053066L;

	/**
	 * Constructor.
	 */
	public MSLImportsAdapter() {
		super(2);
	}

	/**
	 * @see org.eclipse.emf.common.notify.Adapter#notifyChanged(org.eclipse.emf.common.notify.Notification)
	 */
	public void notifyChanged(Notification notification) {
		// do nothing.
	}

	/**
	 * @see org.eclipse.emf.common.notify.Adapter#getTarget()
	 */
	public Notifier getTarget() {
		return null;
	}

	/**
	 * @see org.eclipse.emf.common.notify.Adapter#setTarget(org.eclipse.emf.common.notify.Notifier)
	 */
	public void setTarget(Notifier newTarget) {
		// do nothing.
	}

	/**
	 * @see org.eclipse.emf.common.notify.Adapter#isAdapterForType(java.lang.Object)
	 */
	public boolean isAdapterForType(Object type) {
		return false;
	}
}




import org.eclipse.gmf.runtime.emf.core.exceptions.MSLRuntimeException;
import org.eclipse.gmf.runtime.emf.core.internal.commands.MSLCommandGenerator;
import org.eclipse.gmf.runtime.emf.core.internal.commands.MSLUndoStack;
import org.eclipse.gmf.runtime.emf.core.internal.index.MSLCrossReferenceAdapter;
import org.eclipse.gmf.runtime.emf.core.internal.index.MSLResourceIndexer;
import org.eclipse.gmf.runtime.emf.core.internal.l10n.EMFCoreMessages;
import org.eclipse.gmf.runtime.emf.core.internal.notifications.MSLContentAdapter;
import org.eclipse.gmf.runtime.emf.core.internal.notifications.MSLEventBroker;


	private MSLPathmap pathmap = null;

	private MSLCrossReferenceAdapter crossReferenceAdapter = null;

	private MSLResourceIndexer resourceIndexer = null;

	private static Map resourceSets = new WeakHashMap();



		pathmap = new MSLPathmap(this);

		crossReferenceAdapter = new MSLCrossReferenceAdapter(this);

		resourceIndexer = new MSLResourceIndexer(this);

		ResourceSet resourceSet = getResourceSet();

		resourceSet.eAdapters().add(crossReferenceAdapter);
		
		extendedMetaData = new MSLExtendedMetaData();

		contentAdapter.listenToModifications(resourceSet);

	}

	/**
	 * Returns the cross reference adapter.
	 */
	public MSLCrossReferenceAdapter getCrossReferenceAdapter() {
		return crossReferenceAdapter;
	}

	/**
	 * Returns the resource indexer.
	 */
	public MSLResourceIndexer getResourceIndexer() {
		return resourceIndexer;
	}

	/**

	 * @see org.eclipse.gmf.runtime.emf.core.edit.MEditingDomain#getImports(org.eclipse.emf.ecore.resource.Resource)
	 */
	public Collection getImports(Resource resource) {
		return crossReferenceAdapter.getImports(resource);
	}

	/**
	 * @see org.eclipse.gmf.runtime.emf.core.edit.MEditingDomain#getExports(org.eclipse.emf.ecore.resource.Resource)
	 */
	public Collection getExports(Resource resource) {
		return crossReferenceAdapter.getExports(resource);
	}
	
	/**


			if (!exports.contains(directExport)) {

				exports.add(directExport);

				getAllExports(directExport, exports, unload);
			}

			if (currentDomain instanceof MSLEditingDomain) {
				// remove current content adapter
				rset.eAdapters().remove(((MSLEditingDomain) currentDomain).getContentAdapter());
				
				// remove cross reference adapter
				rset.eAdapters().remove(((MSLEditingDomain) currentDomain).getCrossReferenceAdapter());
			}
			
			if (domain instanceof MSLEditingDomain) {

				// attach new content adapter
				rset.eAdapters().add(newDomain.getContentAdapter());
				
				// attach new cross reference adapter
				rset.eAdapters().add(newDomain.getCrossReferenceAdapter());
				
				// for each resource that is loaded, ensure that the new domain
				//   know that it has finished loading
				for (Iterator iter = rset.getResources().iterator(); iter.hasNext();) {




/******************************************************************************
 * Copyright (c) 2002-2006 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

import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.xmi.XMLResource;
import org.osgi.framework.Bundle;

import org.eclipse.gmf.runtime.common.core.util.Trace;
import org.eclipse.gmf.runtime.emf.core.EventTypes;
import org.eclipse.gmf.runtime.emf.core.IValidationStatus;

import org.eclipse.gmf.runtime.emf.core.services.metamodel.IMetamodelSupport;
import org.eclipse.gmf.runtime.emf.core.util.EObjectUtil;
import org.eclipse.gmf.runtime.emf.core.util.MetaModelUtil;
import org.osgi.framework.Bundle;

import com.ibm.icu.util.StringTokenizer;


			eClass);

		domain.getContentAdapter().listenToModifications(eObject);
		
		eObject.eAdapters().add(domain.getCrossReferenceAdapter());

		if (sendEvents)
			sendCreateEvent(domain, eObject);

							}
						}

						domain.getResourceIndexer()
							.registerReferences(resource);

						return null;
					}
				});

	}

	/**
	 * Process references and update reference maps.
	 */
	public static void registerReferences(MSLEditingDomain domain,
			EObject eObject, EReference reference, List newObjects,
			List oldObjects) {

		if (reference.isContainment()) {

			if (!newObjects.isEmpty()) {

				Iterator i = newObjects.iterator();

				while (i.hasNext()) {

					EObject newObject = (EObject) i.next();

					domain.getObjectIndexer().registerReferences(eObject,
						newObject);
				}
			}

			if (!oldObjects.isEmpty()) {

				Iterator i = oldObjects.iterator();

				while (i.hasNext()) {

					EObject oldObject = (EObject) i.next();

					domain.getObjectIndexer().deregisterReferences(eObject,
						oldObject);
				}
			}

		} else {

			if (!newObjects.isEmpty()) {

				Iterator i = newObjects.iterator();

				while (i.hasNext()) {

					EObject newObject = (EObject) i.next();

					// registers reference in reverse reference map.
					domain.getObjectIndexer().registerReference(eObject,
						newObject, reference);
				}
			}

			if (!oldObjects.isEmpty()) {

				Iterator i = oldObjects.iterator();

				while (i.hasNext()) {

					EObject oldObject = (EObject) i.next();

					// deregisters reference in reverse reference
					// map.
					domain.getObjectIndexer().deregisterReference(eObject,
						oldObject, reference);
				}
			}
		}
	}

	/**
	 * Returns all of the children of the validation <code>status</code> that
	 * indicate violated constraints (i.e., problems). These will be some
	 * combination of errors, warnings, and informational messages. No reports




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


import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.EcorePackage;
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.Trace;
import org.eclipse.gmf.runtime.emf.clipboard.core.ClipboardUtil;

import org.eclipse.gmf.runtime.emf.core.edit.MRunnable;
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.index.MSLCrossReferenceAdapter;
import org.eclipse.gmf.runtime.emf.core.internal.index.MSLReferenceVisitor;
import org.eclipse.gmf.runtime.emf.core.internal.plugin.MSLDebugOptions;
import org.eclipse.gmf.runtime.emf.core.internal.plugin.MSLPlugin;


						for (int j = 0; j < list.length; j++) {

							Object object = list[j];

							newList.add(object);
						}

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

		MSLCrossReferenceAdapter crossReferenceAdapter =
				MSLCrossReferenceAdapter.getCrossReferenceAdapter(eObject);

		if (crossReferenceAdapter == null) {
			return Collections.EMPTY_LIST;
		}

		if ((features != null) && (features.length != 0)) {

			Collection referencers = new ArrayList();


				EReference feature = features[i];

				Iterator j = crossReferenceAdapter.getInverseReferencers(eObject,
						feature, null).iterator();

				while (j.hasNext()) {


			return referencers;

		} else
			return crossReferenceAdapter.getInverseReferencers(eObject, null, null);
	}

	/**

Lines 1-5 Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/internal/resources/MResource.java (-3 / +6 lines)
1	/******************************************************************************	1	/******************************************************************************
2	* Copyright (c) 2004 IBM Corporation and others.	2	* Copyright (c) 2004-2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 76-85 Link Here
76	}	76	}
77		77
78	// Override to alter the behavior of reference registration.	78	// Override to alter the behavior of reference registration.
		79	/**
		80	* @deprecated No longer necessary to register references. The cross
		81	* reference adapter takes care of this.
		82	*/
79	public void registerReferences(MEditingDomain domain, EObject eObject,	83	public void registerReferences(MEditingDomain domain, EObject eObject,
80	EReference reference, List newObjects, List oldObjects) {	84	EReference reference, List newObjects, List oldObjects) {
81	MSLUtil.registerReferences((MSLEditingDomain) domain, eObject,	85	// empty
82	reference, newObjects, oldObjects);
83	}	86	}
84	}	87	}
85	}	88	}




/******************************************************************************
 * Copyright (c) 2006 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.index;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.common.notify.impl.NotificationImpl;
import org.eclipse.emf.common.util.TreeIterator;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.EStructuralFeature.Setting;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.ECrossReferenceAdapter;
import org.eclipse.gmf.runtime.emf.core.EventTypes;
import org.eclipse.gmf.runtime.emf.core.internal.domain.MSLEditingDomain;

/**
 * An adapter that maintains itself as an adapter for all contained objects.
 * It can be installed for an {@link EObject}, a {@link Resource}, or a {@link ResourceSet}.
 * <p>
 * This adapter maintain information on inverse references, resource imports, and resource
 * exports.
 * 
 * @author Christian Vogt (cvogt)
 */
public class MSLCrossReferenceAdapter extends ECrossReferenceAdapter {

	private MSLEditingDomain domain;

	private Map imports = new HashMap();

	private Map exports = new HashMap();

	/**
	 * Constructor.
	 * 
	 * @param domain a (@link MSLEditingDomain}
	 */
	public MSLCrossReferenceAdapter(MSLEditingDomain domain) {
		super();
		this.domain = domain;
	}

	/**
	 * Updates imports and exports maps.
	 * 
	 * @param notification the event notification
	 */
	public void selfAdapt(Notification notification) {
		super.selfAdapt(notification);
		Object notifier = notification.getNotifier();
		Object feature = notification.getFeature();

		// update import / export information when a resource
		// is unloaded
		if (notifier instanceof Resource) {
			if (notification.getFeatureID(Resource.class) == Resource.RESOURCE__IS_LOADED
					&& !notification.getNewBooleanValue()) {
				deregisterReferences((Resource)notifier);
			}
			return;
		}

		// interested in maintaining import / export information
		// when the notifier is an EObject and the feature is a
		// non-containment EReference
		if (!(notifier instanceof EObject)
				|| !(feature instanceof EReference)) {
			return;
		}

		EReference reference = (EReference)feature;
		if (reference.isContainment()) {
			return;
		}

		switch (notification.getEventType()) {
			case Notification.RESOLVE: 
			case Notification.SET:
			case Notification.UNSET: {
				EObject oldValue = (EObject) notification.getOldValue();
				if (oldValue != null) {
					deregisterReference(
							((EObject)notification.getNotifier()).eResource(),
							oldValue.eResource());
				}
				EObject newValue = (EObject) notification.getNewValue();
				if (newValue != null) {
					registerReference(
							((EObject)notification.getNotifier()).eResource(),
							newValue.eResource());
				}
				break;
			}
			case Notification.ADD: {
				EObject newValue = (EObject) notification.getNewValue();
				if (newValue != null) {
					registerReference(
							((EObject)notification.getNotifier()).eResource(),
							newValue.eResource());
				}
				break;
			}
			case Notification.ADD_MANY: {
				Collection newValues = (Collection) notification.getNewValue();
				for (Iterator i = newValues.iterator(); i.hasNext();) {
					EObject newValue = (EObject) i.next();
					registerReference(
							((EObject)notification.getNotifier()).eResource(),
							newValue.eResource());
				}
				break;
			}
			case Notification.REMOVE: {
				EObject oldValue = (EObject) notification.getOldValue();
				if (oldValue != null) {
					deregisterReference(
							((EObject)notification.getNotifier()).eResource(),
							oldValue.eResource());
				}
				break;
			}
			case Notification.REMOVE_MANY: {
				Collection oldValues = (Collection) notification.getOldValue();
				for (Iterator i = oldValues.iterator(); i.hasNext();) {
					EObject oldValue = (EObject) i.next();
					deregisterReference(
							((EObject)notification.getNotifier()).eResource(),
							oldValue.eResource());
				}
				break;
			}
		}
	}
	
	/**
	 * @see org.eclipse.emf.ecore.util.ECrossReferenceAdapter#setTarget(org.eclipse.emf.common.notify.Notifier)
	 */
	public void setTarget(Notifier target) {
		super.setTarget(target);
		if (target instanceof Resource) {
			Resource resource = (Resource)target;
			for (TreeIterator conents = resource.getAllContents(); conents.hasNext(); ) {
				EObject eObject = (EObject)conents.next();
				List allRefs = eObject.eClass().getEAllReferences();
				for (int i = 0; i < allRefs.size(); ++i) {
					EReference eReference = (EReference)allRefs.get(i);
					if (!eReference.isContainer() && !eReference.isContainment() && eObject.eIsSet(eReference)) {
						if (eReference.isMany()) {
							for (Iterator iter = ((Collection)eObject.eGet(eReference)).iterator(); iter.hasNext(); ) {
								registerReference(resource, ((EObject)iter.next()).eResource());
							}
						} else {
							registerReference(resource, ((EObject)eObject.eGet(eReference)).eResource());
						}
					}
				}
			}
	    }
	}

	/**
	 * @see org.eclipse.emf.ecore.util.ECrossReferenceAdapter#unsetTarget(org.eclipse.emf.common.notify.Notifier)
	 */
	public void unsetTarget(Notifier target) {
		super.unsetTarget(target);
		if (target instanceof Resource) {
			deregisterReferences((Resource)target);
	    }
	}

	/**
	 * @see org.eclipse.emf.ecore.util.ECrossReferenceAdapter#isIncluded(org.eclipse.emf.ecore.EReference)
	 */
	protected boolean isIncluded(EReference eReference) {
		return super.isIncluded(eReference) && eReference.isChangeable()
			&& !eReference.isContainer() && !eReference.isContainment();
	}

	/**
	 * @see org.eclipse.emf.ecore.util.ECrossReferenceAdapter#getInverseReferences(org.eclipse.emf.ecore.EObject)
	 */
	public Collection getInverseReferences(EObject eObject) {
		Collection result = new ArrayList();

		// removed the addition of eContainer from default behavior
		
		Collection nonNavigableInverseReferences = (Collection)inverseCrossReferencer.get(eObject);
		if (nonNavigableInverseReferences != null) {
			result.addAll(nonNavigableInverseReferences);
		}
		
		for (Iterator i = eObject.eClass().getEAllReferences().iterator(); i.hasNext(); ) {
			EReference eReference = (EReference)i.next();
			EReference eOpposite = eReference.getEOpposite();
			// added eReference.isChangeable() from default behavior
			if (eOpposite != null && eReference.isChangeable() && !eReference.isContainer() && !eReference.isContainment() && eObject.eIsSet(eReference)) {
				if (eReference.isMany()) {
					for (Iterator j = ((Collection)eObject.eGet(eReference)).iterator(); j.hasNext(); ) {
						InternalEObject referencingEObject = (InternalEObject)j.next();
						result.add(referencingEObject.eSetting(eOpposite));
					}
				} else {
					result.add(((InternalEObject)eObject.eGet(eReference)).eSetting(eOpposite));
				}
			}
		}
		
		return result;
	}

	/**
	 * Gets the imports of a resource.
	 * 
	 * @param referencer the resource to retrieve imports for
	 * @return a Set of resource imports
	 */
	public Set getImports(Resource referencer) {

		Map importsMap = getImportsMap(referencer);

		if (importsMap != null) {
			return Collections.unmodifiableSet(importsMap.keySet());
		} else {
			return Collections.EMPTY_SET;
		}
	}

	/**
	 * Gets the exports of a resource.
	 * 
	 * @param referenced the resource to retrieve exports for
	 * @return a Set of resource exports
	 */
	public Set getExports(Resource referenced) {

		Map exportsMap = getExportsMap(referenced);

		if (exportsMap != null) {
			return Collections.unmodifiableSet(exportsMap.keySet());
		} else {
			return Collections.EMPTY_SET;
		}
	}

	/**
	 * Returns the imports map of the given resource.
	 * 
	 * @param resource
	 * @return imports map of the given resource
	 */
	private Map getImportsMap(Resource resource) {
		return (Map) imports.get(resource);
	}

	/**
	 * Returns the exports map of the given resource.
	 * 
	 * @param resource
	 * @return exports map of the given resource
	 */
	private Map getExportsMap(Resource resource) {
		return (Map) exports.get(resource);
	}

	/**
	 * Registers a reference updating the imports and exports maps
	 * accordingly.
	 *
	 * @param referencer the referencing resource
	 * @param referenced the referenced resouce
	 */
	private void registerReference(final Resource referencer,
			final Resource referenced) {

		if ((referencer != null) && (referenced != null)
			&& (referencer != referenced)) {

			Map importsMap = getImportsMap(referencer);

			if (importsMap == null) {
				importsMap = new HashMap();
				imports.put(referencer, importsMap);
			}

			Integer importsCount = (Integer) importsMap.get(referenced);

			if (importsCount == null) {

				domain.sendNotification(new NotificationImpl(
					EventTypes.IMPORT, (Object) null, referenced, -1) {

					public Object getNotifier() {
						return referencer;
					}
				});

				importsCount = new Integer(1);

			} else {
				importsCount = new Integer(importsCount.intValue() + 1);
			}

			importsMap.put(referenced, importsCount);

			Map exportsMap = getExportsMap(referenced);

			if (exportsMap == null) {
				exportsMap = new HashMap();
				exports.put(referenced, exportsMap);
			}

			Integer exportsCount = (Integer) exportsMap.get(referencer);

			if (exportsCount == null) {

				domain.sendNotification(new NotificationImpl(
					EventTypes.EXPORT, (Object) null, referencer, -1) {

					public Object getNotifier() {
						return referenced;
					}
				});

				exportsCount = new Integer(1);

			} else {
				exportsCount = new Integer(exportsCount.intValue() + 1);
			}

			exportsMap.put(referencer, exportsCount);
		}
	}

	/**
	 * Deregisters a reference updating the imports and exports maps
	 * accordingly.
	 * 
	 * @param referencer the referencing resource
	 * @param referenced the referenced resource
	 */
	private void deregisterReference(final Resource referencer,
			final Resource referenced) {

		if ((referencer != null) && (referenced != null)
			&& (referencer != referenced)) {

			Map importsMap = getImportsMap(referencer);

			if (importsMap != null) {

				Integer importsCount = (Integer) importsMap.get(referenced);

				if (importsCount != null) {

					if (importsCount.intValue() < 2) {

						importsMap.remove(referenced);

						domain.sendNotification(new NotificationImpl(
							EventTypes.IMPORT, referenced, (Object) null, -1) {

							public Object getNotifier() {
								return referencer;
							}
						});
					} else {
						importsMap.put(referenced, new Integer(importsCount
							.intValue() - 1));
					}
				}

				if (importsMap.isEmpty()) {
					imports.remove(referencer);
				}
			}

			Map exportsMap = getExportsMap(referenced);

			if (exportsMap != null) {

				Integer exportsCount = (Integer) exportsMap.get(referencer);

				if (exportsCount != null) {

					if (exportsCount.intValue() < 2) {

						exportsMap.remove(referencer);

						domain.sendNotification(new NotificationImpl(
							EventTypes.EXPORT, referencer, (Object) null, -1) {

							public Object getNotifier() {
								return referenced;
							}
						});
					} else {
						exportsMap.put(referencer, new Integer(exportsCount
							.intValue() - 1));
					}
				}

				if (exportsMap.isEmpty()) {
					exports.remove(referenced);
				}
			}
		}
	}

	/**
	 * Cleans up a resource from the imports and exports maps.
	 * 
	 * @param referencer the referencing resource
	 */
	private void deregisterReferences(final Resource referencer) {

		Object[] resImports = getImports(referencer).toArray();

		for (int i = 0; i < resImports.length; i++) {

			final Resource referenced = (Resource) resImports[i];

			Map importsMap = getImportsMap(referencer);

			if (importsMap != null) {

				importsMap.remove(referenced);

				domain.sendNotification(new NotificationImpl(
					EventTypes.IMPORT, referenced, (Object) null, -1) {

					public Object getNotifier() {
						return referencer;
					}
				});

				if (importsMap.isEmpty()) {
					imports.remove(referencer);
				}
			}

			Map exportsMap = getExportsMap(referenced);

			if (exportsMap != null) {

				exportsMap.remove(referencer);

				domain.sendNotification(new NotificationImpl(
					EventTypes.EXPORT, referencer, (Object) null, -1) {

					public Object getNotifier() {
						return referenced;
					}
				});

				if (exportsMap.isEmpty()) {
					exports.remove(referenced);
				}
			}
		}
	}
	

	/**
	 * Returns a Set of EObjects that reference the given EObject.
	 * If an EReference is specified, the scope of the search is limited
	 * only to that EReference. To include all references specify a value of null.
	 * If an EClass type is specified, the returned Set will only include those
	 * referencers that match the given type. To include all types specify a value of null.
	 * 
	 * @param referenced the referenced EObject
	 * @param reference the reference to find referencers on, null for any reference
	 * @param type the type of the referencers, use null for any type
	 * @return a Set of referencers
	 */
	public Set getInverseReferencers(EObject referenced, EReference reference, EClass type) {
		return getReferencers(getInverseReferences(referenced), reference, type);
	}

	/**
	 * Returns a Set of EObjects that reference the given EObject through a uni
	 * directional EReferences. If an EReference is specified, the scope of the
	 * search is limited only to that EReference. To include all references specify
	 * a value of null. If an EClass type is specified, the returned Set will only
	 * include those referencers that match the given type. To include all types
	 * specify a value of null.
	 * 
	 * @param referenced the referenced EObject
	 * @param reference the reference to find referencers on, null for any reference
	 * @param type the type of the referencers, use null for any type
	 * @return a Set of referencers
	 */
	public Set getNonNavigableInverseReferencers(EObject referenced, EReference reference, EClass type) {
		return getReferencers(getNonNavigableInverseReferences(referenced), reference, type);
	}

	/**
	 * Extracts the EObjects from the EStructuralFeature.Setting references
	 * and returns a filtered Set based on the given reference and type.
	 * 
	 * @param references a collection of EStructuralFeature.Setting
	 * @param reference the reference to find referencers on, null for any reference
	 * @param type the type of the referencers, use null for any type
	 * @return a Set of referencers
	 */
	private Set getReferencers(Collection references, EReference reference, EClass type) {
		Set set = new HashSet();
		if (!references.isEmpty()) {
			for (Iterator iter = references.iterator(); iter.hasNext(); ) {
				Setting setting = (Setting) iter.next();
				if (reference == null || reference == setting.getEStructuralFeature()) {
					EObject referencer = setting.getEObject();
					if (referencer != null && (type == null || type.isInstance(referencer))) {
						set.add(referencer);
					}
				}
			}
		}
		return set;
	}

	/**
	 * Searches the adapter list of the given Notifier for an MSLCrossReferenceAdapter.
	 * If not found, returns null.
	 * 
	 * @param notifier the notifier to search
	 * @return MSLCrossReferenceAdapter if found, otherwise null
	 */
	public static MSLCrossReferenceAdapter getCrossReferenceAdapter(Notifier notifier) {
		List adapters = notifier.eAdapters();
		
		for (int i = 0, size = adapters.size(); i < size; ++i) {
			Adapter adapter = (Adapter)adapters.get(i);
			if (adapter instanceof MSLCrossReferenceAdapter) {
				return (MSLCrossReferenceAdapter)adapter;
			}
		}
		return null;
	}

}

Return to bug 113892

Added Link Here

(-)src/org/eclipse/gmf/runtime/emf/core/internal/index/MSLCrossReferenceAdapter.java (+564 lines)
1	/******************************************************************************
2	* Copyright (c) 2006 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.index;
13
14	import java.util.ArrayList;
15	import java.util.Collection;
16	import java.util.Collections;
17	import java.util.HashMap;
18	import java.util.HashSet;
19	import java.util.Iterator;
20	import java.util.List;
21	import java.util.Map;
22	import java.util.Set;
23
24	import org.eclipse.emf.common.notify.Adapter;
25	import org.eclipse.emf.common.notify.Notification;
26	import org.eclipse.emf.common.notify.Notifier;
27	import org.eclipse.emf.common.notify.impl.NotificationImpl;
28	import org.eclipse.emf.common.util.TreeIterator;
29	import org.eclipse.emf.ecore.EClass;
30	import org.eclipse.emf.ecore.EObject;
31	import org.eclipse.emf.ecore.EReference;
32	import org.eclipse.emf.ecore.InternalEObject;
33	import org.eclipse.emf.ecore.EStructuralFeature.Setting;
34	import org.eclipse.emf.ecore.resource.Resource;
35	import org.eclipse.emf.ecore.resource.ResourceSet;
36	import org.eclipse.emf.ecore.util.ECrossReferenceAdapter;
37	import org.eclipse.gmf.runtime.emf.core.EventTypes;
38	import org.eclipse.gmf.runtime.emf.core.internal.domain.MSLEditingDomain;
39
40	/**
41	* An adapter that maintains itself as an adapter for all contained objects.
42	* It can be installed for an {@link EObject}, a {@link Resource}, or a {@link ResourceSet}.
43	* <p>
44	* This adapter maintain information on inverse references, resource imports, and resource
45	* exports.
46	*
47	* @author Christian Vogt (cvogt)
48	*/
49	public class MSLCrossReferenceAdapter extends ECrossReferenceAdapter {
50
51	private MSLEditingDomain domain;
52
53	private Map imports = new HashMap();
54
55	private Map exports = new HashMap();
56
57	/**
58	* Constructor.
59	*
60	* @param domain a (@link MSLEditingDomain}
61	*/
62	public MSLCrossReferenceAdapter(MSLEditingDomain domain) {
63	super();
64	this.domain = domain;
65	}
66
67	/**
68	* Updates imports and exports maps.
69	*
70	* @param notification the event notification
71	*/
72	public void selfAdapt(Notification notification) {
73	super.selfAdapt(notification);
74	Object notifier = notification.getNotifier();
75	Object feature = notification.getFeature();
76
77	// update import / export information when a resource
78	// is unloaded
79	if (notifier instanceof Resource) {
80	if (notification.getFeatureID(Resource.class) == Resource.RESOURCE__IS_LOADED
81	&& !notification.getNewBooleanValue()) {
82	deregisterReferences((Resource)notifier);
83	}
84	return;
85	}
86
87	// interested in maintaining import / export information
88	// when the notifier is an EObject and the feature is a
89	// non-containment EReference
90	if (!(notifier instanceof EObject)
91	\|\| !(feature instanceof EReference)) {
92	return;
93	}
94
95	EReference reference = (EReference)feature;
96	if (reference.isContainment()) {
97	return;
98	}
99
100	switch (notification.getEventType()) {
101	case Notification.RESOLVE:
102	case Notification.SET:
103	case Notification.UNSET: {
104	EObject oldValue = (EObject) notification.getOldValue();
105	if (oldValue != null) {
106	deregisterReference(
107	((EObject)notification.getNotifier()).eResource(),
108	oldValue.eResource());
109	}
110	EObject newValue = (EObject) notification.getNewValue();
111	if (newValue != null) {
112	registerReference(
113	((EObject)notification.getNotifier()).eResource(),
114	newValue.eResource());
115	}
116	break;
117	}
118	case Notification.ADD: {
119	EObject newValue = (EObject) notification.getNewValue();
120	if (newValue != null) {
121	registerReference(
122	((EObject)notification.getNotifier()).eResource(),
123	newValue.eResource());
124	}
125	break;
126	}
127	case Notification.ADD_MANY: {
128	Collection newValues = (Collection) notification.getNewValue();
129	for (Iterator i = newValues.iterator(); i.hasNext();) {
130	EObject newValue = (EObject) i.next();
131	registerReference(
132	((EObject)notification.getNotifier()).eResource(),
133	newValue.eResource());
134	}
135	break;
136	}
137	case Notification.REMOVE: {
138	EObject oldValue = (EObject) notification.getOldValue();
139	if (oldValue != null) {
140	deregisterReference(
141	((EObject)notification.getNotifier()).eResource(),
142	oldValue.eResource());
143	}
144	break;
145	}
146	case Notification.REMOVE_MANY: {
147	Collection oldValues = (Collection) notification.getOldValue();
148	for (Iterator i = oldValues.iterator(); i.hasNext();) {
149	EObject oldValue = (EObject) i.next();
150	deregisterReference(
151	((EObject)notification.getNotifier()).eResource(),
152	oldValue.eResource());
153	}
154	break;
155	}
156	}
157	}
158
159	/**
160	* @see org.eclipse.emf.ecore.util.ECrossReferenceAdapter#setTarget(org.eclipse.emf.common.notify.Notifier)
161	*/
162	public void setTarget(Notifier target) {
163	super.setTarget(target);
164	if (target instanceof Resource) {
165	Resource resource = (Resource)target;
166	for (TreeIterator conents = resource.getAllContents(); conents.hasNext(); ) {
167	EObject eObject = (EObject)conents.next();
168	List allRefs = eObject.eClass().getEAllReferences();
169	for (int i = 0; i < allRefs.size(); ++i) {
170	EReference eReference = (EReference)allRefs.get(i);
171	if (!eReference.isContainer() && !eReference.isContainment() && eObject.eIsSet(eReference)) {
172	if (eReference.isMany()) {
173	for (Iterator iter = ((Collection)eObject.eGet(eReference)).iterator(); iter.hasNext(); ) {
174	registerReference(resource, ((EObject)iter.next()).eResource());
175	}
176	} else {
177	registerReference(resource, ((EObject)eObject.eGet(eReference)).eResource());
178	}
179	}
180	}
181	}
182	}
183	}
184
185	/**
186	* @see org.eclipse.emf.ecore.util.ECrossReferenceAdapter#unsetTarget(org.eclipse.emf.common.notify.Notifier)
187	*/
188	public void unsetTarget(Notifier target) {
189	super.unsetTarget(target);
190	if (target instanceof Resource) {
191	deregisterReferences((Resource)target);
192	}
193	}
194
195	/**
196	* @see org.eclipse.emf.ecore.util.ECrossReferenceAdapter#isIncluded(org.eclipse.emf.ecore.EReference)
197	*/
198	protected boolean isIncluded(EReference eReference) {
199	return super.isIncluded(eReference) && eReference.isChangeable()
200	&& !eReference.isContainer() && !eReference.isContainment();
201	}
202
203	/**
204	* @see org.eclipse.emf.ecore.util.ECrossReferenceAdapter#getInverseReferences(org.eclipse.emf.ecore.EObject)
205	*/
206	public Collection getInverseReferences(EObject eObject) {
207	Collection result = new ArrayList();
208
209	// removed the addition of eContainer from default behavior
210
211	Collection nonNavigableInverseReferences = (Collection)inverseCrossReferencer.get(eObject);
212	if (nonNavigableInverseReferences != null) {
213	result.addAll(nonNavigableInverseReferences);
214	}
215
216	for (Iterator i = eObject.eClass().getEAllReferences().iterator(); i.hasNext(); ) {
217	EReference eReference = (EReference)i.next();
218	EReference eOpposite = eReference.getEOpposite();
219	// added eReference.isChangeable() from default behavior
220	if (eOpposite != null && eReference.isChangeable() && !eReference.isContainer() && !eReference.isContainment() && eObject.eIsSet(eReference)) {
221	if (eReference.isMany()) {
222	for (Iterator j = ((Collection)eObject.eGet(eReference)).iterator(); j.hasNext(); ) {
223	InternalEObject referencingEObject = (InternalEObject)j.next();
224	result.add(referencingEObject.eSetting(eOpposite));
225	}
226	} else {
227	result.add(((InternalEObject)eObject.eGet(eReference)).eSetting(eOpposite));
228	}
229	}
230	}
231
232	return result;
233	}
234
235	/**
236	* Gets the imports of a resource.
237	*
238	* @param referencer the resource to retrieve imports for
239	* @return a Set of resource imports
240	*/
241	public Set getImports(Resource referencer) {
242
243	Map importsMap = getImportsMap(referencer);
244
245	if (importsMap != null) {
246	return Collections.unmodifiableSet(importsMap.keySet());
247	} else {
248	return Collections.EMPTY_SET;
249	}
250	}
251
252	/**
253	* Gets the exports of a resource.
254	*
255	* @param referenced the resource to retrieve exports for
256	* @return a Set of resource exports
257	*/
258	public Set getExports(Resource referenced) {
259
260	Map exportsMap = getExportsMap(referenced);
261
262	if (exportsMap != null) {
263	return Collections.unmodifiableSet(exportsMap.keySet());
264	} else {
265	return Collections.EMPTY_SET;
266	}
267	}
268
269	/**
270	* Returns the imports map of the given resource.
271	*
272	* @param resource
273	* @return imports map of the given resource
274	*/
275	private Map getImportsMap(Resource resource) {
276	return (Map) imports.get(resource);
277	}
278
279	/**
280	* Returns the exports map of the given resource.
281	*
282	* @param resource
283	* @return exports map of the given resource
284	*/
285	private Map getExportsMap(Resource resource) {
286	return (Map) exports.get(resource);
287	}
288
289	/**
290	* Registers a reference updating the imports and exports maps
291	* accordingly.
292	*
293	* @param referencer the referencing resource
294	* @param referenced the referenced resouce
295	*/
296	private void registerReference(final Resource referencer,
297	final Resource referenced) {
298
299	if ((referencer != null) && (referenced != null)
300	&& (referencer != referenced)) {
301
302	Map importsMap = getImportsMap(referencer);
303
304	if (importsMap == null) {
305	importsMap = new HashMap();
306	imports.put(referencer, importsMap);
307	}
308
309	Integer importsCount = (Integer) importsMap.get(referenced);
310
311	if (importsCount == null) {
312
313	domain.sendNotification(new NotificationImpl(
314	EventTypes.IMPORT, (Object) null, referenced, -1) {
315
316	public Object getNotifier() {
317	return referencer;
318	}
319	});
320
321	importsCount = new Integer(1);
322
323	} else {
324	importsCount = new Integer(importsCount.intValue() + 1);
325	}
326
327	importsMap.put(referenced, importsCount);
328
329	Map exportsMap = getExportsMap(referenced);
330
331	if (exportsMap == null) {
332	exportsMap = new HashMap();
333	exports.put(referenced, exportsMap);
334	}
335
336	Integer exportsCount = (Integer) exportsMap.get(referencer);
337
338	if (exportsCount == null) {
339
340	domain.sendNotification(new NotificationImpl(
341	EventTypes.EXPORT, (Object) null, referencer, -1) {
342
343	public Object getNotifier() {
344	return referenced;
345	}
346	});
347
348	exportsCount = new Integer(1);
349
350	} else {
351	exportsCount = new Integer(exportsCount.intValue() + 1);
352	}
353
354	exportsMap.put(referencer, exportsCount);
355	}
356	}
357
358	/**
359	* Deregisters a reference updating the imports and exports maps
360	* accordingly.
361	*
362	* @param referencer the referencing resource
363	* @param referenced the referenced resource
364	*/
365	private void deregisterReference(final Resource referencer,
366	final Resource referenced) {
367
368	if ((referencer != null) && (referenced != null)
369	&& (referencer != referenced)) {
370
371	Map importsMap = getImportsMap(referencer);
372
373	if (importsMap != null) {
374
375	Integer importsCount = (Integer) importsMap.get(referenced);
376
377	if (importsCount != null) {
378
379	if (importsCount.intValue() < 2) {
380
381	importsMap.remove(referenced);
382
383	domain.sendNotification(new NotificationImpl(
384	EventTypes.IMPORT, referenced, (Object) null, -1) {
385
386	public Object getNotifier() {
387	return referencer;
388	}
389	});
390	} else {
391	importsMap.put(referenced, new Integer(importsCount
392	.intValue() - 1));
393	}
394	}
395
396	if (importsMap.isEmpty()) {
397	imports.remove(referencer);
398	}
399	}
400
401	Map exportsMap = getExportsMap(referenced);
402
403	if (exportsMap != null) {
404
405	Integer exportsCount = (Integer) exportsMap.get(referencer);
406
407	if (exportsCount != null) {
408
409	if (exportsCount.intValue() < 2) {
410
411	exportsMap.remove(referencer);
412
413	domain.sendNotification(new NotificationImpl(
414	EventTypes.EXPORT, referencer, (Object) null, -1) {
415
416	public Object getNotifier() {
417	return referenced;
418	}
419	});
420	} else {
421	exportsMap.put(referencer, new Integer(exportsCount
422	.intValue() - 1));
423	}
424	}
425
426	if (exportsMap.isEmpty()) {
427	exports.remove(referenced);
428	}
429	}
430	}
431	}
432
433	/**
434	* Cleans up a resource from the imports and exports maps.
435	*
436	* @param referencer the referencing resource
437	*/
438	private void deregisterReferences(final Resource referencer) {
439
440	Object[] resImports = getImports(referencer).toArray();
441
442	for (int i = 0; i < resImports.length; i++) {
443
444	final Resource referenced = (Resource) resImports[i];
445
446	Map importsMap = getImportsMap(referencer);
447
448	if (importsMap != null) {
449
450	importsMap.remove(referenced);
451
452	domain.sendNotification(new NotificationImpl(
453	EventTypes.IMPORT, referenced, (Object) null, -1) {
454
455	public Object getNotifier() {
456	return referencer;
457	}
458	});
459
460	if (importsMap.isEmpty()) {
461	imports.remove(referencer);
462	}
463	}
464
465	Map exportsMap = getExportsMap(referenced);
466
467	if (exportsMap != null) {
468
469	exportsMap.remove(referencer);
470
471	domain.sendNotification(new NotificationImpl(
472	EventTypes.EXPORT, referencer, (Object) null, -1) {
473
474	public Object getNotifier() {
475	return referenced;
476	}
477	});
478
479	if (exportsMap.isEmpty()) {
480	exports.remove(referenced);
481	}
482	}
483	}
484	}
485
486
487	/**
488	* Returns a Set of EObjects that reference the given EObject.
489	* If an EReference is specified, the scope of the search is limited
490	* only to that EReference. To include all references specify a value of null.
491	* If an EClass type is specified, the returned Set will only include those
492	* referencers that match the given type. To include all types specify a value of null.
493	*
494	* @param referenced the referenced EObject
495	* @param reference the reference to find referencers on, null for any reference
496	* @param type the type of the referencers, use null for any type
497	* @return a Set of referencers
498	*/
499	public Set getInverseReferencers(EObject referenced, EReference reference, EClass type) {
500	return getReferencers(getInverseReferences(referenced), reference, type);
501	}
502
503	/**
504	* Returns a Set of EObjects that reference the given EObject through a uni
505	* directional EReferences. If an EReference is specified, the scope of the
506	* search is limited only to that EReference. To include all references specify
507	* a value of null. If an EClass type is specified, the returned Set will only
508	* include those referencers that match the given type. To include all types
509	* specify a value of null.
510	*
511	* @param referenced the referenced EObject
512	* @param reference the reference to find referencers on, null for any reference
513	* @param type the type of the referencers, use null for any type
514	* @return a Set of referencers
515	*/
516	public Set getNonNavigableInverseReferencers(EObject referenced, EReference reference, EClass type) {
517	return getReferencers(getNonNavigableInverseReferences(referenced), reference, type);
518	}
519
520	/**
521	* Extracts the EObjects from the EStructuralFeature.Setting references
522	* and returns a filtered Set based on the given reference and type.
523	*
524	* @param references a collection of EStructuralFeature.Setting
525	* @param reference the reference to find referencers on, null for any reference
526	* @param type the type of the referencers, use null for any type
527	* @return a Set of referencers
528	*/
529	private Set getReferencers(Collection references, EReference reference, EClass type) {
530	Set set = new HashSet();
531	if (!references.isEmpty()) {
532	for (Iterator iter = references.iterator(); iter.hasNext(); ) {
533	Setting setting = (Setting) iter.next();
534	if (reference == null \|\| reference == setting.getEStructuralFeature()) {
535	EObject referencer = setting.getEObject();
536	if (referencer != null && (type == null \|\| type.isInstance(referencer))) {
537	set.add(referencer);
538	}
539	}
540	}
541	}
542	return set;
543	}
544
545	/**
546	* Searches the adapter list of the given Notifier for an MSLCrossReferenceAdapter.
547	* If not found, returns null.
548	*
549	* @param notifier the notifier to search
550	* @return MSLCrossReferenceAdapter if found, otherwise null
551	*/
552	public static MSLCrossReferenceAdapter getCrossReferenceAdapter(Notifier notifier) {
553	List adapters = notifier.eAdapters();
554
555	for (int i = 0, size = adapters.size(); i < size; ++i) {
556	Adapter adapter = (Adapter)adapters.get(i);
557	if (adapter instanceof MSLCrossReferenceAdapter) {
558	return (MSLCrossReferenceAdapter)adapter;
559	}
560	}
561	return null;
562	}
563
564	}