Introduce the new versions of the metamodel and tests for the EMF Compare core.

61 files changed, 12588 insertions, 0 deletions

diff --git a/plugins/org.eclipse.emf.compare.tests/.classpath b/plugins/org.eclipse.emf.compare.tests/.classpath
new file mode 100644
index 000000000..ed2585fb3
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<classpath>

+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>

+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>

+	<classpathentry kind="src" path="src"/>

+	<classpathentry kind="src" path="src-gen"/>

+	<classpathentry kind="output" path="bin"/>

+</classpath>

diff --git a/plugins/org.eclipse.emf.compare.tests/.project b/plugins/org.eclipse.emf.compare.tests/.project
new file mode 100644
index 000000000..436d6c947
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<projectDescription>

+	<name>org.eclipse.emf.compare.tests</name>

+	<comment></comment>

+	<projects>

+	</projects>

+	<buildSpec>

+		<buildCommand>

+			<name>org.eclipse.jdt.core.javabuilder</name>

+			<arguments>

+			</arguments>

+		</buildCommand>

+		<buildCommand>

+			<name>org.eclipse.pde.ManifestBuilder</name>

+			<arguments>

+			</arguments>

+		</buildCommand>

+		<buildCommand>

+			<name>org.eclipse.pde.SchemaBuilder</name>

+			<arguments>

+			</arguments>

+		</buildCommand>

+	</buildSpec>

+	<natures>

+		<nature>org.eclipse.pde.PluginNature</nature>

+		<nature>org.eclipse.jdt.core.javanature</nature>

+	</natures>

+</projectDescription>

diff --git a/plugins/org.eclipse.emf.compare.tests/.settings/org.eclipse.jdt.core.prefs b/plugins/org.eclipse.emf.compare.tests/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 000000000..44217f8c0
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,7 @@
+eclipse.preferences.version=1

+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled

+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5

+org.eclipse.jdt.core.compiler.compliance=1.5

+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error

+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error

+org.eclipse.jdt.core.compiler.source=1.5

diff --git a/plugins/org.eclipse.emf.compare.tests/META-INF/MANIFEST.MF b/plugins/org.eclipse.emf.compare.tests/META-INF/MANIFEST.MF
new file mode 100644
index 000000000..56bf64471
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/META-INF/MANIFEST.MF
@@ -0,0 +1,14 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %pluginName
+Bundle-SymbolicName: org.eclipse.emf.compare.tests
+Bundle-Version: 1.3.0.qualifier
+Bundle-Activator: org.eclipse.emf.compare.tests.EMFCompareTestsPlugin
+Bundle-Vendor: %providerName
+Require-Bundle: org.eclipse.core.runtime,
+ org.eclipse.emf.common,
+ org.eclipse.emf.ecore,
+ org.eclipse.emf.compare;bundle-version="1.3.0",
+ org.junit;bundle-version="4.8.2"
+Bundle-RequiredExecutionEnvironment: J2SE-1.5
+Bundle-ActivationPolicy: lazy
diff --git a/plugins/org.eclipse.emf.compare.tests/build.properties b/plugins/org.eclipse.emf.compare.tests/build.properties
new file mode 100644
index 000000000..bfa526304
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/build.properties
@@ -0,0 +1,5 @@
+source.. = src/,\

+           src-gen/

+output.. = bin/

+bin.includes = META-INF/,\

+               .

diff --git a/plugins/org.eclipse.emf.compare.tests/plugin.properties b/plugins/org.eclipse.emf.compare.tests/plugin.properties
new file mode 100644
index 000000000..d482a8aa9
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/plugin.properties
@@ -0,0 +1,13 @@
+################################################################################
+# Copyright (c) 2006, 2012 Obeo.
+# 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:
+#     Obeo - initial API and implementation
+################################################################################
+pluginName = EMF Compare Core Tests
+providerName = Eclipse Modeling Project
+
diff --git a/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/suite/CompareTestSuite.java b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/suite/CompareTestSuite.java
new file mode 100644
index 000000000..1c24929e6
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/suite/CompareTestSuite.java
@@ -0,0 +1,53 @@
+package org.eclipse.emf.compare.tests.suite;
+
+import junit.framework.JUnit4TestAdapter;
+import junit.framework.Test;
+import junit.textui.TestRunner;
+
+import org.eclipse.emf.compare.tests.unit.AttributeChangeTest;
+import org.eclipse.emf.compare.tests.unit.CompareAdapterFactoryTest;
+import org.eclipse.emf.compare.tests.unit.CompareFactoryTest;
+import org.eclipse.emf.compare.tests.unit.CompareSwitchTest;
+import org.eclipse.emf.compare.tests.unit.ComparisonTest;
+import org.eclipse.emf.compare.tests.unit.ConflictTest;
+import org.eclipse.emf.compare.tests.unit.DiffTest;
+import org.eclipse.emf.compare.tests.unit.DifferenceKindTest;
+import org.eclipse.emf.compare.tests.unit.DifferenceSourceTest;
+import org.eclipse.emf.compare.tests.unit.EquivalenceTest;
+import org.eclipse.emf.compare.tests.unit.MatchResourceTest;
+import org.eclipse.emf.compare.tests.unit.MatchTest;
+import org.eclipse.emf.compare.tests.unit.ReferenceChangeTest;
+import org.eclipse.emf.compare.tests.unit.ResourceAttachmentChangeTest;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+/**
+ * This test suite allows clients to launch all tests generated for package compare at once.
+ * 
+ * @generated
+ */
+@RunWith(Suite.class)
+@SuiteClasses({ComparisonTest.class, MatchResourceTest.class, MatchTest.class, DiffTest.class,
+		ResourceAttachmentChangeTest.class, ReferenceChangeTest.class, AttributeChangeTest.class,
+		ConflictTest.class, EquivalenceTest.class, DifferenceKindTest.class, DifferenceSourceTest.class,
+		CompareAdapterFactoryTest.class, CompareFactoryTest.class, CompareSwitchTest.class, })
+public class CompareTestSuite {
+	/**
+	 * Standalone launcher for package compare's tests.
+	 * 
+	 * @generated
+	 */
+	public static void main(String[] args) {
+		TestRunner.run(suite());
+	}
+
+	/**
+	 * This will return a suite populated with all generated tests for package compare.
+	 * 
+	 * @generated
+	 */
+	public static Test suite() {
+		return new JUnit4TestAdapter(CompareTestSuite.class);
+	}
+}
diff --git a/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/AbstractCompareTest.java b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/AbstractCompareTest.java
new file mode 100644
index 000000000..045de7e8a
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/AbstractCompareTest.java
@@ -0,0 +1,246 @@
+package org.eclipse.emf.compare.tests.unit;
+
+import java.util.Calendar;
+
+import junit.framework.TestCase;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.impl.AdapterImpl;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.EcorePackage;
+
+/**
+ * This class defines utility methods and will be used as the superclass of all {@link TestCase} for
+ * "class-related" tests.
+ * 
+ * @generated
+ */
+@SuppressWarnings("nls")
+public class AbstractCompareTest {
+	/**
+	 * Will hold <code>true</code> if the mock adapter has been notified of a changes.
+	 * 
+	 * @generated
+	 */
+	protected boolean notified;
+
+	/**
+	 * This will return a boolean that is distinct from the given <code>feature</code>'s default value.
+	 * Namely, <code>true</code> if the default is <code>false</code>, <code>false</code> otherwise.
+	 * 
+	 * @param feature
+	 *            Feature which default value is to be considered.
+	 * @return <code>true</code> if the default is <code>false</code>, <code>false</code> otherwise.
+	 * @generated
+	 */
+	protected boolean getBooleanDistinctFromDefault(EStructuralFeature feature) {
+		return !((Boolean)feature.getDefaultValue()).booleanValue();
+	}
+
+	/**
+	 * This will return an int that is distinct from the given <code>feature</code>'s default value. Namely,
+	 * <code>-1</code> if the default is <code>0</code>, <code>0</code> otherwise.
+	 * 
+	 * @param feature
+	 *            Feature which default value is to be considered.
+	 * @return <code>-1</code> if the default is <code>0</code>, <code>0</code> otherwise.
+	 * @generated
+	 */
+	protected int getIntDistinctFromDefault(EStructuralFeature feature) {
+		final int defaultValue = ((Integer)feature.getDefaultValue()).intValue();
+		return defaultValue == 0 ? -1 : 0;
+	}
+
+	/**
+	 * This will return a byte that is distinct from the given <code>feature</code>'s default value. Namely,
+	 * <code>-1</code> if the default is <code>0</code>, <code>0</code> otherwise.
+	 * 
+	 * @param feature
+	 *            Feature which default value is to be considered.
+	 * @return <code>-1</code> if the default is <code>0</code>, <code>0</code> otherwise.
+	 * @generated
+	 */
+	protected byte getByteDistinctFromDefault(EStructuralFeature feature) {
+		final byte defaultValue = ((Byte)feature.getDefaultValue()).byteValue();
+		return defaultValue == 0 ? (byte)-1 : 0;
+	}
+
+	/**
+	 * This will return a char that is distinct from the given <code>feature</code>'s default value. Namely,
+	 * <code>'b'</code> if the default is <code>'a'</code>, <code>'a'</code> otherwise.
+	 * 
+	 * @param feature
+	 *            Feature which default value is to be considered.
+	 * @return <code>'b'</code> if the default is <code>'a'</code>, <code>'a'</code> otherwise.
+	 * @generated
+	 */
+	protected char getCharDistinctFromDefault(EStructuralFeature feature) {
+		final char defaultValue = ((Character)feature.getDefaultValue()).charValue();
+		return defaultValue == 'a' ? 'b' : 'a';
+	}
+
+	/**
+	 * This will return a double that is distinct from the given <code>feature</code>'s default value. Namely,
+	 * <code>-1d</code> if the default is <code>0d</code>, <code>0d</code> otherwise.
+	 * 
+	 * @param feature
+	 *            Feature which default value is to be considered.
+	 * @return <code>-1d</code> if the default is <code>0d</code>, <code>0d</code> otherwise.
+	 * @generated
+	 */
+	protected double getDoubleDistinctFromDefault(EStructuralFeature feature) {
+		final double defaultValue = ((Double)feature.getDefaultValue()).doubleValue();
+		return defaultValue == 0d ? -1d : 0d;
+	}
+
+	/**
+	 * This will return a float that is distinct from the given <code>feature</code>'s default value. Namely,
+	 * <code>-1f</code> if the default is <code>0f</code>, <code>0f</code> otherwise.
+	 * 
+	 * @param feature
+	 *            Feature which default value is to be considered.
+	 * @return <code>-1f</code> if the default is <code>0f</code>, <code>0f</code> otherwise.
+	 * @generated
+	 */
+	protected float getFloatDistinctFromDefault(EStructuralFeature feature) {
+		final float defaultValue = ((Float)feature.getDefaultValue()).floatValue();
+		return defaultValue == 0f ? -1f : 0f;
+	}
+
+	/**
+	 * This will return a long that is distinct from the given <code>feature</code>'s default value. Namely,
+	 * <code>-1L</code> if the default is <code>0L</code>, <code>0L</code> otherwise.
+	 * 
+	 * @param feature
+	 *            Feature which default value is to be considered.
+	 * @return <code>-1L</code> if the default is <code>0L</code>, <code>0L</code> otherwise.
+	 * @generated
+	 */
+	protected long getLongDistinctFromDefault(EStructuralFeature feature) {
+		final long defaultValue = ((Long)feature.getDefaultValue()).longValue();
+		return defaultValue == 0L ? -1L : 0L;
+	}
+
+	/**
+	 * This will return a short that is distinct from the given <code>feature</code>'s default value. Namely,
+	 * <code>-1</code> if the default is <code>0</code>, <code>0</code> otherwise.
+	 * 
+	 * @param feature
+	 *            Feature which default value is to be considered.
+	 * @return <code>-1</code> if the default is <code>0</code>, <code>0</code> otherwise.
+	 * @generated
+	 */
+	protected short getShortDistinctFromDefault(EStructuralFeature feature) {
+		final short defaultValue = ((Short)feature.getDefaultValue()).shortValue();
+		return defaultValue == 0 ? (short)-1 : 0;
+	}
+
+	/**
+	 * This will return an {@link Object} that is distinct from the given <code>feature</code>'s default
+	 * value, yet having the same type.
+	 * <table>
+	 * <tr>
+	 * <td>Type</td>
+	 * <td>Returned value</td>
+	 * </tr>
+	 * <tr>
+	 * <td>EBoolean_OBJECT</td>
+	 * <td>{@link Boolean#FALSE} if default is {@link Boolean#TRUE}, {@link Boolean#TRUE} otherwise</td>
+	 * </tr>
+	 * <tr>
+	 * <td>EINTEGER_OBJECT</td>
+	 * <td><code>-1</code> if default is <code>0</code>, <code>0</code> otherwise</td>
+	 * </tr>
+	 * <tr>
+	 * <td>EBYTE_OBJECT</td>
+	 * <td><code>-1</code> if default is <code>0</code>, <code>0</code> otherwise</td>
+	 * </tr>
+	 * <tr>
+	 * <td>ECHARACTER_OBJECT</td>
+	 * <td><code>'b'</code> if default is <code>'a'</code>, <code>'a'</code> otherwise</td>
+	 * </tr>
+	 * <tr>
+	 * <td>EDOUBLE_OBJECT</td>
+	 * <td><code>-1d</code> if default is <code>0d</code>, <code>0d</code> otherwise</td>
+	 * </tr>
+	 * <tr>
+	 * <td>EFLOAT_OBJECT</td>
+	 * <td><code>-1f</code> if default is <code>0f</code>, <code>0f</code> otherwise</td>
+	 * </tr>
+	 * <tr>
+	 * <td>ELONG_OBJECT</td>
+	 * <td><code>-1L</code> if default is <code>0L</code>, <code>0L</code> otherwise</td>
+	 * </tr>
+	 * <tr>
+	 * <td>ESHORT_OBJECT</td>
+	 * <td><code>-1</code> if default is <code>0</code>, <code>0</code> otherwise</td>
+	 * </tr>
+	 * <tr>
+	 * <td>ESTRING</td>
+	 * <td><code>"notdefault"</code> if default is <code>""</code>, <code>""</code> otherwise</td>
+	 * </tr>
+	 * <tr>
+	 * <td>EDATE</td>
+	 * <td>Returns the current date</td>
+	 * </tr>
+	 * <tr>
+	 * <td>EJAVA_OBJECT</td>
+	 * <td>Returns a new Object</td>
+	 * </tr>
+	 * </table>
+	 * 
+	 * @param feature
+	 *            Feature which default value is to be considered.
+	 * @return An {@link Object} that is distinct from the given <code>feature</code>'s default value.
+	 * @generated
+	 */
+	protected Object getValueDistinctFromDefault(EStructuralFeature feature) {
+		final Object defaultValue = feature.getDefaultValue();
+		if (feature.getEType() == EcorePackage.Literals.EBOOLEAN_OBJECT) {
+			return defaultValue == Boolean.TRUE ? Boolean.FALSE : Boolean.TRUE;
+		} else if (feature.getEType() == EcorePackage.Literals.EINTEGER_OBJECT) {
+			return defaultValue == Integer.valueOf(0) ? Integer.valueOf(-1) : Integer.valueOf(0);
+		} else if (feature.getEType() == EcorePackage.Literals.EBYTE_OBJECT) {
+			return defaultValue == Byte.valueOf("0") ? Byte.valueOf("-1") : Byte.valueOf("0");
+		} else if (feature.getEType() == EcorePackage.Literals.ECHARACTER_OBJECT) {
+			return defaultValue == Character.valueOf('a') ? Character.valueOf('b') : Character.valueOf('a');
+		} else if (feature.getEType() == EcorePackage.Literals.EDOUBLE_OBJECT) {
+			return defaultValue == Double.valueOf(0) ? Double.valueOf(-1) : Double.valueOf(0);
+		} else if (feature.getEType() == EcorePackage.Literals.EFLOAT_OBJECT) {
+			return defaultValue == Float.valueOf(0) ? Float.valueOf(-1) : Float.valueOf(0);
+		} else if (feature.getEType() == EcorePackage.Literals.ELONG_OBJECT) {
+			return defaultValue == Long.valueOf(0) ? Long.valueOf(-1) : Long.valueOf(0);
+		} else if (feature.getEType() == EcorePackage.Literals.ESHORT_OBJECT) {
+			return defaultValue == Short.valueOf((short)0) ? Short.valueOf((short)-1) : Short
+					.valueOf((short)0);
+		} else if (feature.getEType() == EcorePackage.Literals.ESTRING) {
+			return "".equals(defaultValue) ? "notdefault" : "";
+		} else if (feature.getEType() == EcorePackage.Literals.EDATE) {
+			return Calendar.getInstance().getTime();
+		} else if (feature.getEType() == EcorePackage.Literals.EJAVA_OBJECT) {
+			return new Object();
+		} else {
+			throw new RuntimeException();
+		}
+	}
+
+	/**
+	 * This basic implementation of an {@link org.eclipse.emf.common.notify.Adapter} will simply switch a
+	 * boolean to true when it is notified of a change.
+	 * 
+	 * @generated
+	 */
+	protected class MockEAdapter extends AdapterImpl {
+		/**
+		 * {@inheritDoc}
+		 * 
+		 * @see org.eclipse.emf.common.notify.impl.AdapterImpl#notifyChanged(org.eclipse.emf.common.notify.Notification)
+		 * @generated
+		 */
+		@Override
+		public void notifyChanged(Notification msg) {
+			super.notifyChanged(msg);
+			notified = true;
+		}
+	}
+}
diff --git a/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/AttributeChangeTest.java b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/AttributeChangeTest.java
new file mode 100644
index 000000000..f1346290a
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/AttributeChangeTest.java
@@ -0,0 +1,552 @@
+package org.eclipse.emf.compare.tests.unit;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertNull;
+import static junit.framework.Assert.assertSame;
+import static junit.framework.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.emf.compare.AttributeChange;
+import org.eclipse.emf.compare.CompareFactory;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.junit.Test;
+
+/**
+ * Tests the behavior of the {@link AttributeChange} class.
+ * 
+ * @generated
+ */
+public class AttributeChangeTest extends AbstractCompareTest {
+	/**
+	 * Tests the behavior of reference <code>requires</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testRequires() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Requires();
+		AttributeChange attributeChange = CompareFactory.eINSTANCE.createAttributeChange();
+		attributeChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff requiresValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listRequires = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listRequires.add(requiresValue);
+
+		assertFalse(attributeChange.eIsSet(feature));
+		assertTrue(attributeChange.getRequires().isEmpty());
+
+		attributeChange.getRequires().add(requiresValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(attributeChange.getRequires().contains(requiresValue));
+		assertSame(attributeChange.getRequires(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getRequires(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+		assertTrue(requiresValue.getRequiredBy().contains(attributeChange));
+
+		attributeChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(attributeChange.getRequires().isEmpty());
+		assertSame(attributeChange.getRequires(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getRequires(), attributeChange.eGet(feature, false));
+		assertFalse(attributeChange.eIsSet(feature));
+		assertFalse(requiresValue.getRequiredBy().contains(attributeChange));
+
+		attributeChange.eSet(feature, listRequires);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(attributeChange.getRequires().contains(requiresValue));
+		assertSame(attributeChange.getRequires(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getRequires(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+		assertTrue(requiresValue.getRequiredBy().contains(attributeChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>requiredBy</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testRequiredBy() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_RequiredBy();
+		AttributeChange attributeChange = CompareFactory.eINSTANCE.createAttributeChange();
+		attributeChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff requiredByValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listRequiredBy = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listRequiredBy.add(requiredByValue);
+
+		assertFalse(attributeChange.eIsSet(feature));
+		assertTrue(attributeChange.getRequiredBy().isEmpty());
+
+		attributeChange.getRequiredBy().add(requiredByValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(attributeChange.getRequiredBy().contains(requiredByValue));
+		assertSame(attributeChange.getRequiredBy(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getRequiredBy(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+		assertTrue(requiredByValue.getRequires().contains(attributeChange));
+
+		attributeChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(attributeChange.getRequiredBy().isEmpty());
+		assertSame(attributeChange.getRequiredBy(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getRequiredBy(), attributeChange.eGet(feature, false));
+		assertFalse(attributeChange.eIsSet(feature));
+		assertFalse(requiredByValue.getRequires().contains(attributeChange));
+
+		attributeChange.eSet(feature, listRequiredBy);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(attributeChange.getRequiredBy().contains(requiredByValue));
+		assertSame(attributeChange.getRequiredBy(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getRequiredBy(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+		assertTrue(requiredByValue.getRequires().contains(attributeChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>refines</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testRefines() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Refines();
+		AttributeChange attributeChange = CompareFactory.eINSTANCE.createAttributeChange();
+		attributeChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff refinesValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listRefines = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listRefines.add(refinesValue);
+
+		assertFalse(attributeChange.eIsSet(feature));
+		assertTrue(attributeChange.getRefines().isEmpty());
+
+		attributeChange.getRefines().add(refinesValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(attributeChange.getRefines().contains(refinesValue));
+		assertSame(attributeChange.getRefines(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getRefines(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+		assertTrue(refinesValue.getRefinedBy().contains(attributeChange));
+
+		attributeChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(attributeChange.getRefines().isEmpty());
+		assertSame(attributeChange.getRefines(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getRefines(), attributeChange.eGet(feature, false));
+		assertFalse(attributeChange.eIsSet(feature));
+		assertFalse(refinesValue.getRefinedBy().contains(attributeChange));
+
+		attributeChange.eSet(feature, listRefines);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(attributeChange.getRefines().contains(refinesValue));
+		assertSame(attributeChange.getRefines(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getRefines(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+		assertTrue(refinesValue.getRefinedBy().contains(attributeChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>refinedBy</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testRefinedBy() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_RefinedBy();
+		AttributeChange attributeChange = CompareFactory.eINSTANCE.createAttributeChange();
+		attributeChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff refinedByValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listRefinedBy = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listRefinedBy.add(refinedByValue);
+
+		assertFalse(attributeChange.eIsSet(feature));
+		assertTrue(attributeChange.getRefinedBy().isEmpty());
+
+		attributeChange.getRefinedBy().add(refinedByValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(attributeChange.getRefinedBy().contains(refinedByValue));
+		assertSame(attributeChange.getRefinedBy(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getRefinedBy(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+		assertTrue(refinedByValue.getRefines().contains(attributeChange));
+
+		attributeChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(attributeChange.getRefinedBy().isEmpty());
+		assertSame(attributeChange.getRefinedBy(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getRefinedBy(), attributeChange.eGet(feature, false));
+		assertFalse(attributeChange.eIsSet(feature));
+		assertFalse(refinedByValue.getRefines().contains(attributeChange));
+
+		attributeChange.eSet(feature, listRefinedBy);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(attributeChange.getRefinedBy().contains(refinedByValue));
+		assertSame(attributeChange.getRefinedBy(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getRefinedBy(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+		assertTrue(refinedByValue.getRefines().contains(attributeChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>match</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testMatch() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Match();
+		AttributeChange attributeChange = CompareFactory.eINSTANCE.createAttributeChange();
+		attributeChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Match matchValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createMatch();
+
+		assertFalse(attributeChange.eIsSet(feature));
+		assertNull(attributeChange.getMatch());
+
+		attributeChange.setMatch(matchValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(matchValue, attributeChange.getMatch());
+		assertSame(attributeChange.getMatch(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getMatch(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+		assertTrue(matchValue.getDifferences().contains(attributeChange));
+
+		attributeChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertNull(attributeChange.getMatch());
+		assertSame(attributeChange.getMatch(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getMatch(), attributeChange.eGet(feature, false));
+		assertFalse(attributeChange.eIsSet(feature));
+		assertFalse(matchValue.getDifferences().contains(attributeChange));
+
+		attributeChange.setMatch(matchValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(matchValue, attributeChange.getMatch());
+		assertSame(attributeChange.getMatch(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getMatch(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+		assertTrue(matchValue.getDifferences().contains(attributeChange));
+
+		attributeChange.eSet(feature, matchValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(matchValue, attributeChange.getMatch());
+		assertSame(attributeChange.getMatch(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getMatch(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+		assertTrue(matchValue.getDifferences().contains(attributeChange));
+
+		attributeChange.setMatch(null);
+		assertTrue(notified);
+		notified = false;
+		assertNull(attributeChange.getMatch());
+		assertSame(feature.getDefaultValue(), attributeChange.getMatch());
+		assertSame(attributeChange.getMatch(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getMatch(), attributeChange.eGet(feature, false));
+		assertFalse(attributeChange.eIsSet(feature));
+		assertFalse(matchValue.getDifferences().contains(attributeChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>equivalentDiffs</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testEquivalentDiffs() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE
+				.getDiff_EquivalentDiffs();
+		AttributeChange attributeChange = CompareFactory.eINSTANCE.createAttributeChange();
+		attributeChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Equivalence equivalentDiffsValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createEquivalence();
+
+		assertFalse(attributeChange.eIsSet(feature));
+		assertNull(attributeChange.getEquivalentDiffs());
+
+		attributeChange.setEquivalentDiffs(equivalentDiffsValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(equivalentDiffsValue, attributeChange.getEquivalentDiffs());
+		assertSame(attributeChange.getEquivalentDiffs(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getEquivalentDiffs(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+		assertTrue(equivalentDiffsValue.getDifferences().contains(attributeChange));
+
+		attributeChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertNull(attributeChange.getEquivalentDiffs());
+		assertSame(attributeChange.getEquivalentDiffs(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getEquivalentDiffs(), attributeChange.eGet(feature, false));
+		assertFalse(attributeChange.eIsSet(feature));
+		assertFalse(equivalentDiffsValue.getDifferences().contains(attributeChange));
+
+		attributeChange.setEquivalentDiffs(equivalentDiffsValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(equivalentDiffsValue, attributeChange.getEquivalentDiffs());
+		assertSame(attributeChange.getEquivalentDiffs(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getEquivalentDiffs(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+		assertTrue(equivalentDiffsValue.getDifferences().contains(attributeChange));
+
+		attributeChange.eSet(feature, equivalentDiffsValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(equivalentDiffsValue, attributeChange.getEquivalentDiffs());
+		assertSame(attributeChange.getEquivalentDiffs(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getEquivalentDiffs(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+		assertTrue(equivalentDiffsValue.getDifferences().contains(attributeChange));
+
+		attributeChange.setEquivalentDiffs(null);
+		assertTrue(notified);
+		notified = false;
+		assertNull(attributeChange.getEquivalentDiffs());
+		assertSame(feature.getDefaultValue(), attributeChange.getEquivalentDiffs());
+		assertSame(attributeChange.getEquivalentDiffs(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getEquivalentDiffs(), attributeChange.eGet(feature, false));
+		assertFalse(attributeChange.eIsSet(feature));
+		assertFalse(equivalentDiffsValue.getDifferences().contains(attributeChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>conflict</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testConflict() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Conflict();
+		AttributeChange attributeChange = CompareFactory.eINSTANCE.createAttributeChange();
+		attributeChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Conflict conflictValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createConflict();
+
+		assertFalse(attributeChange.eIsSet(feature));
+		assertNull(attributeChange.getConflict());
+
+		attributeChange.setConflict(conflictValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(conflictValue, attributeChange.getConflict());
+		assertSame(attributeChange.getConflict(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getConflict(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+		assertTrue(conflictValue.getDifferences().contains(attributeChange));
+
+		attributeChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertNull(attributeChange.getConflict());
+		assertSame(attributeChange.getConflict(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getConflict(), attributeChange.eGet(feature, false));
+		assertFalse(attributeChange.eIsSet(feature));
+		assertFalse(conflictValue.getDifferences().contains(attributeChange));
+
+		attributeChange.setConflict(conflictValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(conflictValue, attributeChange.getConflict());
+		assertSame(attributeChange.getConflict(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getConflict(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+		assertTrue(conflictValue.getDifferences().contains(attributeChange));
+
+		attributeChange.eSet(feature, conflictValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(conflictValue, attributeChange.getConflict());
+		assertSame(attributeChange.getConflict(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getConflict(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+		assertTrue(conflictValue.getDifferences().contains(attributeChange));
+
+		attributeChange.setConflict(null);
+		assertTrue(notified);
+		notified = false;
+		assertNull(attributeChange.getConflict());
+		assertSame(feature.getDefaultValue(), attributeChange.getConflict());
+		assertSame(attributeChange.getConflict(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getConflict(), attributeChange.eGet(feature, false));
+		assertFalse(attributeChange.eIsSet(feature));
+		assertFalse(conflictValue.getDifferences().contains(attributeChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>attribute</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testAttribute() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE
+				.getAttributeChange_Attribute();
+		AttributeChange attributeChange = CompareFactory.eINSTANCE.createAttributeChange();
+		attributeChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.ecore.EAttribute attributeValue = org.eclipse.emf.ecore.EcoreFactory.eINSTANCE
+				.createEAttribute();
+
+		assertFalse(attributeChange.eIsSet(feature));
+		assertNull(attributeChange.getAttribute());
+
+		attributeChange.setAttribute(attributeValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(attributeValue, attributeChange.getAttribute());
+		assertSame(attributeChange.getAttribute(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getAttribute(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+
+		attributeChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertNull(attributeChange.getAttribute());
+		assertSame(attributeChange.getAttribute(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getAttribute(), attributeChange.eGet(feature, false));
+		assertFalse(attributeChange.eIsSet(feature));
+
+		attributeChange.setAttribute(attributeValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(attributeValue, attributeChange.getAttribute());
+		assertSame(attributeChange.getAttribute(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getAttribute(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+
+		attributeChange.eSet(feature, attributeValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(attributeValue, attributeChange.getAttribute());
+		assertSame(attributeChange.getAttribute(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getAttribute(), attributeChange.eGet(feature, false));
+		assertTrue(attributeChange.eIsSet(feature));
+
+		attributeChange.setAttribute(null);
+		assertTrue(notified);
+		notified = false;
+		assertNull(attributeChange.getAttribute());
+		assertSame(feature.getDefaultValue(), attributeChange.getAttribute());
+		assertSame(attributeChange.getAttribute(), attributeChange.eGet(feature));
+		assertSame(attributeChange.getAttribute(), attributeChange.eGet(feature, false));
+		assertFalse(attributeChange.eIsSet(feature));
+	}
+
+	/**
+	 * Tests the behavior of attribute <code>kind</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testKind() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Kind();
+		AttributeChange attributeChange = CompareFactory.eINSTANCE.createAttributeChange();
+		attributeChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.DifferenceKind kindValue = (org.eclipse.emf.compare.DifferenceKind)feature
+				.getDefaultValue();
+		for (org.eclipse.emf.compare.DifferenceKind aDifferenceKind : org.eclipse.emf.compare.DifferenceKind.VALUES) {
+			if (kindValue.getValue() != aDifferenceKind.getValue()) {
+				kindValue = aDifferenceKind;
+				break;
+			}
+		}
+
+		assertFalse(attributeChange.eIsSet(feature));
+		assertEquals(feature.getDefaultValue(), attributeChange.getKind());
+
+		attributeChange.setKind(kindValue);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(kindValue, attributeChange.getKind());
+		assertEquals(attributeChange.getKind(), attributeChange.eGet(feature));
+		assertTrue(attributeChange.eIsSet(feature));
+
+		attributeChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(feature.getDefaultValue(), attributeChange.getKind());
+		assertEquals(attributeChange.getKind(), attributeChange.eGet(feature));
+		assertFalse(attributeChange.eIsSet(feature));
+
+		attributeChange.eSet(feature, kindValue);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(kindValue, attributeChange.getKind());
+		assertEquals(attributeChange.getKind(), attributeChange.eGet(feature));
+		assertTrue(attributeChange.eIsSet(feature));
+
+		attributeChange.setKind(null);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(feature.getDefaultValue(), attributeChange.getKind());
+		assertEquals(attributeChange.getKind(), attributeChange.eGet(feature));
+		assertFalse(attributeChange.eIsSet(feature));
+	}
+
+	/**
+	 * Tests the behavior of attribute <code>value</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testValue() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE
+				.getAttributeChange_Value();
+		AttributeChange attributeChange = CompareFactory.eINSTANCE.createAttributeChange();
+		attributeChange.eAdapters().add(new MockEAdapter());
+		java.lang.Object valueValue = getValueDistinctFromDefault(feature);
+
+		assertFalse(attributeChange.eIsSet(feature));
+		assertEquals(feature.getDefaultValue(), attributeChange.getValue());
+
+		attributeChange.setValue(valueValue);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(valueValue, attributeChange.getValue());
+		assertEquals(attributeChange.getValue(), attributeChange.eGet(feature));
+		assertTrue(attributeChange.eIsSet(feature));
+
+		attributeChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(feature.getDefaultValue(), attributeChange.getValue());
+		assertEquals(attributeChange.getValue(), attributeChange.eGet(feature));
+		assertFalse(attributeChange.eIsSet(feature));
+
+		attributeChange.eSet(feature, valueValue);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(valueValue, attributeChange.getValue());
+		assertEquals(attributeChange.getValue(), attributeChange.eGet(feature));
+		assertTrue(attributeChange.eIsSet(feature));
+
+		attributeChange.setValue(null);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(feature.getDefaultValue(), attributeChange.getValue());
+		assertEquals(attributeChange.getValue(), attributeChange.eGet(feature));
+		assertFalse(attributeChange.eIsSet(feature));
+	}
+
+}
diff --git a/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/CompareAdapterFactoryTest.java b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/CompareAdapterFactoryTest.java
new file mode 100644
index 000000000..09d397ad3
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/CompareAdapterFactoryTest.java
@@ -0,0 +1,163 @@
+package org.eclipse.emf.compare.tests.unit;
+
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertNull;
+import static junit.framework.Assert.assertTrue;
+
+import org.eclipse.emf.compare.AttributeChange;
+import org.eclipse.emf.compare.CompareFactory;
+import org.eclipse.emf.compare.ComparePackage;
+import org.eclipse.emf.compare.Comparison;
+import org.eclipse.emf.compare.Conflict;
+import org.eclipse.emf.compare.Diff;
+import org.eclipse.emf.compare.Equivalence;
+import org.eclipse.emf.compare.Match;
+import org.eclipse.emf.compare.MatchResource;
+import org.eclipse.emf.compare.ReferenceChange;
+import org.eclipse.emf.compare.ResourceAttachmentChange;
+import org.eclipse.emf.compare.util.CompareAdapterFactory;
+import org.junit.Test;
+
+/*
+ * TODO This is but a skeleton for the tests of CompareAdapterFactory.
+ * Set as "generated NOT" and override each test if you overrode the default generated
+ * behavior.
+ */
+/**
+ * Tests the behavior of the {@link CompareAdapterFactory generated adapter factory} for package compare.
+ * 
+ * @generated
+ */
+public class CompareAdapterFactoryTest {
+	/**
+	 * Ensures that creating adapters for {@link Comparison} can be done through the AdapterFactory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateComparisonAdapter() {
+		CompareAdapterFactory adapterFactory = new CompareAdapterFactory();
+		assertNull(adapterFactory.createComparisonAdapter());
+		assertNull(adapterFactory.createAdapter(CompareFactory.eINSTANCE.createComparison()));
+	}
+
+	/**
+	 * Ensures that creating adapters for {@link MatchResource} can be done through the AdapterFactory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateMatchResourceAdapter() {
+		CompareAdapterFactory adapterFactory = new CompareAdapterFactory();
+		assertNull(adapterFactory.createMatchResourceAdapter());
+		assertNull(adapterFactory.createAdapter(CompareFactory.eINSTANCE.createMatchResource()));
+	}
+
+	/**
+	 * Ensures that creating adapters for {@link Match} can be done through the AdapterFactory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateMatchAdapter() {
+		CompareAdapterFactory adapterFactory = new CompareAdapterFactory();
+		assertNull(adapterFactory.createMatchAdapter());
+		assertNull(adapterFactory.createAdapter(CompareFactory.eINSTANCE.createMatch()));
+	}
+
+	/**
+	 * Ensures that creating adapters for {@link Diff} can be done through the AdapterFactory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateDiffAdapter() {
+		CompareAdapterFactory adapterFactory = new CompareAdapterFactory();
+		assertNull(adapterFactory.createDiffAdapter());
+		assertNull(adapterFactory.createAdapter(CompareFactory.eINSTANCE.createDiff()));
+	}
+
+	/**
+	 * Ensures that creating adapters for {@link ResourceAttachmentChange} can be done through the
+	 * AdapterFactory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateResourceAttachmentChangeAdapter() {
+		CompareAdapterFactory adapterFactory = new CompareAdapterFactory();
+		assertNull(adapterFactory.createResourceAttachmentChangeAdapter());
+		assertNull(adapterFactory.createAdapter(CompareFactory.eINSTANCE.createResourceAttachmentChange()));
+	}
+
+	/**
+	 * Ensures that creating adapters for {@link ReferenceChange} can be done through the AdapterFactory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateReferenceChangeAdapter() {
+		CompareAdapterFactory adapterFactory = new CompareAdapterFactory();
+		assertNull(adapterFactory.createReferenceChangeAdapter());
+		assertNull(adapterFactory.createAdapter(CompareFactory.eINSTANCE.createReferenceChange()));
+	}
+
+	/**
+	 * Ensures that creating adapters for {@link AttributeChange} can be done through the AdapterFactory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateAttributeChangeAdapter() {
+		CompareAdapterFactory adapterFactory = new CompareAdapterFactory();
+		assertNull(adapterFactory.createAttributeChangeAdapter());
+		assertNull(adapterFactory.createAdapter(CompareFactory.eINSTANCE.createAttributeChange()));
+	}
+
+	/**
+	 * Ensures that creating adapters for {@link Conflict} can be done through the AdapterFactory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateConflictAdapter() {
+		CompareAdapterFactory adapterFactory = new CompareAdapterFactory();
+		assertNull(adapterFactory.createConflictAdapter());
+		assertNull(adapterFactory.createAdapter(CompareFactory.eINSTANCE.createConflict()));
+	}
+
+	/**
+	 * Ensures that creating adapters for {@link Equivalence} can be done through the AdapterFactory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateEquivalenceAdapter() {
+		CompareAdapterFactory adapterFactory = new CompareAdapterFactory();
+		assertNull(adapterFactory.createEquivalenceAdapter());
+		assertNull(adapterFactory.createAdapter(CompareFactory.eINSTANCE.createEquivalence()));
+	}
+
+	/**
+	 * Ensures that the AdapterFactory knows all classes of package compare.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testIsFactoryForType() {
+		CompareAdapterFactory adapterFactory = new CompareAdapterFactory();
+		assertTrue(adapterFactory.isFactoryForType(CompareFactory.eINSTANCE.createComparison()));
+		assertTrue(adapterFactory.isFactoryForType(CompareFactory.eINSTANCE.createMatchResource()));
+		assertTrue(adapterFactory.isFactoryForType(CompareFactory.eINSTANCE.createMatch()));
+		assertTrue(adapterFactory.isFactoryForType(CompareFactory.eINSTANCE.createDiff()));
+		assertTrue(adapterFactory.isFactoryForType(CompareFactory.eINSTANCE.createResourceAttachmentChange()));
+		assertTrue(adapterFactory.isFactoryForType(CompareFactory.eINSTANCE.createReferenceChange()));
+		assertTrue(adapterFactory.isFactoryForType(CompareFactory.eINSTANCE.createAttributeChange()));
+		assertTrue(adapterFactory.isFactoryForType(CompareFactory.eINSTANCE.createConflict()));
+		assertTrue(adapterFactory.isFactoryForType(CompareFactory.eINSTANCE.createEquivalence()));
+		assertTrue(adapterFactory.isFactoryForType(ComparePackage.eINSTANCE));
+		org.eclipse.emf.ecore.EClass eClass = org.eclipse.emf.ecore.EcoreFactory.eINSTANCE.createEClass();
+		assertFalse(adapterFactory.isFactoryForType(eClass));
+		assertFalse(adapterFactory.isFactoryForType(new Object()));
+	}
+}
diff --git a/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/CompareFactoryTest.java b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/CompareFactoryTest.java
new file mode 100644
index 000000000..26415e3f9
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/CompareFactoryTest.java
@@ -0,0 +1,307 @@
+package org.eclipse.emf.compare.tests.unit;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertNotNull;
+import static junit.framework.Assert.assertSame;
+import static junit.framework.Assert.assertTrue;
+import static junit.framework.Assert.fail;
+
+import org.eclipse.emf.compare.AttributeChange;
+import org.eclipse.emf.compare.CompareFactory;
+import org.eclipse.emf.compare.ComparePackage;
+import org.eclipse.emf.compare.Comparison;
+import org.eclipse.emf.compare.Conflict;
+import org.eclipse.emf.compare.Diff;
+import org.eclipse.emf.compare.DifferenceKind;
+import org.eclipse.emf.compare.DifferenceSource;
+import org.eclipse.emf.compare.Equivalence;
+import org.eclipse.emf.compare.Match;
+import org.eclipse.emf.compare.MatchResource;
+import org.eclipse.emf.compare.ReferenceChange;
+import org.eclipse.emf.compare.ResourceAttachmentChange;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EEnum;
+import org.eclipse.emf.ecore.EcoreFactory;
+import org.eclipse.emf.ecore.impl.EClassifierImpl;
+import org.junit.Test;
+
+/**
+ * Tests the behavior of the {@link CompareFactory generated factory} for package compare.
+ * 
+ * @generated
+ */
+@SuppressWarnings("nls")
+public class CompareFactoryTest {
+	/**
+	 * Ensures that creating {@link Comparison} can be done through the factory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateComparison() {
+		Object result = CompareFactory.eINSTANCE.createComparison();
+		assertNotNull(result);
+		assertTrue(result instanceof Comparison);
+
+		result = CompareFactory.eINSTANCE.create(ComparePackage.Literals.COMPARISON);
+		assertNotNull(result);
+		assertTrue(result instanceof Comparison);
+	}
+
+	/**
+	 * Ensures that creating {@link MatchResource} can be done through the factory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateMatchResource() {
+		Object result = CompareFactory.eINSTANCE.createMatchResource();
+		assertNotNull(result);
+		assertTrue(result instanceof MatchResource);
+
+		result = CompareFactory.eINSTANCE.create(ComparePackage.Literals.MATCH_RESOURCE);
+		assertNotNull(result);
+		assertTrue(result instanceof MatchResource);
+	}
+
+	/**
+	 * Ensures that creating {@link Match} can be done through the factory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateMatch() {
+		Object result = CompareFactory.eINSTANCE.createMatch();
+		assertNotNull(result);
+		assertTrue(result instanceof Match);
+
+		result = CompareFactory.eINSTANCE.create(ComparePackage.Literals.MATCH);
+		assertNotNull(result);
+		assertTrue(result instanceof Match);
+	}
+
+	/**
+	 * Ensures that creating {@link Diff} can be done through the factory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateDiff() {
+		Object result = CompareFactory.eINSTANCE.createDiff();
+		assertNotNull(result);
+		assertTrue(result instanceof Diff);
+
+		result = CompareFactory.eINSTANCE.create(ComparePackage.Literals.DIFF);
+		assertNotNull(result);
+		assertTrue(result instanceof Diff);
+	}
+
+	/**
+	 * Ensures that creating {@link ResourceAttachmentChange} can be done through the factory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateResourceAttachmentChange() {
+		Object result = CompareFactory.eINSTANCE.createResourceAttachmentChange();
+		assertNotNull(result);
+		assertTrue(result instanceof ResourceAttachmentChange);
+
+		result = CompareFactory.eINSTANCE.create(ComparePackage.Literals.RESOURCE_ATTACHMENT_CHANGE);
+		assertNotNull(result);
+		assertTrue(result instanceof ResourceAttachmentChange);
+	}
+
+	/**
+	 * Ensures that creating {@link ReferenceChange} can be done through the factory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateReferenceChange() {
+		Object result = CompareFactory.eINSTANCE.createReferenceChange();
+		assertNotNull(result);
+		assertTrue(result instanceof ReferenceChange);
+
+		result = CompareFactory.eINSTANCE.create(ComparePackage.Literals.REFERENCE_CHANGE);
+		assertNotNull(result);
+		assertTrue(result instanceof ReferenceChange);
+	}
+
+	/**
+	 * Ensures that creating {@link AttributeChange} can be done through the factory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateAttributeChange() {
+		Object result = CompareFactory.eINSTANCE.createAttributeChange();
+		assertNotNull(result);
+		assertTrue(result instanceof AttributeChange);
+
+		result = CompareFactory.eINSTANCE.create(ComparePackage.Literals.ATTRIBUTE_CHANGE);
+		assertNotNull(result);
+		assertTrue(result instanceof AttributeChange);
+	}
+
+	/**
+	 * Ensures that creating {@link Conflict} can be done through the factory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateConflict() {
+		Object result = CompareFactory.eINSTANCE.createConflict();
+		assertNotNull(result);
+		assertTrue(result instanceof Conflict);
+
+		result = CompareFactory.eINSTANCE.create(ComparePackage.Literals.CONFLICT);
+		assertNotNull(result);
+		assertTrue(result instanceof Conflict);
+	}
+
+	/**
+	 * Ensures that creating {@link Equivalence} can be done through the factory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateEquivalence() {
+		Object result = CompareFactory.eINSTANCE.createEquivalence();
+		assertNotNull(result);
+		assertTrue(result instanceof Equivalence);
+
+		result = CompareFactory.eINSTANCE.create(ComparePackage.Literals.EQUIVALENCE);
+		assertNotNull(result);
+		assertTrue(result instanceof Equivalence);
+	}
+
+	/**
+	 * Ensures that trying to create an {@link EClass} from another package yields the expected exception.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateUnknownEClass() {
+		try {
+			EClass eClass = EcoreFactory.eINSTANCE.createEClass();
+			((EClassifierImpl)eClass).setClassifierID(-1);
+			CompareFactory.eINSTANCE.create(eClass);
+			fail("Expected IllegalArgumentException hasn't been thrown");
+		} catch (IllegalArgumentException e) {
+			// Expected behavior
+		}
+	}
+
+	/**
+	 * Ensures that converting {@link DifferenceKind} to String can be done through the factory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testConvertDifferenceKindToString() {
+		for (DifferenceKind value : DifferenceKind.VALUES) {
+			Object result = CompareFactory.eINSTANCE.convertToString(ComparePackage.Literals.DIFFERENCE_KIND,
+					value);
+			assertNotNull(result);
+			assertEquals(value.toString(), result);
+		}
+	}
+
+	/**
+	 * Ensures that converting {@link DifferenceSource} to String can be done through the factory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testConvertDifferenceSourceToString() {
+		for (DifferenceSource value : DifferenceSource.VALUES) {
+			Object result = CompareFactory.eINSTANCE.convertToString(
+					ComparePackage.Literals.DIFFERENCE_SOURCE, value);
+			assertNotNull(result);
+			assertEquals(value.toString(), result);
+		}
+	}
+
+	/**
+	 * Ensures that trying to convert an {@link EEnum} from another package to String yields the expected
+	 * exception.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testConvertUnknownEEnumToString() {
+		try {
+			EEnum eEnum = EcoreFactory.eINSTANCE.createEEnum();
+			((EClassifierImpl)eEnum).setClassifierID(-1);
+			CompareFactory.eINSTANCE.convertToString(eEnum, eEnum);
+			fail("Expected IllegalArgumentException hasn't been thrown");
+		} catch (IllegalArgumentException e) {
+			// Expected behavior
+		}
+	}
+
+	/**
+	 * Ensures that creating {@link DifferenceKind} from String can be done through the factory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateDifferenceKindFromString() {
+		for (DifferenceKind value : DifferenceKind.VALUES) {
+			Object result = CompareFactory.eINSTANCE.createFromString(
+					ComparePackage.Literals.DIFFERENCE_KIND, value.getLiteral());
+			assertNotNull(result);
+			assertSame(value, result);
+
+			try {
+				CompareFactory.eINSTANCE.createFromString(ComparePackage.Literals.DIFFERENCE_KIND,
+						"ThisShouldntBeAKnownEEnumLiteral");
+				fail("Expected IllegalArgumentException hasn't been thrown");
+			} catch (IllegalArgumentException e) {
+				// Expected behavior
+			}
+		}
+	}
+
+	/**
+	 * Ensures that creating {@link DifferenceSource} from String can be done through the factory.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateDifferenceSourceFromString() {
+		for (DifferenceSource value : DifferenceSource.VALUES) {
+			Object result = CompareFactory.eINSTANCE.createFromString(
+					ComparePackage.Literals.DIFFERENCE_SOURCE, value.getLiteral());
+			assertNotNull(result);
+			assertSame(value, result);
+
+			try {
+				CompareFactory.eINSTANCE.createFromString(ComparePackage.Literals.DIFFERENCE_SOURCE,
+						"ThisShouldntBeAKnownEEnumLiteral");
+				fail("Expected IllegalArgumentException hasn't been thrown");
+			} catch (IllegalArgumentException e) {
+				// Expected behavior
+			}
+		}
+	}
+
+	/**
+	 * Ensures that trying to create an {@link EEnum} from another package from String yields the expected
+	 * exception.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCreateUnknownEEnumFromString() {
+		try {
+			EEnum eEnum = EcoreFactory.eINSTANCE.createEEnum();
+			((EClassifierImpl)eEnum).setClassifierID(-1);
+			CompareFactory.eINSTANCE.createFromString(eEnum, "ThisShouldntBeAKnownEEnumLiteral");
+			fail("Expected IllegalArgumentException hasn't been thrown");
+		} catch (IllegalArgumentException e) {
+			// Expected behavior
+		}
+	}
+}
diff --git a/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/CompareSwitchTest.java b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/CompareSwitchTest.java
new file mode 100644
index 000000000..9b7fc1ba5
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/CompareSwitchTest.java
@@ -0,0 +1,137 @@
+package org.eclipse.emf.compare.tests.unit;
+
+import static junit.framework.Assert.assertNull;
+
+import org.eclipse.emf.compare.AttributeChange;
+import org.eclipse.emf.compare.CompareFactory;
+import org.eclipse.emf.compare.Comparison;
+import org.eclipse.emf.compare.Conflict;
+import org.eclipse.emf.compare.Diff;
+import org.eclipse.emf.compare.Equivalence;
+import org.eclipse.emf.compare.Match;
+import org.eclipse.emf.compare.MatchResource;
+import org.eclipse.emf.compare.ReferenceChange;
+import org.eclipse.emf.compare.ResourceAttachmentChange;
+import org.eclipse.emf.compare.util.CompareSwitch;
+import org.junit.Test;
+
+/*
+ * TODO This is but a skeleton for the tests of CompareSwitch.
+ * Set as "generated NOT" and override each test if you overrode the default generated
+ * behavior.
+ */
+/**
+ * Tests the behavior of the {@link CompareSwitch generated switch} for package compare.
+ * 
+ * @generated
+ */
+public class CompareSwitchTest {
+	/**
+	 * Ensures that the generated switch knows {@link Comparison}.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCaseComparison() {
+		CompareSwitch<?> compareswitch = new CompareSwitch<Object>();
+		assertNull(compareswitch.caseComparison(CompareFactory.eINSTANCE.createComparison()));
+		assertNull(compareswitch.doSwitch(CompareFactory.eINSTANCE.createComparison()));
+	}
+
+	/**
+	 * Ensures that the generated switch knows {@link MatchResource}.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCaseMatchResource() {
+		CompareSwitch<?> compareswitch = new CompareSwitch<Object>();
+		assertNull(compareswitch.caseMatchResource(CompareFactory.eINSTANCE.createMatchResource()));
+		assertNull(compareswitch.doSwitch(CompareFactory.eINSTANCE.createMatchResource()));
+	}
+
+	/**
+	 * Ensures that the generated switch knows {@link Match}.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCaseMatch() {
+		CompareSwitch<?> compareswitch = new CompareSwitch<Object>();
+		assertNull(compareswitch.caseMatch(CompareFactory.eINSTANCE.createMatch()));
+		assertNull(compareswitch.doSwitch(CompareFactory.eINSTANCE.createMatch()));
+	}
+
+	/**
+	 * Ensures that the generated switch knows {@link Diff}.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCaseDiff() {
+		CompareSwitch<?> compareswitch = new CompareSwitch<Object>();
+		assertNull(compareswitch.caseDiff(CompareFactory.eINSTANCE.createDiff()));
+		assertNull(compareswitch.doSwitch(CompareFactory.eINSTANCE.createDiff()));
+	}
+
+	/**
+	 * Ensures that the generated switch knows {@link ResourceAttachmentChange}.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCaseResourceAttachmentChange() {
+		CompareSwitch<?> compareswitch = new CompareSwitch<Object>();
+		assertNull(compareswitch.caseResourceAttachmentChange(CompareFactory.eINSTANCE
+				.createResourceAttachmentChange()));
+		assertNull(compareswitch.doSwitch(CompareFactory.eINSTANCE.createResourceAttachmentChange()));
+	}
+
+	/**
+	 * Ensures that the generated switch knows {@link ReferenceChange}.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCaseReferenceChange() {
+		CompareSwitch<?> compareswitch = new CompareSwitch<Object>();
+		assertNull(compareswitch.caseReferenceChange(CompareFactory.eINSTANCE.createReferenceChange()));
+		assertNull(compareswitch.doSwitch(CompareFactory.eINSTANCE.createReferenceChange()));
+	}
+
+	/**
+	 * Ensures that the generated switch knows {@link AttributeChange}.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCaseAttributeChange() {
+		CompareSwitch<?> compareswitch = new CompareSwitch<Object>();
+		assertNull(compareswitch.caseAttributeChange(CompareFactory.eINSTANCE.createAttributeChange()));
+		assertNull(compareswitch.doSwitch(CompareFactory.eINSTANCE.createAttributeChange()));
+	}
+
+	/**
+	 * Ensures that the generated switch knows {@link Conflict}.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCaseConflict() {
+		CompareSwitch<?> compareswitch = new CompareSwitch<Object>();
+		assertNull(compareswitch.caseConflict(CompareFactory.eINSTANCE.createConflict()));
+		assertNull(compareswitch.doSwitch(CompareFactory.eINSTANCE.createConflict()));
+	}
+
+	/**
+	 * Ensures that the generated switch knows {@link Equivalence}.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testCaseEquivalence() {
+		CompareSwitch<?> compareswitch = new CompareSwitch<Object>();
+		assertNull(compareswitch.caseEquivalence(CompareFactory.eINSTANCE.createEquivalence()));
+		assertNull(compareswitch.doSwitch(CompareFactory.eINSTANCE.createEquivalence()));
+	}
+}
diff --git a/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/ComparisonTest.java b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/ComparisonTest.java
new file mode 100644
index 000000000..5b087a4b1
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/ComparisonTest.java
@@ -0,0 +1,154 @@
+package org.eclipse.emf.compare.tests.unit;
+
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertSame;
+import static junit.framework.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.emf.compare.CompareFactory;
+import org.eclipse.emf.compare.Comparison;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.junit.Test;
+
+/**
+ * Tests the behavior of the {@link Comparison} class.
+ * 
+ * @generated
+ */
+public class ComparisonTest extends AbstractCompareTest {
+	/**
+	 * Tests the behavior of reference <code>matchedResources</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testMatchedResources() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE
+				.getComparison_MatchedResources();
+		Comparison comparison = CompareFactory.eINSTANCE.createComparison();
+		comparison.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.MatchResource matchedResourcesValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createMatchResource();
+		List<org.eclipse.emf.compare.MatchResource> listMatchedResources = new ArrayList<org.eclipse.emf.compare.MatchResource>(
+				1);
+		listMatchedResources.add(matchedResourcesValue);
+
+		assertFalse(comparison.eIsSet(feature));
+		assertTrue(comparison.getMatchedResources().isEmpty());
+
+		comparison.getMatchedResources().add(matchedResourcesValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(comparison.getMatchedResources().contains(matchedResourcesValue));
+		assertSame(comparison.getMatchedResources(), comparison.eGet(feature));
+		assertSame(comparison.getMatchedResources(), comparison.eGet(feature, false));
+		assertTrue(comparison.eIsSet(feature));
+
+		comparison.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(comparison.getMatchedResources().isEmpty());
+		assertSame(comparison.getMatchedResources(), comparison.eGet(feature));
+		assertSame(comparison.getMatchedResources(), comparison.eGet(feature, false));
+		assertFalse(comparison.eIsSet(feature));
+
+		comparison.eSet(feature, listMatchedResources);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(comparison.getMatchedResources().contains(matchedResourcesValue));
+		assertSame(comparison.getMatchedResources(), comparison.eGet(feature));
+		assertSame(comparison.getMatchedResources(), comparison.eGet(feature, false));
+		assertTrue(comparison.eIsSet(feature));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>matches</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testMatches() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getComparison_Matches();
+		Comparison comparison = CompareFactory.eINSTANCE.createComparison();
+		comparison.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Match matchesValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createMatch();
+		List<org.eclipse.emf.compare.Match> listMatches = new ArrayList<org.eclipse.emf.compare.Match>(1);
+		listMatches.add(matchesValue);
+
+		assertFalse(comparison.eIsSet(feature));
+		assertTrue(comparison.getMatches().isEmpty());
+
+		comparison.getMatches().add(matchesValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(comparison.getMatches().contains(matchesValue));
+		assertSame(comparison.getMatches(), comparison.eGet(feature));
+		assertSame(comparison.getMatches(), comparison.eGet(feature, false));
+		assertTrue(comparison.eIsSet(feature));
+
+		comparison.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(comparison.getMatches().isEmpty());
+		assertSame(comparison.getMatches(), comparison.eGet(feature));
+		assertSame(comparison.getMatches(), comparison.eGet(feature, false));
+		assertFalse(comparison.eIsSet(feature));
+
+		comparison.eSet(feature, listMatches);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(comparison.getMatches().contains(matchesValue));
+		assertSame(comparison.getMatches(), comparison.eGet(feature));
+		assertSame(comparison.getMatches(), comparison.eGet(feature, false));
+		assertTrue(comparison.eIsSet(feature));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>conflicts</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testConflicts() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE
+				.getComparison_Conflicts();
+		Comparison comparison = CompareFactory.eINSTANCE.createComparison();
+		comparison.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Conflict conflictsValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createConflict();
+		List<org.eclipse.emf.compare.Conflict> listConflicts = new ArrayList<org.eclipse.emf.compare.Conflict>(
+				1);
+		listConflicts.add(conflictsValue);
+
+		assertFalse(comparison.eIsSet(feature));
+		assertTrue(comparison.getConflicts().isEmpty());
+
+		comparison.getConflicts().add(conflictsValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(comparison.getConflicts().contains(conflictsValue));
+		assertSame(comparison.getConflicts(), comparison.eGet(feature));
+		assertSame(comparison.getConflicts(), comparison.eGet(feature, false));
+		assertTrue(comparison.eIsSet(feature));
+
+		comparison.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(comparison.getConflicts().isEmpty());
+		assertSame(comparison.getConflicts(), comparison.eGet(feature));
+		assertSame(comparison.getConflicts(), comparison.eGet(feature, false));
+		assertFalse(comparison.eIsSet(feature));
+
+		comparison.eSet(feature, listConflicts);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(comparison.getConflicts().contains(conflictsValue));
+		assertSame(comparison.getConflicts(), comparison.eGet(feature));
+		assertSame(comparison.getConflicts(), comparison.eGet(feature, false));
+		assertTrue(comparison.eIsSet(feature));
+	}
+
+}
diff --git a/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/ConflictTest.java b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/ConflictTest.java
new file mode 100644
index 000000000..37fca7a35
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/ConflictTest.java
@@ -0,0 +1,68 @@
+package org.eclipse.emf.compare.tests.unit;
+
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertSame;
+import static junit.framework.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.emf.compare.CompareFactory;
+import org.eclipse.emf.compare.Conflict;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.junit.Test;
+
+/**
+ * Tests the behavior of the {@link Conflict} class.
+ * 
+ * @generated
+ */
+public class ConflictTest extends AbstractCompareTest {
+	/**
+	 * Tests the behavior of reference <code>differences</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testDifferences() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE
+				.getConflict_Differences();
+		Conflict conflict = CompareFactory.eINSTANCE.createConflict();
+		conflict.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff differencesValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listDifferences = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listDifferences.add(differencesValue);
+
+		assertFalse(conflict.eIsSet(feature));
+		assertTrue(conflict.getDifferences().isEmpty());
+
+		conflict.getDifferences().add(differencesValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(conflict.getDifferences().contains(differencesValue));
+		assertSame(conflict.getDifferences(), conflict.eGet(feature));
+		assertSame(conflict.getDifferences(), conflict.eGet(feature, false));
+		assertTrue(conflict.eIsSet(feature));
+		assertTrue(differencesValue.getConflict() == conflict);
+
+		conflict.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(conflict.getDifferences().isEmpty());
+		assertSame(conflict.getDifferences(), conflict.eGet(feature));
+		assertSame(conflict.getDifferences(), conflict.eGet(feature, false));
+		assertFalse(conflict.eIsSet(feature));
+		assertFalse(differencesValue.getConflict() == conflict);
+
+		conflict.eSet(feature, listDifferences);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(conflict.getDifferences().contains(differencesValue));
+		assertSame(conflict.getDifferences(), conflict.eGet(feature));
+		assertSame(conflict.getDifferences(), conflict.eGet(feature, false));
+		assertTrue(conflict.eIsSet(feature));
+		assertTrue(differencesValue.getConflict() == conflict);
+	}
+
+}
diff --git a/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/DiffTest.java b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/DiffTest.java
new file mode 100644
index 000000000..1ae6e6ae5
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/DiffTest.java
@@ -0,0 +1,448 @@
+package org.eclipse.emf.compare.tests.unit;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertNull;
+import static junit.framework.Assert.assertSame;
+import static junit.framework.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.emf.compare.CompareFactory;
+import org.eclipse.emf.compare.Diff;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.junit.Test;
+
+/**
+ * Tests the behavior of the {@link Diff} class.
+ * 
+ * @generated
+ */
+public class DiffTest extends AbstractCompareTest {
+	/**
+	 * Tests the behavior of reference <code>requires</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testRequires() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Requires();
+		Diff diff = CompareFactory.eINSTANCE.createDiff();
+		diff.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff requiresValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listRequires = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listRequires.add(requiresValue);
+
+		assertFalse(diff.eIsSet(feature));
+		assertTrue(diff.getRequires().isEmpty());
+
+		diff.getRequires().add(requiresValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(diff.getRequires().contains(requiresValue));
+		assertSame(diff.getRequires(), diff.eGet(feature));
+		assertSame(diff.getRequires(), diff.eGet(feature, false));
+		assertTrue(diff.eIsSet(feature));
+		assertTrue(requiresValue.getRequiredBy().contains(diff));
+
+		diff.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(diff.getRequires().isEmpty());
+		assertSame(diff.getRequires(), diff.eGet(feature));
+		assertSame(diff.getRequires(), diff.eGet(feature, false));
+		assertFalse(diff.eIsSet(feature));
+		assertFalse(requiresValue.getRequiredBy().contains(diff));
+
+		diff.eSet(feature, listRequires);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(diff.getRequires().contains(requiresValue));
+		assertSame(diff.getRequires(), diff.eGet(feature));
+		assertSame(diff.getRequires(), diff.eGet(feature, false));
+		assertTrue(diff.eIsSet(feature));
+		assertTrue(requiresValue.getRequiredBy().contains(diff));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>requiredBy</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testRequiredBy() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_RequiredBy();
+		Diff diff = CompareFactory.eINSTANCE.createDiff();
+		diff.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff requiredByValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listRequiredBy = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listRequiredBy.add(requiredByValue);
+
+		assertFalse(diff.eIsSet(feature));
+		assertTrue(diff.getRequiredBy().isEmpty());
+
+		diff.getRequiredBy().add(requiredByValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(diff.getRequiredBy().contains(requiredByValue));
+		assertSame(diff.getRequiredBy(), diff.eGet(feature));
+		assertSame(diff.getRequiredBy(), diff.eGet(feature, false));
+		assertTrue(diff.eIsSet(feature));
+		assertTrue(requiredByValue.getRequires().contains(diff));
+
+		diff.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(diff.getRequiredBy().isEmpty());
+		assertSame(diff.getRequiredBy(), diff.eGet(feature));
+		assertSame(diff.getRequiredBy(), diff.eGet(feature, false));
+		assertFalse(diff.eIsSet(feature));
+		assertFalse(requiredByValue.getRequires().contains(diff));
+
+		diff.eSet(feature, listRequiredBy);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(diff.getRequiredBy().contains(requiredByValue));
+		assertSame(diff.getRequiredBy(), diff.eGet(feature));
+		assertSame(diff.getRequiredBy(), diff.eGet(feature, false));
+		assertTrue(diff.eIsSet(feature));
+		assertTrue(requiredByValue.getRequires().contains(diff));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>refines</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testRefines() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Refines();
+		Diff diff = CompareFactory.eINSTANCE.createDiff();
+		diff.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff refinesValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listRefines = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listRefines.add(refinesValue);
+
+		assertFalse(diff.eIsSet(feature));
+		assertTrue(diff.getRefines().isEmpty());
+
+		diff.getRefines().add(refinesValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(diff.getRefines().contains(refinesValue));
+		assertSame(diff.getRefines(), diff.eGet(feature));
+		assertSame(diff.getRefines(), diff.eGet(feature, false));
+		assertTrue(diff.eIsSet(feature));
+		assertTrue(refinesValue.getRefinedBy().contains(diff));
+
+		diff.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(diff.getRefines().isEmpty());
+		assertSame(diff.getRefines(), diff.eGet(feature));
+		assertSame(diff.getRefines(), diff.eGet(feature, false));
+		assertFalse(diff.eIsSet(feature));
+		assertFalse(refinesValue.getRefinedBy().contains(diff));
+
+		diff.eSet(feature, listRefines);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(diff.getRefines().contains(refinesValue));
+		assertSame(diff.getRefines(), diff.eGet(feature));
+		assertSame(diff.getRefines(), diff.eGet(feature, false));
+		assertTrue(diff.eIsSet(feature));
+		assertTrue(refinesValue.getRefinedBy().contains(diff));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>refinedBy</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testRefinedBy() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_RefinedBy();
+		Diff diff = CompareFactory.eINSTANCE.createDiff();
+		diff.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff refinedByValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listRefinedBy = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listRefinedBy.add(refinedByValue);
+
+		assertFalse(diff.eIsSet(feature));
+		assertTrue(diff.getRefinedBy().isEmpty());
+
+		diff.getRefinedBy().add(refinedByValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(diff.getRefinedBy().contains(refinedByValue));
+		assertSame(diff.getRefinedBy(), diff.eGet(feature));
+		assertSame(diff.getRefinedBy(), diff.eGet(feature, false));
+		assertTrue(diff.eIsSet(feature));
+		assertTrue(refinedByValue.getRefines().contains(diff));
+
+		diff.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(diff.getRefinedBy().isEmpty());
+		assertSame(diff.getRefinedBy(), diff.eGet(feature));
+		assertSame(diff.getRefinedBy(), diff.eGet(feature, false));
+		assertFalse(diff.eIsSet(feature));
+		assertFalse(refinedByValue.getRefines().contains(diff));
+
+		diff.eSet(feature, listRefinedBy);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(diff.getRefinedBy().contains(refinedByValue));
+		assertSame(diff.getRefinedBy(), diff.eGet(feature));
+		assertSame(diff.getRefinedBy(), diff.eGet(feature, false));
+		assertTrue(diff.eIsSet(feature));
+		assertTrue(refinedByValue.getRefines().contains(diff));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>match</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testMatch() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Match();
+		Diff diff = CompareFactory.eINSTANCE.createDiff();
+		diff.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Match matchValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createMatch();
+
+		assertFalse(diff.eIsSet(feature));
+		assertNull(diff.getMatch());
+
+		diff.setMatch(matchValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(matchValue, diff.getMatch());
+		assertSame(diff.getMatch(), diff.eGet(feature));
+		assertSame(diff.getMatch(), diff.eGet(feature, false));
+		assertTrue(diff.eIsSet(feature));
+		assertTrue(matchValue.getDifferences().contains(diff));
+
+		diff.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertNull(diff.getMatch());
+		assertSame(diff.getMatch(), diff.eGet(feature));
+		assertSame(diff.getMatch(), diff.eGet(feature, false));
+		assertFalse(diff.eIsSet(feature));
+		assertFalse(matchValue.getDifferences().contains(diff));
+
+		diff.setMatch(matchValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(matchValue, diff.getMatch());
+		assertSame(diff.getMatch(), diff.eGet(feature));
+		assertSame(diff.getMatch(), diff.eGet(feature, false));
+		assertTrue(diff.eIsSet(feature));
+		assertTrue(matchValue.getDifferences().contains(diff));
+
+		diff.eSet(feature, matchValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(matchValue, diff.getMatch());
+		assertSame(diff.getMatch(), diff.eGet(feature));
+		assertSame(diff.getMatch(), diff.eGet(feature, false));
+		assertTrue(diff.eIsSet(feature));
+		assertTrue(matchValue.getDifferences().contains(diff));
+
+		diff.setMatch(null);
+		assertTrue(notified);
+		notified = false;
+		assertNull(diff.getMatch());
+		assertSame(feature.getDefaultValue(), diff.getMatch());
+		assertSame(diff.getMatch(), diff.eGet(feature));
+		assertSame(diff.getMatch(), diff.eGet(feature, false));
+		assertFalse(diff.eIsSet(feature));
+		assertFalse(matchValue.getDifferences().contains(diff));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>equivalentDiffs</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testEquivalentDiffs() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE
+				.getDiff_EquivalentDiffs();
+		Diff diff = CompareFactory.eINSTANCE.createDiff();
+		diff.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Equivalence equivalentDiffsValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createEquivalence();
+
+		assertFalse(diff.eIsSet(feature));
+		assertNull(diff.getEquivalentDiffs());
+
+		diff.setEquivalentDiffs(equivalentDiffsValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(equivalentDiffsValue, diff.getEquivalentDiffs());
+		assertSame(diff.getEquivalentDiffs(), diff.eGet(feature));
+		assertSame(diff.getEquivalentDiffs(), diff.eGet(feature, false));
+		assertTrue(diff.eIsSet(feature));
+		assertTrue(equivalentDiffsValue.getDifferences().contains(diff));
+
+		diff.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertNull(diff.getEquivalentDiffs());
+		assertSame(diff.getEquivalentDiffs(), diff.eGet(feature));
+		assertSame(diff.getEquivalentDiffs(), diff.eGet(feature, false));
+		assertFalse(diff.eIsSet(feature));
+		assertFalse(equivalentDiffsValue.getDifferences().contains(diff));
+
+		diff.setEquivalentDiffs(equivalentDiffsValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(equivalentDiffsValue, diff.getEquivalentDiffs());
+		assertSame(diff.getEquivalentDiffs(), diff.eGet(feature));
+		assertSame(diff.getEquivalentDiffs(), diff.eGet(feature, false));
+		assertTrue(diff.eIsSet(feature));
+		assertTrue(equivalentDiffsValue.getDifferences().contains(diff));
+
+		diff.eSet(feature, equivalentDiffsValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(equivalentDiffsValue, diff.getEquivalentDiffs());
+		assertSame(diff.getEquivalentDiffs(), diff.eGet(feature));
+		assertSame(diff.getEquivalentDiffs(), diff.eGet(feature, false));
+		assertTrue(diff.eIsSet(feature));
+		assertTrue(equivalentDiffsValue.getDifferences().contains(diff));
+
+		diff.setEquivalentDiffs(null);
+		assertTrue(notified);
+		notified = false;
+		assertNull(diff.getEquivalentDiffs());
+		assertSame(feature.getDefaultValue(), diff.getEquivalentDiffs());
+		assertSame(diff.getEquivalentDiffs(), diff.eGet(feature));
+		assertSame(diff.getEquivalentDiffs(), diff.eGet(feature, false));
+		assertFalse(diff.eIsSet(feature));
+		assertFalse(equivalentDiffsValue.getDifferences().contains(diff));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>conflict</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testConflict() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Conflict();
+		Diff diff = CompareFactory.eINSTANCE.createDiff();
+		diff.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Conflict conflictValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createConflict();
+
+		assertFalse(diff.eIsSet(feature));
+		assertNull(diff.getConflict());
+
+		diff.setConflict(conflictValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(conflictValue, diff.getConflict());
+		assertSame(diff.getConflict(), diff.eGet(feature));
+		assertSame(diff.getConflict(), diff.eGet(feature, false));
+		assertTrue(diff.eIsSet(feature));
+		assertTrue(conflictValue.getDifferences().contains(diff));
+
+		diff.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertNull(diff.getConflict());
+		assertSame(diff.getConflict(), diff.eGet(feature));
+		assertSame(diff.getConflict(), diff.eGet(feature, false));
+		assertFalse(diff.eIsSet(feature));
+		assertFalse(conflictValue.getDifferences().contains(diff));
+
+		diff.setConflict(conflictValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(conflictValue, diff.getConflict());
+		assertSame(diff.getConflict(), diff.eGet(feature));
+		assertSame(diff.getConflict(), diff.eGet(feature, false));
+		assertTrue(diff.eIsSet(feature));
+		assertTrue(conflictValue.getDifferences().contains(diff));
+
+		diff.eSet(feature, conflictValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(conflictValue, diff.getConflict());
+		assertSame(diff.getConflict(), diff.eGet(feature));
+		assertSame(diff.getConflict(), diff.eGet(feature, false));
+		assertTrue(diff.eIsSet(feature));
+		assertTrue(conflictValue.getDifferences().contains(diff));
+
+		diff.setConflict(null);
+		assertTrue(notified);
+		notified = false;
+		assertNull(diff.getConflict());
+		assertSame(feature.getDefaultValue(), diff.getConflict());
+		assertSame(diff.getConflict(), diff.eGet(feature));
+		assertSame(diff.getConflict(), diff.eGet(feature, false));
+		assertFalse(diff.eIsSet(feature));
+		assertFalse(conflictValue.getDifferences().contains(diff));
+	}
+
+	/**
+	 * Tests the behavior of attribute <code>kind</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testKind() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Kind();
+		Diff diff = CompareFactory.eINSTANCE.createDiff();
+		diff.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.DifferenceKind kindValue = (org.eclipse.emf.compare.DifferenceKind)feature
+				.getDefaultValue();
+		for (org.eclipse.emf.compare.DifferenceKind aDifferenceKind : org.eclipse.emf.compare.DifferenceKind.VALUES) {
+			if (kindValue.getValue() != aDifferenceKind.getValue()) {
+				kindValue = aDifferenceKind;
+				break;
+			}
+		}
+
+		assertFalse(diff.eIsSet(feature));
+		assertEquals(feature.getDefaultValue(), diff.getKind());
+
+		diff.setKind(kindValue);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(kindValue, diff.getKind());
+		assertEquals(diff.getKind(), diff.eGet(feature));
+		assertTrue(diff.eIsSet(feature));
+
+		diff.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(feature.getDefaultValue(), diff.getKind());
+		assertEquals(diff.getKind(), diff.eGet(feature));
+		assertFalse(diff.eIsSet(feature));
+
+		diff.eSet(feature, kindValue);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(kindValue, diff.getKind());
+		assertEquals(diff.getKind(), diff.eGet(feature));
+		assertTrue(diff.eIsSet(feature));
+
+		diff.setKind(null);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(feature.getDefaultValue(), diff.getKind());
+		assertEquals(diff.getKind(), diff.eGet(feature));
+		assertFalse(diff.eIsSet(feature));
+	}
+
+}
diff --git a/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/DifferenceKindTest.java b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/DifferenceKindTest.java
new file mode 100644
index 000000000..4d7530781
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/DifferenceKindTest.java
@@ -0,0 +1,58 @@
+package org.eclipse.emf.compare.tests.unit;
+
+import static junit.framework.Assert.assertNull;
+import static junit.framework.Assert.assertSame;
+
+import org.eclipse.emf.compare.DifferenceKind;
+import org.junit.Test;
+
+/**
+ * Tests the behavior of the {@link DifferenceKind} enumeration.
+ * 
+ * @generated
+ */
+@SuppressWarnings("nls")
+public class DifferenceKindTest {
+	/**
+	 * Tests the behavior of the {@link DifferenceKind#get(int)} method.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testGetInt() {
+		int highestValue = -1;
+		for (DifferenceKind value : DifferenceKind.VALUES) {
+			assertSame(DifferenceKind.get(value.getValue()), value);
+			if (value.getValue() > highestValue) {
+				highestValue = value.getValue();
+			}
+		}
+		assertNull(DifferenceKind.get(++highestValue));
+	}
+
+	/**
+	 * Tests the behavior of the {@link DifferenceKind#get(java.lang.String)} method.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testGetString() {
+		for (DifferenceKind value : DifferenceKind.VALUES) {
+			assertSame(DifferenceKind.get(value.getLiteral()), value);
+		}
+		assertNull(DifferenceKind.get("ThisIsNotAValueOfTheTestedEnum"));
+	}
+
+	/**
+	 * Tests the behavior of the {@link DifferenceKind#getByName(java.lang.String)} method.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testGetByName() {
+		for (DifferenceKind value : DifferenceKind.VALUES) {
+			assertSame(DifferenceKind.getByName(value.getName()), value);
+		}
+		assertNull(DifferenceKind.getByName("ThisIsNotTheNameOfAValueFromTheTestedEnum"));
+	}
+}
diff --git a/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/DifferenceSourceTest.java b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/DifferenceSourceTest.java
new file mode 100644
index 000000000..2a71deef6
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/DifferenceSourceTest.java
@@ -0,0 +1,58 @@
+package org.eclipse.emf.compare.tests.unit;
+
+import static junit.framework.Assert.assertNull;
+import static junit.framework.Assert.assertSame;
+
+import org.eclipse.emf.compare.DifferenceSource;
+import org.junit.Test;
+
+/**
+ * Tests the behavior of the {@link DifferenceSource} enumeration.
+ * 
+ * @generated
+ */
+@SuppressWarnings("nls")
+public class DifferenceSourceTest {
+	/**
+	 * Tests the behavior of the {@link DifferenceSource#get(int)} method.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testGetInt() {
+		int highestValue = -1;
+		for (DifferenceSource value : DifferenceSource.VALUES) {
+			assertSame(DifferenceSource.get(value.getValue()), value);
+			if (value.getValue() > highestValue) {
+				highestValue = value.getValue();
+			}
+		}
+		assertNull(DifferenceSource.get(++highestValue));
+	}
+
+	/**
+	 * Tests the behavior of the {@link DifferenceSource#get(java.lang.String)} method.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testGetString() {
+		for (DifferenceSource value : DifferenceSource.VALUES) {
+			assertSame(DifferenceSource.get(value.getLiteral()), value);
+		}
+		assertNull(DifferenceSource.get("ThisIsNotAValueOfTheTestedEnum"));
+	}
+
+	/**
+	 * Tests the behavior of the {@link DifferenceSource#getByName(java.lang.String)} method.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testGetByName() {
+		for (DifferenceSource value : DifferenceSource.VALUES) {
+			assertSame(DifferenceSource.getByName(value.getName()), value);
+		}
+		assertNull(DifferenceSource.getByName("ThisIsNotTheNameOfAValueFromTheTestedEnum"));
+	}
+}
diff --git a/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/EquivalenceTest.java b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/EquivalenceTest.java
new file mode 100644
index 000000000..aeae30b2d
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/EquivalenceTest.java
@@ -0,0 +1,68 @@
+package org.eclipse.emf.compare.tests.unit;
+
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertSame;
+import static junit.framework.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.emf.compare.CompareFactory;
+import org.eclipse.emf.compare.Equivalence;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.junit.Test;
+
+/**
+ * Tests the behavior of the {@link Equivalence} class.
+ * 
+ * @generated
+ */
+public class EquivalenceTest extends AbstractCompareTest {
+	/**
+	 * Tests the behavior of reference <code>differences</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testDifferences() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE
+				.getEquivalence_Differences();
+		Equivalence equivalence = CompareFactory.eINSTANCE.createEquivalence();
+		equivalence.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff differencesValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listDifferences = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listDifferences.add(differencesValue);
+
+		assertFalse(equivalence.eIsSet(feature));
+		assertTrue(equivalence.getDifferences().isEmpty());
+
+		equivalence.getDifferences().add(differencesValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(equivalence.getDifferences().contains(differencesValue));
+		assertSame(equivalence.getDifferences(), equivalence.eGet(feature));
+		assertSame(equivalence.getDifferences(), equivalence.eGet(feature, false));
+		assertTrue(equivalence.eIsSet(feature));
+		assertTrue(differencesValue.getEquivalentDiffs() == equivalence);
+
+		equivalence.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(equivalence.getDifferences().isEmpty());
+		assertSame(equivalence.getDifferences(), equivalence.eGet(feature));
+		assertSame(equivalence.getDifferences(), equivalence.eGet(feature, false));
+		assertFalse(equivalence.eIsSet(feature));
+		assertFalse(differencesValue.getEquivalentDiffs() == equivalence);
+
+		equivalence.eSet(feature, listDifferences);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(equivalence.getDifferences().contains(differencesValue));
+		assertSame(equivalence.getDifferences(), equivalence.eGet(feature));
+		assertSame(equivalence.getDifferences(), equivalence.eGet(feature, false));
+		assertTrue(equivalence.eIsSet(feature));
+		assertTrue(differencesValue.getEquivalentDiffs() == equivalence);
+	}
+
+}
diff --git a/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/MatchResourceTest.java b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/MatchResourceTest.java
new file mode 100644
index 000000000..83514e4f7
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/MatchResourceTest.java
@@ -0,0 +1,154 @@
+package org.eclipse.emf.compare.tests.unit;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertTrue;
+
+import org.eclipse.emf.compare.CompareFactory;
+import org.eclipse.emf.compare.MatchResource;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.junit.Test;
+
+/**
+ * Tests the behavior of the {@link MatchResource} class.
+ * 
+ * @generated
+ */
+public class MatchResourceTest extends AbstractCompareTest {
+
+	/**
+	 * Tests the behavior of attribute <code>leftURI</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testLeftURI() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE
+				.getMatchResource_LeftURI();
+		MatchResource matchResource = CompareFactory.eINSTANCE.createMatchResource();
+		matchResource.eAdapters().add(new MockEAdapter());
+		java.lang.String leftURIValue = (java.lang.String)getValueDistinctFromDefault(feature);
+
+		assertFalse(matchResource.eIsSet(feature));
+		assertEquals(feature.getDefaultValue(), matchResource.getLeftURI());
+
+		matchResource.setLeftURI(leftURIValue);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(leftURIValue, matchResource.getLeftURI());
+		assertEquals(matchResource.getLeftURI(), matchResource.eGet(feature));
+		assertTrue(matchResource.eIsSet(feature));
+
+		matchResource.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(feature.getDefaultValue(), matchResource.getLeftURI());
+		assertEquals(matchResource.getLeftURI(), matchResource.eGet(feature));
+		assertFalse(matchResource.eIsSet(feature));
+
+		matchResource.eSet(feature, leftURIValue);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(leftURIValue, matchResource.getLeftURI());
+		assertEquals(matchResource.getLeftURI(), matchResource.eGet(feature));
+		assertTrue(matchResource.eIsSet(feature));
+
+		matchResource.setLeftURI(null);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(feature.getDefaultValue(), matchResource.getLeftURI());
+		assertEquals(matchResource.getLeftURI(), matchResource.eGet(feature));
+		assertFalse(matchResource.eIsSet(feature));
+	}
+
+	/**
+	 * Tests the behavior of attribute <code>rightURI</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testRightURI() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE
+				.getMatchResource_RightURI();
+		MatchResource matchResource = CompareFactory.eINSTANCE.createMatchResource();
+		matchResource.eAdapters().add(new MockEAdapter());
+		java.lang.String rightURIValue = (java.lang.String)getValueDistinctFromDefault(feature);
+
+		assertFalse(matchResource.eIsSet(feature));
+		assertEquals(feature.getDefaultValue(), matchResource.getRightURI());
+
+		matchResource.setRightURI(rightURIValue);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(rightURIValue, matchResource.getRightURI());
+		assertEquals(matchResource.getRightURI(), matchResource.eGet(feature));
+		assertTrue(matchResource.eIsSet(feature));
+
+		matchResource.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(feature.getDefaultValue(), matchResource.getRightURI());
+		assertEquals(matchResource.getRightURI(), matchResource.eGet(feature));
+		assertFalse(matchResource.eIsSet(feature));
+
+		matchResource.eSet(feature, rightURIValue);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(rightURIValue, matchResource.getRightURI());
+		assertEquals(matchResource.getRightURI(), matchResource.eGet(feature));
+		assertTrue(matchResource.eIsSet(feature));
+
+		matchResource.setRightURI(null);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(feature.getDefaultValue(), matchResource.getRightURI());
+		assertEquals(matchResource.getRightURI(), matchResource.eGet(feature));
+		assertFalse(matchResource.eIsSet(feature));
+	}
+
+	/**
+	 * Tests the behavior of attribute <code>originURI</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testOriginURI() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE
+				.getMatchResource_OriginURI();
+		MatchResource matchResource = CompareFactory.eINSTANCE.createMatchResource();
+		matchResource.eAdapters().add(new MockEAdapter());
+		java.lang.String originURIValue = (java.lang.String)getValueDistinctFromDefault(feature);
+
+		assertFalse(matchResource.eIsSet(feature));
+		assertEquals(feature.getDefaultValue(), matchResource.getOriginURI());
+
+		matchResource.setOriginURI(originURIValue);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(originURIValue, matchResource.getOriginURI());
+		assertEquals(matchResource.getOriginURI(), matchResource.eGet(feature));
+		assertTrue(matchResource.eIsSet(feature));
+
+		matchResource.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(feature.getDefaultValue(), matchResource.getOriginURI());
+		assertEquals(matchResource.getOriginURI(), matchResource.eGet(feature));
+		assertFalse(matchResource.eIsSet(feature));
+
+		matchResource.eSet(feature, originURIValue);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(originURIValue, matchResource.getOriginURI());
+		assertEquals(matchResource.getOriginURI(), matchResource.eGet(feature));
+		assertTrue(matchResource.eIsSet(feature));
+
+		matchResource.setOriginURI(null);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(feature.getDefaultValue(), matchResource.getOriginURI());
+		assertEquals(matchResource.getOriginURI(), matchResource.eGet(feature));
+		assertFalse(matchResource.eIsSet(feature));
+	}
+
+}
diff --git a/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/MatchTest.java b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/MatchTest.java
new file mode 100644
index 000000000..49d75a729
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/MatchTest.java
@@ -0,0 +1,285 @@
+package org.eclipse.emf.compare.tests.unit;
+
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertNull;
+import static junit.framework.Assert.assertSame;
+import static junit.framework.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.emf.compare.CompareFactory;
+import org.eclipse.emf.compare.Match;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.junit.Test;
+
+/**
+ * Tests the behavior of the {@link Match} class.
+ * 
+ * @generated
+ */
+public class MatchTest extends AbstractCompareTest {
+	/**
+	 * Tests the behavior of reference <code>subMatches</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testSubMatches() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getMatch_SubMatches();
+		Match match = CompareFactory.eINSTANCE.createMatch();
+		match.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Match subMatchesValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createMatch();
+		List<org.eclipse.emf.compare.Match> listSubMatches = new ArrayList<org.eclipse.emf.compare.Match>(1);
+		listSubMatches.add(subMatchesValue);
+
+		assertFalse(match.eIsSet(feature));
+		assertTrue(match.getSubMatches().isEmpty());
+
+		match.getSubMatches().add(subMatchesValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(match.getSubMatches().contains(subMatchesValue));
+		assertSame(match.getSubMatches(), match.eGet(feature));
+		assertSame(match.getSubMatches(), match.eGet(feature, false));
+		assertTrue(match.eIsSet(feature));
+
+		match.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(match.getSubMatches().isEmpty());
+		assertSame(match.getSubMatches(), match.eGet(feature));
+		assertSame(match.getSubMatches(), match.eGet(feature, false));
+		assertFalse(match.eIsSet(feature));
+
+		match.eSet(feature, listSubMatches);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(match.getSubMatches().contains(subMatchesValue));
+		assertSame(match.getSubMatches(), match.eGet(feature));
+		assertSame(match.getSubMatches(), match.eGet(feature, false));
+		assertTrue(match.eIsSet(feature));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>differences</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testDifferences() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getMatch_Differences();
+		Match match = CompareFactory.eINSTANCE.createMatch();
+		match.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff differencesValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listDifferences = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listDifferences.add(differencesValue);
+
+		assertFalse(match.eIsSet(feature));
+		assertTrue(match.getDifferences().isEmpty());
+
+		match.getDifferences().add(differencesValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(match.getDifferences().contains(differencesValue));
+		assertSame(match.getDifferences(), match.eGet(feature));
+		assertSame(match.getDifferences(), match.eGet(feature, false));
+		assertTrue(match.eIsSet(feature));
+		assertTrue(differencesValue.getMatch() == match);
+
+		match.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(match.getDifferences().isEmpty());
+		assertSame(match.getDifferences(), match.eGet(feature));
+		assertSame(match.getDifferences(), match.eGet(feature, false));
+		assertFalse(match.eIsSet(feature));
+		assertFalse(differencesValue.getMatch() == match);
+
+		match.eSet(feature, listDifferences);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(match.getDifferences().contains(differencesValue));
+		assertSame(match.getDifferences(), match.eGet(feature));
+		assertSame(match.getDifferences(), match.eGet(feature, false));
+		assertTrue(match.eIsSet(feature));
+		assertTrue(differencesValue.getMatch() == match);
+	}
+
+	/**
+	 * Tests the behavior of reference <code>left</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testLeft() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getMatch_Left();
+		Match match = CompareFactory.eINSTANCE.createMatch();
+		match.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.ecore.EObject leftValue = org.eclipse.emf.ecore.EcoreFactory.eINSTANCE
+				.createEObject();
+
+		assertFalse(match.eIsSet(feature));
+		assertNull(match.getLeft());
+
+		match.setLeft(leftValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(leftValue, match.getLeft());
+		assertSame(match.getLeft(), match.eGet(feature));
+		assertSame(match.getLeft(), match.eGet(feature, false));
+		assertTrue(match.eIsSet(feature));
+
+		match.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertNull(match.getLeft());
+		assertSame(match.getLeft(), match.eGet(feature));
+		assertSame(match.getLeft(), match.eGet(feature, false));
+		assertFalse(match.eIsSet(feature));
+
+		match.setLeft(leftValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(leftValue, match.getLeft());
+		assertSame(match.getLeft(), match.eGet(feature));
+		assertSame(match.getLeft(), match.eGet(feature, false));
+		assertTrue(match.eIsSet(feature));
+
+		match.eSet(feature, leftValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(leftValue, match.getLeft());
+		assertSame(match.getLeft(), match.eGet(feature));
+		assertSame(match.getLeft(), match.eGet(feature, false));
+		assertTrue(match.eIsSet(feature));
+
+		match.setLeft(null);
+		assertTrue(notified);
+		notified = false;
+		assertNull(match.getLeft());
+		assertSame(feature.getDefaultValue(), match.getLeft());
+		assertSame(match.getLeft(), match.eGet(feature));
+		assertSame(match.getLeft(), match.eGet(feature, false));
+		assertFalse(match.eIsSet(feature));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>right</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testRight() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getMatch_Right();
+		Match match = CompareFactory.eINSTANCE.createMatch();
+		match.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.ecore.EObject rightValue = org.eclipse.emf.ecore.EcoreFactory.eINSTANCE
+				.createEObject();
+
+		assertFalse(match.eIsSet(feature));
+		assertNull(match.getRight());
+
+		match.setRight(rightValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(rightValue, match.getRight());
+		assertSame(match.getRight(), match.eGet(feature));
+		assertSame(match.getRight(), match.eGet(feature, false));
+		assertTrue(match.eIsSet(feature));
+
+		match.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertNull(match.getRight());
+		assertSame(match.getRight(), match.eGet(feature));
+		assertSame(match.getRight(), match.eGet(feature, false));
+		assertFalse(match.eIsSet(feature));
+
+		match.setRight(rightValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(rightValue, match.getRight());
+		assertSame(match.getRight(), match.eGet(feature));
+		assertSame(match.getRight(), match.eGet(feature, false));
+		assertTrue(match.eIsSet(feature));
+
+		match.eSet(feature, rightValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(rightValue, match.getRight());
+		assertSame(match.getRight(), match.eGet(feature));
+		assertSame(match.getRight(), match.eGet(feature, false));
+		assertTrue(match.eIsSet(feature));
+
+		match.setRight(null);
+		assertTrue(notified);
+		notified = false;
+		assertNull(match.getRight());
+		assertSame(feature.getDefaultValue(), match.getRight());
+		assertSame(match.getRight(), match.eGet(feature));
+		assertSame(match.getRight(), match.eGet(feature, false));
+		assertFalse(match.eIsSet(feature));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>origin</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testOrigin() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getMatch_Origin();
+		Match match = CompareFactory.eINSTANCE.createMatch();
+		match.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.ecore.EObject originValue = org.eclipse.emf.ecore.EcoreFactory.eINSTANCE
+				.createEObject();
+
+		assertFalse(match.eIsSet(feature));
+		assertNull(match.getOrigin());
+
+		match.setOrigin(originValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(originValue, match.getOrigin());
+		assertSame(match.getOrigin(), match.eGet(feature));
+		assertSame(match.getOrigin(), match.eGet(feature, false));
+		assertTrue(match.eIsSet(feature));
+
+		match.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertNull(match.getOrigin());
+		assertSame(match.getOrigin(), match.eGet(feature));
+		assertSame(match.getOrigin(), match.eGet(feature, false));
+		assertFalse(match.eIsSet(feature));
+
+		match.setOrigin(originValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(originValue, match.getOrigin());
+		assertSame(match.getOrigin(), match.eGet(feature));
+		assertSame(match.getOrigin(), match.eGet(feature, false));
+		assertTrue(match.eIsSet(feature));
+
+		match.eSet(feature, originValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(originValue, match.getOrigin());
+		assertSame(match.getOrigin(), match.eGet(feature));
+		assertSame(match.getOrigin(), match.eGet(feature, false));
+		assertTrue(match.eIsSet(feature));
+
+		match.setOrigin(null);
+		assertTrue(notified);
+		notified = false;
+		assertNull(match.getOrigin());
+		assertSame(feature.getDefaultValue(), match.getOrigin());
+		assertSame(match.getOrigin(), match.eGet(feature));
+		assertSame(match.getOrigin(), match.eGet(feature, false));
+		assertFalse(match.eIsSet(feature));
+	}
+
+}
diff --git a/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/ReferenceChangeTest.java b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/ReferenceChangeTest.java
new file mode 100644
index 000000000..cf5c20c03
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/ReferenceChangeTest.java
@@ -0,0 +1,566 @@
+package org.eclipse.emf.compare.tests.unit;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertNull;
+import static junit.framework.Assert.assertSame;
+import static junit.framework.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.emf.compare.CompareFactory;
+import org.eclipse.emf.compare.ReferenceChange;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.junit.Test;
+
+/**
+ * Tests the behavior of the {@link ReferenceChange} class.
+ * 
+ * @generated
+ */
+public class ReferenceChangeTest extends AbstractCompareTest {
+	/**
+	 * Tests the behavior of reference <code>requires</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testRequires() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Requires();
+		ReferenceChange referenceChange = CompareFactory.eINSTANCE.createReferenceChange();
+		referenceChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff requiresValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listRequires = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listRequires.add(requiresValue);
+
+		assertFalse(referenceChange.eIsSet(feature));
+		assertTrue(referenceChange.getRequires().isEmpty());
+
+		referenceChange.getRequires().add(requiresValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(referenceChange.getRequires().contains(requiresValue));
+		assertSame(referenceChange.getRequires(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getRequires(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+		assertTrue(requiresValue.getRequiredBy().contains(referenceChange));
+
+		referenceChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(referenceChange.getRequires().isEmpty());
+		assertSame(referenceChange.getRequires(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getRequires(), referenceChange.eGet(feature, false));
+		assertFalse(referenceChange.eIsSet(feature));
+		assertFalse(requiresValue.getRequiredBy().contains(referenceChange));
+
+		referenceChange.eSet(feature, listRequires);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(referenceChange.getRequires().contains(requiresValue));
+		assertSame(referenceChange.getRequires(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getRequires(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+		assertTrue(requiresValue.getRequiredBy().contains(referenceChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>requiredBy</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testRequiredBy() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_RequiredBy();
+		ReferenceChange referenceChange = CompareFactory.eINSTANCE.createReferenceChange();
+		referenceChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff requiredByValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listRequiredBy = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listRequiredBy.add(requiredByValue);
+
+		assertFalse(referenceChange.eIsSet(feature));
+		assertTrue(referenceChange.getRequiredBy().isEmpty());
+
+		referenceChange.getRequiredBy().add(requiredByValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(referenceChange.getRequiredBy().contains(requiredByValue));
+		assertSame(referenceChange.getRequiredBy(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getRequiredBy(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+		assertTrue(requiredByValue.getRequires().contains(referenceChange));
+
+		referenceChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(referenceChange.getRequiredBy().isEmpty());
+		assertSame(referenceChange.getRequiredBy(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getRequiredBy(), referenceChange.eGet(feature, false));
+		assertFalse(referenceChange.eIsSet(feature));
+		assertFalse(requiredByValue.getRequires().contains(referenceChange));
+
+		referenceChange.eSet(feature, listRequiredBy);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(referenceChange.getRequiredBy().contains(requiredByValue));
+		assertSame(referenceChange.getRequiredBy(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getRequiredBy(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+		assertTrue(requiredByValue.getRequires().contains(referenceChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>refines</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testRefines() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Refines();
+		ReferenceChange referenceChange = CompareFactory.eINSTANCE.createReferenceChange();
+		referenceChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff refinesValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listRefines = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listRefines.add(refinesValue);
+
+		assertFalse(referenceChange.eIsSet(feature));
+		assertTrue(referenceChange.getRefines().isEmpty());
+
+		referenceChange.getRefines().add(refinesValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(referenceChange.getRefines().contains(refinesValue));
+		assertSame(referenceChange.getRefines(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getRefines(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+		assertTrue(refinesValue.getRefinedBy().contains(referenceChange));
+
+		referenceChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(referenceChange.getRefines().isEmpty());
+		assertSame(referenceChange.getRefines(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getRefines(), referenceChange.eGet(feature, false));
+		assertFalse(referenceChange.eIsSet(feature));
+		assertFalse(refinesValue.getRefinedBy().contains(referenceChange));
+
+		referenceChange.eSet(feature, listRefines);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(referenceChange.getRefines().contains(refinesValue));
+		assertSame(referenceChange.getRefines(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getRefines(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+		assertTrue(refinesValue.getRefinedBy().contains(referenceChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>refinedBy</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testRefinedBy() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_RefinedBy();
+		ReferenceChange referenceChange = CompareFactory.eINSTANCE.createReferenceChange();
+		referenceChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff refinedByValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listRefinedBy = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listRefinedBy.add(refinedByValue);
+
+		assertFalse(referenceChange.eIsSet(feature));
+		assertTrue(referenceChange.getRefinedBy().isEmpty());
+
+		referenceChange.getRefinedBy().add(refinedByValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(referenceChange.getRefinedBy().contains(refinedByValue));
+		assertSame(referenceChange.getRefinedBy(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getRefinedBy(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+		assertTrue(refinedByValue.getRefines().contains(referenceChange));
+
+		referenceChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(referenceChange.getRefinedBy().isEmpty());
+		assertSame(referenceChange.getRefinedBy(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getRefinedBy(), referenceChange.eGet(feature, false));
+		assertFalse(referenceChange.eIsSet(feature));
+		assertFalse(refinedByValue.getRefines().contains(referenceChange));
+
+		referenceChange.eSet(feature, listRefinedBy);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(referenceChange.getRefinedBy().contains(refinedByValue));
+		assertSame(referenceChange.getRefinedBy(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getRefinedBy(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+		assertTrue(refinedByValue.getRefines().contains(referenceChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>match</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testMatch() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Match();
+		ReferenceChange referenceChange = CompareFactory.eINSTANCE.createReferenceChange();
+		referenceChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Match matchValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createMatch();
+
+		assertFalse(referenceChange.eIsSet(feature));
+		assertNull(referenceChange.getMatch());
+
+		referenceChange.setMatch(matchValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(matchValue, referenceChange.getMatch());
+		assertSame(referenceChange.getMatch(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getMatch(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+		assertTrue(matchValue.getDifferences().contains(referenceChange));
+
+		referenceChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertNull(referenceChange.getMatch());
+		assertSame(referenceChange.getMatch(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getMatch(), referenceChange.eGet(feature, false));
+		assertFalse(referenceChange.eIsSet(feature));
+		assertFalse(matchValue.getDifferences().contains(referenceChange));
+
+		referenceChange.setMatch(matchValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(matchValue, referenceChange.getMatch());
+		assertSame(referenceChange.getMatch(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getMatch(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+		assertTrue(matchValue.getDifferences().contains(referenceChange));
+
+		referenceChange.eSet(feature, matchValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(matchValue, referenceChange.getMatch());
+		assertSame(referenceChange.getMatch(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getMatch(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+		assertTrue(matchValue.getDifferences().contains(referenceChange));
+
+		referenceChange.setMatch(null);
+		assertTrue(notified);
+		notified = false;
+		assertNull(referenceChange.getMatch());
+		assertSame(feature.getDefaultValue(), referenceChange.getMatch());
+		assertSame(referenceChange.getMatch(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getMatch(), referenceChange.eGet(feature, false));
+		assertFalse(referenceChange.eIsSet(feature));
+		assertFalse(matchValue.getDifferences().contains(referenceChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>equivalentDiffs</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testEquivalentDiffs() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE
+				.getDiff_EquivalentDiffs();
+		ReferenceChange referenceChange = CompareFactory.eINSTANCE.createReferenceChange();
+		referenceChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Equivalence equivalentDiffsValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createEquivalence();
+
+		assertFalse(referenceChange.eIsSet(feature));
+		assertNull(referenceChange.getEquivalentDiffs());
+
+		referenceChange.setEquivalentDiffs(equivalentDiffsValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(equivalentDiffsValue, referenceChange.getEquivalentDiffs());
+		assertSame(referenceChange.getEquivalentDiffs(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getEquivalentDiffs(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+		assertTrue(equivalentDiffsValue.getDifferences().contains(referenceChange));
+
+		referenceChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertNull(referenceChange.getEquivalentDiffs());
+		assertSame(referenceChange.getEquivalentDiffs(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getEquivalentDiffs(), referenceChange.eGet(feature, false));
+		assertFalse(referenceChange.eIsSet(feature));
+		assertFalse(equivalentDiffsValue.getDifferences().contains(referenceChange));
+
+		referenceChange.setEquivalentDiffs(equivalentDiffsValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(equivalentDiffsValue, referenceChange.getEquivalentDiffs());
+		assertSame(referenceChange.getEquivalentDiffs(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getEquivalentDiffs(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+		assertTrue(equivalentDiffsValue.getDifferences().contains(referenceChange));
+
+		referenceChange.eSet(feature, equivalentDiffsValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(equivalentDiffsValue, referenceChange.getEquivalentDiffs());
+		assertSame(referenceChange.getEquivalentDiffs(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getEquivalentDiffs(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+		assertTrue(equivalentDiffsValue.getDifferences().contains(referenceChange));
+
+		referenceChange.setEquivalentDiffs(null);
+		assertTrue(notified);
+		notified = false;
+		assertNull(referenceChange.getEquivalentDiffs());
+		assertSame(feature.getDefaultValue(), referenceChange.getEquivalentDiffs());
+		assertSame(referenceChange.getEquivalentDiffs(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getEquivalentDiffs(), referenceChange.eGet(feature, false));
+		assertFalse(referenceChange.eIsSet(feature));
+		assertFalse(equivalentDiffsValue.getDifferences().contains(referenceChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>conflict</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testConflict() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Conflict();
+		ReferenceChange referenceChange = CompareFactory.eINSTANCE.createReferenceChange();
+		referenceChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Conflict conflictValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createConflict();
+
+		assertFalse(referenceChange.eIsSet(feature));
+		assertNull(referenceChange.getConflict());
+
+		referenceChange.setConflict(conflictValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(conflictValue, referenceChange.getConflict());
+		assertSame(referenceChange.getConflict(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getConflict(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+		assertTrue(conflictValue.getDifferences().contains(referenceChange));
+
+		referenceChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertNull(referenceChange.getConflict());
+		assertSame(referenceChange.getConflict(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getConflict(), referenceChange.eGet(feature, false));
+		assertFalse(referenceChange.eIsSet(feature));
+		assertFalse(conflictValue.getDifferences().contains(referenceChange));
+
+		referenceChange.setConflict(conflictValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(conflictValue, referenceChange.getConflict());
+		assertSame(referenceChange.getConflict(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getConflict(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+		assertTrue(conflictValue.getDifferences().contains(referenceChange));
+
+		referenceChange.eSet(feature, conflictValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(conflictValue, referenceChange.getConflict());
+		assertSame(referenceChange.getConflict(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getConflict(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+		assertTrue(conflictValue.getDifferences().contains(referenceChange));
+
+		referenceChange.setConflict(null);
+		assertTrue(notified);
+		notified = false;
+		assertNull(referenceChange.getConflict());
+		assertSame(feature.getDefaultValue(), referenceChange.getConflict());
+		assertSame(referenceChange.getConflict(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getConflict(), referenceChange.eGet(feature, false));
+		assertFalse(referenceChange.eIsSet(feature));
+		assertFalse(conflictValue.getDifferences().contains(referenceChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>reference</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testReference() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE
+				.getReferenceChange_Reference();
+		ReferenceChange referenceChange = CompareFactory.eINSTANCE.createReferenceChange();
+		referenceChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.ecore.EReference referenceValue = org.eclipse.emf.ecore.EcoreFactory.eINSTANCE
+				.createEReference();
+
+		assertFalse(referenceChange.eIsSet(feature));
+		assertNull(referenceChange.getReference());
+
+		referenceChange.setReference(referenceValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(referenceValue, referenceChange.getReference());
+		assertSame(referenceChange.getReference(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getReference(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+
+		referenceChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertNull(referenceChange.getReference());
+		assertSame(referenceChange.getReference(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getReference(), referenceChange.eGet(feature, false));
+		assertFalse(referenceChange.eIsSet(feature));
+
+		referenceChange.setReference(referenceValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(referenceValue, referenceChange.getReference());
+		assertSame(referenceChange.getReference(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getReference(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+
+		referenceChange.eSet(feature, referenceValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(referenceValue, referenceChange.getReference());
+		assertSame(referenceChange.getReference(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getReference(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+
+		referenceChange.setReference(null);
+		assertTrue(notified);
+		notified = false;
+		assertNull(referenceChange.getReference());
+		assertSame(feature.getDefaultValue(), referenceChange.getReference());
+		assertSame(referenceChange.getReference(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getReference(), referenceChange.eGet(feature, false));
+		assertFalse(referenceChange.eIsSet(feature));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>value</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testValue() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE
+				.getReferenceChange_Value();
+		ReferenceChange referenceChange = CompareFactory.eINSTANCE.createReferenceChange();
+		referenceChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.ecore.EObject valueValue = org.eclipse.emf.ecore.EcoreFactory.eINSTANCE
+				.createEObject();
+
+		assertFalse(referenceChange.eIsSet(feature));
+		assertNull(referenceChange.getValue());
+
+		referenceChange.setValue(valueValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(valueValue, referenceChange.getValue());
+		assertSame(referenceChange.getValue(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getValue(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+
+		referenceChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertNull(referenceChange.getValue());
+		assertSame(referenceChange.getValue(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getValue(), referenceChange.eGet(feature, false));
+		assertFalse(referenceChange.eIsSet(feature));
+
+		referenceChange.setValue(valueValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(valueValue, referenceChange.getValue());
+		assertSame(referenceChange.getValue(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getValue(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+
+		referenceChange.eSet(feature, valueValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(valueValue, referenceChange.getValue());
+		assertSame(referenceChange.getValue(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getValue(), referenceChange.eGet(feature, false));
+		assertTrue(referenceChange.eIsSet(feature));
+
+		referenceChange.setValue(null);
+		assertTrue(notified);
+		notified = false;
+		assertNull(referenceChange.getValue());
+		assertSame(feature.getDefaultValue(), referenceChange.getValue());
+		assertSame(referenceChange.getValue(), referenceChange.eGet(feature));
+		assertSame(referenceChange.getValue(), referenceChange.eGet(feature, false));
+		assertFalse(referenceChange.eIsSet(feature));
+	}
+
+	/**
+	 * Tests the behavior of attribute <code>kind</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testKind() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Kind();
+		ReferenceChange referenceChange = CompareFactory.eINSTANCE.createReferenceChange();
+		referenceChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.DifferenceKind kindValue = (org.eclipse.emf.compare.DifferenceKind)feature
+				.getDefaultValue();
+		for (org.eclipse.emf.compare.DifferenceKind aDifferenceKind : org.eclipse.emf.compare.DifferenceKind.VALUES) {
+			if (kindValue.getValue() != aDifferenceKind.getValue()) {
+				kindValue = aDifferenceKind;
+				break;
+			}
+		}
+
+		assertFalse(referenceChange.eIsSet(feature));
+		assertEquals(feature.getDefaultValue(), referenceChange.getKind());
+
+		referenceChange.setKind(kindValue);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(kindValue, referenceChange.getKind());
+		assertEquals(referenceChange.getKind(), referenceChange.eGet(feature));
+		assertTrue(referenceChange.eIsSet(feature));
+
+		referenceChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(feature.getDefaultValue(), referenceChange.getKind());
+		assertEquals(referenceChange.getKind(), referenceChange.eGet(feature));
+		assertFalse(referenceChange.eIsSet(feature));
+
+		referenceChange.eSet(feature, kindValue);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(kindValue, referenceChange.getKind());
+		assertEquals(referenceChange.getKind(), referenceChange.eGet(feature));
+		assertTrue(referenceChange.eIsSet(feature));
+
+		referenceChange.setKind(null);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(feature.getDefaultValue(), referenceChange.getKind());
+		assertEquals(referenceChange.getKind(), referenceChange.eGet(feature));
+		assertFalse(referenceChange.eIsSet(feature));
+	}
+
+}
diff --git a/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/ResourceAttachmentChangeTest.java b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/ResourceAttachmentChangeTest.java
new file mode 100644
index 000000000..311d669d6
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/src-gen/org/eclipse/emf/compare/tests/unit/ResourceAttachmentChangeTest.java
@@ -0,0 +1,507 @@
+package org.eclipse.emf.compare.tests.unit;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertNull;
+import static junit.framework.Assert.assertSame;
+import static junit.framework.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.emf.compare.CompareFactory;
+import org.eclipse.emf.compare.ResourceAttachmentChange;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.junit.Test;
+
+/**
+ * Tests the behavior of the {@link ResourceAttachmentChange} class.
+ * 
+ * @generated
+ */
+public class ResourceAttachmentChangeTest extends AbstractCompareTest {
+	/**
+	 * Tests the behavior of reference <code>requires</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testRequires() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Requires();
+		ResourceAttachmentChange resourceAttachmentChange = CompareFactory.eINSTANCE
+				.createResourceAttachmentChange();
+		resourceAttachmentChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff requiresValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listRequires = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listRequires.add(requiresValue);
+
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(resourceAttachmentChange.getRequires().isEmpty());
+
+		resourceAttachmentChange.getRequires().add(requiresValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(resourceAttachmentChange.getRequires().contains(requiresValue));
+		assertSame(resourceAttachmentChange.getRequires(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getRequires(), resourceAttachmentChange.eGet(feature, false));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(requiresValue.getRequiredBy().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(resourceAttachmentChange.getRequires().isEmpty());
+		assertSame(resourceAttachmentChange.getRequires(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getRequires(), resourceAttachmentChange.eGet(feature, false));
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertFalse(requiresValue.getRequiredBy().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.eSet(feature, listRequires);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(resourceAttachmentChange.getRequires().contains(requiresValue));
+		assertSame(resourceAttachmentChange.getRequires(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getRequires(), resourceAttachmentChange.eGet(feature, false));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(requiresValue.getRequiredBy().contains(resourceAttachmentChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>requiredBy</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testRequiredBy() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_RequiredBy();
+		ResourceAttachmentChange resourceAttachmentChange = CompareFactory.eINSTANCE
+				.createResourceAttachmentChange();
+		resourceAttachmentChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff requiredByValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listRequiredBy = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listRequiredBy.add(requiredByValue);
+
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(resourceAttachmentChange.getRequiredBy().isEmpty());
+
+		resourceAttachmentChange.getRequiredBy().add(requiredByValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(resourceAttachmentChange.getRequiredBy().contains(requiredByValue));
+		assertSame(resourceAttachmentChange.getRequiredBy(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getRequiredBy(), resourceAttachmentChange.eGet(feature, false));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(requiredByValue.getRequires().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(resourceAttachmentChange.getRequiredBy().isEmpty());
+		assertSame(resourceAttachmentChange.getRequiredBy(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getRequiredBy(), resourceAttachmentChange.eGet(feature, false));
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertFalse(requiredByValue.getRequires().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.eSet(feature, listRequiredBy);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(resourceAttachmentChange.getRequiredBy().contains(requiredByValue));
+		assertSame(resourceAttachmentChange.getRequiredBy(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getRequiredBy(), resourceAttachmentChange.eGet(feature, false));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(requiredByValue.getRequires().contains(resourceAttachmentChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>refines</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testRefines() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Refines();
+		ResourceAttachmentChange resourceAttachmentChange = CompareFactory.eINSTANCE
+				.createResourceAttachmentChange();
+		resourceAttachmentChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff refinesValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listRefines = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listRefines.add(refinesValue);
+
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(resourceAttachmentChange.getRefines().isEmpty());
+
+		resourceAttachmentChange.getRefines().add(refinesValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(resourceAttachmentChange.getRefines().contains(refinesValue));
+		assertSame(resourceAttachmentChange.getRefines(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getRefines(), resourceAttachmentChange.eGet(feature, false));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(refinesValue.getRefinedBy().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(resourceAttachmentChange.getRefines().isEmpty());
+		assertSame(resourceAttachmentChange.getRefines(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getRefines(), resourceAttachmentChange.eGet(feature, false));
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertFalse(refinesValue.getRefinedBy().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.eSet(feature, listRefines);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(resourceAttachmentChange.getRefines().contains(refinesValue));
+		assertSame(resourceAttachmentChange.getRefines(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getRefines(), resourceAttachmentChange.eGet(feature, false));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(refinesValue.getRefinedBy().contains(resourceAttachmentChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>refinedBy</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testRefinedBy() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_RefinedBy();
+		ResourceAttachmentChange resourceAttachmentChange = CompareFactory.eINSTANCE
+				.createResourceAttachmentChange();
+		resourceAttachmentChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Diff refinedByValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createDiff();
+		List<org.eclipse.emf.compare.Diff> listRefinedBy = new ArrayList<org.eclipse.emf.compare.Diff>(1);
+		listRefinedBy.add(refinedByValue);
+
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(resourceAttachmentChange.getRefinedBy().isEmpty());
+
+		resourceAttachmentChange.getRefinedBy().add(refinedByValue);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(resourceAttachmentChange.getRefinedBy().contains(refinedByValue));
+		assertSame(resourceAttachmentChange.getRefinedBy(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getRefinedBy(), resourceAttachmentChange.eGet(feature, false));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(refinedByValue.getRefines().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(resourceAttachmentChange.getRefinedBy().isEmpty());
+		assertSame(resourceAttachmentChange.getRefinedBy(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getRefinedBy(), resourceAttachmentChange.eGet(feature, false));
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertFalse(refinedByValue.getRefines().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.eSet(feature, listRefinedBy);
+		assertTrue(notified);
+		notified = false;
+		assertTrue(resourceAttachmentChange.getRefinedBy().contains(refinedByValue));
+		assertSame(resourceAttachmentChange.getRefinedBy(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getRefinedBy(), resourceAttachmentChange.eGet(feature, false));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(refinedByValue.getRefines().contains(resourceAttachmentChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>match</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testMatch() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Match();
+		ResourceAttachmentChange resourceAttachmentChange = CompareFactory.eINSTANCE
+				.createResourceAttachmentChange();
+		resourceAttachmentChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Match matchValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createMatch();
+
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertNull(resourceAttachmentChange.getMatch());
+
+		resourceAttachmentChange.setMatch(matchValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(matchValue, resourceAttachmentChange.getMatch());
+		assertSame(resourceAttachmentChange.getMatch(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getMatch(), resourceAttachmentChange.eGet(feature, false));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(matchValue.getDifferences().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertNull(resourceAttachmentChange.getMatch());
+		assertSame(resourceAttachmentChange.getMatch(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getMatch(), resourceAttachmentChange.eGet(feature, false));
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertFalse(matchValue.getDifferences().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.setMatch(matchValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(matchValue, resourceAttachmentChange.getMatch());
+		assertSame(resourceAttachmentChange.getMatch(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getMatch(), resourceAttachmentChange.eGet(feature, false));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(matchValue.getDifferences().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.eSet(feature, matchValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(matchValue, resourceAttachmentChange.getMatch());
+		assertSame(resourceAttachmentChange.getMatch(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getMatch(), resourceAttachmentChange.eGet(feature, false));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(matchValue.getDifferences().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.setMatch(null);
+		assertTrue(notified);
+		notified = false;
+		assertNull(resourceAttachmentChange.getMatch());
+		assertSame(feature.getDefaultValue(), resourceAttachmentChange.getMatch());
+		assertSame(resourceAttachmentChange.getMatch(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getMatch(), resourceAttachmentChange.eGet(feature, false));
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertFalse(matchValue.getDifferences().contains(resourceAttachmentChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>equivalentDiffs</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testEquivalentDiffs() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE
+				.getDiff_EquivalentDiffs();
+		ResourceAttachmentChange resourceAttachmentChange = CompareFactory.eINSTANCE
+				.createResourceAttachmentChange();
+		resourceAttachmentChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Equivalence equivalentDiffsValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createEquivalence();
+
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertNull(resourceAttachmentChange.getEquivalentDiffs());
+
+		resourceAttachmentChange.setEquivalentDiffs(equivalentDiffsValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(equivalentDiffsValue, resourceAttachmentChange.getEquivalentDiffs());
+		assertSame(resourceAttachmentChange.getEquivalentDiffs(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getEquivalentDiffs(), resourceAttachmentChange.eGet(feature,
+				false));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(equivalentDiffsValue.getDifferences().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertNull(resourceAttachmentChange.getEquivalentDiffs());
+		assertSame(resourceAttachmentChange.getEquivalentDiffs(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getEquivalentDiffs(), resourceAttachmentChange.eGet(feature,
+				false));
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertFalse(equivalentDiffsValue.getDifferences().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.setEquivalentDiffs(equivalentDiffsValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(equivalentDiffsValue, resourceAttachmentChange.getEquivalentDiffs());
+		assertSame(resourceAttachmentChange.getEquivalentDiffs(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getEquivalentDiffs(), resourceAttachmentChange.eGet(feature,
+				false));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(equivalentDiffsValue.getDifferences().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.eSet(feature, equivalentDiffsValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(equivalentDiffsValue, resourceAttachmentChange.getEquivalentDiffs());
+		assertSame(resourceAttachmentChange.getEquivalentDiffs(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getEquivalentDiffs(), resourceAttachmentChange.eGet(feature,
+				false));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(equivalentDiffsValue.getDifferences().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.setEquivalentDiffs(null);
+		assertTrue(notified);
+		notified = false;
+		assertNull(resourceAttachmentChange.getEquivalentDiffs());
+		assertSame(feature.getDefaultValue(), resourceAttachmentChange.getEquivalentDiffs());
+		assertSame(resourceAttachmentChange.getEquivalentDiffs(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getEquivalentDiffs(), resourceAttachmentChange.eGet(feature,
+				false));
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertFalse(equivalentDiffsValue.getDifferences().contains(resourceAttachmentChange));
+	}
+
+	/**
+	 * Tests the behavior of reference <code>conflict</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testConflict() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Conflict();
+		ResourceAttachmentChange resourceAttachmentChange = CompareFactory.eINSTANCE
+				.createResourceAttachmentChange();
+		resourceAttachmentChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.Conflict conflictValue = org.eclipse.emf.compare.CompareFactory.eINSTANCE
+				.createConflict();
+
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertNull(resourceAttachmentChange.getConflict());
+
+		resourceAttachmentChange.setConflict(conflictValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(conflictValue, resourceAttachmentChange.getConflict());
+		assertSame(resourceAttachmentChange.getConflict(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getConflict(), resourceAttachmentChange.eGet(feature, false));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(conflictValue.getDifferences().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertNull(resourceAttachmentChange.getConflict());
+		assertSame(resourceAttachmentChange.getConflict(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getConflict(), resourceAttachmentChange.eGet(feature, false));
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertFalse(conflictValue.getDifferences().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.setConflict(conflictValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(conflictValue, resourceAttachmentChange.getConflict());
+		assertSame(resourceAttachmentChange.getConflict(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getConflict(), resourceAttachmentChange.eGet(feature, false));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(conflictValue.getDifferences().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.eSet(feature, conflictValue);
+		assertTrue(notified);
+		notified = false;
+		assertSame(conflictValue, resourceAttachmentChange.getConflict());
+		assertSame(resourceAttachmentChange.getConflict(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getConflict(), resourceAttachmentChange.eGet(feature, false));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+		assertTrue(conflictValue.getDifferences().contains(resourceAttachmentChange));
+
+		resourceAttachmentChange.setConflict(null);
+		assertTrue(notified);
+		notified = false;
+		assertNull(resourceAttachmentChange.getConflict());
+		assertSame(feature.getDefaultValue(), resourceAttachmentChange.getConflict());
+		assertSame(resourceAttachmentChange.getConflict(), resourceAttachmentChange.eGet(feature));
+		assertSame(resourceAttachmentChange.getConflict(), resourceAttachmentChange.eGet(feature, false));
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertFalse(conflictValue.getDifferences().contains(resourceAttachmentChange));
+	}
+
+	/**
+	 * Tests the behavior of attribute <code>kind</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testKind() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE.getDiff_Kind();
+		ResourceAttachmentChange resourceAttachmentChange = CompareFactory.eINSTANCE
+				.createResourceAttachmentChange();
+		resourceAttachmentChange.eAdapters().add(new MockEAdapter());
+		org.eclipse.emf.compare.DifferenceKind kindValue = (org.eclipse.emf.compare.DifferenceKind)feature
+				.getDefaultValue();
+		for (org.eclipse.emf.compare.DifferenceKind aDifferenceKind : org.eclipse.emf.compare.DifferenceKind.VALUES) {
+			if (kindValue.getValue() != aDifferenceKind.getValue()) {
+				kindValue = aDifferenceKind;
+				break;
+			}
+		}
+
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertEquals(feature.getDefaultValue(), resourceAttachmentChange.getKind());
+
+		resourceAttachmentChange.setKind(kindValue);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(kindValue, resourceAttachmentChange.getKind());
+		assertEquals(resourceAttachmentChange.getKind(), resourceAttachmentChange.eGet(feature));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+
+		resourceAttachmentChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(feature.getDefaultValue(), resourceAttachmentChange.getKind());
+		assertEquals(resourceAttachmentChange.getKind(), resourceAttachmentChange.eGet(feature));
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+
+		resourceAttachmentChange.eSet(feature, kindValue);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(kindValue, resourceAttachmentChange.getKind());
+		assertEquals(resourceAttachmentChange.getKind(), resourceAttachmentChange.eGet(feature));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+
+		resourceAttachmentChange.setKind(null);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(feature.getDefaultValue(), resourceAttachmentChange.getKind());
+		assertEquals(resourceAttachmentChange.getKind(), resourceAttachmentChange.eGet(feature));
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+	}
+
+	/**
+	 * Tests the behavior of attribute <code>resourceURI</code>'s accessors.
+	 * 
+	 * @generated
+	 */
+	@Test
+	public void testResourceURI() {
+		EStructuralFeature feature = org.eclipse.emf.compare.ComparePackage.eINSTANCE
+				.getResourceAttachmentChange_ResourceURI();
+		ResourceAttachmentChange resourceAttachmentChange = CompareFactory.eINSTANCE
+				.createResourceAttachmentChange();
+		resourceAttachmentChange.eAdapters().add(new MockEAdapter());
+		java.lang.String resourceURIValue = (java.lang.String)getValueDistinctFromDefault(feature);
+
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+		assertEquals(feature.getDefaultValue(), resourceAttachmentChange.getResourceURI());
+
+		resourceAttachmentChange.setResourceURI(resourceURIValue);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(resourceURIValue, resourceAttachmentChange.getResourceURI());
+		assertEquals(resourceAttachmentChange.getResourceURI(), resourceAttachmentChange.eGet(feature));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+
+		resourceAttachmentChange.eUnset(feature);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(feature.getDefaultValue(), resourceAttachmentChange.getResourceURI());
+		assertEquals(resourceAttachmentChange.getResourceURI(), resourceAttachmentChange.eGet(feature));
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+
+		resourceAttachmentChange.eSet(feature, resourceURIValue);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(resourceURIValue, resourceAttachmentChange.getResourceURI());
+		assertEquals(resourceAttachmentChange.getResourceURI(), resourceAttachmentChange.eGet(feature));
+		assertTrue(resourceAttachmentChange.eIsSet(feature));
+
+		resourceAttachmentChange.setResourceURI(null);
+		assertTrue(notified);
+		notified = false;
+		assertEquals(feature.getDefaultValue(), resourceAttachmentChange.getResourceURI());
+		assertEquals(resourceAttachmentChange.getResourceURI(), resourceAttachmentChange.eGet(feature));
+		assertFalse(resourceAttachmentChange.eIsSet(feature));
+	}
+
+}
diff --git a/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/EMFCompareTestsPlugin.java b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/EMFCompareTestsPlugin.java
new file mode 100644
index 000000000..7f5187831
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare.tests/src/org/eclipse/emf/compare/tests/EMFCompareTestsPlugin.java
@@ -0,0 +1,30 @@
+package org.eclipse.emf.compare.tests;

+

+import org.osgi.framework.BundleActivator;

+import org.osgi.framework.BundleContext;

+

+public class EMFCompareTestsPlugin implements BundleActivator {

+

+	private static BundleContext context;

+

+	static BundleContext getContext() {

+		return context;

+	}

+

+	/*

+	 * (non-Javadoc)

+	 * @see org.osgi.framework.BundleActivator#start(org.osgi.framework.BundleContext)

+	 */

+	public void start(BundleContext bundleContext) throws Exception {

+		EMFCompareTestsPlugin.context = bundleContext;

+	}

+

+	/*

+	 * (non-Javadoc)

+	 * @see org.osgi.framework.BundleActivator#stop(org.osgi.framework.BundleContext)

+	 */

+	public void stop(BundleContext bundleContext) throws Exception {

+		EMFCompareTestsPlugin.context = null;

+	}

+

+}

diff --git a/plugins/org.eclipse.emf.compare/.checkstyle b/plugins/org.eclipse.emf.compare/.checkstyle
new file mode 100644
index 000000000..9d20703eb
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/.checkstyle
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<fileset-config file-format-version="1.2.0" simple-config="true" sync-formatter="false">
+  <local-check-config name="EMF Compare" location="/org.eclipse.emf.compare-parent/codeStyle/EMFCompareCheckstyle5Configuration.xml" type="project" description="">
+    <additional-data name="protect-config-file" value="false"/>
+  </local-check-config>
+  <fileset name="all" enabled="true" check-config-name="EMF Compare" local="true">
+    <file-match-pattern match-pattern="." include-pattern="true"/>
+  </fileset>
+  <filter name="FilesFromPackage" enabled="true">
+    <filter-data value="src-gen"/>
+  </filter>
+</fileset-config>
diff --git a/plugins/org.eclipse.emf.compare/.classpath b/plugins/org.eclipse.emf.compare/.classpath
new file mode 100644
index 000000000..9c0318f0f
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<classpath>

+	<classpathentry kind="src" path="src-gen"/>

+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>

+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>

+	<classpathentry kind="src" path="src"/>

+	<classpathentry kind="output" path="bin"/>

+</classpath>

diff --git a/plugins/org.eclipse.emf.compare/.project b/plugins/org.eclipse.emf.compare/.project
new file mode 100644
index 000000000..ec1142a95
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/.project
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<projectDescription>

+	<name>org.eclipse.emf.compare</name>

+	<comment></comment>

+	<projects>

+	</projects>

+	<buildSpec>

+		<buildCommand>

+			<name>org.eclipse.jdt.core.javabuilder</name>

+			<arguments>

+			</arguments>

+		</buildCommand>

+		<buildCommand>

+			<name>org.eclipse.pde.ManifestBuilder</name>

+			<arguments>

+			</arguments>

+		</buildCommand>

+		<buildCommand>

+			<name>org.eclipse.pde.SchemaBuilder</name>

+			<arguments>

+			</arguments>

+		</buildCommand>

+		<buildCommand>

+			<name>net.sf.eclipsecs.core.CheckstyleBuilder</name>

+			<arguments>

+			</arguments>

+		</buildCommand>

+	</buildSpec>

+	<natures>

+		<nature>org.eclipse.pde.PluginNature</nature>

+		<nature>org.eclipse.jdt.core.javanature</nature>

+		<nature>net.sf.eclipsecs.core.CheckstyleNature</nature>

+	</natures>

+</projectDescription>

diff --git a/plugins/org.eclipse.emf.compare/.settings/org.eclipse.jdt.core.prefs b/plugins/org.eclipse.emf.compare/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 000000000..a361b7ecb
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,374 @@
+eclipse.preferences.version=1

+org.eclipse.jdt.core.compiler.annotation.nonnull=org.eclipse.jdt.annotation.NonNull

+org.eclipse.jdt.core.compiler.annotation.nonnullbydefault=org.eclipse.jdt.annotation.NonNullByDefault

+org.eclipse.jdt.core.compiler.annotation.nonnullisdefault=disabled

+org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable

+org.eclipse.jdt.core.compiler.annotation.nullanalysis=disabled

+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled

+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5

+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve

+org.eclipse.jdt.core.compiler.compliance=1.5

+org.eclipse.jdt.core.compiler.debug.lineNumber=generate

+org.eclipse.jdt.core.compiler.debug.localVariable=generate

+org.eclipse.jdt.core.compiler.debug.sourceFile=generate

+org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning

+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error

+org.eclipse.jdt.core.compiler.problem.autoboxing=warning

+org.eclipse.jdt.core.compiler.problem.comparingIdentical=error

+org.eclipse.jdt.core.compiler.problem.deadCode=error

+org.eclipse.jdt.core.compiler.problem.deprecation=warning

+org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled

+org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled

+org.eclipse.jdt.core.compiler.problem.discouragedReference=warning

+org.eclipse.jdt.core.compiler.problem.emptyStatement=error

+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error

+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=ignore

+org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore

+org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled

+org.eclipse.jdt.core.compiler.problem.fieldHiding=warning

+org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning

+org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=error

+org.eclipse.jdt.core.compiler.problem.forbiddenReference=error

+org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=error

+org.eclipse.jdt.core.compiler.problem.includeFieldsInNullAnalysis=disabled

+org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts=enabled

+org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning

+org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore

+org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=warning

+org.eclipse.jdt.core.compiler.problem.localVariableHiding=warning

+org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning

+org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=error

+org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod=error

+org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=warning

+org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation=disabled

+org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning

+org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod=warning

+org.eclipse.jdt.core.compiler.problem.noEffectAssignment=error

+org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=error

+org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=warning

+org.eclipse.jdt.core.compiler.problem.nullReference=error

+org.eclipse.jdt.core.compiler.problem.nullSpecInsufficientInfo=warning

+org.eclipse.jdt.core.compiler.problem.nullSpecViolation=error

+org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning

+org.eclipse.jdt.core.compiler.problem.parameterAssignment=error

+org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=error

+org.eclipse.jdt.core.compiler.problem.potentialNullReference=error

+org.eclipse.jdt.core.compiler.problem.potentialNullSpecViolation=error

+org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable=warning

+org.eclipse.jdt.core.compiler.problem.rawTypeReference=warning

+org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning

+org.eclipse.jdt.core.compiler.problem.redundantNullCheck=error

+org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=ignore

+org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=warning

+org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore

+org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=warning

+org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled

+org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning

+org.eclipse.jdt.core.compiler.problem.suppressOptionalErrors=disabled

+org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled

+org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore

+org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning

+org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems=enabled

+org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning

+org.eclipse.jdt.core.compiler.problem.unclosedCloseable=warning

+org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore

+org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning

+org.eclipse.jdt.core.compiler.problem.unnecessaryElse=warning

+org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=warning

+org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore

+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore

+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable=enabled

+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled

+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled

+org.eclipse.jdt.core.compiler.problem.unusedImport=warning

+org.eclipse.jdt.core.compiler.problem.unusedLabel=warning

+org.eclipse.jdt.core.compiler.problem.unusedLocal=warning

+org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation=ignore

+org.eclipse.jdt.core.compiler.problem.unusedParameter=warning

+org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled

+org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled

+org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled

+org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning

+org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning

+org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning

+org.eclipse.jdt.core.compiler.source=1.5

+org.eclipse.jdt.core.formatter.align_type_members_on_columns=false

+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16

+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0

+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16

+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16

+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16

+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16

+org.eclipse.jdt.core.formatter.alignment_for_assignment=0

+org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16

+org.eclipse.jdt.core.formatter.alignment_for_compact_if=16

+org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80

+org.eclipse.jdt.core.formatter.alignment_for_enum_constants=0

+org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16

+org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0

+org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16

+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16

+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16

+org.eclipse.jdt.core.formatter.alignment_for_resources_in_try=80

+org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16

+org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=0

+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16

+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=0

+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16

+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16

+org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch=16

+org.eclipse.jdt.core.formatter.blank_lines_after_imports=1

+org.eclipse.jdt.core.formatter.blank_lines_after_package=1

+org.eclipse.jdt.core.formatter.blank_lines_before_field=1

+org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0

+org.eclipse.jdt.core.formatter.blank_lines_before_imports=1

+org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1

+org.eclipse.jdt.core.formatter.blank_lines_before_method=1

+org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1

+org.eclipse.jdt.core.formatter.blank_lines_before_package=0

+org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1

+org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1

+org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line

+org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line

+org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line

+org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line

+org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line

+org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line

+org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line

+org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line

+org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line

+org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line

+org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line

+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=true

+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=true

+org.eclipse.jdt.core.formatter.comment.format_block_comments=true

+org.eclipse.jdt.core.formatter.comment.format_header=false

+org.eclipse.jdt.core.formatter.comment.format_html=true

+org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true

+org.eclipse.jdt.core.formatter.comment.format_line_comments=true

+org.eclipse.jdt.core.formatter.comment.format_source_code=true

+org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true

+org.eclipse.jdt.core.formatter.comment.indent_root_tags=true

+org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert

+org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert

+org.eclipse.jdt.core.formatter.comment.line_length=110

+org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true

+org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries=true

+org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments=false

+org.eclipse.jdt.core.formatter.compact_else_if=true

+org.eclipse.jdt.core.formatter.continuation_indentation=2

+org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2

+org.eclipse.jdt.core.formatter.disabling_tag=@formatter\:off

+org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on

+org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false

+org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column=true

+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true

+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true

+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true

+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true

+org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true

+org.eclipse.jdt.core.formatter.indent_empty_lines=false

+org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true

+org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true

+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true

+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=true

+org.eclipse.jdt.core.formatter.indentation.size=8

+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field=insert

+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert

+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method=insert

+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package=insert

+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert

+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type=insert

+org.eclipse.jdt.core.formatter.insert_new_line_after_label=do not insert

+org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert

+org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=insert

+org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert

+org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert

+org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert

+org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert

+org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert

+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert

+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert

+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert

+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert

+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert

+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert

+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert

+org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert

+org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert

+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert

+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert

+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert

+org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert

+org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert

+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert

+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert

+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert

+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert

+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert

+org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert

+org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert

+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert

+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources=insert

+org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert

+org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert

+org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert

+org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert

+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert

+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert

+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try=insert

+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert

+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert

+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert

+org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert

+org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources=do not insert

+org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert

+org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert

+org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert

+org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert

+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert

+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert

+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert

+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert

+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert

+org.eclipse.jdt.core.formatter.join_lines_in_comments=true

+org.eclipse.jdt.core.formatter.join_wrapped_lines=true

+org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false

+org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false

+org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false

+org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false

+org.eclipse.jdt.core.formatter.lineSplit=110

+org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false

+org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false

+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0

+org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1

+org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true

+org.eclipse.jdt.core.formatter.tabulation.char=tab

+org.eclipse.jdt.core.formatter.tabulation.size=4

+org.eclipse.jdt.core.formatter.use_on_off_tags=false

+org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false

+org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true

+org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch=true

+org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=false

diff --git a/plugins/org.eclipse.emf.compare/.settings/org.eclipse.jdt.ui.prefs b/plugins/org.eclipse.emf.compare/.settings/org.eclipse.jdt.ui.prefs
new file mode 100644
index 000000000..4517c0f23
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/.settings/org.eclipse.jdt.ui.prefs
@@ -0,0 +1,60 @@
+eclipse.preferences.version=1

+editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true

+formatter_profile=_EMF Compare

+formatter_settings_version=12

+org.eclipse.jdt.ui.ignorelowercasenames=true

+org.eclipse.jdt.ui.importorder=fr;com;java;javax;org;

+org.eclipse.jdt.ui.ondemandthreshold=99

+org.eclipse.jdt.ui.staticondemandthreshold=99

+sp_cleanup.add_default_serial_version_id=true

+sp_cleanup.add_generated_serial_version_id=false

+sp_cleanup.add_missing_annotations=true

+sp_cleanup.add_missing_deprecated_annotations=true

+sp_cleanup.add_missing_methods=false

+sp_cleanup.add_missing_nls_tags=false

+sp_cleanup.add_missing_override_annotations=true

+sp_cleanup.add_missing_override_annotations_interface_methods=false

+sp_cleanup.add_serial_version_id=false

+sp_cleanup.always_use_blocks=true

+sp_cleanup.always_use_parentheses_in_expressions=false

+sp_cleanup.always_use_this_for_non_static_field_access=false

+sp_cleanup.always_use_this_for_non_static_method_access=false

+sp_cleanup.convert_to_enhanced_for_loop=false

+sp_cleanup.correct_indentation=false

+sp_cleanup.format_source_code=true

+sp_cleanup.format_source_code_changes_only=false

+sp_cleanup.make_local_variable_final=false

+sp_cleanup.make_parameters_final=false

+sp_cleanup.make_private_fields_final=true

+sp_cleanup.make_type_abstract_if_missing_method=false

+sp_cleanup.make_variable_declarations_final=false

+sp_cleanup.never_use_blocks=false

+sp_cleanup.never_use_parentheses_in_expressions=true

+sp_cleanup.on_save_use_additional_actions=true

+sp_cleanup.organize_imports=true

+sp_cleanup.qualify_static_field_accesses_with_declaring_class=false

+sp_cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true

+sp_cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true

+sp_cleanup.qualify_static_member_accesses_with_declaring_class=false

+sp_cleanup.qualify_static_method_accesses_with_declaring_class=false

+sp_cleanup.remove_private_constructors=true

+sp_cleanup.remove_trailing_whitespaces=false

+sp_cleanup.remove_trailing_whitespaces_all=true

+sp_cleanup.remove_trailing_whitespaces_ignore_empty=false

+sp_cleanup.remove_unnecessary_casts=false

+sp_cleanup.remove_unnecessary_nls_tags=true

+sp_cleanup.remove_unused_imports=true

+sp_cleanup.remove_unused_local_variables=false

+sp_cleanup.remove_unused_private_fields=true

+sp_cleanup.remove_unused_private_members=false

+sp_cleanup.remove_unused_private_methods=true

+sp_cleanup.remove_unused_private_types=true

+sp_cleanup.sort_members=false

+sp_cleanup.sort_members_all=false

+sp_cleanup.use_blocks=true

+sp_cleanup.use_blocks_only_for_return_and_throw=false

+sp_cleanup.use_parentheses_in_expressions=false

+sp_cleanup.use_this_for_non_static_field_access=false

+sp_cleanup.use_this_for_non_static_field_access_only_if_necessary=true

+sp_cleanup.use_this_for_non_static_method_access=false

+sp_cleanup.use_this_for_non_static_method_access_only_if_necessary=true

diff --git a/plugins/org.eclipse.emf.compare/META-INF/MANIFEST.MF b/plugins/org.eclipse.emf.compare/META-INF/MANIFEST.MF
new file mode 100644
index 000000000..1b3f131a8
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/META-INF/MANIFEST.MF
@@ -0,0 +1,16 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %pluginName
+Bundle-SymbolicName: org.eclipse.emf.compare;singleton:=true
+Bundle-Version: 1.3.0.qualifier
+Bundle-ClassPath: .
+Bundle-Vendor: %providerName
+Bundle-Localization: plugin
+Bundle-RequiredExecutionEnvironment: J2SE-1.5
+Export-Package: org.eclipse.emf.compare,
+ org.eclipse.emf.compare.impl,
+ org.eclipse.emf.compare.util
+Require-Bundle: org.eclipse.core.runtime,
+ org.eclipse.emf.ecore;visibility:=reexport
+Bundle-ActivationPolicy: lazy
+Bundle-Activator: org.eclipse.emf.compare.EMFComparePlugin
diff --git a/plugins/org.eclipse.emf.compare/build.properties b/plugins/org.eclipse.emf.compare/build.properties
new file mode 100644
index 000000000..3ac073500
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/build.properties
@@ -0,0 +1,18 @@
+# Copyright (c) 2012 Obeo.

+# 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:

+#     Obeo - initial API and implementation

+

+bin.includes = .,\

+               model/,\

+               META-INF/,\

+               plugin.xml,\

+               plugin.properties

+jars.compile.order = .

+source.. = src-gen/,\

+           src/

+output.. = bin/

diff --git a/plugins/org.eclipse.emf.compare/model/compare.ecore b/plugins/org.eclipse.emf.compare/model/compare.ecore
new file mode 100644
index 000000000..7ec8f3267
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/model/compare.ecore
@@ -0,0 +1,308 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

+    xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="compare" nsURI="http://www.eclipse.org/emf/compare" nsPrefix="compare">

+  <eClassifiers xsi:type="ecore:EClass" name="Comparison">

+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+      <details key="documentation" value="This will act as the &quot;root&quot; of a comparison. It will reference one match for every root of the input models, along with the differences detected for each of them."/>

+    </eAnnotations>

+    <eOperations name="getDifferences" upperBound="-1" eType="#//Diff">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="Returns all differences contained by this Comparison and its children."/>

+      </eAnnotations>

+    </eOperations>

+    <eOperations name="getDifferences" upperBound="-1" eType="#//Diff">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="Returns all differences that were detected on the given EObject or one of its counterpart in left, right or origin."/>

+      </eAnnotations>

+      <eParameters name="element" eType="ecore:EClass platform:/plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//EObject">

+        <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+          <details key="documentation" value="The EObject for which we seek all related differences."/>

+        </eAnnotations>

+      </eParameters>

+    </eOperations>

+    <eOperations name="getMatch" eType="#//Match">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="Finds and return the Match for the given EObject."/>

+      </eAnnotations>

+      <eParameters name="element" eType="ecore:EClass platform:/plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//EObject">

+        <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+          <details key="documentation" value="The EObject for which we seek the match."/>

+        </eAnnotations>

+      </eParameters>

+    </eOperations>

+    <eOperations name="addDiff">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="Adds the given diff under the match corresponding to the given EObject."/>

+      </eAnnotations>

+      <eParameters name="element" eType="ecore:EClass platform:/plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//EObject">

+        <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+          <details key="documentation" value="EObject on which we need to add a new difference."/>

+        </eAnnotations>

+      </eParameters>

+      <eParameters name="newDiff" eType="#//Diff">

+        <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+          <details key="documentation" value="The difference we are to add to the comparison model."/>

+        </eAnnotations>

+      </eParameters>

+    </eOperations>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="matchedResources" upperBound="-1"

+        eType="#//MatchResource" containment="true">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="This contains the mappings for each compared Resource."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="matches" upperBound="-1"

+        eType="#//Match" containment="true">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="This contains the match tree &quot;mimicking&quot; the input models' hierarchy."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="conflicts" upperBound="-1"

+        eType="#//Conflict" containment="true">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="If we detected any conflict during the comparison process, this will contain them."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+  </eClassifiers>

+  <eClassifiers xsi:type="ecore:EClass" name="MatchResource">

+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+      <details key="documentation" value="A MatchResource element represents the mapping between two or three resources : left, right, and their optional common ancestor. The resource will be identified through its URI."/>

+    </eAnnotations>

+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="leftURI" lowerBound="1"

+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="Cannot be null. Represents the URI of the left resource of this mapping."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="rightURI" lowerBound="1"

+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="Cannot be null. Represents the URI of the right resource of this mapping."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="originURI" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="This can be null in the case of two-way comparisons. If assigned, it will represent the URI of the origin resource for this mapping; the common ancestor of both others."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+  </eClassifiers>

+  <eClassifiers xsi:type="ecore:EClass" name="Match">

+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+      <details key="documentation" value="A MatchElement describes the mapping between the EObjects of two or three resources. This will reference all three of left, right and origin resources. However, note that instances of this class will also represent unmatched elements, in which case only one of either &quot;left&quot; or &quot;right&quot; will be assigned."/>

+    </eAnnotations>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="subMatches" upperBound="-1"

+        eType="#//Match" containment="true">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="The MatchElements will &quot;mimic&quot; the hierarchy of the input model(s). This containment feature will serve that purpose."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="differences" upperBound="-1"

+        eType="#//Diff" containment="true" eOpposite="#//Diff/match">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="This will contain the list of all differences pertaining to this mapping, if any."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="left" eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="This can be null in the case of unmatched elements in the right model. In all other cases, it will reference the left element of this mapping."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="right" eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="This can be null in the case of unmatched elements in the left model. In all other cases, it will reference the right element of this mapping."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="origin" eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="This can be null in the case of two-way comparisons, or unmatched elements that are only located in either left or right, i.e an element that was added since the origin, either in the left copy or the right one. In any other course of event, this will reference the origin element of this mapping."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+  </eClassifiers>

+  <eClassifiers xsi:type="ecore:EClass" name="Diff">

+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+      <details key="documentation" value="A DiffElement describes a difference related to the EObjects mapped by its parent MatchElement."/>

+    </eAnnotations>

+    <eOperations name="getSource" eType="#//DifferenceSource">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="Returns the source of this diff, either one of DifferenceSource.LEFT (for two-way comparisons or differences detected between the left and origin elements) or DifferenceSource.RIGHT (for differences between the right and origin elements)."/>

+      </eAnnotations>

+    </eOperations>

+    <eOperations name="apply">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="This will merge the diff from left to right."/>

+      </eAnnotations>

+    </eOperations>

+    <eOperations name="reverse">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="This will merge the diff from right to left."/>

+      </eAnnotations>

+    </eOperations>

+    <eOperations name="discard">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="This will remove the diff from the model, effectively &quot;forgetting&quot; about it."/>

+      </eAnnotations>

+    </eOperations>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="match" lowerBound="1" eType="#//Match"

+        eOpposite="#//Match/differences">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="Back-reference towards this difference's parent match, it points towards the mapping on which this difference has been detected."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="requires" upperBound="-1"

+        eType="#//Diff" eOpposite="#//Diff/requiredBy">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="This will reference all differences that should be merged before this one."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="requiredBy" upperBound="-1"

+        eType="#//Diff" eOpposite="#//Diff/requires">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="This will reference all differences that depend on this one for their merging."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="refines" upperBound="-1"

+        eType="#//Diff" eOpposite="#//Diff/refinedBy">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="This can be used to create &quot;high level&quot; differences to regroup one or more diffs in a common &quot;container&quot;. For example, this could be used to regroup &lt;i>n&lt;/i> technical differences into one single semantic difference, such as the differences &quot;profile application added&quot; and &quot;reference to stereotype added&quot; that can actually be regrouped under a single, more understandable &quot;stereotype application added&quot;."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="refinedBy" upperBound="-1"

+        eType="#//Diff" eOpposite="#//Diff/refines">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="This will reference the higher-level difference that shadows this one, if any."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="kind" lowerBound="1" eType="#//DifferenceKind">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="Describes the kind of this difference, whether it is an addition, deletion, change, or move."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="equivalentDiffs" eType="#//Equivalence"

+        eOpposite="#//Equivalence/differences">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="If this diff is equivalent to another, we will reference the equivalence from here. For example, if a reference has an eOpposite, we will detect one diff for each side of the bidirectional reference, yet merging one of these diffs is enough. We consider them equivalent."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="conflict" eType="#//Conflict"

+        eOpposite="#//Conflict/differences">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="If this element is in conflict with one (or more) other differences, this will reference the Conflict association."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+  </eClassifiers>

+  <eClassifiers xsi:type="ecore:EClass" name="ResourceAttachmentChange" eSuperTypes="#//Diff">

+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+      <details key="documentation" value="This particular kind of difference describes the fragmentation (or un-fragmentation) of a model element in its own (or back in its parent's) resource."/>

+    </eAnnotations>

+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="resourceURI" lowerBound="1"

+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="URI of the resource in which the parent mapping's element is now located."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+  </eClassifiers>

+  <eClassifiers xsi:type="ecore:EClass" name="ReferenceChange" eSuperTypes="#//Diff">

+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+      <details key="documentation" value="This particular kind of difference will be used to describe changes within a reference, whether the feature is multi-valued or not. In the case of a MOVE difference, this could actually mean two things : either the value has been moved from one index to another (moving the value at another position of the same reference), or the value has been moved from one container to another. This second case will only happen with containment references."/>

+    </eAnnotations>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="reference" lowerBound="1"

+        eType="ecore:EClass platform:/plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//EReference">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="The reference in which &quot;something&quot; changed. If this difference is a MOVE from one reference to another, this will point towards the left reference."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="value" eType="ecore:EClass platform:/plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//EObject">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="References the actual value on which a difference has been detected."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+  </eClassifiers>

+  <eClassifiers xsi:type="ecore:EClass" name="AttributeChange" eSuperTypes="#//Diff">

+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+      <details key="documentation" value="This particular kind of difference will be used to describe changes within an attribute, whether the feature is multi-valued or not."/>

+    </eAnnotations>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="attribute" lowerBound="1"

+        eType="ecore:EClass platform:/plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//EAttribute">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="The attribute in which &quot;something&quot; changed."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" eType="ecore:EDataType platform:/plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//EJavaObject">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="References the actual value on which a difference has been detected."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+  </eClassifiers>

+  <eClassifiers xsi:type="ecore:EClass" name="Conflict">

+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+      <details key="documentation" value="Instances of this class describe conflicts between one or more differences in the left model as compared to differences in the right model. Conflicts can only happen in the case of three-way comparisons, when we have a common ancestor of both sides."/>

+    </eAnnotations>

+    <eOperations name="getLeftDifferences" lowerBound="1" upperBound="-1" eType="#//Diff">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="This can be used to retrieve the list of differences that were made in the left element."/>

+      </eAnnotations>

+    </eOperations>

+    <eOperations name="getRightDifferences" lowerBound="1" upperBound="-1" eType="#//Diff">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="This can be used to retrieve the list of differences that were made in the right element."/>

+      </eAnnotations>

+    </eOperations>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="differences" lowerBound="2"

+        upperBound="-1" eType="#//Diff" eOpposite="#//Diff/conflict">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="This will reference all differences that are related to this conflict. The number of elements contained in this list is &lt;u>at least&lt;/u> two."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+  </eClassifiers>

+  <eClassifiers xsi:type="ecore:EClass" name="Equivalence">

+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+      <details key="documentation" value="Diffs are considered equivalent if merging one is enough to resolve both differences. For example, if a reference has an eOpposite, we will detect one diff for each side of the bidirectional reference, yet merging one of these diffs will automatically update the model in such a way that the second diff is &quot;merged&quot;."/>

+    </eAnnotations>

+    <eStructuralFeatures xsi:type="ecore:EReference" name="differences" lowerBound="2"

+        upperBound="-1" eType="#//Diff" eOpposite="#//Diff/equivalentDiffs">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="References the &lt;i>n&lt;/i> diffs composing this equivalence. There are &lt;u>at least&lt;/u> two diffs in this list."/>

+      </eAnnotations>

+    </eStructuralFeatures>

+  </eClassifiers>

+  <eClassifiers xsi:type="ecore:EEnum" name="DifferenceKind">

+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+      <details key="documentation" value="The differences detected through EMF Compare can be of 4 general types.&#xD;&#xA;&lt;ul>&#xD;&#xA;&#x9;&lt;li>ADD represent addition of model element or feature values,&lt;/li>&#xD;&#xA;&#x9;&lt;li>DELETE represent suppression of model element or feature values,&lt;/li>&#xD;&#xA;&#x9;&lt;li>CHANGE represent the modification of a feature value,&lt;/li>&#xD;&#xA;&#x9;&lt;li>MOVE will be used for difference on the containment feature of a model element, or differences on the order of a feature's values.&lt;/li>&#xD;&#xA;&lt;/ul>"/>

+    </eAnnotations>

+    <eLiterals name="ADD">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="Represents the addition of model elements or feature values."/>

+      </eAnnotations>

+    </eLiterals>

+    <eLiterals name="DELETE" value="1">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="Represents the suppression of model elements or feature values."/>

+      </eAnnotations>

+    </eLiterals>

+    <eLiterals name="CHANGE" value="2">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="Represents the modification of a feature value."/>

+      </eAnnotations>

+    </eLiterals>

+    <eLiterals name="MOVE" value="3">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="Describes a difference on the containment feature of a model element, or differences on the order of a feature's values."/>

+      </eAnnotations>

+    </eLiterals>

+  </eClassifiers>

+  <eClassifiers xsi:type="ecore:EEnum" name="DifferenceSource">

+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+      <details key="documentation" value="This will be used to represent the source of a detected diff.&#xD;&#xA;&lt;ul>&#xD;&#xA;&#x9;&lt;li>LEFT if the difference has been detected between the left element and its origin,&lt;/li>&#xD;&#xA;&#x9;&lt;li>RIGHT if the difference has been detected between the right element and its origin.&lt;/li>&#xD;&#xA;&lt;/ul>&#xD;&#xA;&lt;b>Note&lt;/b> that differences detected during two-way comparisons will only be LEFT."/>

+    </eAnnotations>

+    <eLiterals name="LEFT">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="Will be used if the difference has been detected between the left element and its origin. Differences detected during two-way comparisons will always have this has their source."/>

+      </eAnnotations>

+    </eLiterals>

+    <eLiterals name="RIGHT" value="1">

+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">

+        <details key="documentation" value="Will be used if the difference has been detected between the right element and its origin."/>

+      </eAnnotations>

+    </eLiterals>

+  </eClassifiers>

+</ecore:EPackage>

diff --git a/plugins/org.eclipse.emf.compare/model/compare.genmodel b/plugins/org.eclipse.emf.compare/model/compare.genmodel
new file mode 100644
index 000000000..353206b88
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/model/compare.genmodel
@@ -0,0 +1,87 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<genmodel:GenModel xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"

+    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText="Copyright (c) 2012 Obeo.&#xD;&#xA;All rights reserved. This program and the accompanying materials&#xD;&#xA;are made available under the terms of the Eclipse Public License v1.0&#xD;&#xA;which accompanies this distribution, and is available at&#xD;&#xA;http://www.eclipse.org/legal/epl-v10.html&#xD;&#xA;&#xD;&#xA;Contributors:&#xD;&#xA;    Obeo - initial API and implementation"

+    modelDirectory="/org.eclipse.emf.compare/src-gen" editDirectory="/org.eclipse.emf.compare.edit/src-gen"

+    editorDirectory="/org.eclipse.emf.compare.editor/src-gen" modelPluginID="org.eclipse.emf.compare"

+    modelName="Compare" editPluginClass="org.eclipse.emf.compare.provider.EMFCompareEditPlugin"

+    editorPluginClass="org.eclipse.emf.compare.presentation.EMFCompareEditorPlugin"

+    nonNLSMarkers="true" rootExtendsClass="org.eclipse.emf.ecore.impl.MinimalEObjectImpl"

+    codeFormatting="true" testsDirectory="/org.eclipse.emf.compare.tests/src-gen"

+    testSuiteClass="org.eclipse.emf.compare.tests.CompareAllTests" importerID="org.eclipse.emf.importer.ecore"

+    complianceLevel="5.0" runtimeVersion="2.5" usedGenPackages="platform:/plugin/org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore">

+  <foreignModel>compare.ecore</foreignModel>

+  <genPackages prefix="Compare" basePackage="org.eclipse.emf" disposableProviderFactory="true"

+      ecorePackage="compare.ecore#/">

+    <genEnums typeSafeEnumCompatible="false" ecoreEnum="compare.ecore#//DifferenceKind">

+      <genEnumLiterals ecoreEnumLiteral="compare.ecore#//DifferenceKind/ADD"/>

+      <genEnumLiterals ecoreEnumLiteral="compare.ecore#//DifferenceKind/DELETE"/>

+      <genEnumLiterals ecoreEnumLiteral="compare.ecore#//DifferenceKind/CHANGE"/>

+      <genEnumLiterals ecoreEnumLiteral="compare.ecore#//DifferenceKind/MOVE"/>

+    </genEnums>

+    <genEnums typeSafeEnumCompatible="false" ecoreEnum="compare.ecore#//DifferenceSource">

+      <genEnumLiterals ecoreEnumLiteral="compare.ecore#//DifferenceSource/LEFT"/>

+      <genEnumLiterals ecoreEnumLiteral="compare.ecore#//DifferenceSource/RIGHT"/>

+    </genEnums>

+    <genClasses ecoreClass="compare.ecore#//Comparison">

+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference compare.ecore#//Comparison/matchedResources"/>

+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference compare.ecore#//Comparison/matches"/>

+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference compare.ecore#//Comparison/conflicts"/>

+      <genOperations ecoreOperation="compare.ecore#//Comparison/getDifferences"/>

+      <genOperations ecoreOperation="compare.ecore#//Comparison/getDifferences.1">

+        <genParameters ecoreParameter="compare.ecore#//Comparison/getDifferences.1/element"/>

+      </genOperations>

+      <genOperations ecoreOperation="compare.ecore#//Comparison/getMatch">

+        <genParameters ecoreParameter="compare.ecore#//Comparison/getMatch/element"/>

+      </genOperations>

+      <genOperations ecoreOperation="compare.ecore#//Comparison/addDiff">

+        <genParameters ecoreParameter="compare.ecore#//Comparison/addDiff/element"/>

+        <genParameters ecoreParameter="compare.ecore#//Comparison/addDiff/newDiff"/>

+      </genOperations>

+    </genClasses>

+    <genClasses ecoreClass="compare.ecore#//MatchResource">

+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute compare.ecore#//MatchResource/leftURI"/>

+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute compare.ecore#//MatchResource/rightURI"/>

+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute compare.ecore#//MatchResource/originURI"/>

+    </genClasses>

+    <genClasses ecoreClass="compare.ecore#//Match">

+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference compare.ecore#//Match/subMatches"/>

+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference compare.ecore#//Match/differences"/>

+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference compare.ecore#//Match/left"/>

+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference compare.ecore#//Match/right"/>

+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference compare.ecore#//Match/origin"/>

+    </genClasses>

+    <genClasses ecoreClass="compare.ecore#//Diff">

+      <genFeatures property="None" notify="false" createChild="false" ecoreFeature="ecore:EReference compare.ecore#//Diff/match"/>

+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference compare.ecore#//Diff/requires"/>

+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference compare.ecore#//Diff/requiredBy"/>

+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference compare.ecore#//Diff/refines"/>

+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference compare.ecore#//Diff/refinedBy"/>

+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute compare.ecore#//Diff/kind"/>

+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference compare.ecore#//Diff/equivalentDiffs"/>

+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference compare.ecore#//Diff/conflict"/>

+      <genOperations ecoreOperation="compare.ecore#//Diff/getSource"/>

+      <genOperations ecoreOperation="compare.ecore#//Diff/apply"/>

+      <genOperations ecoreOperation="compare.ecore#//Diff/reverse"/>

+      <genOperations ecoreOperation="compare.ecore#//Diff/discard"/>

+    </genClasses>

+    <genClasses ecoreClass="compare.ecore#//ResourceAttachmentChange">

+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute compare.ecore#//ResourceAttachmentChange/resourceURI"/>

+    </genClasses>

+    <genClasses ecoreClass="compare.ecore#//ReferenceChange">

+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference compare.ecore#//ReferenceChange/reference"/>

+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference compare.ecore#//ReferenceChange/value"/>

+    </genClasses>

+    <genClasses ecoreClass="compare.ecore#//AttributeChange">

+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference compare.ecore#//AttributeChange/attribute"/>

+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute compare.ecore#//AttributeChange/value"/>

+    </genClasses>

+    <genClasses ecoreClass="compare.ecore#//Conflict">

+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference compare.ecore#//Conflict/differences"/>

+      <genOperations ecoreOperation="compare.ecore#//Conflict/getLeftDifferences"/>

+      <genOperations ecoreOperation="compare.ecore#//Conflict/getRightDifferences"/>

+    </genClasses>

+    <genClasses ecoreClass="compare.ecore#//Equivalence">

+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference compare.ecore#//Equivalence/differences"/>

+    </genClasses>

+  </genPackages>

+</genmodel:GenModel>

diff --git a/plugins/org.eclipse.emf.compare/plugin.properties b/plugins/org.eclipse.emf.compare/plugin.properties
new file mode 100644
index 000000000..059cd673b
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/plugin.properties
@@ -0,0 +1,13 @@
+################################################################################
+# Copyright (c) 2006, 2012 Obeo.
+# 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:
+#     Obeo - initial API and implementation
+################################################################################
+pluginName = EMF Compare Core
+providerName = Eclipse Modeling Project
+
diff --git a/plugins/org.eclipse.emf.compare/plugin.xml b/plugins/org.eclipse.emf.compare/plugin.xml
new file mode 100644
index 000000000..d2ea40aa0
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/plugin.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<?eclipse version="3.0"?>

+

+<!--

+ Copyright (c) 2012 Obeo.

+ 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:

+     Obeo - initial API and implementation

+-->

+

+<plugin>

+

+   <extension point="org.eclipse.emf.ecore.generated_package">

+      <package

+            uri="http://www.eclipse.org/emf/compare"

+            class="org.eclipse.emf.compare.ComparePackage"

+            genModel="model/compare.genmodel"/>

+   </extension>

+

+</plugin>

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/AttributeChange.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/AttributeChange.java
new file mode 100644
index 000000000..76b9d5c2f
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/AttributeChange.java
@@ -0,0 +1,94 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare;

+

+import org.eclipse.emf.ecore.EAttribute;

+

+/**

+ * <!-- begin-user-doc -->

+ * A representation of the model object '<em><b>Attribute Change</b></em>'.

+ * <!-- end-user-doc -->

+ *

+ * <!-- begin-model-doc -->

+ * This particular kind of difference will be used to describe changes within an attribute, whether the feature is multi-valued or not.

+ * <!-- end-model-doc -->

+ *

+ * <p>

+ * The following features are supported:

+ * <ul>

+ *   <li>{@link org.eclipse.emf.compare.AttributeChange#getAttribute <em>Attribute</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.AttributeChange#getValue <em>Value</em>}</li>

+ * </ul>

+ * </p>

+ *

+ * @see org.eclipse.emf.compare.ComparePackage#getAttributeChange()

+ * @model

+ * @generated

+ */

+public interface AttributeChange extends Diff {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * Returns the value of the '<em><b>Attribute</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * The attribute in which "something" changed.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Attribute</em>' reference.

+	 * @see #setAttribute(EAttribute)

+	 * @see org.eclipse.emf.compare.ComparePackage#getAttributeChange_Attribute()

+	 * @model required="true"

+	 * @generated

+	 */

+	EAttribute getAttribute();

+

+	/**

+	 * Sets the value of the '{@link org.eclipse.emf.compare.AttributeChange#getAttribute <em>Attribute</em>}' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @param value the new value of the '<em>Attribute</em>' reference.

+	 * @see #getAttribute()

+	 * @generated

+	 */

+	void setAttribute(EAttribute value);

+

+	/**

+	 * Returns the value of the '<em><b>Value</b></em>' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * References the actual value on which a difference has been detected.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Value</em>' attribute.

+	 * @see #setValue(Object)

+	 * @see org.eclipse.emf.compare.ComparePackage#getAttributeChange_Value()

+	 * @model

+	 * @generated

+	 */

+	Object getValue();

+

+	/**

+	 * Sets the value of the '{@link org.eclipse.emf.compare.AttributeChange#getValue <em>Value</em>}' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @param value the new value of the '<em>Value</em>' attribute.

+	 * @see #getValue()

+	 * @generated

+	 */

+	void setValue(Object value);

+

+} // AttributeChange

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/CompareFactory.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/CompareFactory.java
new file mode 100644
index 000000000..b442094b4
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/CompareFactory.java
@@ -0,0 +1,129 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare;

+

+import org.eclipse.emf.ecore.EFactory;

+

+/**

+ * <!-- begin-user-doc -->

+ * The <b>Factory</b> for the model.

+ * It provides a create method for each non-abstract class of the model.

+ * <!-- end-user-doc -->

+ * @see org.eclipse.emf.compare.ComparePackage

+ * @generated

+ */

+public interface CompareFactory extends EFactory {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * The singleton instance of the factory.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	CompareFactory eINSTANCE = org.eclipse.emf.compare.impl.CompareFactoryImpl.init();

+

+	/**

+	 * Returns a new object of class '<em>Comparison</em>'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return a new object of class '<em>Comparison</em>'.

+	 * @generated

+	 */

+	Comparison createComparison();

+

+	/**

+	 * Returns a new object of class '<em>Match Resource</em>'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return a new object of class '<em>Match Resource</em>'.

+	 * @generated

+	 */

+	MatchResource createMatchResource();

+

+	/**

+	 * Returns a new object of class '<em>Match</em>'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return a new object of class '<em>Match</em>'.

+	 * @generated

+	 */

+	Match createMatch();

+

+	/**

+	 * Returns a new object of class '<em>Diff</em>'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return a new object of class '<em>Diff</em>'.

+	 * @generated

+	 */

+	Diff createDiff();

+

+	/**

+	 * Returns a new object of class '<em>Resource Attachment Change</em>'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return a new object of class '<em>Resource Attachment Change</em>'.

+	 * @generated

+	 */

+	ResourceAttachmentChange createResourceAttachmentChange();

+

+	/**

+	 * Returns a new object of class '<em>Reference Change</em>'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return a new object of class '<em>Reference Change</em>'.

+	 * @generated

+	 */

+	ReferenceChange createReferenceChange();

+

+	/**

+	 * Returns a new object of class '<em>Attribute Change</em>'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return a new object of class '<em>Attribute Change</em>'.

+	 * @generated

+	 */

+	AttributeChange createAttributeChange();

+

+	/**

+	 * Returns a new object of class '<em>Conflict</em>'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return a new object of class '<em>Conflict</em>'.

+	 * @generated

+	 */

+	Conflict createConflict();

+

+	/**

+	 * Returns a new object of class '<em>Equivalence</em>'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return a new object of class '<em>Equivalence</em>'.

+	 * @generated

+	 */

+	Equivalence createEquivalence();

+

+	/**

+	 * Returns the package supported by this factory.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the package supported by this factory.

+	 * @generated

+	 */

+	ComparePackage getComparePackage();

+

+} //CompareFactory

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/ComparePackage.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/ComparePackage.java
new file mode 100644
index 000000000..35f797675
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/ComparePackage.java
@@ -0,0 +1,1455 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare;

+

+import org.eclipse.emf.ecore.EAttribute;

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

+import org.eclipse.emf.ecore.EEnum;

+import org.eclipse.emf.ecore.EPackage;

+import org.eclipse.emf.ecore.EReference;

+

+/**

+ * <!-- begin-user-doc -->

+ * The <b>Package</b> for the model.

+ * It contains accessors for the meta objects to represent

+ * <ul>

+ *   <li>each class,</li>

+ *   <li>each feature of each class,</li>

+ *   <li>each enum,</li>

+ *   <li>and each data type</li>

+ * </ul>

+ * <!-- end-user-doc -->

+ * @see org.eclipse.emf.compare.CompareFactory

+ * @model kind="package"

+ * @generated

+ */

+public interface ComparePackage extends EPackage {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * The package name.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	String eNAME = "compare"; //$NON-NLS-1$

+

+	/**

+	 * The package namespace URI.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	String eNS_URI = "http://www.eclipse.org/emf/compare"; //$NON-NLS-1$

+

+	/**

+	 * The package namespace name.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	String eNS_PREFIX = "compare"; //$NON-NLS-1$

+

+	/**

+	 * The singleton instance of the package.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	ComparePackage eINSTANCE = org.eclipse.emf.compare.impl.ComparePackageImpl.init();

+

+	/**

+	 * The meta object id for the '{@link org.eclipse.emf.compare.impl.ComparisonImpl <em>Comparison</em>}' class.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see org.eclipse.emf.compare.impl.ComparisonImpl

+	 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getComparison()

+	 * @generated

+	 */

+	int COMPARISON = 0;

+

+	/**

+	 * The feature id for the '<em><b>Matched Resources</b></em>' containment reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int COMPARISON__MATCHED_RESOURCES = 0;

+

+	/**

+	 * The feature id for the '<em><b>Matches</b></em>' containment reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int COMPARISON__MATCHES = 1;

+

+	/**

+	 * The feature id for the '<em><b>Conflicts</b></em>' containment reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int COMPARISON__CONFLICTS = 2;

+

+	/**

+	 * The number of structural features of the '<em>Comparison</em>' class.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int COMPARISON_FEATURE_COUNT = 3;

+

+	/**

+	 * The meta object id for the '{@link org.eclipse.emf.compare.impl.MatchResourceImpl <em>Match Resource</em>}' class.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see org.eclipse.emf.compare.impl.MatchResourceImpl

+	 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getMatchResource()

+	 * @generated

+	 */

+	int MATCH_RESOURCE = 1;

+

+	/**

+	 * The feature id for the '<em><b>Left URI</b></em>' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int MATCH_RESOURCE__LEFT_URI = 0;

+

+	/**

+	 * The feature id for the '<em><b>Right URI</b></em>' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int MATCH_RESOURCE__RIGHT_URI = 1;

+

+	/**

+	 * The feature id for the '<em><b>Origin URI</b></em>' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int MATCH_RESOURCE__ORIGIN_URI = 2;

+

+	/**

+	 * The number of structural features of the '<em>Match Resource</em>' class.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int MATCH_RESOURCE_FEATURE_COUNT = 3;

+

+	/**

+	 * The meta object id for the '{@link org.eclipse.emf.compare.impl.MatchImpl <em>Match</em>}' class.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see org.eclipse.emf.compare.impl.MatchImpl

+	 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getMatch()

+	 * @generated

+	 */

+	int MATCH = 2;

+

+	/**

+	 * The feature id for the '<em><b>Sub Matches</b></em>' containment reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int MATCH__SUB_MATCHES = 0;

+

+	/**

+	 * The feature id for the '<em><b>Differences</b></em>' containment reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int MATCH__DIFFERENCES = 1;

+

+	/**

+	 * The feature id for the '<em><b>Left</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int MATCH__LEFT = 2;

+

+	/**

+	 * The feature id for the '<em><b>Right</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int MATCH__RIGHT = 3;

+

+	/**

+	 * The feature id for the '<em><b>Origin</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int MATCH__ORIGIN = 4;

+

+	/**

+	 * The number of structural features of the '<em>Match</em>' class.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int MATCH_FEATURE_COUNT = 5;

+

+	/**

+	 * The meta object id for the '{@link org.eclipse.emf.compare.impl.DiffImpl <em>Diff</em>}' class.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see org.eclipse.emf.compare.impl.DiffImpl

+	 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getDiff()

+	 * @generated

+	 */

+	int DIFF = 3;

+

+	/**

+	 * The feature id for the '<em><b>Match</b></em>' container reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int DIFF__MATCH = 0;

+

+	/**

+	 * The feature id for the '<em><b>Requires</b></em>' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int DIFF__REQUIRES = 1;

+

+	/**

+	 * The feature id for the '<em><b>Required By</b></em>' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int DIFF__REQUIRED_BY = 2;

+

+	/**

+	 * The feature id for the '<em><b>Refines</b></em>' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int DIFF__REFINES = 3;

+

+	/**

+	 * The feature id for the '<em><b>Refined By</b></em>' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int DIFF__REFINED_BY = 4;

+

+	/**

+	 * The feature id for the '<em><b>Kind</b></em>' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int DIFF__KIND = 5;

+

+	/**

+	 * The feature id for the '<em><b>Equivalent Diffs</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int DIFF__EQUIVALENT_DIFFS = 6;

+

+	/**

+	 * The feature id for the '<em><b>Conflict</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int DIFF__CONFLICT = 7;

+

+	/**

+	 * The number of structural features of the '<em>Diff</em>' class.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int DIFF_FEATURE_COUNT = 8;

+

+	/**

+	 * The meta object id for the '{@link org.eclipse.emf.compare.impl.ResourceAttachmentChangeImpl <em>Resource Attachment Change</em>}' class.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see org.eclipse.emf.compare.impl.ResourceAttachmentChangeImpl

+	 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getResourceAttachmentChange()

+	 * @generated

+	 */

+	int RESOURCE_ATTACHMENT_CHANGE = 4;

+

+	/**

+	 * The feature id for the '<em><b>Match</b></em>' container reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int RESOURCE_ATTACHMENT_CHANGE__MATCH = DIFF__MATCH;

+

+	/**

+	 * The feature id for the '<em><b>Requires</b></em>' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int RESOURCE_ATTACHMENT_CHANGE__REQUIRES = DIFF__REQUIRES;

+

+	/**

+	 * The feature id for the '<em><b>Required By</b></em>' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int RESOURCE_ATTACHMENT_CHANGE__REQUIRED_BY = DIFF__REQUIRED_BY;

+

+	/**

+	 * The feature id for the '<em><b>Refines</b></em>' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int RESOURCE_ATTACHMENT_CHANGE__REFINES = DIFF__REFINES;

+

+	/**

+	 * The feature id for the '<em><b>Refined By</b></em>' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int RESOURCE_ATTACHMENT_CHANGE__REFINED_BY = DIFF__REFINED_BY;

+

+	/**

+	 * The feature id for the '<em><b>Kind</b></em>' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int RESOURCE_ATTACHMENT_CHANGE__KIND = DIFF__KIND;

+

+	/**

+	 * The feature id for the '<em><b>Equivalent Diffs</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int RESOURCE_ATTACHMENT_CHANGE__EQUIVALENT_DIFFS = DIFF__EQUIVALENT_DIFFS;

+

+	/**

+	 * The feature id for the '<em><b>Conflict</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int RESOURCE_ATTACHMENT_CHANGE__CONFLICT = DIFF__CONFLICT;

+

+	/**

+	 * The feature id for the '<em><b>Resource URI</b></em>' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int RESOURCE_ATTACHMENT_CHANGE__RESOURCE_URI = DIFF_FEATURE_COUNT + 0;

+

+	/**

+	 * The number of structural features of the '<em>Resource Attachment Change</em>' class.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int RESOURCE_ATTACHMENT_CHANGE_FEATURE_COUNT = DIFF_FEATURE_COUNT + 1;

+

+	/**

+	 * The meta object id for the '{@link org.eclipse.emf.compare.impl.ReferenceChangeImpl <em>Reference Change</em>}' class.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see org.eclipse.emf.compare.impl.ReferenceChangeImpl

+	 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getReferenceChange()

+	 * @generated

+	 */

+	int REFERENCE_CHANGE = 5;

+

+	/**

+	 * The feature id for the '<em><b>Match</b></em>' container reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int REFERENCE_CHANGE__MATCH = DIFF__MATCH;

+

+	/**

+	 * The feature id for the '<em><b>Requires</b></em>' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int REFERENCE_CHANGE__REQUIRES = DIFF__REQUIRES;

+

+	/**

+	 * The feature id for the '<em><b>Required By</b></em>' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int REFERENCE_CHANGE__REQUIRED_BY = DIFF__REQUIRED_BY;

+

+	/**

+	 * The feature id for the '<em><b>Refines</b></em>' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int REFERENCE_CHANGE__REFINES = DIFF__REFINES;

+

+	/**

+	 * The feature id for the '<em><b>Refined By</b></em>' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int REFERENCE_CHANGE__REFINED_BY = DIFF__REFINED_BY;

+

+	/**

+	 * The feature id for the '<em><b>Kind</b></em>' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int REFERENCE_CHANGE__KIND = DIFF__KIND;

+

+	/**

+	 * The feature id for the '<em><b>Equivalent Diffs</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int REFERENCE_CHANGE__EQUIVALENT_DIFFS = DIFF__EQUIVALENT_DIFFS;

+

+	/**

+	 * The feature id for the '<em><b>Conflict</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int REFERENCE_CHANGE__CONFLICT = DIFF__CONFLICT;

+

+	/**

+	 * The feature id for the '<em><b>Reference</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int REFERENCE_CHANGE__REFERENCE = DIFF_FEATURE_COUNT + 0;

+

+	/**

+	 * The feature id for the '<em><b>Value</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int REFERENCE_CHANGE__VALUE = DIFF_FEATURE_COUNT + 1;

+

+	/**

+	 * The number of structural features of the '<em>Reference Change</em>' class.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int REFERENCE_CHANGE_FEATURE_COUNT = DIFF_FEATURE_COUNT + 2;

+

+	/**

+	 * The meta object id for the '{@link org.eclipse.emf.compare.impl.AttributeChangeImpl <em>Attribute Change</em>}' class.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see org.eclipse.emf.compare.impl.AttributeChangeImpl

+	 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getAttributeChange()

+	 * @generated

+	 */

+	int ATTRIBUTE_CHANGE = 6;

+

+	/**

+	 * The feature id for the '<em><b>Match</b></em>' container reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int ATTRIBUTE_CHANGE__MATCH = DIFF__MATCH;

+

+	/**

+	 * The feature id for the '<em><b>Requires</b></em>' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int ATTRIBUTE_CHANGE__REQUIRES = DIFF__REQUIRES;

+

+	/**

+	 * The feature id for the '<em><b>Required By</b></em>' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int ATTRIBUTE_CHANGE__REQUIRED_BY = DIFF__REQUIRED_BY;

+

+	/**

+	 * The feature id for the '<em><b>Refines</b></em>' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int ATTRIBUTE_CHANGE__REFINES = DIFF__REFINES;

+

+	/**

+	 * The feature id for the '<em><b>Refined By</b></em>' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int ATTRIBUTE_CHANGE__REFINED_BY = DIFF__REFINED_BY;

+

+	/**

+	 * The feature id for the '<em><b>Kind</b></em>' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int ATTRIBUTE_CHANGE__KIND = DIFF__KIND;

+

+	/**

+	 * The feature id for the '<em><b>Equivalent Diffs</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int ATTRIBUTE_CHANGE__EQUIVALENT_DIFFS = DIFF__EQUIVALENT_DIFFS;

+

+	/**

+	 * The feature id for the '<em><b>Conflict</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int ATTRIBUTE_CHANGE__CONFLICT = DIFF__CONFLICT;

+

+	/**

+	 * The feature id for the '<em><b>Attribute</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int ATTRIBUTE_CHANGE__ATTRIBUTE = DIFF_FEATURE_COUNT + 0;

+

+	/**

+	 * The feature id for the '<em><b>Value</b></em>' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int ATTRIBUTE_CHANGE__VALUE = DIFF_FEATURE_COUNT + 1;

+

+	/**

+	 * The number of structural features of the '<em>Attribute Change</em>' class.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int ATTRIBUTE_CHANGE_FEATURE_COUNT = DIFF_FEATURE_COUNT + 2;

+

+	/**

+	 * The meta object id for the '{@link org.eclipse.emf.compare.impl.ConflictImpl <em>Conflict</em>}' class.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see org.eclipse.emf.compare.impl.ConflictImpl

+	 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getConflict()

+	 * @generated

+	 */

+	int CONFLICT = 7;

+

+	/**

+	 * The feature id for the '<em><b>Differences</b></em>' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int CONFLICT__DIFFERENCES = 0;

+

+	/**

+	 * The number of structural features of the '<em>Conflict</em>' class.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int CONFLICT_FEATURE_COUNT = 1;

+

+	/**

+	 * The meta object id for the '{@link org.eclipse.emf.compare.impl.EquivalenceImpl <em>Equivalence</em>}' class.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see org.eclipse.emf.compare.impl.EquivalenceImpl

+	 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getEquivalence()

+	 * @generated

+	 */

+	int EQUIVALENCE = 8;

+

+	/**

+	 * The feature id for the '<em><b>Differences</b></em>' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int EQUIVALENCE__DIFFERENCES = 0;

+

+	/**

+	 * The number of structural features of the '<em>Equivalence</em>' class.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 * @ordered

+	 */

+	int EQUIVALENCE_FEATURE_COUNT = 1;

+

+	/**

+	 * The meta object id for the '{@link org.eclipse.emf.compare.DifferenceKind <em>Difference Kind</em>}' enum.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see org.eclipse.emf.compare.DifferenceKind

+	 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getDifferenceKind()

+	 * @generated

+	 */

+	int DIFFERENCE_KIND = 9;

+

+	/**

+	 * The meta object id for the '{@link org.eclipse.emf.compare.DifferenceSource <em>Difference Source</em>}' enum.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see org.eclipse.emf.compare.DifferenceSource

+	 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getDifferenceSource()

+	 * @generated

+	 */

+	int DIFFERENCE_SOURCE = 10;

+

+	/**

+	 * Returns the meta object for class '{@link org.eclipse.emf.compare.Comparison <em>Comparison</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for class '<em>Comparison</em>'.

+	 * @see org.eclipse.emf.compare.Comparison

+	 * @generated

+	 */

+	EClass getComparison();

+

+	/**

+	 * Returns the meta object for the containment reference list '{@link org.eclipse.emf.compare.Comparison#getMatchedResources <em>Matched Resources</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the containment reference list '<em>Matched Resources</em>'.

+	 * @see org.eclipse.emf.compare.Comparison#getMatchedResources()

+	 * @see #getComparison()

+	 * @generated

+	 */

+	EReference getComparison_MatchedResources();

+

+	/**

+	 * Returns the meta object for the containment reference list '{@link org.eclipse.emf.compare.Comparison#getMatches <em>Matches</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the containment reference list '<em>Matches</em>'.

+	 * @see org.eclipse.emf.compare.Comparison#getMatches()

+	 * @see #getComparison()

+	 * @generated

+	 */

+	EReference getComparison_Matches();

+

+	/**

+	 * Returns the meta object for the containment reference list '{@link org.eclipse.emf.compare.Comparison#getConflicts <em>Conflicts</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the containment reference list '<em>Conflicts</em>'.

+	 * @see org.eclipse.emf.compare.Comparison#getConflicts()

+	 * @see #getComparison()

+	 * @generated

+	 */

+	EReference getComparison_Conflicts();

+

+	/**

+	 * Returns the meta object for class '{@link org.eclipse.emf.compare.MatchResource <em>Match Resource</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for class '<em>Match Resource</em>'.

+	 * @see org.eclipse.emf.compare.MatchResource

+	 * @generated

+	 */

+	EClass getMatchResource();

+

+	/**

+	 * Returns the meta object for the attribute '{@link org.eclipse.emf.compare.MatchResource#getLeftURI <em>Left URI</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the attribute '<em>Left URI</em>'.

+	 * @see org.eclipse.emf.compare.MatchResource#getLeftURI()

+	 * @see #getMatchResource()

+	 * @generated

+	 */

+	EAttribute getMatchResource_LeftURI();

+

+	/**

+	 * Returns the meta object for the attribute '{@link org.eclipse.emf.compare.MatchResource#getRightURI <em>Right URI</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the attribute '<em>Right URI</em>'.

+	 * @see org.eclipse.emf.compare.MatchResource#getRightURI()

+	 * @see #getMatchResource()

+	 * @generated

+	 */

+	EAttribute getMatchResource_RightURI();

+

+	/**

+	 * Returns the meta object for the attribute '{@link org.eclipse.emf.compare.MatchResource#getOriginURI <em>Origin URI</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the attribute '<em>Origin URI</em>'.

+	 * @see org.eclipse.emf.compare.MatchResource#getOriginURI()

+	 * @see #getMatchResource()

+	 * @generated

+	 */

+	EAttribute getMatchResource_OriginURI();

+

+	/**

+	 * Returns the meta object for class '{@link org.eclipse.emf.compare.Match <em>Match</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for class '<em>Match</em>'.

+	 * @see org.eclipse.emf.compare.Match

+	 * @generated

+	 */

+	EClass getMatch();

+

+	/**

+	 * Returns the meta object for the containment reference list '{@link org.eclipse.emf.compare.Match#getSubMatches <em>Sub Matches</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the containment reference list '<em>Sub Matches</em>'.

+	 * @see org.eclipse.emf.compare.Match#getSubMatches()

+	 * @see #getMatch()

+	 * @generated

+	 */

+	EReference getMatch_SubMatches();

+

+	/**

+	 * Returns the meta object for the containment reference list '{@link org.eclipse.emf.compare.Match#getDifferences <em>Differences</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the containment reference list '<em>Differences</em>'.

+	 * @see org.eclipse.emf.compare.Match#getDifferences()

+	 * @see #getMatch()

+	 * @generated

+	 */

+	EReference getMatch_Differences();

+

+	/**

+	 * Returns the meta object for the reference '{@link org.eclipse.emf.compare.Match#getLeft <em>Left</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the reference '<em>Left</em>'.

+	 * @see org.eclipse.emf.compare.Match#getLeft()

+	 * @see #getMatch()

+	 * @generated

+	 */

+	EReference getMatch_Left();

+

+	/**

+	 * Returns the meta object for the reference '{@link org.eclipse.emf.compare.Match#getRight <em>Right</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the reference '<em>Right</em>'.

+	 * @see org.eclipse.emf.compare.Match#getRight()

+	 * @see #getMatch()

+	 * @generated

+	 */

+	EReference getMatch_Right();

+

+	/**

+	 * Returns the meta object for the reference '{@link org.eclipse.emf.compare.Match#getOrigin <em>Origin</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the reference '<em>Origin</em>'.

+	 * @see org.eclipse.emf.compare.Match#getOrigin()

+	 * @see #getMatch()

+	 * @generated

+	 */

+	EReference getMatch_Origin();

+

+	/**

+	 * Returns the meta object for class '{@link org.eclipse.emf.compare.Diff <em>Diff</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for class '<em>Diff</em>'.

+	 * @see org.eclipse.emf.compare.Diff

+	 * @generated

+	 */

+	EClass getDiff();

+

+	/**

+	 * Returns the meta object for the container reference '{@link org.eclipse.emf.compare.Diff#getMatch <em>Match</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the container reference '<em>Match</em>'.

+	 * @see org.eclipse.emf.compare.Diff#getMatch()

+	 * @see #getDiff()

+	 * @generated

+	 */

+	EReference getDiff_Match();

+

+	/**

+	 * Returns the meta object for the reference list '{@link org.eclipse.emf.compare.Diff#getRequires <em>Requires</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the reference list '<em>Requires</em>'.

+	 * @see org.eclipse.emf.compare.Diff#getRequires()

+	 * @see #getDiff()

+	 * @generated

+	 */

+	EReference getDiff_Requires();

+

+	/**

+	 * Returns the meta object for the reference list '{@link org.eclipse.emf.compare.Diff#getRequiredBy <em>Required By</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the reference list '<em>Required By</em>'.

+	 * @see org.eclipse.emf.compare.Diff#getRequiredBy()

+	 * @see #getDiff()

+	 * @generated

+	 */

+	EReference getDiff_RequiredBy();

+

+	/**

+	 * Returns the meta object for the reference list '{@link org.eclipse.emf.compare.Diff#getRefines <em>Refines</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the reference list '<em>Refines</em>'.

+	 * @see org.eclipse.emf.compare.Diff#getRefines()

+	 * @see #getDiff()

+	 * @generated

+	 */

+	EReference getDiff_Refines();

+

+	/**

+	 * Returns the meta object for the reference list '{@link org.eclipse.emf.compare.Diff#getRefinedBy <em>Refined By</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the reference list '<em>Refined By</em>'.

+	 * @see org.eclipse.emf.compare.Diff#getRefinedBy()

+	 * @see #getDiff()

+	 * @generated

+	 */

+	EReference getDiff_RefinedBy();

+

+	/**

+	 * Returns the meta object for the attribute '{@link org.eclipse.emf.compare.Diff#getKind <em>Kind</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the attribute '<em>Kind</em>'.

+	 * @see org.eclipse.emf.compare.Diff#getKind()

+	 * @see #getDiff()

+	 * @generated

+	 */

+	EAttribute getDiff_Kind();

+

+	/**

+	 * Returns the meta object for the reference '{@link org.eclipse.emf.compare.Diff#getEquivalentDiffs <em>Equivalent Diffs</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the reference '<em>Equivalent Diffs</em>'.

+	 * @see org.eclipse.emf.compare.Diff#getEquivalentDiffs()

+	 * @see #getDiff()

+	 * @generated

+	 */

+	EReference getDiff_EquivalentDiffs();

+

+	/**

+	 * Returns the meta object for the reference '{@link org.eclipse.emf.compare.Diff#getConflict <em>Conflict</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the reference '<em>Conflict</em>'.

+	 * @see org.eclipse.emf.compare.Diff#getConflict()

+	 * @see #getDiff()

+	 * @generated

+	 */

+	EReference getDiff_Conflict();

+

+	/**

+	 * Returns the meta object for class '{@link org.eclipse.emf.compare.ResourceAttachmentChange <em>Resource Attachment Change</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for class '<em>Resource Attachment Change</em>'.

+	 * @see org.eclipse.emf.compare.ResourceAttachmentChange

+	 * @generated

+	 */

+	EClass getResourceAttachmentChange();

+

+	/**

+	 * Returns the meta object for the attribute '{@link org.eclipse.emf.compare.ResourceAttachmentChange#getResourceURI <em>Resource URI</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the attribute '<em>Resource URI</em>'.

+	 * @see org.eclipse.emf.compare.ResourceAttachmentChange#getResourceURI()

+	 * @see #getResourceAttachmentChange()

+	 * @generated

+	 */

+	EAttribute getResourceAttachmentChange_ResourceURI();

+

+	/**

+	 * Returns the meta object for class '{@link org.eclipse.emf.compare.ReferenceChange <em>Reference Change</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for class '<em>Reference Change</em>'.

+	 * @see org.eclipse.emf.compare.ReferenceChange

+	 * @generated

+	 */

+	EClass getReferenceChange();

+

+	/**

+	 * Returns the meta object for the reference '{@link org.eclipse.emf.compare.ReferenceChange#getReference <em>Reference</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the reference '<em>Reference</em>'.

+	 * @see org.eclipse.emf.compare.ReferenceChange#getReference()

+	 * @see #getReferenceChange()

+	 * @generated

+	 */

+	EReference getReferenceChange_Reference();

+

+	/**

+	 * Returns the meta object for the reference '{@link org.eclipse.emf.compare.ReferenceChange#getValue <em>Value</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the reference '<em>Value</em>'.

+	 * @see org.eclipse.emf.compare.ReferenceChange#getValue()

+	 * @see #getReferenceChange()

+	 * @generated

+	 */

+	EReference getReferenceChange_Value();

+

+	/**

+	 * Returns the meta object for class '{@link org.eclipse.emf.compare.AttributeChange <em>Attribute Change</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for class '<em>Attribute Change</em>'.

+	 * @see org.eclipse.emf.compare.AttributeChange

+	 * @generated

+	 */

+	EClass getAttributeChange();

+

+	/**

+	 * Returns the meta object for the reference '{@link org.eclipse.emf.compare.AttributeChange#getAttribute <em>Attribute</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the reference '<em>Attribute</em>'.

+	 * @see org.eclipse.emf.compare.AttributeChange#getAttribute()

+	 * @see #getAttributeChange()

+	 * @generated

+	 */

+	EReference getAttributeChange_Attribute();

+

+	/**

+	 * Returns the meta object for the attribute '{@link org.eclipse.emf.compare.AttributeChange#getValue <em>Value</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the attribute '<em>Value</em>'.

+	 * @see org.eclipse.emf.compare.AttributeChange#getValue()

+	 * @see #getAttributeChange()

+	 * @generated

+	 */

+	EAttribute getAttributeChange_Value();

+

+	/**

+	 * Returns the meta object for class '{@link org.eclipse.emf.compare.Conflict <em>Conflict</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for class '<em>Conflict</em>'.

+	 * @see org.eclipse.emf.compare.Conflict

+	 * @generated

+	 */

+	EClass getConflict();

+

+	/**

+	 * Returns the meta object for the reference list '{@link org.eclipse.emf.compare.Conflict#getDifferences <em>Differences</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the reference list '<em>Differences</em>'.

+	 * @see org.eclipse.emf.compare.Conflict#getDifferences()

+	 * @see #getConflict()

+	 * @generated

+	 */

+	EReference getConflict_Differences();

+

+	/**

+	 * Returns the meta object for class '{@link org.eclipse.emf.compare.Equivalence <em>Equivalence</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for class '<em>Equivalence</em>'.

+	 * @see org.eclipse.emf.compare.Equivalence

+	 * @generated

+	 */

+	EClass getEquivalence();

+

+	/**

+	 * Returns the meta object for the reference list '{@link org.eclipse.emf.compare.Equivalence#getDifferences <em>Differences</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for the reference list '<em>Differences</em>'.

+	 * @see org.eclipse.emf.compare.Equivalence#getDifferences()

+	 * @see #getEquivalence()

+	 * @generated

+	 */

+	EReference getEquivalence_Differences();

+

+	/**

+	 * Returns the meta object for enum '{@link org.eclipse.emf.compare.DifferenceKind <em>Difference Kind</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for enum '<em>Difference Kind</em>'.

+	 * @see org.eclipse.emf.compare.DifferenceKind

+	 * @generated

+	 */

+	EEnum getDifferenceKind();

+

+	/**

+	 * Returns the meta object for enum '{@link org.eclipse.emf.compare.DifferenceSource <em>Difference Source</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the meta object for enum '<em>Difference Source</em>'.

+	 * @see org.eclipse.emf.compare.DifferenceSource

+	 * @generated

+	 */

+	EEnum getDifferenceSource();

+

+	/**

+	 * Returns the factory that creates the instances of the model.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the factory that creates the instances of the model.

+	 * @generated

+	 */

+	CompareFactory getCompareFactory();

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * Defines literals for the meta objects that represent

+	 * <ul>

+	 *   <li>each class,</li>

+	 *   <li>each feature of each class,</li>

+	 *   <li>each enum,</li>

+	 *   <li>and each data type</li>

+	 * </ul>

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@SuppressWarnings("hiding") // generated code, removing warnings

+	interface Literals {

+		/**

+		 * The meta object literal for the '{@link org.eclipse.emf.compare.impl.ComparisonImpl <em>Comparison</em>}' class.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @see org.eclipse.emf.compare.impl.ComparisonImpl

+		 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getComparison()

+		 * @generated

+		 */

+		EClass COMPARISON = eINSTANCE.getComparison();

+

+		/**

+		 * The meta object literal for the '<em><b>Matched Resources</b></em>' containment reference list feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference COMPARISON__MATCHED_RESOURCES = eINSTANCE.getComparison_MatchedResources();

+

+		/**

+		 * The meta object literal for the '<em><b>Matches</b></em>' containment reference list feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference COMPARISON__MATCHES = eINSTANCE.getComparison_Matches();

+

+		/**

+		 * The meta object literal for the '<em><b>Conflicts</b></em>' containment reference list feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference COMPARISON__CONFLICTS = eINSTANCE.getComparison_Conflicts();

+

+		/**

+		 * The meta object literal for the '{@link org.eclipse.emf.compare.impl.MatchResourceImpl <em>Match Resource</em>}' class.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @see org.eclipse.emf.compare.impl.MatchResourceImpl

+		 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getMatchResource()

+		 * @generated

+		 */

+		EClass MATCH_RESOURCE = eINSTANCE.getMatchResource();

+

+		/**

+		 * The meta object literal for the '<em><b>Left URI</b></em>' attribute feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EAttribute MATCH_RESOURCE__LEFT_URI = eINSTANCE.getMatchResource_LeftURI();

+

+		/**

+		 * The meta object literal for the '<em><b>Right URI</b></em>' attribute feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EAttribute MATCH_RESOURCE__RIGHT_URI = eINSTANCE.getMatchResource_RightURI();

+

+		/**

+		 * The meta object literal for the '<em><b>Origin URI</b></em>' attribute feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EAttribute MATCH_RESOURCE__ORIGIN_URI = eINSTANCE.getMatchResource_OriginURI();

+

+		/**

+		 * The meta object literal for the '{@link org.eclipse.emf.compare.impl.MatchImpl <em>Match</em>}' class.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @see org.eclipse.emf.compare.impl.MatchImpl

+		 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getMatch()

+		 * @generated

+		 */

+		EClass MATCH = eINSTANCE.getMatch();

+

+		/**

+		 * The meta object literal for the '<em><b>Sub Matches</b></em>' containment reference list feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference MATCH__SUB_MATCHES = eINSTANCE.getMatch_SubMatches();

+

+		/**

+		 * The meta object literal for the '<em><b>Differences</b></em>' containment reference list feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference MATCH__DIFFERENCES = eINSTANCE.getMatch_Differences();

+

+		/**

+		 * The meta object literal for the '<em><b>Left</b></em>' reference feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference MATCH__LEFT = eINSTANCE.getMatch_Left();

+

+		/**

+		 * The meta object literal for the '<em><b>Right</b></em>' reference feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference MATCH__RIGHT = eINSTANCE.getMatch_Right();

+

+		/**

+		 * The meta object literal for the '<em><b>Origin</b></em>' reference feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference MATCH__ORIGIN = eINSTANCE.getMatch_Origin();

+

+		/**

+		 * The meta object literal for the '{@link org.eclipse.emf.compare.impl.DiffImpl <em>Diff</em>}' class.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @see org.eclipse.emf.compare.impl.DiffImpl

+		 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getDiff()

+		 * @generated

+		 */

+		EClass DIFF = eINSTANCE.getDiff();

+

+		/**

+		 * The meta object literal for the '<em><b>Match</b></em>' container reference feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference DIFF__MATCH = eINSTANCE.getDiff_Match();

+

+		/**

+		 * The meta object literal for the '<em><b>Requires</b></em>' reference list feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference DIFF__REQUIRES = eINSTANCE.getDiff_Requires();

+

+		/**

+		 * The meta object literal for the '<em><b>Required By</b></em>' reference list feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference DIFF__REQUIRED_BY = eINSTANCE.getDiff_RequiredBy();

+

+		/**

+		 * The meta object literal for the '<em><b>Refines</b></em>' reference list feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference DIFF__REFINES = eINSTANCE.getDiff_Refines();

+

+		/**

+		 * The meta object literal for the '<em><b>Refined By</b></em>' reference list feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference DIFF__REFINED_BY = eINSTANCE.getDiff_RefinedBy();

+

+		/**

+		 * The meta object literal for the '<em><b>Kind</b></em>' attribute feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EAttribute DIFF__KIND = eINSTANCE.getDiff_Kind();

+

+		/**

+		 * The meta object literal for the '<em><b>Equivalent Diffs</b></em>' reference feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference DIFF__EQUIVALENT_DIFFS = eINSTANCE.getDiff_EquivalentDiffs();

+

+		/**

+		 * The meta object literal for the '<em><b>Conflict</b></em>' reference feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference DIFF__CONFLICT = eINSTANCE.getDiff_Conflict();

+

+		/**

+		 * The meta object literal for the '{@link org.eclipse.emf.compare.impl.ResourceAttachmentChangeImpl <em>Resource Attachment Change</em>}' class.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @see org.eclipse.emf.compare.impl.ResourceAttachmentChangeImpl

+		 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getResourceAttachmentChange()

+		 * @generated

+		 */

+		EClass RESOURCE_ATTACHMENT_CHANGE = eINSTANCE.getResourceAttachmentChange();

+

+		/**

+		 * The meta object literal for the '<em><b>Resource URI</b></em>' attribute feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EAttribute RESOURCE_ATTACHMENT_CHANGE__RESOURCE_URI = eINSTANCE

+				.getResourceAttachmentChange_ResourceURI();

+

+		/**

+		 * The meta object literal for the '{@link org.eclipse.emf.compare.impl.ReferenceChangeImpl <em>Reference Change</em>}' class.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @see org.eclipse.emf.compare.impl.ReferenceChangeImpl

+		 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getReferenceChange()

+		 * @generated

+		 */

+		EClass REFERENCE_CHANGE = eINSTANCE.getReferenceChange();

+

+		/**

+		 * The meta object literal for the '<em><b>Reference</b></em>' reference feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference REFERENCE_CHANGE__REFERENCE = eINSTANCE.getReferenceChange_Reference();

+

+		/**

+		 * The meta object literal for the '<em><b>Value</b></em>' reference feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference REFERENCE_CHANGE__VALUE = eINSTANCE.getReferenceChange_Value();

+

+		/**

+		 * The meta object literal for the '{@link org.eclipse.emf.compare.impl.AttributeChangeImpl <em>Attribute Change</em>}' class.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @see org.eclipse.emf.compare.impl.AttributeChangeImpl

+		 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getAttributeChange()

+		 * @generated

+		 */

+		EClass ATTRIBUTE_CHANGE = eINSTANCE.getAttributeChange();

+

+		/**

+		 * The meta object literal for the '<em><b>Attribute</b></em>' reference feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference ATTRIBUTE_CHANGE__ATTRIBUTE = eINSTANCE.getAttributeChange_Attribute();

+

+		/**

+		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EAttribute ATTRIBUTE_CHANGE__VALUE = eINSTANCE.getAttributeChange_Value();

+

+		/**

+		 * The meta object literal for the '{@link org.eclipse.emf.compare.impl.ConflictImpl <em>Conflict</em>}' class.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @see org.eclipse.emf.compare.impl.ConflictImpl

+		 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getConflict()

+		 * @generated

+		 */

+		EClass CONFLICT = eINSTANCE.getConflict();

+

+		/**

+		 * The meta object literal for the '<em><b>Differences</b></em>' reference list feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference CONFLICT__DIFFERENCES = eINSTANCE.getConflict_Differences();

+

+		/**

+		 * The meta object literal for the '{@link org.eclipse.emf.compare.impl.EquivalenceImpl <em>Equivalence</em>}' class.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @see org.eclipse.emf.compare.impl.EquivalenceImpl

+		 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getEquivalence()

+		 * @generated

+		 */

+		EClass EQUIVALENCE = eINSTANCE.getEquivalence();

+

+		/**

+		 * The meta object literal for the '<em><b>Differences</b></em>' reference list feature.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @generated

+		 */

+		EReference EQUIVALENCE__DIFFERENCES = eINSTANCE.getEquivalence_Differences();

+

+		/**

+		 * The meta object literal for the '{@link org.eclipse.emf.compare.DifferenceKind <em>Difference Kind</em>}' enum.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @see org.eclipse.emf.compare.DifferenceKind

+		 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getDifferenceKind()

+		 * @generated

+		 */

+		EEnum DIFFERENCE_KIND = eINSTANCE.getDifferenceKind();

+

+		/**

+		 * The meta object literal for the '{@link org.eclipse.emf.compare.DifferenceSource <em>Difference Source</em>}' enum.

+		 * <!-- begin-user-doc -->

+		 * <!-- end-user-doc -->

+		 * @see org.eclipse.emf.compare.DifferenceSource

+		 * @see org.eclipse.emf.compare.impl.ComparePackageImpl#getDifferenceSource()

+		 * @generated

+		 */

+		EEnum DIFFERENCE_SOURCE = eINSTANCE.getDifferenceSource();

+

+	}

+

+} //ComparePackage

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/Comparison.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/Comparison.java
new file mode 100644
index 000000000..189acf51d
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/Comparison.java
@@ -0,0 +1,140 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare;

+

+import org.eclipse.emf.common.util.EList;

+

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

+

+/**

+ * <!-- begin-user-doc -->

+ * A representation of the model object '<em><b>Comparison</b></em>'.

+ * <!-- end-user-doc -->

+ *

+ * <!-- begin-model-doc -->

+ * This will act as the "root" of a comparison. It will reference one match for every root of the input models, along with the differences detected for each of them.

+ * <!-- end-model-doc -->

+ *

+ * <p>

+ * The following features are supported:

+ * <ul>

+ *   <li>{@link org.eclipse.emf.compare.Comparison#getMatchedResources <em>Matched Resources</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.Comparison#getMatches <em>Matches</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.Comparison#getConflicts <em>Conflicts</em>}</li>

+ * </ul>

+ * </p>

+ *

+ * @see org.eclipse.emf.compare.ComparePackage#getComparison()

+ * @model

+ * @generated

+ */

+public interface Comparison extends EObject {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * Returns the value of the '<em><b>Matched Resources</b></em>' containment reference list.

+	 * The list contents are of type {@link org.eclipse.emf.compare.MatchResource}.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * This contains the mappings for each compared Resource.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Matched Resources</em>' containment reference list.

+	 * @see org.eclipse.emf.compare.ComparePackage#getComparison_MatchedResources()

+	 * @model containment="true"

+	 * @generated

+	 */

+	EList<MatchResource> getMatchedResources();

+

+	/**

+	 * Returns the value of the '<em><b>Matches</b></em>' containment reference list.

+	 * The list contents are of type {@link org.eclipse.emf.compare.Match}.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * This contains the match tree "mimicking" the input models' hierarchy.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Matches</em>' containment reference list.

+	 * @see org.eclipse.emf.compare.ComparePackage#getComparison_Matches()

+	 * @model containment="true"

+	 * @generated

+	 */

+	EList<Match> getMatches();

+

+	/**

+	 * Returns the value of the '<em><b>Conflicts</b></em>' containment reference list.

+	 * The list contents are of type {@link org.eclipse.emf.compare.Conflict}.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * If we detected any conflict during the comparison process, this will contain them.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Conflicts</em>' containment reference list.

+	 * @see org.eclipse.emf.compare.ComparePackage#getComparison_Conflicts()

+	 * @model containment="true"

+	 * @generated

+	 */

+	EList<Conflict> getConflicts();

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * Returns all differences contained by this Comparison and its children.

+	 * <!-- end-model-doc -->

+	 * @model kind="operation"

+	 * @generated

+	 */

+	EList<Diff> getDifferences();

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * Returns all differences that were detected on the given EObject or one of its counterpart in left, right or origin.

+	 * @param element The EObject for which we seek all related differences.

+	 * <!-- end-model-doc -->

+	 * @model

+	 * @generated

+	 */

+	EList<Diff> getDifferences(EObject element);

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * Finds and return the Match for the given EObject.

+	 * @param element The EObject for which we seek the match.

+	 * <!-- end-model-doc -->

+	 * @model

+	 * @generated

+	 */

+	Match getMatch(EObject element);

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * Adds the given diff under the match corresponding to the given EObject.

+	 * @param element EObject on which we need to add a new difference.

+	 * @param newDiff The difference we are to add to the comparison model.

+	 * <!-- end-model-doc -->

+	 * @model

+	 * @generated

+	 */

+	void addDiff(EObject element, Diff newDiff);

+

+} // Comparison

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/Conflict.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/Conflict.java
new file mode 100644
index 000000000..8d31c95fe
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/Conflict.java
@@ -0,0 +1,84 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare;

+

+import org.eclipse.emf.common.util.EList;

+

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

+

+/**

+ * <!-- begin-user-doc -->

+ * A representation of the model object '<em><b>Conflict</b></em>'.

+ * <!-- end-user-doc -->

+ *

+ * <!-- begin-model-doc -->

+ * Instances of this class describe conflicts between one or more differences in the left model as compared to differences in the right model. Conflicts can only happen in the case of three-way comparisons, when we have a common ancestor of both sides.

+ * <!-- end-model-doc -->

+ *

+ * <p>

+ * The following features are supported:

+ * <ul>

+ *   <li>{@link org.eclipse.emf.compare.Conflict#getDifferences <em>Differences</em>}</li>

+ * </ul>

+ * </p>

+ *

+ * @see org.eclipse.emf.compare.ComparePackage#getConflict()

+ * @model

+ * @generated

+ */

+public interface Conflict extends EObject {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * Returns the value of the '<em><b>Differences</b></em>' reference list.

+	 * The list contents are of type {@link org.eclipse.emf.compare.Diff}.

+	 * It is bidirectional and its opposite is '{@link org.eclipse.emf.compare.Diff#getConflict <em>Conflict</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * This will reference all differences that are related to this conflict. The number of elements contained in this list is <u>at least</u> two.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Differences</em>' reference list.

+	 * @see org.eclipse.emf.compare.ComparePackage#getConflict_Differences()

+	 * @see org.eclipse.emf.compare.Diff#getConflict

+	 * @model opposite="conflict" lower="2"

+	 * @generated

+	 */

+	EList<Diff> getDifferences();

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * This can be used to retrieve the list of differences that were made in the left element.

+	 * <!-- end-model-doc -->

+	 * @model kind="operation" required="true"

+	 * @generated

+	 */

+	EList<Diff> getLeftDifferences();

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * This can be used to retrieve the list of differences that were made in the right element.

+	 * <!-- end-model-doc -->

+	 * @model kind="operation" required="true"

+	 * @generated

+	 */

+	EList<Diff> getRightDifferences();

+

+} // Conflict

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/Diff.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/Diff.java
new file mode 100644
index 000000000..a7f457f02
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/Diff.java
@@ -0,0 +1,273 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare;

+

+import org.eclipse.emf.common.util.EList;

+

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

+

+/**

+ * <!-- begin-user-doc -->

+ * A representation of the model object '<em><b>Diff</b></em>'.

+ * <!-- end-user-doc -->

+ *

+ * <!-- begin-model-doc -->

+ * A DiffElement describes a difference related to the EObjects mapped by its parent MatchElement.

+ * <!-- end-model-doc -->

+ *

+ * <p>

+ * The following features are supported:

+ * <ul>

+ *   <li>{@link org.eclipse.emf.compare.Diff#getMatch <em>Match</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.Diff#getRequires <em>Requires</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.Diff#getRequiredBy <em>Required By</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.Diff#getRefines <em>Refines</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.Diff#getRefinedBy <em>Refined By</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.Diff#getKind <em>Kind</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.Diff#getEquivalentDiffs <em>Equivalent Diffs</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.Diff#getConflict <em>Conflict</em>}</li>

+ * </ul>

+ * </p>

+ *

+ * @see org.eclipse.emf.compare.ComparePackage#getDiff()

+ * @model

+ * @generated

+ */

+public interface Diff extends EObject {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * Returns the value of the '<em><b>Match</b></em>' container reference.

+	 * It is bidirectional and its opposite is '{@link org.eclipse.emf.compare.Match#getDifferences <em>Differences</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * Back-reference towards this difference's parent match, it points towards the mapping on which this difference has been detected.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Match</em>' container reference.

+	 * @see #setMatch(Match)

+	 * @see org.eclipse.emf.compare.ComparePackage#getDiff_Match()

+	 * @see org.eclipse.emf.compare.Match#getDifferences

+	 * @model opposite="differences" required="true" transient="false"

+	 * @generated

+	 */

+	Match getMatch();

+

+	/**

+	 * Sets the value of the '{@link org.eclipse.emf.compare.Diff#getMatch <em>Match</em>}' container reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @param value the new value of the '<em>Match</em>' container reference.

+	 * @see #getMatch()

+	 * @generated

+	 */

+	void setMatch(Match value);

+

+	/**

+	 * Returns the value of the '<em><b>Requires</b></em>' reference list.

+	 * The list contents are of type {@link org.eclipse.emf.compare.Diff}.

+	 * It is bidirectional and its opposite is '{@link org.eclipse.emf.compare.Diff#getRequiredBy <em>Required By</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * This will reference all differences that should be merged before this one.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Requires</em>' reference list.

+	 * @see org.eclipse.emf.compare.ComparePackage#getDiff_Requires()

+	 * @see org.eclipse.emf.compare.Diff#getRequiredBy

+	 * @model opposite="requiredBy"

+	 * @generated

+	 */

+	EList<Diff> getRequires();

+

+	/**

+	 * Returns the value of the '<em><b>Required By</b></em>' reference list.

+	 * The list contents are of type {@link org.eclipse.emf.compare.Diff}.

+	 * It is bidirectional and its opposite is '{@link org.eclipse.emf.compare.Diff#getRequires <em>Requires</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * This will reference all differences that depend on this one for their merging.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Required By</em>' reference list.

+	 * @see org.eclipse.emf.compare.ComparePackage#getDiff_RequiredBy()

+	 * @see org.eclipse.emf.compare.Diff#getRequires

+	 * @model opposite="requires"

+	 * @generated

+	 */

+	EList<Diff> getRequiredBy();

+

+	/**

+	 * Returns the value of the '<em><b>Refines</b></em>' reference list.

+	 * The list contents are of type {@link org.eclipse.emf.compare.Diff}.

+	 * It is bidirectional and its opposite is '{@link org.eclipse.emf.compare.Diff#getRefinedBy <em>Refined By</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * This can be used to create "high level" differences to regroup one or more diffs in a common "container". For example, this could be used to regroup <i>n</i> technical differences into one single semantic difference, such as the differences "profile application added" and "reference to stereotype added" that can actually be regrouped under a single, more understandable "stereotype application added".

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Refines</em>' reference list.

+	 * @see org.eclipse.emf.compare.ComparePackage#getDiff_Refines()

+	 * @see org.eclipse.emf.compare.Diff#getRefinedBy

+	 * @model opposite="refinedBy"

+	 * @generated

+	 */

+	EList<Diff> getRefines();

+

+	/**

+	 * Returns the value of the '<em><b>Refined By</b></em>' reference list.

+	 * The list contents are of type {@link org.eclipse.emf.compare.Diff}.

+	 * It is bidirectional and its opposite is '{@link org.eclipse.emf.compare.Diff#getRefines <em>Refines</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * This will reference the higher-level difference that shadows this one, if any.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Refined By</em>' reference list.

+	 * @see org.eclipse.emf.compare.ComparePackage#getDiff_RefinedBy()

+	 * @see org.eclipse.emf.compare.Diff#getRefines

+	 * @model opposite="refines"

+	 * @generated

+	 */

+	EList<Diff> getRefinedBy();

+

+	/**

+	 * Returns the value of the '<em><b>Kind</b></em>' attribute.

+	 * The literals are from the enumeration {@link org.eclipse.emf.compare.DifferenceKind}.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * Describes the kind of this difference, whether it is an addition, deletion, change, or move.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Kind</em>' attribute.

+	 * @see org.eclipse.emf.compare.DifferenceKind

+	 * @see #setKind(DifferenceKind)

+	 * @see org.eclipse.emf.compare.ComparePackage#getDiff_Kind()

+	 * @model required="true"

+	 * @generated

+	 */

+	DifferenceKind getKind();

+

+	/**

+	 * Sets the value of the '{@link org.eclipse.emf.compare.Diff#getKind <em>Kind</em>}' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @param value the new value of the '<em>Kind</em>' attribute.

+	 * @see org.eclipse.emf.compare.DifferenceKind

+	 * @see #getKind()

+	 * @generated

+	 */

+	void setKind(DifferenceKind value);

+

+	/**

+	 * Returns the value of the '<em><b>Equivalent Diffs</b></em>' reference.

+	 * It is bidirectional and its opposite is '{@link org.eclipse.emf.compare.Equivalence#getDifferences <em>Differences</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * If this diff is equivalent to another, we will reference the equivalence from here. For example, if a reference has an eOpposite, we will detect one diff for each side of the bidirectional reference, yet merging one of these diffs is enough. We consider them equivalent.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Equivalent Diffs</em>' reference.

+	 * @see #setEquivalentDiffs(Equivalence)

+	 * @see org.eclipse.emf.compare.ComparePackage#getDiff_EquivalentDiffs()

+	 * @see org.eclipse.emf.compare.Equivalence#getDifferences

+	 * @model opposite="differences"

+	 * @generated

+	 */

+	Equivalence getEquivalentDiffs();

+

+	/**

+	 * Sets the value of the '{@link org.eclipse.emf.compare.Diff#getEquivalentDiffs <em>Equivalent Diffs</em>}' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @param value the new value of the '<em>Equivalent Diffs</em>' reference.

+	 * @see #getEquivalentDiffs()

+	 * @generated

+	 */

+	void setEquivalentDiffs(Equivalence value);

+

+	/**

+	 * Returns the value of the '<em><b>Conflict</b></em>' reference.

+	 * It is bidirectional and its opposite is '{@link org.eclipse.emf.compare.Conflict#getDifferences <em>Differences</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * If this element is in conflict with one (or more) other differences, this will reference the Conflict association.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Conflict</em>' reference.

+	 * @see #setConflict(Conflict)

+	 * @see org.eclipse.emf.compare.ComparePackage#getDiff_Conflict()

+	 * @see org.eclipse.emf.compare.Conflict#getDifferences

+	 * @model opposite="differences"

+	 * @generated

+	 */

+	Conflict getConflict();

+

+	/**

+	 * Sets the value of the '{@link org.eclipse.emf.compare.Diff#getConflict <em>Conflict</em>}' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @param value the new value of the '<em>Conflict</em>' reference.

+	 * @see #getConflict()

+	 * @generated

+	 */

+	void setConflict(Conflict value);

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * Returns the source of this diff, either one of DifferenceSource.LEFT (for two-way comparisons or differences detected between the left and origin elements) or DifferenceSource.RIGHT (for differences between the right and origin elements).

+	 * <!-- end-model-doc -->

+	 * @model kind="operation"

+	 * @generated

+	 */

+	DifferenceSource getSource();

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * This will merge the diff from left to right.

+	 * <!-- end-model-doc -->

+	 * @model

+	 * @generated

+	 */

+	void apply();

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * This will merge the diff from right to left.

+	 * <!-- end-model-doc -->

+	 * @model

+	 * @generated

+	 */

+	void reverse();

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * This will remove the diff from the model, effectively "forgetting" about it.

+	 * <!-- end-model-doc -->

+	 * @model

+	 * @generated

+	 */

+	void discard();

+

+} // Diff

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/DifferenceKind.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/DifferenceKind.java
new file mode 100644
index 000000000..e7780314a
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/DifferenceKind.java
@@ -0,0 +1,281 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare;

+

+import java.util.Arrays;

+import java.util.Collections;

+import java.util.List;

+

+import org.eclipse.emf.common.util.Enumerator;

+

+/**

+ * <!-- begin-user-doc -->

+ * A representation of the literals of the enumeration '<em><b>Difference Kind</b></em>',

+ * and utility methods for working with them.

+ * <!-- end-user-doc -->

+ * <!-- begin-model-doc -->

+ * The differences detected through EMF Compare can be of 4 general types.

+ * <ul>

+ * 	<li>ADD represent addition of model element or feature values,</li>

+ * 	<li>DELETE represent suppression of model element or feature values,</li>

+ * 	<li>CHANGE represent the modification of a feature value,</li>

+ * 	<li>MOVE will be used for difference on the containment feature of a model element, or differences on the order of a feature's values.</li>

+ * </ul>

+ * <!-- end-model-doc -->

+ * @see org.eclipse.emf.compare.ComparePackage#getDifferenceKind()

+ * @model

+ * @generated

+ */

+public enum DifferenceKind implements Enumerator {

+	/**

+	 * The '<em><b>ADD</b></em>' literal object.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #ADD_VALUE

+	 * @generated

+	 * @ordered

+	 */

+	ADD(0, "ADD", "ADD"), //$NON-NLS-1$ //$NON-NLS-2$

+

+	/**

+	 * The '<em><b>DELETE</b></em>' literal object.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #DELETE_VALUE

+	 * @generated

+	 * @ordered

+	 */

+	DELETE(1, "DELETE", "DELETE"), //$NON-NLS-1$ //$NON-NLS-2$

+

+	/**

+	 * The '<em><b>CHANGE</b></em>' literal object.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #CHANGE_VALUE

+	 * @generated

+	 * @ordered

+	 */

+	CHANGE(2, "CHANGE", "CHANGE"), //$NON-NLS-1$ //$NON-NLS-2$

+

+	/**

+	 * The '<em><b>MOVE</b></em>' literal object.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #MOVE_VALUE

+	 * @generated

+	 * @ordered

+	 */

+	MOVE(3, "MOVE", "MOVE"); //$NON-NLS-1$ //$NON-NLS-2$

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static final String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * The '<em><b>ADD</b></em>' literal value.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * Represents the addition of model elements or feature values.

+	 * <!-- end-model-doc -->

+	 * @see #ADD

+	 * @model

+	 * @generated

+	 * @ordered

+	 */

+	public static final int ADD_VALUE = 0;

+

+	/**

+	 * The '<em><b>DELETE</b></em>' literal value.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * Represents the suppression of model elements or feature values.

+	 * <!-- end-model-doc -->

+	 * @see #DELETE

+	 * @model

+	 * @generated

+	 * @ordered

+	 */

+	public static final int DELETE_VALUE = 1;

+

+	/**

+	 * The '<em><b>CHANGE</b></em>' literal value.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * Represents the modification of a feature value.

+	 * <!-- end-model-doc -->

+	 * @see #CHANGE

+	 * @model

+	 * @generated

+	 * @ordered

+	 */

+	public static final int CHANGE_VALUE = 2;

+

+	/**

+	 * The '<em><b>MOVE</b></em>' literal value.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * Describes a difference on the containment feature of a model element, or differences on the order of a feature's values.

+	 * <!-- end-model-doc -->

+	 * @see #MOVE

+	 * @model

+	 * @generated

+	 * @ordered

+	 */

+	public static final int MOVE_VALUE = 3;

+

+	/**

+	 * An array of all the '<em><b>Difference Kind</b></em>' enumerators.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private static final DifferenceKind[] VALUES_ARRAY = new DifferenceKind[] {ADD, DELETE, CHANGE, MOVE, };

+

+	/**

+	 * A public read-only list of all the '<em><b>Difference Kind</b></em>' enumerators.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static final List<DifferenceKind> VALUES = Collections.unmodifiableList(Arrays

+			.asList(VALUES_ARRAY));

+

+	/**

+	 * Returns the '<em><b>Difference Kind</b></em>' literal with the specified literal value.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static DifferenceKind get(String literal) {

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

+			DifferenceKind result = VALUES_ARRAY[i];

+			if (result.toString().equals(literal)) {

+				return result;

+			}

+		}

+		return null;

+	}

+

+	/**

+	 * Returns the '<em><b>Difference Kind</b></em>' literal with the specified name.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static DifferenceKind getByName(String name) {

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

+			DifferenceKind result = VALUES_ARRAY[i];

+			if (result.getName().equals(name)) {

+				return result;

+			}

+		}

+		return null;

+	}

+

+	/**

+	 * Returns the '<em><b>Difference Kind</b></em>' literal with the specified integer value.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static DifferenceKind get(int value) {

+		switch (value) {

+			case ADD_VALUE:

+				return ADD;

+			case DELETE_VALUE:

+				return DELETE;

+			case CHANGE_VALUE:

+				return CHANGE;

+			case MOVE_VALUE:

+				return MOVE;

+		}

+		return null;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private final int value;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private final String name;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private final String literal;

+

+	/**

+	 * Only this class can construct instances.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private DifferenceKind(int value, String name, String literal) {

+		this.value = value;

+		this.name = name;

+		this.literal = literal;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public int getValue() {

+		return value;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public String getName() {

+		return name;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public String getLiteral() {

+		return literal;

+	}

+

+	/**

+	 * Returns the literal value of the enumerator, which is its string representation.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public String toString() {

+		return literal;

+	}

+

+} //DifferenceKind

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/DifferenceSource.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/DifferenceSource.java
new file mode 100644
index 000000000..0e1448931
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/DifferenceSource.java
@@ -0,0 +1,228 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare;

+

+import java.util.Arrays;

+import java.util.Collections;

+import java.util.List;

+

+import org.eclipse.emf.common.util.Enumerator;

+

+/**

+ * <!-- begin-user-doc -->

+ * A representation of the literals of the enumeration '<em><b>Difference Source</b></em>',

+ * and utility methods for working with them.

+ * <!-- end-user-doc -->

+ * <!-- begin-model-doc -->

+ * This will be used to represent the source of a detected diff.

+ * <ul>

+ * 	<li>LEFT if the difference has been detected between the left element and its origin,</li>

+ * 	<li>RIGHT if the difference has been detected between the right element and its origin.</li>

+ * </ul>

+ * <b>Note</b> that differences detected during two-way comparisons will only be LEFT.

+ * <!-- end-model-doc -->

+ * @see org.eclipse.emf.compare.ComparePackage#getDifferenceSource()

+ * @model

+ * @generated

+ */

+public enum DifferenceSource implements Enumerator {

+	/**

+	 * The '<em><b>LEFT</b></em>' literal object.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #LEFT_VALUE

+	 * @generated

+	 * @ordered

+	 */

+	LEFT(0, "LEFT", "LEFT"), //$NON-NLS-1$ //$NON-NLS-2$

+

+	/**

+	 * The '<em><b>RIGHT</b></em>' literal object.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #RIGHT_VALUE

+	 * @generated

+	 * @ordered

+	 */

+	RIGHT(1, "RIGHT", "RIGHT"); //$NON-NLS-1$ //$NON-NLS-2$

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static final String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * The '<em><b>LEFT</b></em>' literal value.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * Will be used if the difference has been detected between the left element and its origin. Differences detected during two-way comparisons will always have this has their source.

+	 * <!-- end-model-doc -->

+	 * @see #LEFT

+	 * @model

+	 * @generated

+	 * @ordered

+	 */

+	public static final int LEFT_VALUE = 0;

+

+	/**

+	 * The '<em><b>RIGHT</b></em>' literal value.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * Will be used if the difference has been detected between the right element and its origin.

+	 * <!-- end-model-doc -->

+	 * @see #RIGHT

+	 * @model

+	 * @generated

+	 * @ordered

+	 */

+	public static final int RIGHT_VALUE = 1;

+

+	/**

+	 * An array of all the '<em><b>Difference Source</b></em>' enumerators.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private static final DifferenceSource[] VALUES_ARRAY = new DifferenceSource[] {LEFT, RIGHT, };

+

+	/**

+	 * A public read-only list of all the '<em><b>Difference Source</b></em>' enumerators.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static final List<DifferenceSource> VALUES = Collections.unmodifiableList(Arrays

+			.asList(VALUES_ARRAY));

+

+	/**

+	 * Returns the '<em><b>Difference Source</b></em>' literal with the specified literal value.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static DifferenceSource get(String literal) {

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

+			DifferenceSource result = VALUES_ARRAY[i];

+			if (result.toString().equals(literal)) {

+				return result;

+			}

+		}

+		return null;

+	}

+

+	/**

+	 * Returns the '<em><b>Difference Source</b></em>' literal with the specified name.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static DifferenceSource getByName(String name) {

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

+			DifferenceSource result = VALUES_ARRAY[i];

+			if (result.getName().equals(name)) {

+				return result;

+			}

+		}

+		return null;

+	}

+

+	/**

+	 * Returns the '<em><b>Difference Source</b></em>' literal with the specified integer value.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static DifferenceSource get(int value) {

+		switch (value) {

+			case LEFT_VALUE:

+				return LEFT;

+			case RIGHT_VALUE:

+				return RIGHT;

+		}

+		return null;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private final int value;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private final String name;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private final String literal;

+

+	/**

+	 * Only this class can construct instances.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private DifferenceSource(int value, String name, String literal) {

+		this.value = value;

+		this.name = name;

+		this.literal = literal;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public int getValue() {

+		return value;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public String getName() {

+		return name;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public String getLiteral() {

+		return literal;

+	}

+

+	/**

+	 * Returns the literal value of the enumerator, which is its string representation.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public String toString() {

+		return literal;

+	}

+

+} //DifferenceSource

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/Equivalence.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/Equivalence.java
new file mode 100644
index 000000000..cf633be79
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/Equivalence.java
@@ -0,0 +1,62 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare;

+

+import org.eclipse.emf.common.util.EList;

+

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

+

+/**

+ * <!-- begin-user-doc -->

+ * A representation of the model object '<em><b>Equivalence</b></em>'.

+ * <!-- end-user-doc -->

+ *

+ * <!-- begin-model-doc -->

+ * Diffs are considered equivalent if merging one is enough to resolve both differences. For example, if a reference has an eOpposite, we will detect one diff for each side of the bidirectional reference, yet merging one of these diffs will automatically update the model in such a way that the second diff is "merged".

+ * <!-- end-model-doc -->

+ *

+ * <p>

+ * The following features are supported:

+ * <ul>

+ *   <li>{@link org.eclipse.emf.compare.Equivalence#getDifferences <em>Differences</em>}</li>

+ * </ul>

+ * </p>

+ *

+ * @see org.eclipse.emf.compare.ComparePackage#getEquivalence()

+ * @model

+ * @generated

+ */

+public interface Equivalence extends EObject {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * Returns the value of the '<em><b>Differences</b></em>' reference list.

+	 * The list contents are of type {@link org.eclipse.emf.compare.Diff}.

+	 * It is bidirectional and its opposite is '{@link org.eclipse.emf.compare.Diff#getEquivalentDiffs <em>Equivalent Diffs</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * References the <i>n</i> diffs composing this equivalence. There are <u>at least</u> two diffs in this list.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Differences</em>' reference list.

+	 * @see org.eclipse.emf.compare.ComparePackage#getEquivalence_Differences()

+	 * @see org.eclipse.emf.compare.Diff#getEquivalentDiffs

+	 * @model opposite="equivalentDiffs" lower="2"

+	 * @generated

+	 */

+	EList<Diff> getDifferences();

+

+} // Equivalence

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/Match.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/Match.java
new file mode 100644
index 000000000..30f31012a
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/Match.java
@@ -0,0 +1,156 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare;

+

+import org.eclipse.emf.common.util.EList;

+

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

+

+/**

+ * <!-- begin-user-doc -->

+ * A representation of the model object '<em><b>Match</b></em>'.

+ * <!-- end-user-doc -->

+ *

+ * <!-- begin-model-doc -->

+ * A MatchElement describes the mapping between the EObjects of two or three resources. This will reference all three of left, right and origin resources. However, note that instances of this class will also represent unmatched elements, in which case only one of either "left" or "right" will be assigned.

+ * <!-- end-model-doc -->

+ *

+ * <p>

+ * The following features are supported:

+ * <ul>

+ *   <li>{@link org.eclipse.emf.compare.Match#getSubMatches <em>Sub Matches</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.Match#getDifferences <em>Differences</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.Match#getLeft <em>Left</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.Match#getRight <em>Right</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.Match#getOrigin <em>Origin</em>}</li>

+ * </ul>

+ * </p>

+ *

+ * @see org.eclipse.emf.compare.ComparePackage#getMatch()

+ * @model

+ * @generated

+ */

+public interface Match extends EObject {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * Returns the value of the '<em><b>Sub Matches</b></em>' containment reference list.

+	 * The list contents are of type {@link org.eclipse.emf.compare.Match}.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * The MatchElements will "mimic" the hierarchy of the input model(s). This containment feature will serve that purpose.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Sub Matches</em>' containment reference list.

+	 * @see org.eclipse.emf.compare.ComparePackage#getMatch_SubMatches()

+	 * @model containment="true"

+	 * @generated

+	 */

+	EList<Match> getSubMatches();

+

+	/**

+	 * Returns the value of the '<em><b>Differences</b></em>' containment reference list.

+	 * The list contents are of type {@link org.eclipse.emf.compare.Diff}.

+	 * It is bidirectional and its opposite is '{@link org.eclipse.emf.compare.Diff#getMatch <em>Match</em>}'.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * This will contain the list of all differences pertaining to this mapping, if any.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Differences</em>' containment reference list.

+	 * @see org.eclipse.emf.compare.ComparePackage#getMatch_Differences()

+	 * @see org.eclipse.emf.compare.Diff#getMatch

+	 * @model opposite="match" containment="true"

+	 * @generated

+	 */

+	EList<Diff> getDifferences();

+

+	/**

+	 * Returns the value of the '<em><b>Left</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * This can be null in the case of unmatched elements in the right model. In all other cases, it will reference the left element of this mapping.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Left</em>' reference.

+	 * @see #setLeft(EObject)

+	 * @see org.eclipse.emf.compare.ComparePackage#getMatch_Left()

+	 * @model

+	 * @generated

+	 */

+	EObject getLeft();

+

+	/**

+	 * Sets the value of the '{@link org.eclipse.emf.compare.Match#getLeft <em>Left</em>}' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @param value the new value of the '<em>Left</em>' reference.

+	 * @see #getLeft()

+	 * @generated

+	 */

+	void setLeft(EObject value);

+

+	/**

+	 * Returns the value of the '<em><b>Right</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * This can be null in the case of unmatched elements in the left model. In all other cases, it will reference the right element of this mapping.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Right</em>' reference.

+	 * @see #setRight(EObject)

+	 * @see org.eclipse.emf.compare.ComparePackage#getMatch_Right()

+	 * @model

+	 * @generated

+	 */

+	EObject getRight();

+

+	/**

+	 * Sets the value of the '{@link org.eclipse.emf.compare.Match#getRight <em>Right</em>}' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @param value the new value of the '<em>Right</em>' reference.

+	 * @see #getRight()

+	 * @generated

+	 */

+	void setRight(EObject value);

+

+	/**

+	 * Returns the value of the '<em><b>Origin</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * This can be null in the case of two-way comparisons, or unmatched elements that are only located in either left or right, i.e an element that was added since the origin, either in the left copy or the right one. In any other course of event, this will reference the origin element of this mapping.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Origin</em>' reference.

+	 * @see #setOrigin(EObject)

+	 * @see org.eclipse.emf.compare.ComparePackage#getMatch_Origin()

+	 * @model

+	 * @generated

+	 */

+	EObject getOrigin();

+

+	/**

+	 * Sets the value of the '{@link org.eclipse.emf.compare.Match#getOrigin <em>Origin</em>}' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @param value the new value of the '<em>Origin</em>' reference.

+	 * @see #getOrigin()

+	 * @generated

+	 */

+	void setOrigin(EObject value);

+

+} // Match

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/MatchResource.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/MatchResource.java
new file mode 100644
index 000000000..9b1ecda06
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/MatchResource.java
@@ -0,0 +1,120 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare;

+

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

+

+/**

+ * <!-- begin-user-doc -->

+ * A representation of the model object '<em><b>Match Resource</b></em>'.

+ * <!-- end-user-doc -->

+ *

+ * <!-- begin-model-doc -->

+ * A MatchResource element represents the mapping between two or three resources : left, right, and their optional common ancestor. The resource will be identified through its URI.

+ * <!-- end-model-doc -->

+ *

+ * <p>

+ * The following features are supported:

+ * <ul>

+ *   <li>{@link org.eclipse.emf.compare.MatchResource#getLeftURI <em>Left URI</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.MatchResource#getRightURI <em>Right URI</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.MatchResource#getOriginURI <em>Origin URI</em>}</li>

+ * </ul>

+ * </p>

+ *

+ * @see org.eclipse.emf.compare.ComparePackage#getMatchResource()

+ * @model

+ * @generated

+ */

+public interface MatchResource extends EObject {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * Returns the value of the '<em><b>Left URI</b></em>' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * Cannot be null. Represents the URI of the left resource of this mapping.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Left URI</em>' attribute.

+	 * @see #setLeftURI(String)

+	 * @see org.eclipse.emf.compare.ComparePackage#getMatchResource_LeftURI()

+	 * @model required="true"

+	 * @generated

+	 */

+	String getLeftURI();

+

+	/**

+	 * Sets the value of the '{@link org.eclipse.emf.compare.MatchResource#getLeftURI <em>Left URI</em>}' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @param value the new value of the '<em>Left URI</em>' attribute.

+	 * @see #getLeftURI()

+	 * @generated

+	 */

+	void setLeftURI(String value);

+

+	/**

+	 * Returns the value of the '<em><b>Right URI</b></em>' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * Cannot be null. Represents the URI of the right resource of this mapping.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Right URI</em>' attribute.

+	 * @see #setRightURI(String)

+	 * @see org.eclipse.emf.compare.ComparePackage#getMatchResource_RightURI()

+	 * @model required="true"

+	 * @generated

+	 */

+	String getRightURI();

+

+	/**

+	 * Sets the value of the '{@link org.eclipse.emf.compare.MatchResource#getRightURI <em>Right URI</em>}' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @param value the new value of the '<em>Right URI</em>' attribute.

+	 * @see #getRightURI()

+	 * @generated

+	 */

+	void setRightURI(String value);

+

+	/**

+	 * Returns the value of the '<em><b>Origin URI</b></em>' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * This can be null in the case of two-way comparisons. If assigned, it will represent the URI of the origin resource for this mapping; the common ancestor of both others.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Origin URI</em>' attribute.

+	 * @see #setOriginURI(String)

+	 * @see org.eclipse.emf.compare.ComparePackage#getMatchResource_OriginURI()

+	 * @model

+	 * @generated

+	 */

+	String getOriginURI();

+

+	/**

+	 * Sets the value of the '{@link org.eclipse.emf.compare.MatchResource#getOriginURI <em>Origin URI</em>}' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @param value the new value of the '<em>Origin URI</em>' attribute.

+	 * @see #getOriginURI()

+	 * @generated

+	 */

+	void setOriginURI(String value);

+

+} // MatchResource

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/ReferenceChange.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/ReferenceChange.java
new file mode 100644
index 000000000..30a7160e6
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/ReferenceChange.java
@@ -0,0 +1,95 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare;

+

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

+import org.eclipse.emf.ecore.EReference;

+

+/**

+ * <!-- begin-user-doc -->

+ * A representation of the model object '<em><b>Reference Change</b></em>'.

+ * <!-- end-user-doc -->

+ *

+ * <!-- begin-model-doc -->

+ * This particular kind of difference will be used to describe changes within a reference, whether the feature is multi-valued or not. In the case of a MOVE difference, this could actually mean two things : either the value has been moved from one index to another (moving the value at another position of the same reference), or the value has been moved from one container to another. This second case will only happen with containment references.

+ * <!-- end-model-doc -->

+ *

+ * <p>

+ * The following features are supported:

+ * <ul>

+ *   <li>{@link org.eclipse.emf.compare.ReferenceChange#getReference <em>Reference</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.ReferenceChange#getValue <em>Value</em>}</li>

+ * </ul>

+ * </p>

+ *

+ * @see org.eclipse.emf.compare.ComparePackage#getReferenceChange()

+ * @model

+ * @generated

+ */

+public interface ReferenceChange extends Diff {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * Returns the value of the '<em><b>Reference</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * The reference in which "something" changed. If this difference is a MOVE from one reference to another, this will point towards the left reference.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Reference</em>' reference.

+	 * @see #setReference(EReference)

+	 * @see org.eclipse.emf.compare.ComparePackage#getReferenceChange_Reference()

+	 * @model required="true"

+	 * @generated

+	 */

+	EReference getReference();

+

+	/**

+	 * Sets the value of the '{@link org.eclipse.emf.compare.ReferenceChange#getReference <em>Reference</em>}' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @param value the new value of the '<em>Reference</em>' reference.

+	 * @see #getReference()

+	 * @generated

+	 */

+	void setReference(EReference value);

+

+	/**

+	 * Returns the value of the '<em><b>Value</b></em>' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * References the actual value on which a difference has been detected.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Value</em>' reference.

+	 * @see #setValue(EObject)

+	 * @see org.eclipse.emf.compare.ComparePackage#getReferenceChange_Value()

+	 * @model

+	 * @generated

+	 */

+	EObject getValue();

+

+	/**

+	 * Sets the value of the '{@link org.eclipse.emf.compare.ReferenceChange#getValue <em>Value</em>}' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @param value the new value of the '<em>Value</em>' reference.

+	 * @see #getValue()

+	 * @generated

+	 */

+	void setValue(EObject value);

+

+} // ReferenceChange

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/ResourceAttachmentChange.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/ResourceAttachmentChange.java
new file mode 100644
index 000000000..e81a55ea4
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/ResourceAttachmentChange.java
@@ -0,0 +1,66 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare;

+

+/**

+ * <!-- begin-user-doc -->

+ * A representation of the model object '<em><b>Resource Attachment Change</b></em>'.

+ * <!-- end-user-doc -->

+ *

+ * <!-- begin-model-doc -->

+ * This particular kind of difference describes the fragmentation (or un-fragmentation) of a model element in its own (or back in its parent's) resource.

+ * <!-- end-model-doc -->

+ *

+ * <p>

+ * The following features are supported:

+ * <ul>

+ *   <li>{@link org.eclipse.emf.compare.ResourceAttachmentChange#getResourceURI <em>Resource URI</em>}</li>

+ * </ul>

+ * </p>

+ *

+ * @see org.eclipse.emf.compare.ComparePackage#getResourceAttachmentChange()

+ * @model

+ * @generated

+ */

+public interface ResourceAttachmentChange extends Diff {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * Returns the value of the '<em><b>Resource URI</b></em>' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * <!-- begin-model-doc -->

+	 * URI of the resource in which the parent mapping's element is now located.

+	 * <!-- end-model-doc -->

+	 * @return the value of the '<em>Resource URI</em>' attribute.

+	 * @see #setResourceURI(String)

+	 * @see org.eclipse.emf.compare.ComparePackage#getResourceAttachmentChange_ResourceURI()

+	 * @model required="true"

+	 * @generated

+	 */

+	String getResourceURI();

+

+	/**

+	 * Sets the value of the '{@link org.eclipse.emf.compare.ResourceAttachmentChange#getResourceURI <em>Resource URI</em>}' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @param value the new value of the '<em>Resource URI</em>' attribute.

+	 * @see #getResourceURI()

+	 * @generated

+	 */

+	void setResourceURI(String value);

+

+} // ResourceAttachmentChange

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/AttributeChangeImpl.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/AttributeChangeImpl.java
new file mode 100644
index 000000000..c10dd8883
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/AttributeChangeImpl.java
@@ -0,0 +1,245 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare.impl;

+

+import org.eclipse.emf.common.notify.Notification;

+

+import org.eclipse.emf.compare.AttributeChange;

+import org.eclipse.emf.compare.ComparePackage;

+

+import org.eclipse.emf.ecore.EAttribute;

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

+import org.eclipse.emf.ecore.InternalEObject;

+

+import org.eclipse.emf.ecore.impl.ENotificationImpl;

+

+/**

+ * <!-- begin-user-doc -->

+ * An implementation of the model object '<em><b>Attribute Change</b></em>'.

+ * <!-- end-user-doc -->

+ * <p>

+ * The following features are implemented:

+ * <ul>

+ *   <li>{@link org.eclipse.emf.compare.impl.AttributeChangeImpl#getAttribute <em>Attribute</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.impl.AttributeChangeImpl#getValue <em>Value</em>}</li>

+ * </ul>

+ * </p>

+ *

+ * @generated

+ */

+public class AttributeChangeImpl extends DiffImpl implements AttributeChange {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@SuppressWarnings("hiding") // generated code, removing warnings

+	public static final String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * The cached value of the '{@link #getAttribute() <em>Attribute</em>}' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getAttribute()

+	 * @generated

+	 * @ordered

+	 */

+	protected EAttribute attribute;

+

+	/**

+	 * The default value of the '{@link #getValue() <em>Value</em>}' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getValue()

+	 * @generated

+	 * @ordered

+	 */

+	protected static final Object VALUE_EDEFAULT = null;

+

+	/**

+	 * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getValue()

+	 * @generated

+	 * @ordered

+	 */

+	protected Object value = VALUE_EDEFAULT;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	protected AttributeChangeImpl() {

+		super();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	protected EClass eStaticClass() {

+		return ComparePackage.Literals.ATTRIBUTE_CHANGE;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EAttribute getAttribute() {

+		if (attribute != null && attribute.eIsProxy()) {

+			InternalEObject oldAttribute = (InternalEObject)attribute;

+			attribute = (EAttribute)eResolveProxy(oldAttribute);

+			if (attribute != oldAttribute) {

+				if (eNotificationRequired())

+					eNotify(new ENotificationImpl(this, Notification.RESOLVE,

+							ComparePackage.ATTRIBUTE_CHANGE__ATTRIBUTE, oldAttribute, attribute));

+			}

+		}

+		return attribute;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EAttribute basicGetAttribute() {

+		return attribute;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void setAttribute(EAttribute newAttribute) {

+		EAttribute oldAttribute = attribute;

+		attribute = newAttribute;

+		if (eNotificationRequired())

+			eNotify(new ENotificationImpl(this, Notification.SET, ComparePackage.ATTRIBUTE_CHANGE__ATTRIBUTE,

+					oldAttribute, attribute));

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public Object getValue() {

+		return value;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void setValue(Object newValue) {

+		Object oldValue = value;

+		value = newValue;

+		if (eNotificationRequired())

+			eNotify(new ENotificationImpl(this, Notification.SET, ComparePackage.ATTRIBUTE_CHANGE__VALUE,

+					oldValue, value));

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public Object eGet(int featureID, boolean resolve, boolean coreType) {

+		switch (featureID) {

+			case ComparePackage.ATTRIBUTE_CHANGE__ATTRIBUTE:

+				if (resolve)

+					return getAttribute();

+				return basicGetAttribute();

+			case ComparePackage.ATTRIBUTE_CHANGE__VALUE:

+				return getValue();

+		}

+		return super.eGet(featureID, resolve, coreType);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public void eSet(int featureID, Object newValue) {

+		switch (featureID) {

+			case ComparePackage.ATTRIBUTE_CHANGE__ATTRIBUTE:

+				setAttribute((EAttribute)newValue);

+				return;

+			case ComparePackage.ATTRIBUTE_CHANGE__VALUE:

+				setValue(newValue);

+				return;

+		}

+		super.eSet(featureID, newValue);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public void eUnset(int featureID) {

+		switch (featureID) {

+			case ComparePackage.ATTRIBUTE_CHANGE__ATTRIBUTE:

+				setAttribute((EAttribute)null);

+				return;

+			case ComparePackage.ATTRIBUTE_CHANGE__VALUE:

+				setValue(VALUE_EDEFAULT);

+				return;

+		}

+		super.eUnset(featureID);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public boolean eIsSet(int featureID) {

+		switch (featureID) {

+			case ComparePackage.ATTRIBUTE_CHANGE__ATTRIBUTE:

+				return attribute != null;

+			case ComparePackage.ATTRIBUTE_CHANGE__VALUE:

+				return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value);

+		}

+		return super.eIsSet(featureID);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public String toString() {

+		if (eIsProxy())

+			return super.toString();

+

+		StringBuffer result = new StringBuffer(super.toString());

+		result.append(" (value: "); //$NON-NLS-1$

+		result.append(value);

+		result.append(')');

+		return result.toString();

+	}

+

+} //AttributeChangeImpl

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/CompareFactoryImpl.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/CompareFactoryImpl.java
new file mode 100644
index 000000000..ebff09aa2
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/CompareFactoryImpl.java
@@ -0,0 +1,290 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare.impl;

+

+import org.eclipse.emf.compare.*;

+

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

+import org.eclipse.emf.ecore.EDataType;

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

+import org.eclipse.emf.ecore.EPackage;

+

+import org.eclipse.emf.ecore.impl.EFactoryImpl;

+

+import org.eclipse.emf.ecore.plugin.EcorePlugin;

+

+/**

+ * <!-- begin-user-doc -->

+ * An implementation of the model <b>Factory</b>.

+ * <!-- end-user-doc -->

+ * @generated

+ */

+@SuppressWarnings("unused") // generated code, removing warnings

+public class CompareFactoryImpl extends EFactoryImpl implements CompareFactory {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static final String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * Creates the default factory implementation.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static CompareFactory init() {

+		try {

+			CompareFactory theCompareFactory = (CompareFactory)EPackage.Registry.INSTANCE

+					.getEFactory("http://www.eclipse.org/emf/compare"); //$NON-NLS-1$ 

+			if (theCompareFactory != null) {

+				return theCompareFactory;

+			}

+		} catch (Exception exception) {

+			EcorePlugin.INSTANCE.log(exception);

+		}

+		return new CompareFactoryImpl();

+	}

+

+	/**

+	 * Creates an instance of the factory.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public CompareFactoryImpl() {

+		super();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public EObject create(EClass eClass) {

+		switch (eClass.getClassifierID()) {

+			case ComparePackage.COMPARISON:

+				return createComparison();

+			case ComparePackage.MATCH_RESOURCE:

+				return createMatchResource();

+			case ComparePackage.MATCH:

+				return createMatch();

+			case ComparePackage.DIFF:

+				return createDiff();

+			case ComparePackage.RESOURCE_ATTACHMENT_CHANGE:

+				return createResourceAttachmentChange();

+			case ComparePackage.REFERENCE_CHANGE:

+				return createReferenceChange();

+			case ComparePackage.ATTRIBUTE_CHANGE:

+				return createAttributeChange();

+			case ComparePackage.CONFLICT:

+				return createConflict();

+			case ComparePackage.EQUIVALENCE:

+				return createEquivalence();

+			default:

+				throw new IllegalArgumentException(

+						"The class '" + eClass.getName() + "' is not a valid classifier"); //$NON-NLS-1$ //$NON-NLS-2$

+		}

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public Object createFromString(EDataType eDataType, String initialValue) {

+		switch (eDataType.getClassifierID()) {

+			case ComparePackage.DIFFERENCE_KIND:

+				return createDifferenceKindFromString(eDataType, initialValue);

+			case ComparePackage.DIFFERENCE_SOURCE:

+				return createDifferenceSourceFromString(eDataType, initialValue);

+			default:

+				throw new IllegalArgumentException(

+						"The datatype '" + eDataType.getName() + "' is not a valid classifier"); //$NON-NLS-1$ //$NON-NLS-2$

+		}

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public String convertToString(EDataType eDataType, Object instanceValue) {

+		switch (eDataType.getClassifierID()) {

+			case ComparePackage.DIFFERENCE_KIND:

+				return convertDifferenceKindToString(eDataType, instanceValue);

+			case ComparePackage.DIFFERENCE_SOURCE:

+				return convertDifferenceSourceToString(eDataType, instanceValue);

+			default:

+				throw new IllegalArgumentException(

+						"The datatype '" + eDataType.getName() + "' is not a valid classifier"); //$NON-NLS-1$ //$NON-NLS-2$

+		}

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public Comparison createComparison() {

+		ComparisonImpl comparison = new ComparisonImpl();

+		return comparison;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public MatchResource createMatchResource() {

+		MatchResourceImpl matchResource = new MatchResourceImpl();

+		return matchResource;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public Match createMatch() {

+		MatchImpl match = new MatchImpl();

+		return match;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public Diff createDiff() {

+		DiffImpl diff = new DiffImpl();

+		return diff;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public ResourceAttachmentChange createResourceAttachmentChange() {

+		ResourceAttachmentChangeImpl resourceAttachmentChange = new ResourceAttachmentChangeImpl();

+		return resourceAttachmentChange;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public ReferenceChange createReferenceChange() {

+		ReferenceChangeImpl referenceChange = new ReferenceChangeImpl();

+		return referenceChange;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public AttributeChange createAttributeChange() {

+		AttributeChangeImpl attributeChange = new AttributeChangeImpl();

+		return attributeChange;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public Conflict createConflict() {

+		ConflictImpl conflict = new ConflictImpl();

+		return conflict;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public Equivalence createEquivalence() {

+		EquivalenceImpl equivalence = new EquivalenceImpl();

+		return equivalence;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public DifferenceKind createDifferenceKindFromString(EDataType eDataType, String initialValue) {

+		DifferenceKind result = DifferenceKind.get(initialValue);

+		if (result == null)

+			throw new IllegalArgumentException(

+					"The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

+		return result;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public String convertDifferenceKindToString(EDataType eDataType, Object instanceValue) {

+		return instanceValue == null ? null : instanceValue.toString();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public DifferenceSource createDifferenceSourceFromString(EDataType eDataType, String initialValue) {

+		DifferenceSource result = DifferenceSource.get(initialValue);

+		if (result == null)

+			throw new IllegalArgumentException(

+					"The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

+		return result;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public String convertDifferenceSourceToString(EDataType eDataType, Object instanceValue) {

+		return instanceValue == null ? null : instanceValue.toString();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public ComparePackage getComparePackage() {

+		return (ComparePackage)getEPackage();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @deprecated

+	 * @generated

+	 */

+	@Deprecated

+	public static ComparePackage getPackage() {

+		return ComparePackage.eINSTANCE;

+	}

+

+} //CompareFactoryImpl

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/ComparePackageImpl.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/ComparePackageImpl.java
new file mode 100644
index 000000000..78d380bf0
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/ComparePackageImpl.java
@@ -0,0 +1,833 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare.impl;

+

+import org.eclipse.emf.compare.AttributeChange;

+import org.eclipse.emf.compare.CompareFactory;

+import org.eclipse.emf.compare.ComparePackage;

+import org.eclipse.emf.compare.Comparison;

+import org.eclipse.emf.compare.Conflict;

+import org.eclipse.emf.compare.Diff;

+import org.eclipse.emf.compare.DifferenceKind;

+import org.eclipse.emf.compare.DifferenceSource;

+import org.eclipse.emf.compare.Equivalence;

+import org.eclipse.emf.compare.Match;

+import org.eclipse.emf.compare.MatchResource;

+import org.eclipse.emf.compare.ReferenceChange;

+import org.eclipse.emf.compare.ResourceAttachmentChange;

+

+import org.eclipse.emf.ecore.EAttribute;

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

+import org.eclipse.emf.ecore.EEnum;

+import org.eclipse.emf.ecore.EOperation;

+import org.eclipse.emf.ecore.EPackage;

+import org.eclipse.emf.ecore.EReference;

+import org.eclipse.emf.ecore.EcorePackage;

+

+import org.eclipse.emf.ecore.impl.EPackageImpl;

+

+/**

+ * <!-- begin-user-doc -->

+ * An implementation of the model <b>Package</b>.

+ * <!-- end-user-doc -->

+ * @generated

+ */

+public class ComparePackageImpl extends EPackageImpl implements ComparePackage {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static final String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private EClass comparisonEClass = null;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private EClass matchResourceEClass = null;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private EClass matchEClass = null;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private EClass diffEClass = null;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private EClass resourceAttachmentChangeEClass = null;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private EClass referenceChangeEClass = null;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private EClass attributeChangeEClass = null;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private EClass conflictEClass = null;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private EClass equivalenceEClass = null;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private EEnum differenceKindEEnum = null;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private EEnum differenceSourceEEnum = null;

+

+	/**

+	 * Creates an instance of the model <b>Package</b>, registered with

+	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package

+	 * package URI value.

+	 * <p>Note: the correct way to create the package is via the static

+	 * factory method {@link #init init()}, which also performs

+	 * initialization of the package, or returns the registered package,

+	 * if one already exists.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see org.eclipse.emf.ecore.EPackage.Registry

+	 * @see org.eclipse.emf.compare.ComparePackage#eNS_URI

+	 * @see #init()

+	 * @generated

+	 */

+	private ComparePackageImpl() {

+		super(eNS_URI, CompareFactory.eINSTANCE);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private static boolean isInited = false;

+

+	/**

+	 * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon which it depends.

+	 * 

+	 * <p>This method is used to initialize {@link ComparePackage#eINSTANCE} when that field is accessed.

+	 * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #eNS_URI

+	 * @see #createPackageContents()

+	 * @see #initializePackageContents()

+	 * @generated

+	 */

+	public static ComparePackage init() {

+		if (isInited)

+			return (ComparePackage)EPackage.Registry.INSTANCE.getEPackage(ComparePackage.eNS_URI);

+

+		// Obtain or create and register package

+		ComparePackageImpl theComparePackage = (ComparePackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof ComparePackageImpl ? EPackage.Registry.INSTANCE

+				.get(eNS_URI)

+				: new ComparePackageImpl());

+

+		isInited = true;

+

+		// Initialize simple dependencies

+		EcorePackage.eINSTANCE.eClass();

+

+		// Create package meta-data objects

+		theComparePackage.createPackageContents();

+

+		// Initialize created meta-data

+		theComparePackage.initializePackageContents();

+

+		// Mark meta-data to indicate it can't be changed

+		theComparePackage.freeze();

+

+		// Update the registry and return the package

+		EPackage.Registry.INSTANCE.put(ComparePackage.eNS_URI, theComparePackage);

+		return theComparePackage;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EClass getComparison() {

+		return comparisonEClass;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getComparison_MatchedResources() {

+		return (EReference)comparisonEClass.getEStructuralFeatures().get(0);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getComparison_Matches() {

+		return (EReference)comparisonEClass.getEStructuralFeatures().get(1);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getComparison_Conflicts() {

+		return (EReference)comparisonEClass.getEStructuralFeatures().get(2);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EClass getMatchResource() {

+		return matchResourceEClass;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EAttribute getMatchResource_LeftURI() {

+		return (EAttribute)matchResourceEClass.getEStructuralFeatures().get(0);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EAttribute getMatchResource_RightURI() {

+		return (EAttribute)matchResourceEClass.getEStructuralFeatures().get(1);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EAttribute getMatchResource_OriginURI() {

+		return (EAttribute)matchResourceEClass.getEStructuralFeatures().get(2);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EClass getMatch() {

+		return matchEClass;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getMatch_SubMatches() {

+		return (EReference)matchEClass.getEStructuralFeatures().get(0);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getMatch_Differences() {

+		return (EReference)matchEClass.getEStructuralFeatures().get(1);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getMatch_Left() {

+		return (EReference)matchEClass.getEStructuralFeatures().get(2);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getMatch_Right() {

+		return (EReference)matchEClass.getEStructuralFeatures().get(3);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getMatch_Origin() {

+		return (EReference)matchEClass.getEStructuralFeatures().get(4);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EClass getDiff() {

+		return diffEClass;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getDiff_Match() {

+		return (EReference)diffEClass.getEStructuralFeatures().get(0);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getDiff_Requires() {

+		return (EReference)diffEClass.getEStructuralFeatures().get(1);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getDiff_RequiredBy() {

+		return (EReference)diffEClass.getEStructuralFeatures().get(2);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getDiff_Refines() {

+		return (EReference)diffEClass.getEStructuralFeatures().get(3);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getDiff_RefinedBy() {

+		return (EReference)diffEClass.getEStructuralFeatures().get(4);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EAttribute getDiff_Kind() {

+		return (EAttribute)diffEClass.getEStructuralFeatures().get(5);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getDiff_EquivalentDiffs() {

+		return (EReference)diffEClass.getEStructuralFeatures().get(6);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getDiff_Conflict() {

+		return (EReference)diffEClass.getEStructuralFeatures().get(7);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EClass getResourceAttachmentChange() {

+		return resourceAttachmentChangeEClass;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EAttribute getResourceAttachmentChange_ResourceURI() {

+		return (EAttribute)resourceAttachmentChangeEClass.getEStructuralFeatures().get(0);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EClass getReferenceChange() {

+		return referenceChangeEClass;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getReferenceChange_Reference() {

+		return (EReference)referenceChangeEClass.getEStructuralFeatures().get(0);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getReferenceChange_Value() {

+		return (EReference)referenceChangeEClass.getEStructuralFeatures().get(1);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EClass getAttributeChange() {

+		return attributeChangeEClass;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getAttributeChange_Attribute() {

+		return (EReference)attributeChangeEClass.getEStructuralFeatures().get(0);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EAttribute getAttributeChange_Value() {

+		return (EAttribute)attributeChangeEClass.getEStructuralFeatures().get(1);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EClass getConflict() {

+		return conflictEClass;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getConflict_Differences() {

+		return (EReference)conflictEClass.getEStructuralFeatures().get(0);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EClass getEquivalence() {

+		return equivalenceEClass;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getEquivalence_Differences() {

+		return (EReference)equivalenceEClass.getEStructuralFeatures().get(0);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EEnum getDifferenceKind() {

+		return differenceKindEEnum;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EEnum getDifferenceSource() {

+		return differenceSourceEEnum;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public CompareFactory getCompareFactory() {

+		return (CompareFactory)getEFactoryInstance();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private boolean isCreated = false;

+

+	/**

+	 * Creates the meta-model objects for the package.  This method is

+	 * guarded to have no affect on any invocation but its first.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void createPackageContents() {

+		if (isCreated)

+			return;

+		isCreated = true;

+

+		// Create classes and their features

+		comparisonEClass = createEClass(COMPARISON);

+		createEReference(comparisonEClass, COMPARISON__MATCHED_RESOURCES);

+		createEReference(comparisonEClass, COMPARISON__MATCHES);

+		createEReference(comparisonEClass, COMPARISON__CONFLICTS);

+

+		matchResourceEClass = createEClass(MATCH_RESOURCE);

+		createEAttribute(matchResourceEClass, MATCH_RESOURCE__LEFT_URI);

+		createEAttribute(matchResourceEClass, MATCH_RESOURCE__RIGHT_URI);

+		createEAttribute(matchResourceEClass, MATCH_RESOURCE__ORIGIN_URI);

+

+		matchEClass = createEClass(MATCH);

+		createEReference(matchEClass, MATCH__SUB_MATCHES);

+		createEReference(matchEClass, MATCH__DIFFERENCES);

+		createEReference(matchEClass, MATCH__LEFT);

+		createEReference(matchEClass, MATCH__RIGHT);

+		createEReference(matchEClass, MATCH__ORIGIN);

+

+		diffEClass = createEClass(DIFF);

+		createEReference(diffEClass, DIFF__MATCH);

+		createEReference(diffEClass, DIFF__REQUIRES);

+		createEReference(diffEClass, DIFF__REQUIRED_BY);

+		createEReference(diffEClass, DIFF__REFINES);

+		createEReference(diffEClass, DIFF__REFINED_BY);

+		createEAttribute(diffEClass, DIFF__KIND);

+		createEReference(diffEClass, DIFF__EQUIVALENT_DIFFS);

+		createEReference(diffEClass, DIFF__CONFLICT);

+

+		resourceAttachmentChangeEClass = createEClass(RESOURCE_ATTACHMENT_CHANGE);

+		createEAttribute(resourceAttachmentChangeEClass, RESOURCE_ATTACHMENT_CHANGE__RESOURCE_URI);

+

+		referenceChangeEClass = createEClass(REFERENCE_CHANGE);

+		createEReference(referenceChangeEClass, REFERENCE_CHANGE__REFERENCE);

+		createEReference(referenceChangeEClass, REFERENCE_CHANGE__VALUE);

+

+		attributeChangeEClass = createEClass(ATTRIBUTE_CHANGE);

+		createEReference(attributeChangeEClass, ATTRIBUTE_CHANGE__ATTRIBUTE);

+		createEAttribute(attributeChangeEClass, ATTRIBUTE_CHANGE__VALUE);

+

+		conflictEClass = createEClass(CONFLICT);

+		createEReference(conflictEClass, CONFLICT__DIFFERENCES);

+

+		equivalenceEClass = createEClass(EQUIVALENCE);

+		createEReference(equivalenceEClass, EQUIVALENCE__DIFFERENCES);

+

+		// Create enums

+		differenceKindEEnum = createEEnum(DIFFERENCE_KIND);

+		differenceSourceEEnum = createEEnum(DIFFERENCE_SOURCE);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	private boolean isInitialized = false;

+

+	/**

+	 * Complete the initialization of the package and its meta-model.  This

+	 * method is guarded to have no affect on any invocation but its first.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void initializePackageContents() {

+		if (isInitialized)

+			return;

+		isInitialized = true;

+

+		// Initialize package

+		setName(eNAME);

+		setNsPrefix(eNS_PREFIX);

+		setNsURI(eNS_URI);

+

+		// Obtain other dependent packages

+		EcorePackage theEcorePackage = (EcorePackage)EPackage.Registry.INSTANCE

+				.getEPackage(EcorePackage.eNS_URI);

+

+		// Create type parameters

+

+		// Set bounds for type parameters

+

+		// Add supertypes to classes

+		resourceAttachmentChangeEClass.getESuperTypes().add(this.getDiff());

+		referenceChangeEClass.getESuperTypes().add(this.getDiff());

+		attributeChangeEClass.getESuperTypes().add(this.getDiff());

+

+		// Initialize classes and features; add operations and parameters

+		initEClass(comparisonEClass, Comparison.class,

+				"Comparison", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$

+		initEReference(

+				getComparison_MatchedResources(),

+				this.getMatchResource(),

+				null,

+				"matchedResources", null, 0, -1, Comparison.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+		initEReference(

+				getComparison_Matches(),

+				this.getMatch(),

+				null,

+				"matches", null, 0, -1, Comparison.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+		initEReference(

+				getComparison_Conflicts(),

+				this.getConflict(),

+				null,

+				"conflicts", null, 0, -1, Comparison.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+

+		addEOperation(comparisonEClass, this.getDiff(), "getDifferences", 0, -1, IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$

+

+		EOperation op = addEOperation(comparisonEClass, this.getDiff(),

+				"getDifferences", 0, -1, IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$

+		addEParameter(op, theEcorePackage.getEObject(), "element", 0, 1, IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$

+

+		op = addEOperation(comparisonEClass, this.getMatch(), "getMatch", 0, 1, IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$

+		addEParameter(op, theEcorePackage.getEObject(), "element", 0, 1, IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$

+

+		op = addEOperation(comparisonEClass, null, "addDiff", 0, 1, IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$

+		addEParameter(op, theEcorePackage.getEObject(), "element", 0, 1, IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$

+		addEParameter(op, this.getDiff(), "newDiff", 0, 1, IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$

+

+		initEClass(matchResourceEClass, MatchResource.class,

+				"MatchResource", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$

+		initEAttribute(

+				getMatchResource_LeftURI(),

+				ecorePackage.getEString(),

+				"leftURI", null, 1, 1, MatchResource.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+		initEAttribute(

+				getMatchResource_RightURI(),

+				ecorePackage.getEString(),

+				"rightURI", null, 1, 1, MatchResource.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+		initEAttribute(

+				getMatchResource_OriginURI(),

+				ecorePackage.getEString(),

+				"originURI", null, 0, 1, MatchResource.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+

+		initEClass(matchEClass, Match.class,

+				"Match", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$

+		initEReference(

+				getMatch_SubMatches(),

+				this.getMatch(),

+				null,

+				"subMatches", null, 0, -1, Match.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+		initEReference(

+				getMatch_Differences(),

+				this.getDiff(),

+				this.getDiff_Match(),

+				"differences", null, 0, -1, Match.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+		initEReference(

+				getMatch_Left(),

+				ecorePackage.getEObject(),

+				null,

+				"left", null, 0, 1, Match.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+		initEReference(

+				getMatch_Right(),

+				ecorePackage.getEObject(),

+				null,

+				"right", null, 0, 1, Match.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+		initEReference(

+				getMatch_Origin(),

+				ecorePackage.getEObject(),

+				null,

+				"origin", null, 0, 1, Match.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+

+		initEClass(diffEClass, Diff.class, "Diff", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$

+		initEReference(

+				getDiff_Match(),

+				this.getMatch(),

+				this.getMatch_Differences(),

+				"match", null, 1, 1, Diff.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+		initEReference(

+				getDiff_Requires(),

+				this.getDiff(),

+				this.getDiff_RequiredBy(),

+				"requires", null, 0, -1, Diff.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+		initEReference(

+				getDiff_RequiredBy(),

+				this.getDiff(),

+				this.getDiff_Requires(),

+				"requiredBy", null, 0, -1, Diff.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+		initEReference(

+				getDiff_Refines(),

+				this.getDiff(),

+				this.getDiff_RefinedBy(),

+				"refines", null, 0, -1, Diff.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+		initEReference(

+				getDiff_RefinedBy(),

+				this.getDiff(),

+				this.getDiff_Refines(),

+				"refinedBy", null, 0, -1, Diff.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+		initEAttribute(

+				getDiff_Kind(),

+				this.getDifferenceKind(),

+				"kind", null, 1, 1, Diff.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+		initEReference(

+				getDiff_EquivalentDiffs(),

+				this.getEquivalence(),

+				this.getEquivalence_Differences(),

+				"equivalentDiffs", null, 0, 1, Diff.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+		initEReference(

+				getDiff_Conflict(),

+				this.getConflict(),

+				this.getConflict_Differences(),

+				"conflict", null, 0, 1, Diff.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+

+		addEOperation(diffEClass, this.getDifferenceSource(), "getSource", 0, 1, IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$

+

+		addEOperation(diffEClass, null, "apply", 0, 1, IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$

+

+		addEOperation(diffEClass, null, "reverse", 0, 1, IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$

+

+		addEOperation(diffEClass, null, "discard", 0, 1, IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$

+

+		initEClass(resourceAttachmentChangeEClass, ResourceAttachmentChange.class,

+				"ResourceAttachmentChange", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$

+		initEAttribute(

+				getResourceAttachmentChange_ResourceURI(),

+				ecorePackage.getEString(),

+				"resourceURI", null, 1, 1, ResourceAttachmentChange.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+

+		initEClass(referenceChangeEClass, ReferenceChange.class,

+				"ReferenceChange", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$

+		initEReference(

+				getReferenceChange_Reference(),

+				theEcorePackage.getEReference(),

+				null,

+				"reference", null, 1, 1, ReferenceChange.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+		initEReference(

+				getReferenceChange_Value(),

+				theEcorePackage.getEObject(),

+				null,

+				"value", null, 0, 1, ReferenceChange.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+

+		initEClass(attributeChangeEClass, AttributeChange.class,

+				"AttributeChange", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$

+		initEReference(

+				getAttributeChange_Attribute(),

+				theEcorePackage.getEAttribute(),

+				null,

+				"attribute", null, 1, 1, AttributeChange.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+		initEAttribute(

+				getAttributeChange_Value(),

+				theEcorePackage.getEJavaObject(),

+				"value", null, 0, 1, AttributeChange.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+

+		initEClass(conflictEClass, Conflict.class,

+				"Conflict", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$

+		initEReference(

+				getConflict_Differences(),

+				this.getDiff(),

+				this.getDiff_Conflict(),

+				"differences", null, 2, -1, Conflict.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+

+		addEOperation(conflictEClass, this.getDiff(), "getLeftDifferences", 1, -1, IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$

+

+		addEOperation(conflictEClass, this.getDiff(), "getRightDifferences", 1, -1, IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$

+

+		initEClass(equivalenceEClass, Equivalence.class,

+				"Equivalence", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$

+		initEReference(

+				getEquivalence_Differences(),

+				this.getDiff(),

+				this.getDiff_EquivalentDiffs(),

+				"differences", null, 2, -1, Equivalence.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

+

+		// Initialize enums and add enum literals

+		initEEnum(differenceKindEEnum, DifferenceKind.class, "DifferenceKind"); //$NON-NLS-1$

+		addEEnumLiteral(differenceKindEEnum, DifferenceKind.ADD);

+		addEEnumLiteral(differenceKindEEnum, DifferenceKind.DELETE);

+		addEEnumLiteral(differenceKindEEnum, DifferenceKind.CHANGE);

+		addEEnumLiteral(differenceKindEEnum, DifferenceKind.MOVE);

+

+		initEEnum(differenceSourceEEnum, DifferenceSource.class, "DifferenceSource"); //$NON-NLS-1$

+		addEEnumLiteral(differenceSourceEEnum, DifferenceSource.LEFT);

+		addEEnumLiteral(differenceSourceEEnum, DifferenceSource.RIGHT);

+

+		// Create resource

+		createResource(eNS_URI);

+	}

+

+} //ComparePackageImpl

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/ComparisonImpl.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/ComparisonImpl.java
new file mode 100644
index 000000000..6435a1dd6
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/ComparisonImpl.java
@@ -0,0 +1,290 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare.impl;

+

+import java.util.Collection;

+

+import org.eclipse.emf.common.notify.NotificationChain;

+

+import org.eclipse.emf.common.util.EList;

+

+import org.eclipse.emf.compare.ComparePackage;

+import org.eclipse.emf.compare.Comparison;

+import org.eclipse.emf.compare.Conflict;

+import org.eclipse.emf.compare.Diff;

+import org.eclipse.emf.compare.Match;

+import org.eclipse.emf.compare.MatchResource;

+

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

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

+import org.eclipse.emf.ecore.InternalEObject;

+

+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;

+

+import org.eclipse.emf.ecore.util.EObjectContainmentEList;

+import org.eclipse.emf.ecore.util.InternalEList;

+

+/**

+ * <!-- begin-user-doc -->

+ * An implementation of the model object '<em><b>Comparison</b></em>'.

+ * <!-- end-user-doc -->

+ * <p>

+ * The following features are implemented:

+ * <ul>

+ *   <li>{@link org.eclipse.emf.compare.impl.ComparisonImpl#getMatchedResources <em>Matched Resources</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.impl.ComparisonImpl#getMatches <em>Matches</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.impl.ComparisonImpl#getConflicts <em>Conflicts</em>}</li>

+ * </ul>

+ * </p>

+ *

+ * @generated

+ */

+public class ComparisonImpl extends MinimalEObjectImpl implements Comparison {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static final String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * The cached value of the '{@link #getMatchedResources() <em>Matched Resources</em>}' containment reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getMatchedResources()

+	 * @generated

+	 * @ordered

+	 */

+	protected EList<MatchResource> matchedResources;

+

+	/**

+	 * The cached value of the '{@link #getMatches() <em>Matches</em>}' containment reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getMatches()

+	 * @generated

+	 * @ordered

+	 */

+	protected EList<Match> matches;

+

+	/**

+	 * The cached value of the '{@link #getConflicts() <em>Conflicts</em>}' containment reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getConflicts()

+	 * @generated

+	 * @ordered

+	 */

+	protected EList<Conflict> conflicts;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	protected ComparisonImpl() {

+		super();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	protected EClass eStaticClass() {

+		return ComparePackage.Literals.COMPARISON;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EList<MatchResource> getMatchedResources() {

+		if (matchedResources == null) {

+			matchedResources = new EObjectContainmentEList<MatchResource>(MatchResource.class, this,

+					ComparePackage.COMPARISON__MATCHED_RESOURCES);

+		}

+		return matchedResources;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EList<Match> getMatches() {

+		if (matches == null) {

+			matches = new EObjectContainmentEList<Match>(Match.class, this,

+					ComparePackage.COMPARISON__MATCHES);

+		}

+		return matches;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EList<Conflict> getConflicts() {

+		if (conflicts == null) {

+			conflicts = new EObjectContainmentEList<Conflict>(Conflict.class, this,

+					ComparePackage.COMPARISON__CONFLICTS);

+		}

+		return conflicts;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EList<Diff> getDifferences() {

+		// TODO: implement this method

+		// Ensure that you remove @generated or mark it @generated NOT

+		throw new UnsupportedOperationException();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EList<Diff> getDifferences(EObject element) {

+		// TODO: implement this method

+		// Ensure that you remove @generated or mark it @generated NOT

+		throw new UnsupportedOperationException();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public Match getMatch(EObject element) {

+		// TODO: implement this method

+		// Ensure that you remove @generated or mark it @generated NOT

+		throw new UnsupportedOperationException();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void addDiff(EObject element, Diff newDiff) {

+		// TODO: implement this method

+		// Ensure that you remove @generated or mark it @generated NOT

+		throw new UnsupportedOperationException();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {

+		switch (featureID) {

+			case ComparePackage.COMPARISON__MATCHED_RESOURCES:

+				return ((InternalEList<?>)getMatchedResources()).basicRemove(otherEnd, msgs);

+			case ComparePackage.COMPARISON__MATCHES:

+				return ((InternalEList<?>)getMatches()).basicRemove(otherEnd, msgs);

+			case ComparePackage.COMPARISON__CONFLICTS:

+				return ((InternalEList<?>)getConflicts()).basicRemove(otherEnd, msgs);

+		}

+		return super.eInverseRemove(otherEnd, featureID, msgs);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public Object eGet(int featureID, boolean resolve, boolean coreType) {

+		switch (featureID) {

+			case ComparePackage.COMPARISON__MATCHED_RESOURCES:

+				return getMatchedResources();

+			case ComparePackage.COMPARISON__MATCHES:

+				return getMatches();

+			case ComparePackage.COMPARISON__CONFLICTS:

+				return getConflicts();

+		}

+		return super.eGet(featureID, resolve, coreType);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@SuppressWarnings("unchecked")

+	@Override

+	public void eSet(int featureID, Object newValue) {

+		switch (featureID) {

+			case ComparePackage.COMPARISON__MATCHED_RESOURCES:

+				getMatchedResources().clear();

+				getMatchedResources().addAll((Collection<? extends MatchResource>)newValue);

+				return;

+			case ComparePackage.COMPARISON__MATCHES:

+				getMatches().clear();

+				getMatches().addAll((Collection<? extends Match>)newValue);

+				return;

+			case ComparePackage.COMPARISON__CONFLICTS:

+				getConflicts().clear();

+				getConflicts().addAll((Collection<? extends Conflict>)newValue);

+				return;

+		}

+		super.eSet(featureID, newValue);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public void eUnset(int featureID) {

+		switch (featureID) {

+			case ComparePackage.COMPARISON__MATCHED_RESOURCES:

+				getMatchedResources().clear();

+				return;

+			case ComparePackage.COMPARISON__MATCHES:

+				getMatches().clear();

+				return;

+			case ComparePackage.COMPARISON__CONFLICTS:

+				getConflicts().clear();

+				return;

+		}

+		super.eUnset(featureID);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public boolean eIsSet(int featureID) {

+		switch (featureID) {

+			case ComparePackage.COMPARISON__MATCHED_RESOURCES:

+				return matchedResources != null && !matchedResources.isEmpty();

+			case ComparePackage.COMPARISON__MATCHES:

+				return matches != null && !matches.isEmpty();

+			case ComparePackage.COMPARISON__CONFLICTS:

+				return conflicts != null && !conflicts.isEmpty();

+		}

+		return super.eIsSet(featureID);

+	}

+

+} //ComparisonImpl

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/ConflictImpl.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/ConflictImpl.java
new file mode 100644
index 000000000..5020f819f
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/ConflictImpl.java
@@ -0,0 +1,206 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare.impl;

+

+import java.util.Collection;

+

+import org.eclipse.emf.common.notify.NotificationChain;

+

+import org.eclipse.emf.common.util.EList;

+

+import org.eclipse.emf.compare.ComparePackage;

+import org.eclipse.emf.compare.Conflict;

+import org.eclipse.emf.compare.Diff;

+

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

+import org.eclipse.emf.ecore.InternalEObject;

+

+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;

+

+import org.eclipse.emf.ecore.util.EObjectWithInverseResolvingEList;

+import org.eclipse.emf.ecore.util.InternalEList;

+

+/**

+ * <!-- begin-user-doc -->

+ * An implementation of the model object '<em><b>Conflict</b></em>'.

+ * <!-- end-user-doc -->

+ * <p>

+ * The following features are implemented:

+ * <ul>

+ *   <li>{@link org.eclipse.emf.compare.impl.ConflictImpl#getDifferences <em>Differences</em>}</li>

+ * </ul>

+ * </p>

+ *

+ * @generated

+ */

+public class ConflictImpl extends MinimalEObjectImpl implements Conflict {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static final String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * The cached value of the '{@link #getDifferences() <em>Differences</em>}' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getDifferences()

+	 * @generated

+	 * @ordered

+	 */

+	protected EList<Diff> differences;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	protected ConflictImpl() {

+		super();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	protected EClass eStaticClass() {

+		return ComparePackage.Literals.CONFLICT;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EList<Diff> getDifferences() {

+		if (differences == null) {

+			differences = new EObjectWithInverseResolvingEList<Diff>(Diff.class, this,

+					ComparePackage.CONFLICT__DIFFERENCES, ComparePackage.DIFF__CONFLICT);

+		}

+		return differences;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EList<Diff> getLeftDifferences() {

+		// TODO: implement this method

+		// Ensure that you remove @generated or mark it @generated NOT

+		throw new UnsupportedOperationException();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EList<Diff> getRightDifferences() {

+		// TODO: implement this method

+		// Ensure that you remove @generated or mark it @generated NOT

+		throw new UnsupportedOperationException();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@SuppressWarnings("unchecked")

+	@Override

+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {

+		switch (featureID) {

+			case ComparePackage.CONFLICT__DIFFERENCES:

+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getDifferences()).basicAdd(

+						otherEnd, msgs);

+		}

+		return super.eInverseAdd(otherEnd, featureID, msgs);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {

+		switch (featureID) {

+			case ComparePackage.CONFLICT__DIFFERENCES:

+				return ((InternalEList<?>)getDifferences()).basicRemove(otherEnd, msgs);

+		}

+		return super.eInverseRemove(otherEnd, featureID, msgs);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public Object eGet(int featureID, boolean resolve, boolean coreType) {

+		switch (featureID) {

+			case ComparePackage.CONFLICT__DIFFERENCES:

+				return getDifferences();

+		}

+		return super.eGet(featureID, resolve, coreType);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@SuppressWarnings("unchecked")

+	@Override

+	public void eSet(int featureID, Object newValue) {

+		switch (featureID) {

+			case ComparePackage.CONFLICT__DIFFERENCES:

+				getDifferences().clear();

+				getDifferences().addAll((Collection<? extends Diff>)newValue);

+				return;

+		}

+		super.eSet(featureID, newValue);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public void eUnset(int featureID) {

+		switch (featureID) {

+			case ComparePackage.CONFLICT__DIFFERENCES:

+				getDifferences().clear();

+				return;

+		}

+		super.eUnset(featureID);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public boolean eIsSet(int featureID) {

+		switch (featureID) {

+			case ComparePackage.CONFLICT__DIFFERENCES:

+				return differences != null && !differences.isEmpty();

+		}

+		return super.eIsSet(featureID);

+	}

+

+} //ConflictImpl

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/DiffImpl.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/DiffImpl.java
new file mode 100644
index 000000000..a6a148066
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/DiffImpl.java
@@ -0,0 +1,703 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare.impl;

+

+import java.util.Collection;

+

+import org.eclipse.emf.common.notify.Notification;

+import org.eclipse.emf.common.notify.NotificationChain;

+

+import org.eclipse.emf.common.util.EList;

+

+import org.eclipse.emf.compare.ComparePackage;

+import org.eclipse.emf.compare.Conflict;

+import org.eclipse.emf.compare.Diff;

+import org.eclipse.emf.compare.DifferenceKind;

+import org.eclipse.emf.compare.DifferenceSource;

+import org.eclipse.emf.compare.Equivalence;

+import org.eclipse.emf.compare.Match;

+

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

+import org.eclipse.emf.ecore.InternalEObject;

+

+import org.eclipse.emf.ecore.impl.ENotificationImpl;

+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;

+

+import org.eclipse.emf.ecore.util.EObjectWithInverseResolvingEList;

+import org.eclipse.emf.ecore.util.EcoreUtil;

+import org.eclipse.emf.ecore.util.InternalEList;

+

+/**

+ * <!-- begin-user-doc -->

+ * An implementation of the model object '<em><b>Diff</b></em>'.

+ * <!-- end-user-doc -->

+ * <p>

+ * The following features are implemented:

+ * <ul>

+ *   <li>{@link org.eclipse.emf.compare.impl.DiffImpl#getMatch <em>Match</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.impl.DiffImpl#getRequires <em>Requires</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.impl.DiffImpl#getRequiredBy <em>Required By</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.impl.DiffImpl#getRefines <em>Refines</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.impl.DiffImpl#getRefinedBy <em>Refined By</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.impl.DiffImpl#getKind <em>Kind</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.impl.DiffImpl#getEquivalentDiffs <em>Equivalent Diffs</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.impl.DiffImpl#getConflict <em>Conflict</em>}</li>

+ * </ul>

+ * </p>

+ *

+ * @generated

+ */

+public class DiffImpl extends MinimalEObjectImpl implements Diff {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static final String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * The cached value of the '{@link #getRequires() <em>Requires</em>}' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getRequires()

+	 * @generated

+	 * @ordered

+	 */

+	protected EList<Diff> requires;

+

+	/**

+	 * The cached value of the '{@link #getRequiredBy() <em>Required By</em>}' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getRequiredBy()

+	 * @generated

+	 * @ordered

+	 */

+	protected EList<Diff> requiredBy;

+

+	/**

+	 * The cached value of the '{@link #getRefines() <em>Refines</em>}' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getRefines()

+	 * @generated

+	 * @ordered

+	 */

+	protected EList<Diff> refines;

+

+	/**

+	 * The cached value of the '{@link #getRefinedBy() <em>Refined By</em>}' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getRefinedBy()

+	 * @generated

+	 * @ordered

+	 */

+	protected EList<Diff> refinedBy;

+

+	/**

+	 * The default value of the '{@link #getKind() <em>Kind</em>}' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getKind()

+	 * @generated

+	 * @ordered

+	 */

+	protected static final DifferenceKind KIND_EDEFAULT = DifferenceKind.ADD;

+

+	/**

+	 * The cached value of the '{@link #getKind() <em>Kind</em>}' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getKind()

+	 * @generated

+	 * @ordered

+	 */

+	protected DifferenceKind kind = KIND_EDEFAULT;

+

+	/**

+	 * The cached value of the '{@link #getEquivalentDiffs() <em>Equivalent Diffs</em>}' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getEquivalentDiffs()

+	 * @generated

+	 * @ordered

+	 */

+	protected Equivalence equivalentDiffs;

+

+	/**

+	 * The cached value of the '{@link #getConflict() <em>Conflict</em>}' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getConflict()

+	 * @generated

+	 * @ordered

+	 */

+	protected Conflict conflict;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	protected DiffImpl() {

+		super();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	protected EClass eStaticClass() {

+		return ComparePackage.Literals.DIFF;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public Match getMatch() {

+		if (eContainerFeatureID() != ComparePackage.DIFF__MATCH)

+			return null;

+		return (Match)eContainer();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public NotificationChain basicSetMatch(Match newMatch, NotificationChain msgs) {

+		// not generated : happy compiler!

+		return eBasicSetContainer((InternalEObject)newMatch, ComparePackage.DIFF__MATCH, msgs);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void setMatch(Match newMatch) {

+		if (newMatch != eInternalContainer()

+				|| (eContainerFeatureID() != ComparePackage.DIFF__MATCH && newMatch != null)) {

+			if (EcoreUtil.isAncestor(this, newMatch))

+				throw new IllegalArgumentException("Recursive containment not allowed for " + toString()); //$NON-NLS-1$

+			NotificationChain msgs = null;

+			if (eInternalContainer() != null)

+				msgs = eBasicRemoveFromContainer(msgs);

+			if (newMatch != null)

+				msgs = ((InternalEObject)newMatch).eInverseAdd(this, ComparePackage.MATCH__DIFFERENCES,

+						Match.class, msgs);

+			msgs = basicSetMatch(newMatch, msgs);

+			if (msgs != null)

+				msgs.dispatch();

+		} else if (eNotificationRequired())

+			eNotify(new ENotificationImpl(this, Notification.SET, ComparePackage.DIFF__MATCH, newMatch,

+					newMatch));

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EList<Diff> getRequires() {

+		if (requires == null) {

+			requires = new EObjectWithInverseResolvingEList.ManyInverse<Diff>(Diff.class, this,

+					ComparePackage.DIFF__REQUIRES, ComparePackage.DIFF__REQUIRED_BY);

+		}

+		return requires;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EList<Diff> getRequiredBy() {

+		if (requiredBy == null) {

+			requiredBy = new EObjectWithInverseResolvingEList.ManyInverse<Diff>(Diff.class, this,

+					ComparePackage.DIFF__REQUIRED_BY, ComparePackage.DIFF__REQUIRES);

+		}

+		return requiredBy;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EList<Diff> getRefines() {

+		if (refines == null) {

+			refines = new EObjectWithInverseResolvingEList.ManyInverse<Diff>(Diff.class, this,

+					ComparePackage.DIFF__REFINES, ComparePackage.DIFF__REFINED_BY);

+		}

+		return refines;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EList<Diff> getRefinedBy() {

+		if (refinedBy == null) {

+			refinedBy = new EObjectWithInverseResolvingEList.ManyInverse<Diff>(Diff.class, this,

+					ComparePackage.DIFF__REFINED_BY, ComparePackage.DIFF__REFINES);

+		}

+		return refinedBy;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public DifferenceKind getKind() {

+		return kind;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void setKind(DifferenceKind newKind) {

+		DifferenceKind oldKind = kind;

+		kind = newKind == null ? KIND_EDEFAULT : newKind;

+		if (eNotificationRequired())

+			eNotify(new ENotificationImpl(this, Notification.SET, ComparePackage.DIFF__KIND, oldKind, kind));

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public Equivalence getEquivalentDiffs() {

+		if (equivalentDiffs != null && equivalentDiffs.eIsProxy()) {

+			InternalEObject oldEquivalentDiffs = (InternalEObject)equivalentDiffs;

+			equivalentDiffs = (Equivalence)eResolveProxy(oldEquivalentDiffs);

+			if (equivalentDiffs != oldEquivalentDiffs) {

+				if (eNotificationRequired())

+					eNotify(new ENotificationImpl(this, Notification.RESOLVE,

+							ComparePackage.DIFF__EQUIVALENT_DIFFS, oldEquivalentDiffs, equivalentDiffs));

+			}

+		}

+		return equivalentDiffs;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public Equivalence basicGetEquivalentDiffs() {

+		return equivalentDiffs;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public NotificationChain basicSetEquivalentDiffs(Equivalence newEquivalentDiffs, NotificationChain msgs) {

+		Equivalence oldEquivalentDiffs = equivalentDiffs;

+		equivalentDiffs = newEquivalentDiffs;

+		// not generated : happy compiler!

+		NotificationChain messages = msgs;

+		if (eNotificationRequired()) {

+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET,

+					ComparePackage.DIFF__EQUIVALENT_DIFFS, oldEquivalentDiffs, newEquivalentDiffs);

+			if (messages == null)

+				messages = notification;

+			else

+				messages.add(notification);

+		}

+		return messages;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void setEquivalentDiffs(Equivalence newEquivalentDiffs) {

+		if (newEquivalentDiffs != equivalentDiffs) {

+			NotificationChain msgs = null;

+			if (equivalentDiffs != null)

+				msgs = ((InternalEObject)equivalentDiffs).eInverseRemove(this,

+						ComparePackage.EQUIVALENCE__DIFFERENCES, Equivalence.class, msgs);

+			if (newEquivalentDiffs != null)

+				msgs = ((InternalEObject)newEquivalentDiffs).eInverseAdd(this,

+						ComparePackage.EQUIVALENCE__DIFFERENCES, Equivalence.class, msgs);

+			msgs = basicSetEquivalentDiffs(newEquivalentDiffs, msgs);

+			if (msgs != null)

+				msgs.dispatch();

+		} else if (eNotificationRequired())

+			eNotify(new ENotificationImpl(this, Notification.SET, ComparePackage.DIFF__EQUIVALENT_DIFFS,

+					newEquivalentDiffs, newEquivalentDiffs));

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public Conflict getConflict() {

+		if (conflict != null && conflict.eIsProxy()) {

+			InternalEObject oldConflict = (InternalEObject)conflict;

+			conflict = (Conflict)eResolveProxy(oldConflict);

+			if (conflict != oldConflict) {

+				if (eNotificationRequired())

+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, ComparePackage.DIFF__CONFLICT,

+							oldConflict, conflict));

+			}

+		}

+		return conflict;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public Conflict basicGetConflict() {

+		return conflict;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public NotificationChain basicSetConflict(Conflict newConflict, NotificationChain msgs) {

+		Conflict oldConflict = conflict;

+		conflict = newConflict;

+		// not generated : happy compiler!

+		NotificationChain messages = msgs;

+		if (eNotificationRequired()) {

+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET,

+					ComparePackage.DIFF__CONFLICT, oldConflict, newConflict);

+			if (messages == null)

+				messages = notification;

+			else

+				messages.add(notification);

+		}

+		return messages;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void setConflict(Conflict newConflict) {

+		if (newConflict != conflict) {

+			NotificationChain msgs = null;

+			if (conflict != null)

+				msgs = ((InternalEObject)conflict).eInverseRemove(this, ComparePackage.CONFLICT__DIFFERENCES,

+						Conflict.class, msgs);

+			if (newConflict != null)

+				msgs = ((InternalEObject)newConflict).eInverseAdd(this, ComparePackage.CONFLICT__DIFFERENCES,

+						Conflict.class, msgs);

+			msgs = basicSetConflict(newConflict, msgs);

+			if (msgs != null)

+				msgs.dispatch();

+		} else if (eNotificationRequired())

+			eNotify(new ENotificationImpl(this, Notification.SET, ComparePackage.DIFF__CONFLICT, newConflict,

+					newConflict));

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public DifferenceSource getSource() {

+		// TODO: implement this method

+		// Ensure that you remove @generated or mark it @generated NOT

+		throw new UnsupportedOperationException();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void apply() {

+		// TODO: implement this method

+		// Ensure that you remove @generated or mark it @generated NOT

+		throw new UnsupportedOperationException();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void reverse() {

+		// TODO: implement this method

+		// Ensure that you remove @generated or mark it @generated NOT

+		throw new UnsupportedOperationException();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void discard() {

+		// TODO: implement this method

+		// Ensure that you remove @generated or mark it @generated NOT

+		throw new UnsupportedOperationException();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@SuppressWarnings("unchecked")

+	@Override

+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {

+		// not generated : happy compiler!

+		NotificationChain messages = msgs;

+		switch (featureID) {

+			case ComparePackage.DIFF__MATCH:

+				if (eInternalContainer() != null)

+					messages = eBasicRemoveFromContainer(msgs);

+				return basicSetMatch((Match)otherEnd, messages);

+			case ComparePackage.DIFF__REQUIRES:

+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getRequires()).basicAdd(otherEnd,

+						msgs);

+			case ComparePackage.DIFF__REQUIRED_BY:

+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getRequiredBy()).basicAdd(otherEnd,

+						msgs);

+			case ComparePackage.DIFF__REFINES:

+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getRefines()).basicAdd(otherEnd,

+						msgs);

+			case ComparePackage.DIFF__REFINED_BY:

+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getRefinedBy()).basicAdd(otherEnd,

+						msgs);

+			case ComparePackage.DIFF__EQUIVALENT_DIFFS:

+				if (equivalentDiffs != null)

+					messages = ((InternalEObject)equivalentDiffs).eInverseRemove(this,

+							ComparePackage.EQUIVALENCE__DIFFERENCES, Equivalence.class, msgs);

+				return basicSetEquivalentDiffs((Equivalence)otherEnd, messages);

+			case ComparePackage.DIFF__CONFLICT:

+				if (conflict != null)

+					messages = ((InternalEObject)conflict).eInverseRemove(this,

+							ComparePackage.CONFLICT__DIFFERENCES, Conflict.class, msgs);

+				return basicSetConflict((Conflict)otherEnd, messages);

+		}

+		return super.eInverseAdd(otherEnd, featureID, msgs);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {

+		switch (featureID) {

+			case ComparePackage.DIFF__MATCH:

+				return basicSetMatch(null, msgs);

+			case ComparePackage.DIFF__REQUIRES:

+				return ((InternalEList<?>)getRequires()).basicRemove(otherEnd, msgs);

+			case ComparePackage.DIFF__REQUIRED_BY:

+				return ((InternalEList<?>)getRequiredBy()).basicRemove(otherEnd, msgs);

+			case ComparePackage.DIFF__REFINES:

+				return ((InternalEList<?>)getRefines()).basicRemove(otherEnd, msgs);

+			case ComparePackage.DIFF__REFINED_BY:

+				return ((InternalEList<?>)getRefinedBy()).basicRemove(otherEnd, msgs);

+			case ComparePackage.DIFF__EQUIVALENT_DIFFS:

+				return basicSetEquivalentDiffs(null, msgs);

+			case ComparePackage.DIFF__CONFLICT:

+				return basicSetConflict(null, msgs);

+		}

+		return super.eInverseRemove(otherEnd, featureID, msgs);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {

+		switch (eContainerFeatureID()) {

+			case ComparePackage.DIFF__MATCH:

+				return eInternalContainer().eInverseRemove(this, ComparePackage.MATCH__DIFFERENCES,

+						Match.class, msgs);

+		}

+		return super.eBasicRemoveFromContainerFeature(msgs);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public Object eGet(int featureID, boolean resolve, boolean coreType) {

+		switch (featureID) {

+			case ComparePackage.DIFF__MATCH:

+				return getMatch();

+			case ComparePackage.DIFF__REQUIRES:

+				return getRequires();

+			case ComparePackage.DIFF__REQUIRED_BY:

+				return getRequiredBy();

+			case ComparePackage.DIFF__REFINES:

+				return getRefines();

+			case ComparePackage.DIFF__REFINED_BY:

+				return getRefinedBy();

+			case ComparePackage.DIFF__KIND:

+				return getKind();

+			case ComparePackage.DIFF__EQUIVALENT_DIFFS:

+				if (resolve)

+					return getEquivalentDiffs();

+				return basicGetEquivalentDiffs();

+			case ComparePackage.DIFF__CONFLICT:

+				if (resolve)

+					return getConflict();

+				return basicGetConflict();

+		}

+		return super.eGet(featureID, resolve, coreType);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@SuppressWarnings("unchecked")

+	@Override

+	public void eSet(int featureID, Object newValue) {

+		switch (featureID) {

+			case ComparePackage.DIFF__MATCH:

+				setMatch((Match)newValue);

+				return;

+			case ComparePackage.DIFF__REQUIRES:

+				getRequires().clear();

+				getRequires().addAll((Collection<? extends Diff>)newValue);

+				return;

+			case ComparePackage.DIFF__REQUIRED_BY:

+				getRequiredBy().clear();

+				getRequiredBy().addAll((Collection<? extends Diff>)newValue);

+				return;

+			case ComparePackage.DIFF__REFINES:

+				getRefines().clear();

+				getRefines().addAll((Collection<? extends Diff>)newValue);

+				return;

+			case ComparePackage.DIFF__REFINED_BY:

+				getRefinedBy().clear();

+				getRefinedBy().addAll((Collection<? extends Diff>)newValue);

+				return;

+			case ComparePackage.DIFF__KIND:

+				setKind((DifferenceKind)newValue);

+				return;

+			case ComparePackage.DIFF__EQUIVALENT_DIFFS:

+				setEquivalentDiffs((Equivalence)newValue);

+				return;

+			case ComparePackage.DIFF__CONFLICT:

+				setConflict((Conflict)newValue);

+				return;

+		}

+		super.eSet(featureID, newValue);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public void eUnset(int featureID) {

+		switch (featureID) {

+			case ComparePackage.DIFF__MATCH:

+				setMatch((Match)null);

+				return;

+			case ComparePackage.DIFF__REQUIRES:

+				getRequires().clear();

+				return;

+			case ComparePackage.DIFF__REQUIRED_BY:

+				getRequiredBy().clear();

+				return;

+			case ComparePackage.DIFF__REFINES:

+				getRefines().clear();

+				return;

+			case ComparePackage.DIFF__REFINED_BY:

+				getRefinedBy().clear();

+				return;

+			case ComparePackage.DIFF__KIND:

+				setKind(KIND_EDEFAULT);

+				return;

+			case ComparePackage.DIFF__EQUIVALENT_DIFFS:

+				setEquivalentDiffs((Equivalence)null);

+				return;

+			case ComparePackage.DIFF__CONFLICT:

+				setConflict((Conflict)null);

+				return;

+		}

+		super.eUnset(featureID);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public boolean eIsSet(int featureID) {

+		switch (featureID) {

+			case ComparePackage.DIFF__MATCH:

+				return getMatch() != null;

+			case ComparePackage.DIFF__REQUIRES:

+				return requires != null && !requires.isEmpty();

+			case ComparePackage.DIFF__REQUIRED_BY:

+				return requiredBy != null && !requiredBy.isEmpty();

+			case ComparePackage.DIFF__REFINES:

+				return refines != null && !refines.isEmpty();

+			case ComparePackage.DIFF__REFINED_BY:

+				return refinedBy != null && !refinedBy.isEmpty();

+			case ComparePackage.DIFF__KIND:

+				return kind != KIND_EDEFAULT;

+			case ComparePackage.DIFF__EQUIVALENT_DIFFS:

+				return equivalentDiffs != null;

+			case ComparePackage.DIFF__CONFLICT:

+				return conflict != null;

+		}

+		return super.eIsSet(featureID);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public String toString() {

+		if (eIsProxy())

+			return super.toString();

+

+		StringBuffer result = new StringBuffer(super.toString());

+		result.append(" (kind: "); //$NON-NLS-1$

+		result.append(kind);

+		result.append(')');

+		return result.toString();

+	}

+

+} //DiffImpl

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/EquivalenceImpl.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/EquivalenceImpl.java
new file mode 100644
index 000000000..9a6557baa
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/EquivalenceImpl.java
@@ -0,0 +1,184 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare.impl;

+

+import java.util.Collection;

+

+import org.eclipse.emf.common.notify.NotificationChain;

+

+import org.eclipse.emf.common.util.EList;

+

+import org.eclipse.emf.compare.ComparePackage;

+import org.eclipse.emf.compare.Diff;

+import org.eclipse.emf.compare.Equivalence;

+

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

+import org.eclipse.emf.ecore.InternalEObject;

+

+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;

+

+import org.eclipse.emf.ecore.util.EObjectWithInverseResolvingEList;

+import org.eclipse.emf.ecore.util.InternalEList;

+

+/**

+ * <!-- begin-user-doc -->

+ * An implementation of the model object '<em><b>Equivalence</b></em>'.

+ * <!-- end-user-doc -->

+ * <p>

+ * The following features are implemented:

+ * <ul>

+ *   <li>{@link org.eclipse.emf.compare.impl.EquivalenceImpl#getDifferences <em>Differences</em>}</li>

+ * </ul>

+ * </p>

+ *

+ * @generated

+ */

+public class EquivalenceImpl extends MinimalEObjectImpl implements Equivalence {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static final String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * The cached value of the '{@link #getDifferences() <em>Differences</em>}' reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getDifferences()

+	 * @generated

+	 * @ordered

+	 */

+	protected EList<Diff> differences;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	protected EquivalenceImpl() {

+		super();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	protected EClass eStaticClass() {

+		return ComparePackage.Literals.EQUIVALENCE;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EList<Diff> getDifferences() {

+		if (differences == null) {

+			differences = new EObjectWithInverseResolvingEList<Diff>(Diff.class, this,

+					ComparePackage.EQUIVALENCE__DIFFERENCES, ComparePackage.DIFF__EQUIVALENT_DIFFS);

+		}

+		return differences;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@SuppressWarnings("unchecked")

+	@Override

+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {

+		switch (featureID) {

+			case ComparePackage.EQUIVALENCE__DIFFERENCES:

+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getDifferences()).basicAdd(

+						otherEnd, msgs);

+		}

+		return super.eInverseAdd(otherEnd, featureID, msgs);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {

+		switch (featureID) {

+			case ComparePackage.EQUIVALENCE__DIFFERENCES:

+				return ((InternalEList<?>)getDifferences()).basicRemove(otherEnd, msgs);

+		}

+		return super.eInverseRemove(otherEnd, featureID, msgs);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public Object eGet(int featureID, boolean resolve, boolean coreType) {

+		switch (featureID) {

+			case ComparePackage.EQUIVALENCE__DIFFERENCES:

+				return getDifferences();

+		}

+		return super.eGet(featureID, resolve, coreType);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@SuppressWarnings("unchecked")

+	@Override

+	public void eSet(int featureID, Object newValue) {

+		switch (featureID) {

+			case ComparePackage.EQUIVALENCE__DIFFERENCES:

+				getDifferences().clear();

+				getDifferences().addAll((Collection<? extends Diff>)newValue);

+				return;

+		}

+		super.eSet(featureID, newValue);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public void eUnset(int featureID) {

+		switch (featureID) {

+			case ComparePackage.EQUIVALENCE__DIFFERENCES:

+				getDifferences().clear();

+				return;

+		}

+		super.eUnset(featureID);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public boolean eIsSet(int featureID) {

+		switch (featureID) {

+			case ComparePackage.EQUIVALENCE__DIFFERENCES:

+				return differences != null && !differences.isEmpty();

+		}

+		return super.eIsSet(featureID);

+	}

+

+} //EquivalenceImpl

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/MatchImpl.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/MatchImpl.java
new file mode 100644
index 000000000..86a447598
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/MatchImpl.java
@@ -0,0 +1,413 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare.impl;

+

+import java.util.Collection;

+

+import org.eclipse.emf.common.notify.Notification;

+import org.eclipse.emf.common.notify.NotificationChain;

+

+import org.eclipse.emf.common.util.EList;

+

+import org.eclipse.emf.compare.ComparePackage;

+import org.eclipse.emf.compare.Diff;

+import org.eclipse.emf.compare.Match;

+

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

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

+import org.eclipse.emf.ecore.InternalEObject;

+

+import org.eclipse.emf.ecore.impl.ENotificationImpl;

+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;

+

+import org.eclipse.emf.ecore.util.EObjectContainmentEList;

+import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;

+import org.eclipse.emf.ecore.util.InternalEList;

+

+/**

+ * <!-- begin-user-doc -->

+ * An implementation of the model object '<em><b>Match</b></em>'.

+ * <!-- end-user-doc -->

+ * <p>

+ * The following features are implemented:

+ * <ul>

+ *   <li>{@link org.eclipse.emf.compare.impl.MatchImpl#getSubMatches <em>Sub Matches</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.impl.MatchImpl#getDifferences <em>Differences</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.impl.MatchImpl#getLeft <em>Left</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.impl.MatchImpl#getRight <em>Right</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.impl.MatchImpl#getOrigin <em>Origin</em>}</li>

+ * </ul>

+ * </p>

+ *

+ * @generated

+ */

+public class MatchImpl extends MinimalEObjectImpl implements Match {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static final String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * The cached value of the '{@link #getSubMatches() <em>Sub Matches</em>}' containment reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getSubMatches()

+	 * @generated

+	 * @ordered

+	 */

+	protected EList<Match> subMatches;

+

+	/**

+	 * The cached value of the '{@link #getDifferences() <em>Differences</em>}' containment reference list.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getDifferences()

+	 * @generated

+	 * @ordered

+	 */

+	protected EList<Diff> differences;

+

+	/**

+	 * The cached value of the '{@link #getLeft() <em>Left</em>}' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getLeft()

+	 * @generated

+	 * @ordered

+	 */

+	protected EObject left;

+

+	/**

+	 * The cached value of the '{@link #getRight() <em>Right</em>}' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getRight()

+	 * @generated

+	 * @ordered

+	 */

+	protected EObject right;

+

+	/**

+	 * The cached value of the '{@link #getOrigin() <em>Origin</em>}' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getOrigin()

+	 * @generated

+	 * @ordered

+	 */

+	protected EObject origin;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	protected MatchImpl() {

+		super();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	protected EClass eStaticClass() {

+		return ComparePackage.Literals.MATCH;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EList<Match> getSubMatches() {

+		if (subMatches == null) {

+			subMatches = new EObjectContainmentEList<Match>(Match.class, this,

+					ComparePackage.MATCH__SUB_MATCHES);

+		}

+		return subMatches;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EList<Diff> getDifferences() {

+		if (differences == null) {

+			differences = new EObjectContainmentWithInverseEList<Diff>(Diff.class, this,

+					ComparePackage.MATCH__DIFFERENCES, ComparePackage.DIFF__MATCH);

+		}

+		return differences;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EObject getLeft() {

+		if (left != null && left.eIsProxy()) {

+			InternalEObject oldLeft = (InternalEObject)left;

+			left = eResolveProxy(oldLeft);

+			if (left != oldLeft) {

+				if (eNotificationRequired())

+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, ComparePackage.MATCH__LEFT,

+							oldLeft, left));

+			}

+		}

+		return left;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EObject basicGetLeft() {

+		return left;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void setLeft(EObject newLeft) {

+		EObject oldLeft = left;

+		left = newLeft;

+		if (eNotificationRequired())

+			eNotify(new ENotificationImpl(this, Notification.SET, ComparePackage.MATCH__LEFT, oldLeft, left));

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EObject getRight() {

+		if (right != null && right.eIsProxy()) {

+			InternalEObject oldRight = (InternalEObject)right;

+			right = eResolveProxy(oldRight);

+			if (right != oldRight) {

+				if (eNotificationRequired())

+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, ComparePackage.MATCH__RIGHT,

+							oldRight, right));

+			}

+		}

+		return right;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EObject basicGetRight() {

+		return right;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void setRight(EObject newRight) {

+		EObject oldRight = right;

+		right = newRight;

+		if (eNotificationRequired())

+			eNotify(new ENotificationImpl(this, Notification.SET, ComparePackage.MATCH__RIGHT, oldRight,

+					right));

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EObject getOrigin() {

+		if (origin != null && origin.eIsProxy()) {

+			InternalEObject oldOrigin = (InternalEObject)origin;

+			origin = eResolveProxy(oldOrigin);

+			if (origin != oldOrigin) {

+				if (eNotificationRequired())

+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, ComparePackage.MATCH__ORIGIN,

+							oldOrigin, origin));

+			}

+		}

+		return origin;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EObject basicGetOrigin() {

+		return origin;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void setOrigin(EObject newOrigin) {

+		EObject oldOrigin = origin;

+		origin = newOrigin;

+		if (eNotificationRequired())

+			eNotify(new ENotificationImpl(this, Notification.SET, ComparePackage.MATCH__ORIGIN, oldOrigin,

+					origin));

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@SuppressWarnings("unchecked")

+	@Override

+	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {

+		switch (featureID) {

+			case ComparePackage.MATCH__DIFFERENCES:

+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getDifferences()).basicAdd(

+						otherEnd, msgs);

+		}

+		return super.eInverseAdd(otherEnd, featureID, msgs);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {

+		switch (featureID) {

+			case ComparePackage.MATCH__SUB_MATCHES:

+				return ((InternalEList<?>)getSubMatches()).basicRemove(otherEnd, msgs);

+			case ComparePackage.MATCH__DIFFERENCES:

+				return ((InternalEList<?>)getDifferences()).basicRemove(otherEnd, msgs);

+		}

+		return super.eInverseRemove(otherEnd, featureID, msgs);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public Object eGet(int featureID, boolean resolve, boolean coreType) {

+		switch (featureID) {

+			case ComparePackage.MATCH__SUB_MATCHES:

+				return getSubMatches();

+			case ComparePackage.MATCH__DIFFERENCES:

+				return getDifferences();

+			case ComparePackage.MATCH__LEFT:

+				if (resolve)

+					return getLeft();

+				return basicGetLeft();

+			case ComparePackage.MATCH__RIGHT:

+				if (resolve)

+					return getRight();

+				return basicGetRight();

+			case ComparePackage.MATCH__ORIGIN:

+				if (resolve)

+					return getOrigin();

+				return basicGetOrigin();

+		}

+		return super.eGet(featureID, resolve, coreType);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@SuppressWarnings("unchecked")

+	@Override

+	public void eSet(int featureID, Object newValue) {

+		switch (featureID) {

+			case ComparePackage.MATCH__SUB_MATCHES:

+				getSubMatches().clear();

+				getSubMatches().addAll((Collection<? extends Match>)newValue);

+				return;

+			case ComparePackage.MATCH__DIFFERENCES:

+				getDifferences().clear();

+				getDifferences().addAll((Collection<? extends Diff>)newValue);

+				return;

+			case ComparePackage.MATCH__LEFT:

+				setLeft((EObject)newValue);

+				return;

+			case ComparePackage.MATCH__RIGHT:

+				setRight((EObject)newValue);

+				return;

+			case ComparePackage.MATCH__ORIGIN:

+				setOrigin((EObject)newValue);

+				return;

+		}

+		super.eSet(featureID, newValue);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public void eUnset(int featureID) {

+		switch (featureID) {

+			case ComparePackage.MATCH__SUB_MATCHES:

+				getSubMatches().clear();

+				return;

+			case ComparePackage.MATCH__DIFFERENCES:

+				getDifferences().clear();

+				return;

+			case ComparePackage.MATCH__LEFT:

+				setLeft((EObject)null);

+				return;

+			case ComparePackage.MATCH__RIGHT:

+				setRight((EObject)null);

+				return;

+			case ComparePackage.MATCH__ORIGIN:

+				setOrigin((EObject)null);

+				return;

+		}

+		super.eUnset(featureID);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public boolean eIsSet(int featureID) {

+		switch (featureID) {

+			case ComparePackage.MATCH__SUB_MATCHES:

+				return subMatches != null && !subMatches.isEmpty();

+			case ComparePackage.MATCH__DIFFERENCES:

+				return differences != null && !differences.isEmpty();

+			case ComparePackage.MATCH__LEFT:

+				return left != null;

+			case ComparePackage.MATCH__RIGHT:

+				return right != null;

+			case ComparePackage.MATCH__ORIGIN:

+				return origin != null;

+		}

+		return super.eIsSet(featureID);

+	}

+

+} //MatchImpl

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/MatchResourceImpl.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/MatchResourceImpl.java
new file mode 100644
index 000000000..7fca242b5
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/MatchResourceImpl.java
@@ -0,0 +1,291 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare.impl;

+

+import org.eclipse.emf.common.notify.Notification;

+

+import org.eclipse.emf.compare.ComparePackage;

+import org.eclipse.emf.compare.MatchResource;

+

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

+

+import org.eclipse.emf.ecore.impl.ENotificationImpl;

+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;

+

+/**

+ * <!-- begin-user-doc -->

+ * An implementation of the model object '<em><b>Match Resource</b></em>'.

+ * <!-- end-user-doc -->

+ * <p>

+ * The following features are implemented:

+ * <ul>

+ *   <li>{@link org.eclipse.emf.compare.impl.MatchResourceImpl#getLeftURI <em>Left URI</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.impl.MatchResourceImpl#getRightURI <em>Right URI</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.impl.MatchResourceImpl#getOriginURI <em>Origin URI</em>}</li>

+ * </ul>

+ * </p>

+ *

+ * @generated

+ */

+public class MatchResourceImpl extends MinimalEObjectImpl implements MatchResource {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static final String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * The default value of the '{@link #getLeftURI() <em>Left URI</em>}' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getLeftURI()

+	 * @generated

+	 * @ordered

+	 */

+	protected static final String LEFT_URI_EDEFAULT = null;

+

+	/**

+	 * The cached value of the '{@link #getLeftURI() <em>Left URI</em>}' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getLeftURI()

+	 * @generated

+	 * @ordered

+	 */

+	protected String leftURI = LEFT_URI_EDEFAULT;

+

+	/**

+	 * The default value of the '{@link #getRightURI() <em>Right URI</em>}' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getRightURI()

+	 * @generated

+	 * @ordered

+	 */

+	protected static final String RIGHT_URI_EDEFAULT = null;

+

+	/**

+	 * The cached value of the '{@link #getRightURI() <em>Right URI</em>}' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getRightURI()

+	 * @generated

+	 * @ordered

+	 */

+	protected String rightURI = RIGHT_URI_EDEFAULT;

+

+	/**

+	 * The default value of the '{@link #getOriginURI() <em>Origin URI</em>}' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getOriginURI()

+	 * @generated

+	 * @ordered

+	 */

+	protected static final String ORIGIN_URI_EDEFAULT = null;

+

+	/**

+	 * The cached value of the '{@link #getOriginURI() <em>Origin URI</em>}' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getOriginURI()

+	 * @generated

+	 * @ordered

+	 */

+	protected String originURI = ORIGIN_URI_EDEFAULT;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	protected MatchResourceImpl() {

+		super();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	protected EClass eStaticClass() {

+		return ComparePackage.Literals.MATCH_RESOURCE;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public String getLeftURI() {

+		return leftURI;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void setLeftURI(String newLeftURI) {

+		String oldLeftURI = leftURI;

+		leftURI = newLeftURI;

+		if (eNotificationRequired())

+			eNotify(new ENotificationImpl(this, Notification.SET, ComparePackage.MATCH_RESOURCE__LEFT_URI,

+					oldLeftURI, leftURI));

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public String getRightURI() {

+		return rightURI;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void setRightURI(String newRightURI) {

+		String oldRightURI = rightURI;

+		rightURI = newRightURI;

+		if (eNotificationRequired())

+			eNotify(new ENotificationImpl(this, Notification.SET, ComparePackage.MATCH_RESOURCE__RIGHT_URI,

+					oldRightURI, rightURI));

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public String getOriginURI() {

+		return originURI;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void setOriginURI(String newOriginURI) {

+		String oldOriginURI = originURI;

+		originURI = newOriginURI;

+		if (eNotificationRequired())

+			eNotify(new ENotificationImpl(this, Notification.SET, ComparePackage.MATCH_RESOURCE__ORIGIN_URI,

+					oldOriginURI, originURI));

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public Object eGet(int featureID, boolean resolve, boolean coreType) {

+		switch (featureID) {

+			case ComparePackage.MATCH_RESOURCE__LEFT_URI:

+				return getLeftURI();

+			case ComparePackage.MATCH_RESOURCE__RIGHT_URI:

+				return getRightURI();

+			case ComparePackage.MATCH_RESOURCE__ORIGIN_URI:

+				return getOriginURI();

+		}

+		return super.eGet(featureID, resolve, coreType);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public void eSet(int featureID, Object newValue) {

+		switch (featureID) {

+			case ComparePackage.MATCH_RESOURCE__LEFT_URI:

+				setLeftURI((String)newValue);

+				return;

+			case ComparePackage.MATCH_RESOURCE__RIGHT_URI:

+				setRightURI((String)newValue);

+				return;

+			case ComparePackage.MATCH_RESOURCE__ORIGIN_URI:

+				setOriginURI((String)newValue);

+				return;

+		}

+		super.eSet(featureID, newValue);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public void eUnset(int featureID) {

+		switch (featureID) {

+			case ComparePackage.MATCH_RESOURCE__LEFT_URI:

+				setLeftURI(LEFT_URI_EDEFAULT);

+				return;

+			case ComparePackage.MATCH_RESOURCE__RIGHT_URI:

+				setRightURI(RIGHT_URI_EDEFAULT);

+				return;

+			case ComparePackage.MATCH_RESOURCE__ORIGIN_URI:

+				setOriginURI(ORIGIN_URI_EDEFAULT);

+				return;

+		}

+		super.eUnset(featureID);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public boolean eIsSet(int featureID) {

+		switch (featureID) {

+			case ComparePackage.MATCH_RESOURCE__LEFT_URI:

+				return LEFT_URI_EDEFAULT == null ? leftURI != null : !LEFT_URI_EDEFAULT.equals(leftURI);

+			case ComparePackage.MATCH_RESOURCE__RIGHT_URI:

+				return RIGHT_URI_EDEFAULT == null ? rightURI != null : !RIGHT_URI_EDEFAULT.equals(rightURI);

+			case ComparePackage.MATCH_RESOURCE__ORIGIN_URI:

+				return ORIGIN_URI_EDEFAULT == null ? originURI != null : !ORIGIN_URI_EDEFAULT

+						.equals(originURI);

+		}

+		return super.eIsSet(featureID);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public String toString() {

+		if (eIsProxy())

+			return super.toString();

+

+		StringBuffer result = new StringBuffer(super.toString());

+		result.append(" (leftURI: "); //$NON-NLS-1$

+		result.append(leftURI);

+		result.append(", rightURI: "); //$NON-NLS-1$

+		result.append(rightURI);

+		result.append(", originURI: "); //$NON-NLS-1$

+		result.append(originURI);

+		result.append(')');

+		return result.toString();

+	}

+

+} //MatchResourceImpl

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/ReferenceChangeImpl.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/ReferenceChangeImpl.java
new file mode 100644
index 000000000..d0175003b
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/ReferenceChangeImpl.java
@@ -0,0 +1,239 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare.impl;

+

+import org.eclipse.emf.common.notify.Notification;

+

+import org.eclipse.emf.compare.ComparePackage;

+import org.eclipse.emf.compare.ReferenceChange;

+

+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.impl.ENotificationImpl;

+

+/**

+ * <!-- begin-user-doc -->

+ * An implementation of the model object '<em><b>Reference Change</b></em>'.

+ * <!-- end-user-doc -->

+ * <p>

+ * The following features are implemented:

+ * <ul>

+ *   <li>{@link org.eclipse.emf.compare.impl.ReferenceChangeImpl#getReference <em>Reference</em>}</li>

+ *   <li>{@link org.eclipse.emf.compare.impl.ReferenceChangeImpl#getValue <em>Value</em>}</li>

+ * </ul>

+ * </p>

+ *

+ * @generated

+ */

+public class ReferenceChangeImpl extends DiffImpl implements ReferenceChange {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@SuppressWarnings("hiding") // generated code, removing warnings

+	public static final String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * The cached value of the '{@link #getReference() <em>Reference</em>}' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getReference()

+	 * @generated

+	 * @ordered

+	 */

+	protected EReference reference;

+

+	/**

+	 * The cached value of the '{@link #getValue() <em>Value</em>}' reference.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getValue()

+	 * @generated

+	 * @ordered

+	 */

+	protected EObject value;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	protected ReferenceChangeImpl() {

+		super();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	protected EClass eStaticClass() {

+		return ComparePackage.Literals.REFERENCE_CHANGE;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference getReference() {

+		if (reference != null && reference.eIsProxy()) {

+			InternalEObject oldReference = (InternalEObject)reference;

+			reference = (EReference)eResolveProxy(oldReference);

+			if (reference != oldReference) {

+				if (eNotificationRequired())

+					eNotify(new ENotificationImpl(this, Notification.RESOLVE,

+							ComparePackage.REFERENCE_CHANGE__REFERENCE, oldReference, reference));

+			}

+		}

+		return reference;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EReference basicGetReference() {

+		return reference;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void setReference(EReference newReference) {

+		EReference oldReference = reference;

+		reference = newReference;

+		if (eNotificationRequired())

+			eNotify(new ENotificationImpl(this, Notification.SET, ComparePackage.REFERENCE_CHANGE__REFERENCE,

+					oldReference, reference));

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EObject getValue() {

+		if (value != null && value.eIsProxy()) {

+			InternalEObject oldValue = (InternalEObject)value;

+			value = eResolveProxy(oldValue);

+			if (value != oldValue) {

+				if (eNotificationRequired())

+					eNotify(new ENotificationImpl(this, Notification.RESOLVE,

+							ComparePackage.REFERENCE_CHANGE__VALUE, oldValue, value));

+			}

+		}

+		return value;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public EObject basicGetValue() {

+		return value;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void setValue(EObject newValue) {

+		EObject oldValue = value;

+		value = newValue;

+		if (eNotificationRequired())

+			eNotify(new ENotificationImpl(this, Notification.SET, ComparePackage.REFERENCE_CHANGE__VALUE,

+					oldValue, value));

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public Object eGet(int featureID, boolean resolve, boolean coreType) {

+		switch (featureID) {

+			case ComparePackage.REFERENCE_CHANGE__REFERENCE:

+				if (resolve)

+					return getReference();

+				return basicGetReference();

+			case ComparePackage.REFERENCE_CHANGE__VALUE:

+				if (resolve)

+					return getValue();

+				return basicGetValue();

+		}

+		return super.eGet(featureID, resolve, coreType);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public void eSet(int featureID, Object newValue) {

+		switch (featureID) {

+			case ComparePackage.REFERENCE_CHANGE__REFERENCE:

+				setReference((EReference)newValue);

+				return;

+			case ComparePackage.REFERENCE_CHANGE__VALUE:

+				setValue((EObject)newValue);

+				return;

+		}

+		super.eSet(featureID, newValue);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public void eUnset(int featureID) {

+		switch (featureID) {

+			case ComparePackage.REFERENCE_CHANGE__REFERENCE:

+				setReference((EReference)null);

+				return;

+			case ComparePackage.REFERENCE_CHANGE__VALUE:

+				setValue((EObject)null);

+				return;

+		}

+		super.eUnset(featureID);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public boolean eIsSet(int featureID) {

+		switch (featureID) {

+			case ComparePackage.REFERENCE_CHANGE__REFERENCE:

+				return reference != null;

+			case ComparePackage.REFERENCE_CHANGE__VALUE:

+				return value != null;

+		}

+		return super.eIsSet(featureID);

+	}

+

+} //ReferenceChangeImpl

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/ResourceAttachmentChangeImpl.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/ResourceAttachmentChangeImpl.java
new file mode 100644
index 000000000..c39a4aa03
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/impl/ResourceAttachmentChangeImpl.java
@@ -0,0 +1,181 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare.impl;

+

+import org.eclipse.emf.common.notify.Notification;

+

+import org.eclipse.emf.compare.ComparePackage;

+import org.eclipse.emf.compare.ResourceAttachmentChange;

+

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

+

+import org.eclipse.emf.ecore.impl.ENotificationImpl;

+

+/**

+ * <!-- begin-user-doc -->

+ * An implementation of the model object '<em><b>Resource Attachment Change</b></em>'.

+ * <!-- end-user-doc -->

+ * <p>

+ * The following features are implemented:

+ * <ul>

+ *   <li>{@link org.eclipse.emf.compare.impl.ResourceAttachmentChangeImpl#getResourceURI <em>Resource URI</em>}</li>

+ * </ul>

+ * </p>

+ *

+ * @generated

+ */

+public class ResourceAttachmentChangeImpl extends DiffImpl implements ResourceAttachmentChange {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@SuppressWarnings("hiding") // generated code, removing warnings

+	public static final String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * The default value of the '{@link #getResourceURI() <em>Resource URI</em>}' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getResourceURI()

+	 * @generated

+	 * @ordered

+	 */

+	protected static final String RESOURCE_URI_EDEFAULT = null;

+

+	/**

+	 * The cached value of the '{@link #getResourceURI() <em>Resource URI</em>}' attribute.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @see #getResourceURI()

+	 * @generated

+	 * @ordered

+	 */

+	protected String resourceURI = RESOURCE_URI_EDEFAULT;

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	protected ResourceAttachmentChangeImpl() {

+		super();

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	protected EClass eStaticClass() {

+		return ComparePackage.Literals.RESOURCE_ATTACHMENT_CHANGE;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public String getResourceURI() {

+		return resourceURI;

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public void setResourceURI(String newResourceURI) {

+		String oldResourceURI = resourceURI;

+		resourceURI = newResourceURI;

+		if (eNotificationRequired())

+			eNotify(new ENotificationImpl(this, Notification.SET,

+					ComparePackage.RESOURCE_ATTACHMENT_CHANGE__RESOURCE_URI, oldResourceURI, resourceURI));

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public Object eGet(int featureID, boolean resolve, boolean coreType) {

+		switch (featureID) {

+			case ComparePackage.RESOURCE_ATTACHMENT_CHANGE__RESOURCE_URI:

+				return getResourceURI();

+		}

+		return super.eGet(featureID, resolve, coreType);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public void eSet(int featureID, Object newValue) {

+		switch (featureID) {

+			case ComparePackage.RESOURCE_ATTACHMENT_CHANGE__RESOURCE_URI:

+				setResourceURI((String)newValue);

+				return;

+		}

+		super.eSet(featureID, newValue);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public void eUnset(int featureID) {

+		switch (featureID) {

+			case ComparePackage.RESOURCE_ATTACHMENT_CHANGE__RESOURCE_URI:

+				setResourceURI(RESOURCE_URI_EDEFAULT);

+				return;

+		}

+		super.eUnset(featureID);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public boolean eIsSet(int featureID) {

+		switch (featureID) {

+			case ComparePackage.RESOURCE_ATTACHMENT_CHANGE__RESOURCE_URI:

+				return RESOURCE_URI_EDEFAULT == null ? resourceURI != null : !RESOURCE_URI_EDEFAULT

+						.equals(resourceURI);

+		}

+		return super.eIsSet(featureID);

+	}

+

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	@Override

+	public String toString() {

+		if (eIsProxy())

+			return super.toString();

+

+		StringBuffer result = new StringBuffer(super.toString());

+		result.append(" (resourceURI: "); //$NON-NLS-1$

+		result.append(resourceURI);

+		result.append(')');

+		return result.toString();

+	}

+

+} //ResourceAttachmentChangeImpl

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/util/CompareAdapterFactory.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/util/CompareAdapterFactory.java
new file mode 100644
index 000000000..a43b4976a
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/util/CompareAdapterFactory.java
@@ -0,0 +1,286 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare.util;

+

+import org.eclipse.emf.common.notify.Adapter;

+import org.eclipse.emf.common.notify.Notifier;

+

+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;

+

+import org.eclipse.emf.compare.*;

+

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

+

+/**

+ * <!-- begin-user-doc -->

+ * The <b>Adapter Factory</b> for the model.

+ * It provides an adapter <code>createXXX</code> method for each class of the model.

+ * <!-- end-user-doc -->

+ * @see org.eclipse.emf.compare.ComparePackage

+ * @generated

+ */

+public class CompareAdapterFactory extends AdapterFactoryImpl {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static final String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * The cached model package.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	protected static ComparePackage modelPackage;

+

+	/**

+	 * Creates an instance of the adapter factory.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public CompareAdapterFactory() {

+		if (modelPackage == null) {

+			modelPackage = ComparePackage.eINSTANCE;

+		}

+	}

+

+	/**

+	 * Returns whether this factory is applicable for the type of the object.

+	 * <!-- begin-user-doc -->

+	 * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.

+	 * <!-- end-user-doc -->

+	 * @return whether this factory is applicable for the type of the object.

+	 * @generated

+	 */

+	@Override

+	public boolean isFactoryForType(Object object) {

+		if (object == modelPackage) {

+			return true;

+		}

+		if (object instanceof EObject) {

+			return ((EObject)object).eClass().getEPackage() == modelPackage;

+		}

+		return false;

+	}

+

+	/**

+	 * The switch that delegates to the <code>createXXX</code> methods.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	protected CompareSwitch<Adapter> modelSwitch = new CompareSwitch<Adapter>() {

+		@Override

+		public Adapter caseComparison(Comparison object) {

+			return createComparisonAdapter();

+		}

+

+		@Override

+		public Adapter caseMatchResource(MatchResource object) {

+			return createMatchResourceAdapter();

+		}

+

+		@Override

+		public Adapter caseMatch(Match object) {

+			return createMatchAdapter();

+		}

+

+		@Override

+		public Adapter caseDiff(Diff object) {

+			return createDiffAdapter();

+		}

+

+		@Override

+		public Adapter caseResourceAttachmentChange(ResourceAttachmentChange object) {

+			return createResourceAttachmentChangeAdapter();

+		}

+

+		@Override

+		public Adapter caseReferenceChange(ReferenceChange object) {

+			return createReferenceChangeAdapter();

+		}

+

+		@Override

+		public Adapter caseAttributeChange(AttributeChange object) {

+			return createAttributeChangeAdapter();

+		}

+

+		@Override

+		public Adapter caseConflict(Conflict object) {

+			return createConflictAdapter();

+		}

+

+		@Override

+		public Adapter caseEquivalence(Equivalence object) {

+			return createEquivalenceAdapter();

+		}

+

+		@Override

+		public Adapter defaultCase(EObject object) {

+			return createEObjectAdapter();

+		}

+	};

+

+	/**

+	 * Creates an adapter for the <code>target</code>.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @param target the object to adapt.

+	 * @return the adapter for the <code>target</code>.

+	 * @generated

+	 */

+	@Override

+	public Adapter createAdapter(Notifier target) {

+		return modelSwitch.doSwitch((EObject)target);

+	}

+

+	/**

+	 * Creates a new adapter for an object of class '{@link org.eclipse.emf.compare.Comparison <em>Comparison</em>}'.

+	 * <!-- begin-user-doc -->

+	 * This default implementation returns null so that we can easily ignore cases;

+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.

+	 * <!-- end-user-doc -->

+	 * @return the new adapter.

+	 * @see org.eclipse.emf.compare.Comparison

+	 * @generated

+	 */

+	public Adapter createComparisonAdapter() {

+		return null;

+	}

+

+	/**

+	 * Creates a new adapter for an object of class '{@link org.eclipse.emf.compare.MatchResource <em>Match Resource</em>}'.

+	 * <!-- begin-user-doc -->

+	 * This default implementation returns null so that we can easily ignore cases;

+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.

+	 * <!-- end-user-doc -->

+	 * @return the new adapter.

+	 * @see org.eclipse.emf.compare.MatchResource

+	 * @generated

+	 */

+	public Adapter createMatchResourceAdapter() {

+		return null;

+	}

+

+	/**

+	 * Creates a new adapter for an object of class '{@link org.eclipse.emf.compare.Match <em>Match</em>}'.

+	 * <!-- begin-user-doc -->

+	 * This default implementation returns null so that we can easily ignore cases;

+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.

+	 * <!-- end-user-doc -->

+	 * @return the new adapter.

+	 * @see org.eclipse.emf.compare.Match

+	 * @generated

+	 */

+	public Adapter createMatchAdapter() {

+		return null;

+	}

+

+	/**

+	 * Creates a new adapter for an object of class '{@link org.eclipse.emf.compare.Diff <em>Diff</em>}'.

+	 * <!-- begin-user-doc -->

+	 * This default implementation returns null so that we can easily ignore cases;

+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.

+	 * <!-- end-user-doc -->

+	 * @return the new adapter.

+	 * @see org.eclipse.emf.compare.Diff

+	 * @generated

+	 */

+	public Adapter createDiffAdapter() {

+		return null;

+	}

+

+	/**

+	 * Creates a new adapter for an object of class '{@link org.eclipse.emf.compare.ResourceAttachmentChange <em>Resource Attachment Change</em>}'.

+	 * <!-- begin-user-doc -->

+	 * This default implementation returns null so that we can easily ignore cases;

+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.

+	 * <!-- end-user-doc -->

+	 * @return the new adapter.

+	 * @see org.eclipse.emf.compare.ResourceAttachmentChange

+	 * @generated

+	 */

+	public Adapter createResourceAttachmentChangeAdapter() {

+		return null;

+	}

+

+	/**

+	 * Creates a new adapter for an object of class '{@link org.eclipse.emf.compare.ReferenceChange <em>Reference Change</em>}'.

+	 * <!-- begin-user-doc -->

+	 * This default implementation returns null so that we can easily ignore cases;

+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.

+	 * <!-- end-user-doc -->

+	 * @return the new adapter.

+	 * @see org.eclipse.emf.compare.ReferenceChange

+	 * @generated

+	 */

+	public Adapter createReferenceChangeAdapter() {

+		return null;

+	}

+

+	/**

+	 * Creates a new adapter for an object of class '{@link org.eclipse.emf.compare.AttributeChange <em>Attribute Change</em>}'.

+	 * <!-- begin-user-doc -->

+	 * This default implementation returns null so that we can easily ignore cases;

+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.

+	 * <!-- end-user-doc -->

+	 * @return the new adapter.

+	 * @see org.eclipse.emf.compare.AttributeChange

+	 * @generated

+	 */

+	public Adapter createAttributeChangeAdapter() {

+		return null;

+	}

+

+	/**

+	 * Creates a new adapter for an object of class '{@link org.eclipse.emf.compare.Conflict <em>Conflict</em>}'.

+	 * <!-- begin-user-doc -->

+	 * This default implementation returns null so that we can easily ignore cases;

+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.

+	 * <!-- end-user-doc -->

+	 * @return the new adapter.

+	 * @see org.eclipse.emf.compare.Conflict

+	 * @generated

+	 */

+	public Adapter createConflictAdapter() {

+		return null;

+	}

+

+	/**

+	 * Creates a new adapter for an object of class '{@link org.eclipse.emf.compare.Equivalence <em>Equivalence</em>}'.

+	 * <!-- begin-user-doc -->

+	 * This default implementation returns null so that we can easily ignore cases;

+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.

+	 * <!-- end-user-doc -->

+	 * @return the new adapter.

+	 * @see org.eclipse.emf.compare.Equivalence

+	 * @generated

+	 */

+	public Adapter createEquivalenceAdapter() {

+		return null;

+	}

+

+	/**

+	 * Creates a new adapter for the default case.

+	 * <!-- begin-user-doc -->

+	 * This default implementation returns null.

+	 * <!-- end-user-doc -->

+	 * @return the new adapter.

+	 * @generated

+	 */

+	public Adapter createEObjectAdapter() {

+		return null;

+	}

+

+} //CompareAdapterFactory

diff --git a/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/util/CompareSwitch.java b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/util/CompareSwitch.java
new file mode 100644
index 000000000..8f68da706
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src-gen/org/eclipse/emf/compare/util/CompareSwitch.java
@@ -0,0 +1,321 @@
+/**

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ */

+package org.eclipse.emf.compare.util;

+

+import java.util.List;

+

+import org.eclipse.emf.compare.*;

+

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

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

+

+/**

+ * <!-- begin-user-doc -->

+ * The <b>Switch</b> for the model's inheritance hierarchy.

+ * It supports the call {@link #doSwitch(EObject) doSwitch(object)}

+ * to invoke the <code>caseXXX</code> method for each class of the model,

+ * starting with the actual class of the object

+ * and proceeding up the inheritance hierarchy

+ * until a non-null result is returned,

+ * which is the result of the switch.

+ * <!-- end-user-doc -->

+ * @see org.eclipse.emf.compare.ComparePackage

+ * @generated

+ */

+public class CompareSwitch<T> {

+	/**

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public static final String copyright = "Copyright (c) 2012 Obeo.\r\nAll rights reserved. This program and the accompanying materials\r\nare made available under the terms of the Eclipse Public License v1.0\r\nwhich accompanies this distribution, and is available at\r\nhttp://www.eclipse.org/legal/epl-v10.html\r\n\r\nContributors:\r\n    Obeo - initial API and implementation"; //$NON-NLS-1$

+

+	/**

+	 * The cached model package

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	protected static ComparePackage modelPackage;

+

+	/**

+	 * Creates an instance of the switch.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @generated

+	 */

+	public CompareSwitch() {

+		if (modelPackage == null) {

+			modelPackage = ComparePackage.eINSTANCE;

+		}

+	}

+

+	/**

+	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the first non-null result returned by a <code>caseXXX</code> call.

+	 * @generated

+	 */

+	public T doSwitch(EObject theEObject) {

+		return doSwitch(theEObject.eClass(), theEObject);

+	}

+

+	/**

+	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the first non-null result returned by a <code>caseXXX</code> call.

+	 * @generated

+	 */

+	protected T doSwitch(EClass theEClass, EObject theEObject) {

+		if (theEClass.eContainer() == modelPackage) {

+			return doSwitch(theEClass.getClassifierID(), theEObject);

+		}

+		// Not generated : happy compiler!

+		List<EClass> eSuperTypes = theEClass.getESuperTypes();

+		return eSuperTypes.isEmpty() ? defaultCase(theEObject) : doSwitch(eSuperTypes.get(0), theEObject);

+	}

+

+	/**

+	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.

+	 * <!-- begin-user-doc -->

+	 * <!-- end-user-doc -->

+	 * @return the first non-null result returned by a <code>caseXXX</code> call.

+	 * @generated

+	 */

+	protected T doSwitch(int classifierID, EObject theEObject) {

+		switch (classifierID) {

+			case ComparePackage.COMPARISON: {

+				Comparison comparison = (Comparison)theEObject;

+				T result = caseComparison(comparison);

+				if (result == null)

+					result = defaultCase(theEObject);

+				return result;

+			}

+			case ComparePackage.MATCH_RESOURCE: {

+				MatchResource matchResource = (MatchResource)theEObject;

+				T result = caseMatchResource(matchResource);

+				if (result == null)

+					result = defaultCase(theEObject);

+				return result;

+			}

+			case ComparePackage.MATCH: {

+				Match match = (Match)theEObject;

+				T result = caseMatch(match);

+				if (result == null)

+					result = defaultCase(theEObject);

+				return result;

+			}

+			case ComparePackage.DIFF: {

+				Diff diff = (Diff)theEObject;

+				T result = caseDiff(diff);

+				if (result == null)

+					result = defaultCase(theEObject);

+				return result;

+			}

+			case ComparePackage.RESOURCE_ATTACHMENT_CHANGE: {

+				ResourceAttachmentChange resourceAttachmentChange = (ResourceAttachmentChange)theEObject;

+				T result = caseResourceAttachmentChange(resourceAttachmentChange);

+				if (result == null)

+					result = caseDiff(resourceAttachmentChange);

+				if (result == null)

+					result = defaultCase(theEObject);

+				return result;

+			}

+			case ComparePackage.REFERENCE_CHANGE: {

+				ReferenceChange referenceChange = (ReferenceChange)theEObject;

+				T result = caseReferenceChange(referenceChange);

+				if (result == null)

+					result = caseDiff(referenceChange);

+				if (result == null)

+					result = defaultCase(theEObject);

+				return result;

+			}

+			case ComparePackage.ATTRIBUTE_CHANGE: {

+				AttributeChange attributeChange = (AttributeChange)theEObject;

+				T result = caseAttributeChange(attributeChange);

+				if (result == null)

+					result = caseDiff(attributeChange);

+				if (result == null)

+					result = defaultCase(theEObject);

+				return result;

+			}

+			case ComparePackage.CONFLICT: {

+				Conflict conflict = (Conflict)theEObject;

+				T result = caseConflict(conflict);

+				if (result == null)

+					result = defaultCase(theEObject);

+				return result;

+			}

+			case ComparePackage.EQUIVALENCE: {

+				Equivalence equivalence = (Equivalence)theEObject;

+				T result = caseEquivalence(equivalence);

+				if (result == null)

+					result = defaultCase(theEObject);

+				return result;

+			}

+			default:

+				return defaultCase(theEObject);

+		}

+	}

+

+	/**

+	 * Returns the result of interpreting the object as an instance of '<em>Comparison</em>'.

+	 * <!-- begin-user-doc -->

+	 * This implementation returns null;

+	 * returning a non-null result will terminate the switch.

+	 * <!-- end-user-doc -->

+	 * @param object the target of the switch.

+	 * @return the result of interpreting the object as an instance of '<em>Comparison</em>'.

+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)

+	 * @generated

+	 */

+	public T caseComparison(Comparison object) {

+		return null;

+	}

+

+	/**

+	 * Returns the result of interpreting the object as an instance of '<em>Match Resource</em>'.

+	 * <!-- begin-user-doc -->

+	 * This implementation returns null;

+	 * returning a non-null result will terminate the switch.

+	 * <!-- end-user-doc -->

+	 * @param object the target of the switch.

+	 * @return the result of interpreting the object as an instance of '<em>Match Resource</em>'.

+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)

+	 * @generated

+	 */

+	public T caseMatchResource(MatchResource object) {

+		return null;

+	}

+

+	/**

+	 * Returns the result of interpreting the object as an instance of '<em>Match</em>'.

+	 * <!-- begin-user-doc -->

+	 * This implementation returns null;

+	 * returning a non-null result will terminate the switch.

+	 * <!-- end-user-doc -->

+	 * @param object the target of the switch.

+	 * @return the result of interpreting the object as an instance of '<em>Match</em>'.

+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)

+	 * @generated

+	 */

+	public T caseMatch(Match object) {

+		return null;

+	}

+

+	/**

+	 * Returns the result of interpreting the object as an instance of '<em>Diff</em>'.

+	 * <!-- begin-user-doc -->

+	 * This implementation returns null;

+	 * returning a non-null result will terminate the switch.

+	 * <!-- end-user-doc -->

+	 * @param object the target of the switch.

+	 * @return the result of interpreting the object as an instance of '<em>Diff</em>'.

+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)

+	 * @generated

+	 */

+	public T caseDiff(Diff object) {

+		return null;

+	}

+

+	/**

+	 * Returns the result of interpreting the object as an instance of '<em>Resource Attachment Change</em>'.

+	 * <!-- begin-user-doc -->

+	 * This implementation returns null;

+	 * returning a non-null result will terminate the switch.

+	 * <!-- end-user-doc -->

+	 * @param object the target of the switch.

+	 * @return the result of interpreting the object as an instance of '<em>Resource Attachment Change</em>'.

+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)

+	 * @generated

+	 */

+	public T caseResourceAttachmentChange(ResourceAttachmentChange object) {

+		return null;

+	}

+

+	/**

+	 * Returns the result of interpreting the object as an instance of '<em>Reference Change</em>'.

+	 * <!-- begin-user-doc -->

+	 * This implementation returns null;

+	 * returning a non-null result will terminate the switch.

+	 * <!-- end-user-doc -->

+	 * @param object the target of the switch.

+	 * @return the result of interpreting the object as an instance of '<em>Reference Change</em>'.

+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)

+	 * @generated

+	 */

+	public T caseReferenceChange(ReferenceChange object) {

+		return null;

+	}

+

+	/**

+	 * Returns the result of interpreting the object as an instance of '<em>Attribute Change</em>'.

+	 * <!-- begin-user-doc -->

+	 * This implementation returns null;

+	 * returning a non-null result will terminate the switch.

+	 * <!-- end-user-doc -->

+	 * @param object the target of the switch.

+	 * @return the result of interpreting the object as an instance of '<em>Attribute Change</em>'.

+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)

+	 * @generated

+	 */

+	public T caseAttributeChange(AttributeChange object) {

+		return null;

+	}

+

+	/**

+	 * Returns the result of interpreting the object as an instance of '<em>Conflict</em>'.

+	 * <!-- begin-user-doc -->

+	 * This implementation returns null;

+	 * returning a non-null result will terminate the switch.

+	 * <!-- end-user-doc -->

+	 * @param object the target of the switch.

+	 * @return the result of interpreting the object as an instance of '<em>Conflict</em>'.

+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)

+	 * @generated

+	 */

+	public T caseConflict(Conflict object) {

+		return null;

+	}

+

+	/**

+	 * Returns the result of interpreting the object as an instance of '<em>Equivalence</em>'.

+	 * <!-- begin-user-doc -->

+	 * This implementation returns null;

+	 * returning a non-null result will terminate the switch.

+	 * <!-- end-user-doc -->

+	 * @param object the target of the switch.

+	 * @return the result of interpreting the object as an instance of '<em>Equivalence</em>'.

+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)

+	 * @generated

+	 */

+	public T caseEquivalence(Equivalence object) {

+		return null;

+	}

+

+	/**

+	 * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.

+	 * <!-- begin-user-doc -->

+	 * This implementation returns null;

+	 * returning a non-null result will terminate the switch, but this is the last case anyway.

+	 * <!-- end-user-doc -->

+	 * @param object the target of the switch.

+	 * @return the result of interpreting the object as an instance of '<em>EObject</em>'.

+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)

+	 * @generated

+	 */

+	public T defaultCase(EObject object) {

+		return null;

+	}

+

+} //CompareSwitch

diff --git a/plugins/org.eclipse.emf.compare/src/org/eclipse/emf/compare/EMFComparePlugin.java b/plugins/org.eclipse.emf.compare/src/org/eclipse/emf/compare/EMFComparePlugin.java
new file mode 100644
index 000000000..3a4aca494
--- /dev/null
+++ b/plugins/org.eclipse.emf.compare/src/org/eclipse/emf/compare/EMFComparePlugin.java
@@ -0,0 +1,39 @@
+/*******************************************************************************

+ * Copyright (c) 2012 Obeo.

+ * 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:

+ *     Obeo - initial API and implementation

+ *******************************************************************************/

+package org.eclipse.emf.compare;

+

+import org.osgi.framework.BundleActivator;

+import org.osgi.framework.BundleContext;

+

+/**

+ * The activator class, controls the plug-in life cycle.

+ * 

+ * @author <a href="mailto:laurent.goubet@obeo.fr">Laurent Goubet</a>

+ */

+public class EMFComparePlugin implements BundleActivator {

+	/**

+	 * {@inheritDoc}

+	 * 

+	 * @see org.osgi.framework.BundleActivator#start(org.osgi.framework.BundleContext)

+	 */

+	public void start(BundleContext bundleContext) throws Exception {

+		// Empty implementation

+	}

+

+	/**

+	 * {@inheritDoc}

+	 * 

+	 * @see org.osgi.framework.BundleActivator#stop(org.osgi.framework.BundleContext)

+	 */

+	public void stop(BundleContext bundleContext) throws Exception {

+		// Empty implementation

+	}

+}